Struct CircuitTransaction

pub struct CircuitTransaction(pub Transaction);

Tuple Fields

0: Transaction

Implementations

impl CircuitTransaction

pub fn from(transaction: Transaction) -> Self

pub fn inner(&self) -> &Transaction

pub fn txid(&self) -> [u8; 32]

Returns the transaction id, in big-endian byte order. One must be careful when dealing with Bitcoin transaction ids, as they are little-endian in the Bitcoin protocol.

pub fn mid_state_txid(&self) -> [u8; 32]

Returns the first digest of the transaction to be used in SPV

Methods from Deref<Target = Transaction>

pub const MAX_STANDARD_WEIGHT: Weight

pub fn ntxid(&self) -> Hash

👎Deprecated since 0.31.0: ntxid has been renamed to compute_ntxid to note that it’s computationally expensive. use compute_ntxid() instead.

Computes a “normalized TXID” which does not include any signatures.

This method is deprecated. Use compute_ntxid instead.

pub fn compute_ntxid(&self) -> Hash

Computes a “normalized TXID” which does not include any signatures.

This gives a way to identify a transaction that is “the same” as another in the sense of having same inputs and outputs.

pub fn txid(&self) -> Txid

👎Deprecated since 0.31.0: txid has been renamed to compute_txid to note that it’s computationally expensive. use compute_txid() instead.

Computes the [Txid].

This method is deprecated. Use compute_txid instead.

pub fn compute_txid(&self) -> Txid

Computes the [Txid].

Hashes the transaction excluding the segwit data (i.e. the marker, flag bytes, and the witness fields themselves). For non-segwit transactions which do not have any segwit data, this will be equal to [Transaction::compute_wtxid()].

pub fn wtxid(&self) -> Wtxid

👎Deprecated since 0.31.0: wtxid has been renamed to compute_wtxid to note that it’s computationally expensive. use compute_wtxid() instead.

Computes the segwit version of the transaction id.

This method is deprecated. Use compute_wtxid instead.

pub fn compute_wtxid(&self) -> Wtxid

Computes the segwit version of the transaction id.

Hashes the transaction including all segwit data (i.e. the marker, flag bytes, and the witness fields themselves). For non-segwit transactions which do not have any segwit data, this will be equal to [Transaction::txid()].

pub fn weight(&self) -> Weight

Returns the weight of this transaction, as defined by BIP-141.

Transaction weight is defined as Base transaction size * 3 + Total transaction size (ie. the same method as calculating Block weight from Base size and Total size).

For transactions with an empty witness, this is simply the consensus-serialized size times four. For transactions with a witness, this is the non-witness consensus-serialized size multiplied by three plus the with-witness consensus-serialized size.

For transactions with no inputs, this function will return a value 2 less than the actual weight of the serialized transaction. The reason is that zero-input transactions, post-segwit, cannot be unambiguously serialized; we make a choice that adds two extra bytes. For more details see BIP 141 which uses a “input count” of 0x00 as a marker for a Segwit-encoded transaction.

If you need to use 0-input transactions, we strongly recommend you do so using the PSBT API. The unsigned transaction encoded within PSBT is always a non-segwit transaction and can therefore avoid this ambiguity.

pub fn base_size(&self) -> usize

Returns the base transaction size.

Base transaction size is the size of the transaction serialised with the witness data stripped.

pub fn total_size(&self) -> usize

Returns the total transaction size.

Total transaction size is the transaction size in bytes serialized as described in BIP144, including base data and witness data.

pub fn vsize(&self) -> usize

Returns the “virtual size” (vsize) of this transaction.

Will be ceil(weight / 4.0). Note this implements the virtual size as per BIP141, which is different to what is implemented in Bitcoin Core. The computation should be the same for any remotely sane transaction, and a standardness-rule-correct version is available in the policy module.

Virtual transaction size is defined as Transaction weight / 4 (rounded up to the next integer).

pub fn is_coinbase(&self) -> bool

Checks if this is a coinbase transaction.

The first transaction in the block distributes the mining reward and is called the coinbase transaction. It is impossible to check if the transaction is first in the block, so this function checks the structure of the transaction instead - the previous output must be all-zeros (creates satoshis “out of thin air”).

pub fn is_explicitly_rbf(&self) -> bool

Returns true if the transaction itself opted in to be BIP-125-replaceable (RBF).

Warning

Incorrectly relying on RBF may lead to monetary loss!

This does not cover the case where a transaction becomes replaceable due to ancestors being RBF. Please note that transactions may be replaced even if they do not include the RBF signal: https://bitcoinops.org/en/newsletters/2022/10/19/#transaction-replacement-option.

pub fn is_absolute_timelock_satisfied(&self, height: Height, time: Time) -> bool

Returns true if this [Transaction]’s absolute timelock is satisfied at height/time.

Returns

By definition if the lock time is not enabled the transaction’s absolute timelock is considered to be satisfied i.e., there are no timelock constraints restricting this transaction from being mined immediately.

pub fn is_lock_time_enabled(&self) -> bool

Returns true if this transactions nLockTime is enabled (BIP-65).

pub fn script_pubkey_lens(&self) -> impl Iterator<Item = usize>

Returns an iterator over lengths of script_pubkeys in the outputs.

This is useful in combination with [predict_weight] if you have the transaction already constructed with a dummy value in the fee output which you’ll adjust after calculating the weight.

pub fn total_sigop_cost<S>(&self, spent: S) -> usize

where S: FnMut(&OutPoint) -> Option<TxOut>,

Counts the total number of sigops.

This value is for pre-taproot transactions only.

In taproot, a different mechanism is used. Instead of having a global per-block limit, there is a per-transaction-input limit, proportional to the size of that input. ref: https://bitcoin.stackexchange.com/questions/117356/what-is-sigop-signature-operation#117359

The spent parameter is a closure/function that looks up the output being spent by each input It takes in an [OutPoint] and returns a [TxOut]. If you can’t provide this, a placeholder of |_| None can be used. Without access to the previous [TxOut], any sigops in a redeemScript (P2SH) as well as any segwit sigops will not be counted for that input.

pub fn tx_in(&self, input_index: usize) -> Result<&TxIn, InputsIndexError>

Returns a reference to the input at input_index if it exists.

pub fn tx_out(&self, output_index: usize) -> Result<&TxOut, OutputsIndexError>

Returns a reference to the output at output_index if it exists.

pub fn verify<S>(&self, spent: S) -> Result<(), TxVerifyError>

where S: FnMut(&OutPoint) -> Option<TxOut>,

Verifies that this transaction is able to spend its inputs.

Shorthand for [Self::verify_with_flags] with flag bitcoinconsensus::VERIFY_ALL.

The spent closure should not return the same [TxOut] twice!

pub fn verify_with_flags<S, F>( &self, spent: S, flags: F, ) -> Result<(), TxVerifyError>

where S: FnMut(&OutPoint) -> Option<TxOut>, F: Into<u32>,

Verifies that this transaction is able to spend its inputs.

The spent closure should not return the same [TxOut] twice!

Trait Implementations

impl BorshDeserialize for CircuitTransaction

fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for CircuitTransaction

fn serialize<W: Write>(&self, writer: &mut W) -> Result<()>

impl Clone for CircuitTransaction

fn clone(&self) -> CircuitTransaction

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CircuitTransaction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for CircuitTransaction

type Target = Transaction

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for CircuitTransaction

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl From<CircuitTransaction> for Transaction

fn from(val: CircuitTransaction) -> Self

Converts to this type from the input type.

impl From<Transaction> for CircuitTransaction

fn from(tx: Transaction) -> Self

Converts to this type from the input type.

impl Hash for CircuitTransaction

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CircuitTransaction

fn eq(&self, other: &CircuitTransaction) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for CircuitTransaction

impl StructuralPartialEq for CircuitTransaction