Struct breez_sdk_core::bitcoin::Transaction

pub struct Transaction {
    pub version: i32,
    pub lock_time: PackedLockTime,
    pub input: Vec<TxIn>,
    pub output: Vec<TxOut>,
}

Bitcoin transaction.

An authenticated movement of coins.

See Bitcoin Wiki: Transaction for more information.

Bitcoin Core References

• CTtransaction definition

Serialization notes

If any inputs have nonempty witnesses, the entire transaction is serialized in the post-BIP141 Segwit format which includes a list of witnesses. If all inputs have empty witnesses, the transaction is serialized in the pre-BIP141 format.

There is one major exception to this: to avoid deserialization ambiguity, if the transaction has no inputs, it is serialized in the BIP141 style. Be aware that this differs from the transaction format in PSBT, which never uses BIP141. (Ordinarily there is no conflict, since in PSBT transactions are always unsigned and therefore their inputs have empty witnesses.)

The specific ambiguity is that Segwit uses the flag bytes 0001 where an old serializer would read the number of transaction inputs. The old serializer would interpret this as “no inputs, one output”, which means the transaction is invalid, and simply reject it. Segwit further specifies that this encoding should only be used when some input has a nonempty witness; that is, witness-less transactions should be encoded in the traditional format.

However, in protocols where transactions may legitimately have 0 inputs, e.g. when parties are cooperatively funding a transaction, the “00 means Segwit” heuristic does not work. Since Segwit requires such a transaction be encoded in the original transaction format (since it has no inputs and therefore no input witnesses), a traditionally encoded transaction may have the 0001 Segwit flag in it, which confuses most Segwit parsers including the one in Bitcoin Core.

We therefore deviate from the spec by always using the Segwit witness encoding for 0-input transactions, which results in unambiguously parseable transactions.

Fields

version: i32

The protocol version, is currently expected to be 1 or 2 (BIP 68).

lock_time: PackedLockTime

Block height or timestamp. Transaction cannot be included in a block until this height/time.

Relevant BIPs

• BIP-65 OP_CHECKLOCKTIMEVERIFY
• BIP-113 Median time-past as endpoint for lock-time calculations

input: Vec<TxIn>

List of transaction inputs.

output: Vec<TxOut>

List of transaction outputs.

Implementations

impl Transaction

pub fn 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

Computes the txid. For non-segwit transactions this will be identical to the output of wtxid(), but for segwit transactions, this will give the correct txid (not including witnesses) while wtxid will also hash witnesses.

pub fn wtxid(&self) -> Wtxid

Computes SegWit-version of the transaction id (wtxid). For transaction with the witness data this hash includes witness, for pre-witness transaction it is equal to the normal value returned by txid() function.

pub fn encode_signing_data_to<Write, U>( &self, writer: Write, input_index: usize, script_pubkey: &Script, sighash_type: U, ) -> EncodeSigningDataResult<Error>

where Write: Write, U: Into<u32>,

Encodes the signing data from which a signature hash for a given input index with a given sighash flag can be computed.

To actually produce a scriptSig, this hash needs to be run through an ECDSA signer, the EcdsaSighashType appended to the resulting sig, and a script written around this, but this is the general (and hard) part.

The sighash_type supports an arbitrary u32 value, instead of just EcdsaSighashType, because internally 4 bytes are being hashed, even though only the lowest byte is appended to signature in a transaction.

Warning

• Does NOT attempt to support OP_CODESEPARATOR. In general this would require evaluating script_pubkey to determine which separators get evaluated and which don’t, which we don’t have the information to determine.
• Does NOT handle the sighash single bug (see “Return type” section)

Return type

This function can’t handle the SIGHASH_SINGLE bug internally, so it returns EncodeSigningDataResult that must be handled by the caller (see EncodeSigningDataResult::is_sighash_single_bug).

Panics

If input_index is out of bounds (greater than or equal to self.input.len()).

pub fn signature_hash( &self, input_index: usize, script_pubkey: &Script, sighash_u32: u32, ) -> Sighash

Computes a signature hash for a given input index with a given sighash flag.

To actually produce a scriptSig, this hash needs to be run through an ECDSA signer, the EcdsaSighashType appended to the resulting sig, and a script written around this, but this is the general (and hard) part.

The sighash_type supports an arbitrary u32 value, instead of just EcdsaSighashType, because internally 4 bytes are being hashed, even though only the lowest byte is appended to signature in a transaction.

This function correctly handles the sighash single bug by returning the ‘one array’. The sighash single bug becomes exploitable when one tries to sign a transaction with SIGHASH_SINGLE and there is not a corresponding output with the same index as the input.

Warning

Does NOT attempt to support OP_CODESEPARATOR. In general this would require evaluating script_pubkey to determine which separators get evaluated and which don’t, which we don’t have the information to determine.

Panics

If input_index is out of bounds (greater than or equal to self.input.len()).

pub fn get_weight(&self) -> usize

👎Deprecated since 0.28.0: Please use transaction::weight instead.

Returns the “weight” of this transaction, as defined by BIP141.

pub fn weight(&self) -> usize

Returns the “weight” of this transaction, as defined by BIP141.

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.

pub fn get_size(&self) -> usize

👎Deprecated since 0.28.0: Please use transaction::size instead.

Returns the regular byte-wise consensus-serialized size of this transaction.

pub fn size(&self) -> usize

Returns the regular byte-wise consensus-serialized size of this transaction.

pub fn get_vsize(&self) -> usize

👎Deprecated since 0.28.0: Please use transaction::vsize instead.

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

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.

pub fn get_strippedsize(&self) -> usize

👎Deprecated since 0.28.0: Please use transaction::strippedsize instead.

Returns the size of this transaction excluding the witness data.

pub fn strippedsize(&self) -> usize

Returns the size of this transaction excluding the witness data.

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

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

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

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

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

Verify that this transaction is able to spend its inputs. The spent closure should not return the same TxOut twice!

pub fn is_coin_base(&self) -> bool

Is this a coin base transaction?

pub fn is_explicitly_rbf(&self) -> bool

Returns true if the transaction itself opted in to be BIP-125-replaceable (RBF). This does not cover the case where a transaction becomes replaceable due to ancestors being RBF.

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).

Trait Implementations

impl AsRef<Transaction> for PrefilledTransaction

fn as_ref(&self) -> &Transaction

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Transaction

fn clone(&self) -> Transaction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Transaction

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

Formats the value using the given formatter.

impl Decodable for Transaction

fn consensus_decode_from_finite_reader<R>( r: &mut R, ) -> Result<Transaction, Error>

where R: Read + ?Sized,

Decode Self from a size-limited reader.

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

where R: Read + ?Sized,

Decode an object with a well-defined format.

impl<'de> Deserialize<'de> for Transaction

fn deserialize<__D>( __deserializer: __D, ) -> Result<Transaction, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Deserialize for Transaction

fn deserialize(bytes: &[u8]) -> Result<Transaction, Error>

Deserialize a value from raw data.

impl Encodable for Transaction

fn consensus_encode<W>(&self, w: &mut W) -> Result<usize, Error>

where W: Write + ?Sized,

Encode an object with a well-defined format. Returns the number of bytes written on success.

impl Hash for Transaction

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

where __H: Hasher,

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 Ord for Transaction

fn cmp(&self, other: &Transaction) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Transaction

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for Transaction

fn partial_cmp(&self, other: &Transaction) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Readable for Transaction

fn read<R>(r: &mut R) -> Result<Transaction, DecodeError>

where R: Read,

Reads a Self in from the given Read.

impl Serialize for Transaction

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Serialize for Transaction

fn serialize(&self) -> Vec<u8>

Serialize a value as raw data.

impl Writeable for Transaction

fn write<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Writer,

Writes self out to the given Writer.

fn encode(&self) -> Vec<u8>

Writes self out to a Vec<u8>.

fn serialized_length(&self) -> usize

Gets the length of this object after it has been serialized. This can be overridden to optimize cases where we prepend an object with its length.

impl Eq for Transaction

impl StructuralPartialEq for Transaction