Struct Transaction

pub struct Transaction(/* private fields */);

Bitcoin transaction. An authenticated movement of coins.

Implementations

impl Transaction

pub fn new(transaction_bytes: Vec<u8>) -> Result<Self, TransactionError>

Creates a new Transaction instance from serialized transaction bytes.

pub fn compute_txid(&self) -> Arc<Txid>

Computes the Txid. Hashes the transaction excluding the segwit data (i.e. the marker, flag bytes, and the witness fields themselves).

pub fn compute_wtxid(&self) -> Arc<Wtxid>

Compute the Wtxid, which includes the witness in the transaction hash.

pub fn weight(&self) -> u64

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 total_size(&self) -> u64

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

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.

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_lock_time_enabled(&self) -> bool

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

pub fn version(&self) -> i32

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

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

Serialize transaction into consensus-valid format. See https://docs.rs/bitcoin/latest/bitcoin/struct.Transaction.html#serialization-notes for more notes on transaction serialization.

pub fn input(&self) -> Vec<TxIn>

List of transaction inputs.

pub fn output(&self) -> Vec<TxOut>

List of transaction outputs.

pub fn lock_time(&self) -> u32

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

Trait Implementations

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

Formats the value using the given formatter.

impl Display for Transaction

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

Formats the value using the given formatter.

impl From<&Transaction> for Transaction

fn from(tx: &BdkTransaction) -> Self

Converts to this type from the input type.

impl From<&Transaction> for Transaction

fn from(tx: &Transaction) -> Self

Converts to this type from the input type.

impl From<Transaction> for Transaction

fn from(tx: BdkTransaction) -> Self

Converts to this type from the input type.

impl<UT> LiftRef<UT> for Transaction

type LiftType = Arc<Transaction>

impl<UT> LowerError<UT> for Transaction

fn lower_error(obj: Self) -> RustBuffer

Lower this value for scaffolding function return

impl<UT> LowerReturn<UT> for Transaction

type ReturnType = <Arc<Transaction> as LowerReturn<UniFfiTag>>::ReturnType

The type that should be returned by scaffolding functions for this type.

fn lower_return(obj: Self) -> Result<Self::ReturnType, RustCallError>

Lower the return value from an scaffolding call

fn handle_failed_lift( error: LiftArgsError, ) -> Result<Self::ReturnType, RustCallError>

Lower the return value for failed argument lifts

impl PartialEq for Transaction

fn eq(&self, other: &Transaction) -> 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<UT> TypeId<UT> for Transaction

const TYPE_ID_META: MetadataBuffer

impl Eq for Transaction

impl StructuralPartialEq for Transaction