Struct SighashCache

pub struct SighashCache<T>
where
    T: Deref<Target = Transaction>,
{ /* private fields */ }

Efficiently calculates signature hash message for legacy, segwit and taproot inputs.

Implementations

impl<R> SighashCache<R>

where R: Deref<Target = Transaction>,

pub fn new(tx: R) -> SighashCache<R>

Constructs a new SighashCache from an unsigned transaction.

The sighash components are computed in a lazy manner when required. For the generated sighashes to be valid, no fields in the transaction may change except for script_sig and witness.

pub fn taproot_encode_signing_data_to<Write, T>( &mut self, writer: Write, input_index: usize, prevouts: &Prevouts<'_, T>, annex: Option<Annex<'_>>, leaf_hash_code_separator: Option<(TapLeafHash, u32)>, sighash_type: SchnorrSighashType, ) -> Result<(), Error>

where Write: Write, T: Borrow<TxOut>,

Encodes the BIP341 signing data for any flag type into a given object implementing a io::Write trait.

pub fn taproot_signature_hash<T>( &mut self, input_index: usize, prevouts: &Prevouts<'_, T>, annex: Option<Annex<'_>>, leaf_hash_code_separator: Option<(TapLeafHash, u32)>, sighash_type: SchnorrSighashType, ) -> Result<TapSighashHash, Error>

where T: Borrow<TxOut>,

Computes the BIP341 sighash for any flag type.

pub fn taproot_key_spend_signature_hash<T>( &mut self, input_index: usize, prevouts: &Prevouts<'_, T>, sighash_type: SchnorrSighashType, ) -> Result<TapSighashHash, Error>

where T: Borrow<TxOut>,

Computes the BIP341 sighash for a key spend.

pub fn taproot_script_spend_signature_hash<S, T>( &mut self, input_index: usize, prevouts: &Prevouts<'_, T>, leaf_hash: S, sighash_type: SchnorrSighashType, ) -> Result<TapSighashHash, Error>

where S: Into<TapLeafHash>, T: Borrow<TxOut>,

Computes the BIP341 sighash for a script spend.

Assumes the default OP_CODESEPARATOR position of 0xFFFFFFFF. Custom values can be provided through the more fine-grained API of SighashCache::taproot_encode_signing_data_to.

pub fn segwit_encode_signing_data_to<Write>( &mut self, writer: Write, input_index: usize, script_code: &Script, value: u64, sighash_type: EcdsaSighashType, ) -> Result<(), Error>

where Write: Write,

Encodes the BIP143 signing data for any flag type into a given object implementing a std::io::Write trait.

pub fn segwit_signature_hash( &mut self, input_index: usize, script_code: &Script, value: u64, sighash_type: EcdsaSighashType, ) -> Result<Sighash, Error>

Computes the BIP143 sighash for any flag type.

pub fn legacy_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 legacy signing data for any flag type into a given object implementing a std::io::Write trait. Internally calls Transaction::encode_signing_data_to.

pub fn legacy_signature_hash( &self, input_index: usize, script_pubkey: &Script, sighash_type: u32, ) -> Result<Sighash, Error>

Computes the legacy sighash for any sighash_type.

impl<R> SighashCache<R>

where R: DerefMut<Target = Transaction>,

pub fn witness_mut(&mut self, input_index: usize) -> Option<&mut Witness>

When the SighashCache is initialized with a mutable reference to a transaction instead of a regular reference, this method is available to allow modification to the witnesses.

This allows in-line signing such as

use bitcoin::blockdata::transaction::{Transaction, EcdsaSighashType};
use bitcoin::util::sighash::SighashCache;
use bitcoin::{PackedLockTime, Script};

let mut tx_to_sign = Transaction { version: 2, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: Vec::new() };
let input_count = tx_to_sign.input.len();

let mut sig_hasher = SighashCache::new(&mut tx_to_sign);
for inp in 0..input_count {
    let prevout_script = Script::new();
    let _sighash = sig_hasher.segwit_signature_hash(inp, &prevout_script, 42, EcdsaSighashType::All);
    // ... sign the sighash
    sig_hasher.witness_mut(inp).unwrap().push(&Vec::new());
}

Trait Implementations

impl<T> Debug for SighashCache<T>

where T: Debug + Deref<Target = Transaction>,

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

Formats the value using the given formatter.