Struct bitcoin::util::bip143::SigHashCache

pub struct SigHashCache<R: Deref<Target = Transaction>> { /* private fields */ }

👎Deprecated since 0.28.0: please use [sighash::SighashCache] instead

A replacement for SigHashComponents which supports all sighash modes

Implementations

impl<R: Deref<Target = Transaction>> SigHashCache<R>

pub fn new(tx: R) -> Self

Compute the sighash components from an unsigned transaction and auxiliary 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 witnesses.

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

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

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

Compute the BIP143 sighash for any flag type. See SighashComponents::sighash_all simpler API for the most common case

impl<R: DerefMut<Target = Transaction>> SigHashCache<R>

pub fn access_witness(&mut self, input_index: usize) -> &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

panics if input_index is out of bounds with respect of the number of inputs

use bitcoin::blockdata::transaction::{Transaction, EcdsaSighashType};
use bitcoin::util::bip143::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.signature_hash(inp, &prevout_script, 42, EcdsaSighashType::All);
    // ... sign the sighash
    sig_hasher.access_witness(inp).push(&[]);
}