Struct bitcoins::builder::BitcoinTxBuilder

pub struct BitcoinTxBuilder<T: AddressEncoder> { /* private fields */ }

This is a generic builder for Bitcoin transactions. It allows you to easily build legacy and witness transactions.

Note: due to Bitcoin consensus rules, the order of inputs and outputs may be semantically meaningful. E.g. when signing a transaction with the SINGLE sighash mode.

It is parameterized with an address encoder, so that the same struct and logic can be used on mainnet and testnet.

Implementations

impl<T> BitcoinTxBuilder<T> where
    T: BitcoinEncoderMarker, 

pub fn extend_witnesses<I>(self, witnesses: I) -> Self where
    I: IntoIterator<Item = Witness>, 

Add a set of witnesses to the transaction, and return a witness builder.

pub fn insert_witness(
    self,
    index: usize,
    witness: <<Self as TxBuilder>::Transaction as Transaction>::TxIn
) -> Self

Insert a witness at a speicified index

pub fn op_return(self, message: &[u8]) -> Self

Add an op_return output. Using this twice may render the transaction non-standard.

pub fn set_script_sig(self, input_idx: usize, script_sig: ScriptSig) -> Self

Set the script sig at a specific input. Do nothing if the vin is not that long.

pub fn build_legacy(
    self
) -> Result<LegacyTx, <LegacyTx as Transaction>::TxError>

Consume self, produce a legacy tx. Discard any witness information in the builder

pub fn build_witness(
    self
) -> Result<WitnessTx, <WitnessTx as Transaction>::TxError>

Consume self, produce a witness tx

pub fn pay_script_pubkey(self, value: u64, script_pubkey: ScriptPubkey) -> Self

Add an output paying value to script_pubkey

Trait Implementations

impl<T: Clone + AddressEncoder> Clone for BitcoinTxBuilder<T>

fn clone(&self) -> BitcoinTxBuilder<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + AddressEncoder> Debug for BitcoinTxBuilder<T>

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

Formats the value using the given formatter.

impl<T: PartialEq + AddressEncoder> PartialEq<BitcoinTxBuilder<T>> for BitcoinTxBuilder<T>

fn eq(&self, other: &BitcoinTxBuilder<T>) -> bool

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

fn ne(&self, other: &BitcoinTxBuilder<T>) -> bool

This method tests for !=.

impl<T> TxBuilder for BitcoinTxBuilder<T> where
    T: BitcoinEncoderMarker, 

type Encoder = T

An AddressEncoder that handles encoding and decoding network addresses. This is used in the pay function to decode addresses into associated RecipientIdentifiers.

type Transaction = BitcoinTx

The Transaction type returned by build()

fn new() -> Self

Instantiate a new builder

fn from_tx(tx: Self::Transaction) -> Self

Instantiate a new builder from a transaction by taking ownership of its properties

fn from_tx_ref(tx: &Self::Transaction) -> Self

Instantiate a new builder from a transaction reference by cloning its properties

fn version(self, version: u32) -> Self

Set or overwrite the transaction version.

fn spend<I>(self, prevout: I, sequence: u32) -> Self where
    I: Into<BitcoinOutpoint>, 

Spend an outpoint. Adds an unsigned input spending the associated outpoint with the specified sequence number.

fn pay(self, value: u64, address: &Address) -> Self

Pay an Address. Adds an output paying value to address.

fn insert_input(
    self,
    index: usize,
    input: <Self::Transaction as Transaction>::TxIn
) -> Self

Insert an input at the specified index. Inputs after that are shifted to later indices.

fn extend_inputs<I>(self, inputs: I) -> Self where
    I: IntoIterator<Item = BitcoinTxIn>, 

Add a set of inputs to the transaction.

fn insert_output(
    self,
    index: usize,
    output: <Self::Transaction as Transaction>::TxOut
) -> Self

Insert an output at the specified index. Outputs after that are shifted to later indices.

fn extend_outputs<I>(self, outputs: I) -> Self where
    I: IntoIterator<Item = TxOut>, 

Add a set of outputs to the transaction.

fn locktime(self, locktime: u32) -> Self

Set or overwrite the transaction locktime.

fn build(
    self
) -> Result<Self::Transaction, <Self::Transaction as Transaction>::TxError>

Consume the builder and produce a transaction from the builder’s current state.

fn read_from_tx<R>(
    reader: &mut R
) -> Result<Self, <Self::Transaction as Transaction>::TxError> where
    R: Read, 

Instantiate a new builder from a std::io::Read that contains a serialized tx

fn from_hex_tx(
    hex_str: &str
) -> Result<Self, <Self::Transaction as Transaction>::TxError>

Instantiate a new builder from transaction hex

impl<T: Eq + AddressEncoder> Eq for BitcoinTxBuilder<T>

impl<T: AddressEncoder> StructuralEq for BitcoinTxBuilder<T>

impl<T: AddressEncoder> StructuralPartialEq for BitcoinTxBuilder<T>