X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fchain%2Fchannelmonitor.rs;h=7e721f6307160b8a9d7db20d552932b0789e6875;hb=78c3080537a0ed54bc3b105790b046f938379a2f;hp=fb2cbaddf533a9aa56cbc8586ba7f68f997345f7;hpb=5e86bbf97030c69b0118d1bef39554febfb1cbef;p=rust-lightning diff --git a/lightning/src/chain/channelmonitor.rs b/lightning/src/chain/channelmonitor.rs index fb2cbadd..7e721f63 100644 --- a/lightning/src/chain/channelmonitor.rs +++ b/lightning/src/chain/channelmonitor.rs @@ -20,7 +20,7 @@ //! security-domain-separated system design, you should consider having multiple paths for //! ChannelMonitors to get out of the HSM and onto monitoring devices. -use bitcoin::blockdata::block::{Block, BlockHeader}; +use bitcoin::blockdata::block::BlockHeader; use bitcoin::blockdata::transaction::{TxOut,Transaction}; use bitcoin::blockdata::script::{Script, Builder}; use bitcoin::blockdata::opcodes; @@ -29,8 +29,8 @@ use bitcoin::hashes::Hash; use bitcoin::hashes::sha256::Hash as Sha256; use bitcoin::hash_types::{Txid, BlockHash, WPubkeyHash}; -use bitcoin::secp256k1::{Secp256k1,Signature}; -use bitcoin::secp256k1::key::{SecretKey,PublicKey}; +use bitcoin::secp256k1::{Secp256k1, ecdsa::Signature}; +use bitcoin::secp256k1::{SecretKey, PublicKey}; use bitcoin::secp256k1; use ln::{PaymentHash, PaymentPreimage}; @@ -166,11 +166,11 @@ pub struct HTLCUpdate { pub(crate) payment_hash: PaymentHash, pub(crate) payment_preimage: Option, pub(crate) source: HTLCSource, - pub(crate) onchain_value_satoshis: Option, + pub(crate) htlc_value_satoshis: Option, } impl_writeable_tlv_based!(HTLCUpdate, { (0, payment_hash, required), - (1, onchain_value_satoshis, option), + (1, htlc_value_satoshis, option), (2, source, required), (4, payment_preimage, option), }); @@ -357,10 +357,10 @@ enum OnchainEvent { HTLCUpdate { source: HTLCSource, payment_hash: PaymentHash, - onchain_value_satoshis: Option, + htlc_value_satoshis: Option, /// None in the second case, above, ie when there is no relevant output in the commitment /// transaction which appeared on chain. - input_idx: Option, + commitment_tx_output_idx: Option, }, MaturingOutput { descriptor: SpendableOutputDescriptor, @@ -381,7 +381,7 @@ enum OnchainEvent { /// * a revoked-state HTLC transaction was broadcasted, which was claimed by the revocation /// signature. HTLCSpendConfirmation { - input_idx: u32, + commitment_tx_output_idx: u32, /// If the claim was made by either party with a preimage, this is filled in preimage: Option, /// If the claim was made by us on an inbound HTLC against a local commitment transaction, @@ -423,9 +423,9 @@ impl MaybeReadable for OnchainEventEntry { impl_writeable_tlv_based_enum_upgradable!(OnchainEvent, (0, HTLCUpdate) => { (0, source, required), - (1, onchain_value_satoshis, option), + (1, htlc_value_satoshis, option), (2, payment_hash, required), - (3, input_idx, option), + (3, commitment_tx_output_idx, option), }, (1, MaturingOutput) => { (0, descriptor, required), @@ -434,7 +434,7 @@ impl_writeable_tlv_based_enum_upgradable!(OnchainEvent, (0, on_local_output_csv, option), }, (5, HTLCSpendConfirmation) => { - (0, input_idx, required), + (0, commitment_tx_output_idx, required), (2, preimage, option), (4, on_to_local_output_csv, option), }, @@ -568,13 +568,13 @@ pub enum Balance { /// An HTLC which has been irrevocably resolved on-chain, and has reached ANTI_REORG_DELAY. #[derive(PartialEq)] struct IrrevocablyResolvedHTLC { - input_idx: u32, + commitment_tx_output_idx: u32, /// Only set if the HTLC claim was ours using a payment preimage payment_preimage: Option, } impl_writeable_tlv_based!(IrrevocablyResolvedHTLC, { - (0, input_idx, required), + (0, commitment_tx_output_idx, required), (2, payment_preimage, option), }); @@ -1391,10 +1391,10 @@ impl ChannelMonitor { macro_rules! walk_htlcs { ($holder_commitment: expr, $htlc_iter: expr) => { for htlc in $htlc_iter { - if let Some(htlc_input_idx) = htlc.transaction_output_index { + if let Some(htlc_commitment_tx_output_idx) = htlc.transaction_output_index { if let Some(conf_thresh) = us.onchain_events_awaiting_threshold_conf.iter().find_map(|event| { if let OnchainEvent::MaturingOutput { descriptor: SpendableOutputDescriptor::DelayedPaymentOutput(descriptor) } = &event.event { - if descriptor.outpoint.index as u32 == htlc_input_idx { Some(event.confirmation_threshold()) } else { None } + if descriptor.outpoint.index as u32 == htlc_commitment_tx_output_idx { Some(event.confirmation_threshold()) } else { None } } else { None } }) { debug_assert!($holder_commitment); @@ -1402,7 +1402,7 @@ impl ChannelMonitor { claimable_amount_satoshis: htlc.amount_msat / 1000, confirmation_height: conf_thresh, }); - } else if us.htlcs_resolved_on_chain.iter().any(|v| v.input_idx == htlc_input_idx) { + } else if us.htlcs_resolved_on_chain.iter().any(|v| v.commitment_tx_output_idx == htlc_commitment_tx_output_idx) { // Funding transaction spends should be fully confirmed by the time any // HTLC transactions are resolved, unless we're talking about a holder // commitment tx, whose resolution is delayed until the CSV timeout is @@ -1414,8 +1414,9 @@ impl ChannelMonitor { // indicating we have spent this HTLC with a timeout, claiming it back // and awaiting confirmations on it. let htlc_update_pending = us.onchain_events_awaiting_threshold_conf.iter().find_map(|event| { - if let OnchainEvent::HTLCUpdate { input_idx: Some(input_idx), .. } = event.event { - if input_idx == htlc_input_idx { Some(event.confirmation_threshold()) } else { None } + if let OnchainEvent::HTLCUpdate { commitment_tx_output_idx: Some(commitment_tx_output_idx), .. } = event.event { + if commitment_tx_output_idx == htlc_commitment_tx_output_idx { + Some(event.confirmation_threshold()) } else { None } } else { None } }); if let Some(conf_thresh) = htlc_update_pending { @@ -1436,8 +1437,8 @@ impl ChannelMonitor { // preimage, we lost funds to our counterparty! We will then continue // to show it as ContentiousClaimable until ANTI_REORG_DELAY. let htlc_spend_pending = us.onchain_events_awaiting_threshold_conf.iter().find_map(|event| { - if let OnchainEvent::HTLCSpendConfirmation { input_idx, preimage, .. } = event.event { - if input_idx == htlc_input_idx { + if let OnchainEvent::HTLCSpendConfirmation { commitment_tx_output_idx, preimage, .. } = event.event { + if commitment_tx_output_idx == htlc_commitment_tx_output_idx { Some((event.confirmation_threshold(), preimage.is_some())) } else { None } } else { None } @@ -1546,7 +1547,7 @@ impl ChannelMonitor { macro_rules! walk_htlcs { ($holder_commitment: expr, $htlc_iter: expr) => { for (htlc, source) in $htlc_iter { - if us.htlcs_resolved_on_chain.iter().any(|v| Some(v.input_idx) == htlc.transaction_output_index) { + if us.htlcs_resolved_on_chain.iter().any(|v| Some(v.commitment_tx_output_idx) == htlc.transaction_output_index) { // We should assert that funding_spend_confirmed is_some() here, but we // have some unit tests which violate HTLC transaction CSVs entirely and // would fail. @@ -1557,17 +1558,17 @@ impl ChannelMonitor { // indicating we have spent this HTLC with a timeout, claiming it back // and awaiting confirmations on it. let htlc_update_confd = us.onchain_events_awaiting_threshold_conf.iter().any(|event| { - if let OnchainEvent::HTLCUpdate { input_idx: Some(input_idx), .. } = event.event { + if let OnchainEvent::HTLCUpdate { commitment_tx_output_idx: Some(commitment_tx_output_idx), .. } = event.event { // If the HTLC was timed out, we wait for ANTI_REORG_DELAY blocks // before considering it "no longer pending" - this matches when we // provide the ChannelManager an HTLC failure event. - Some(input_idx) == htlc.transaction_output_index && + Some(commitment_tx_output_idx) == htlc.transaction_output_index && us.best_block.height() >= event.height + ANTI_REORG_DELAY - 1 - } else if let OnchainEvent::HTLCSpendConfirmation { input_idx, .. } = event.event { + } else if let OnchainEvent::HTLCSpendConfirmation { commitment_tx_output_idx, .. } = event.event { // If the HTLC was fulfilled with a preimage, we consider the HTLC // immediately non-pending, matching when we provide ChannelManager // the preimage. - Some(input_idx) == htlc.transaction_output_index + Some(commitment_tx_output_idx) == htlc.transaction_output_index } else { false } }); if !htlc_update_confd { @@ -1688,8 +1689,8 @@ macro_rules! fail_unbroadcast_htlcs { event: OnchainEvent::HTLCUpdate { source: (**source).clone(), payment_hash: htlc.payment_hash.clone(), - onchain_value_satoshis: Some(htlc.amount_msat / 1000), - input_idx: None, + htlc_value_satoshis: Some(htlc.amount_msat / 1000), + commitment_tx_output_idx: None, }, }; log_trace!($logger, "Failing HTLC with payment_hash {} from {} counterparty commitment tx due to broadcast of {} commitment transaction, waiting for confirmation (at height {})", @@ -2522,7 +2523,7 @@ impl ChannelMonitorImpl { // Produce actionable events from on-chain events having reached their threshold. for entry in onchain_events_reaching_threshold_conf.drain(..) { match entry.event { - OnchainEvent::HTLCUpdate { ref source, payment_hash, onchain_value_satoshis, input_idx } => { + OnchainEvent::HTLCUpdate { ref source, payment_hash, htlc_value_satoshis, commitment_tx_output_idx } => { // Check for duplicate HTLC resolutions. #[cfg(debug_assertions)] { @@ -2544,10 +2545,10 @@ impl ChannelMonitorImpl { payment_hash, payment_preimage: None, source: source.clone(), - onchain_value_satoshis, + htlc_value_satoshis, })); - if let Some(idx) = input_idx { - self.htlcs_resolved_on_chain.push(IrrevocablyResolvedHTLC { input_idx: idx, payment_preimage: None }); + if let Some(idx) = commitment_tx_output_idx { + self.htlcs_resolved_on_chain.push(IrrevocablyResolvedHTLC { commitment_tx_output_idx: idx, payment_preimage: None }); } }, OnchainEvent::MaturingOutput { descriptor } => { @@ -2556,8 +2557,8 @@ impl ChannelMonitorImpl { outputs: vec![descriptor] }); }, - OnchainEvent::HTLCSpendConfirmation { input_idx, preimage, .. } => { - self.htlcs_resolved_on_chain.push(IrrevocablyResolvedHTLC { input_idx, payment_preimage: preimage }); + OnchainEvent::HTLCSpendConfirmation { commitment_tx_output_idx, preimage, .. } => { + self.htlcs_resolved_on_chain.push(IrrevocablyResolvedHTLC { commitment_tx_output_idx, payment_preimage: preimage }); }, OnchainEvent::FundingSpendConfirmation { .. } => { self.funding_spend_confirmed = Some(entry.txid); @@ -2653,7 +2654,7 @@ impl ChannelMonitorImpl { // appears to be spending the correct type (ie that the match would // actually succeed in BIP 158/159-style filters). if _script_pubkey.is_v0_p2wsh() { - assert_eq!(&bitcoin::Address::p2wsh(&Script::from(input.witness.last().unwrap().clone()), bitcoin::Network::Bitcoin).script_pubkey(), _script_pubkey); + assert_eq!(&bitcoin::Address::p2wsh(&Script::from(input.witness.last().unwrap().to_vec()), bitcoin::Network::Bitcoin).script_pubkey(), _script_pubkey); } else if _script_pubkey.is_v0_p2wpkh() { assert_eq!(&bitcoin::Address::p2wpkh(&bitcoin::PublicKey::from_slice(&input.witness.last().unwrap()).unwrap(), bitcoin::Network::Bitcoin).unwrap().script_pubkey(), _script_pubkey); } else { panic!(); } @@ -2736,20 +2737,23 @@ impl ChannelMonitorImpl { fn is_resolving_htlc_output(&mut self, tx: &Transaction, height: u32, logger: &L) where L::Target: Logger { 'outer_loop: for input in &tx.input { let mut payment_data = None; - let revocation_sig_claim = (input.witness.len() == 3 && HTLCType::scriptlen_to_htlctype(input.witness[2].len()) == Some(HTLCType::OfferedHTLC) && input.witness[1].len() == 33) - || (input.witness.len() == 3 && HTLCType::scriptlen_to_htlctype(input.witness[2].len()) == Some(HTLCType::AcceptedHTLC) && input.witness[1].len() == 33); - let accepted_preimage_claim = input.witness.len() == 5 && HTLCType::scriptlen_to_htlctype(input.witness[4].len()) == Some(HTLCType::AcceptedHTLC); + let witness_items = input.witness.len(); + let htlctype = input.witness.last().map(|w| w.len()).and_then(HTLCType::scriptlen_to_htlctype); + let prev_last_witness_len = input.witness.second_to_last().map(|w| w.len()).unwrap_or(0); + let revocation_sig_claim = (witness_items == 3 && htlctype == Some(HTLCType::OfferedHTLC) && prev_last_witness_len == 33) + || (witness_items == 3 && htlctype == Some(HTLCType::AcceptedHTLC) && prev_last_witness_len == 33); + let accepted_preimage_claim = witness_items == 5 && htlctype == Some(HTLCType::AcceptedHTLC); #[cfg(not(fuzzing))] - let accepted_timeout_claim = input.witness.len() == 3 && HTLCType::scriptlen_to_htlctype(input.witness[2].len()) == Some(HTLCType::AcceptedHTLC) && !revocation_sig_claim; - let offered_preimage_claim = input.witness.len() == 3 && HTLCType::scriptlen_to_htlctype(input.witness[2].len()) == Some(HTLCType::OfferedHTLC) && !revocation_sig_claim; + let accepted_timeout_claim = witness_items == 3 && htlctype == Some(HTLCType::AcceptedHTLC) && !revocation_sig_claim; + let offered_preimage_claim = witness_items == 3 && htlctype == Some(HTLCType::OfferedHTLC) && !revocation_sig_claim; #[cfg(not(fuzzing))] - let offered_timeout_claim = input.witness.len() == 5 && HTLCType::scriptlen_to_htlctype(input.witness[4].len()) == Some(HTLCType::OfferedHTLC); + let offered_timeout_claim = witness_items == 5 && htlctype == Some(HTLCType::OfferedHTLC); let mut payment_preimage = PaymentPreimage([0; 32]); if accepted_preimage_claim { - payment_preimage.0.copy_from_slice(&input.witness[3]); + payment_preimage.0.copy_from_slice(input.witness.second_to_last().unwrap()); } else if offered_preimage_claim { - payment_preimage.0.copy_from_slice(&input.witness[1]); + payment_preimage.0.copy_from_slice(input.witness.second_to_last().unwrap()); } macro_rules! log_claim { @@ -2823,7 +2827,7 @@ impl ChannelMonitorImpl { self.onchain_events_awaiting_threshold_conf.push(OnchainEventEntry { txid: tx.txid(), height, event: OnchainEvent::HTLCSpendConfirmation { - input_idx: input.previous_output.vout, + commitment_tx_output_idx: input.previous_output.vout, preimage: if accepted_preimage_claim || offered_preimage_claim { Some(payment_preimage) } else { None }, // If this is a payment to us (!outbound_htlc, above), @@ -2874,7 +2878,7 @@ impl ChannelMonitorImpl { txid: tx.txid(), height, event: OnchainEvent::HTLCSpendConfirmation { - input_idx: input.previous_output.vout, + commitment_tx_output_idx: input.previous_output.vout, preimage: Some(payment_preimage), on_to_local_output_csv: None, }, @@ -2883,7 +2887,7 @@ impl ChannelMonitorImpl { source, payment_preimage: Some(payment_preimage), payment_hash, - onchain_value_satoshis: Some(amount_msat / 1000), + htlc_value_satoshis: Some(amount_msat / 1000), })); } } else if offered_preimage_claim { @@ -2895,7 +2899,7 @@ impl ChannelMonitorImpl { txid: tx.txid(), height, event: OnchainEvent::HTLCSpendConfirmation { - input_idx: input.previous_output.vout, + commitment_tx_output_idx: input.previous_output.vout, preimage: Some(payment_preimage), on_to_local_output_csv: None, }, @@ -2904,7 +2908,7 @@ impl ChannelMonitorImpl { source, payment_preimage: Some(payment_preimage), payment_hash, - onchain_value_satoshis: Some(amount_msat / 1000), + htlc_value_satoshis: Some(amount_msat / 1000), })); } } else { @@ -2922,8 +2926,8 @@ impl ChannelMonitorImpl { height, event: OnchainEvent::HTLCUpdate { source, payment_hash, - onchain_value_satoshis: Some(amount_msat / 1000), - input_idx: Some(input.previous_output.vout), + htlc_value_satoshis: Some(amount_msat / 1000), + commitment_tx_output_idx: Some(input.previous_output.vout), }, }; log_info!(logger, "Failing HTLC with payment_hash {} timeout by a spend tx, waiting for confirmation (at height {})", log_bytes!(payment_hash.0), entry.confirmation_threshold()); @@ -3007,9 +3011,8 @@ where F::Target: FeeEstimator, L::Target: Logger, { - fn block_connected(&self, block: &Block, height: u32) { - let txdata: Vec<_> = block.txdata.iter().enumerate().collect(); - self.0.block_connected(&block.header, &txdata, height, &*self.1, &*self.2, &*self.3); + fn filtered_block_connected(&self, header: &BlockHeader, txdata: &TransactionData, height: u32) { + self.0.block_connected(header, txdata, height, &*self.1, &*self.2, &*self.3); } fn block_disconnected(&self, header: &BlockHeader, height: u32) { @@ -3323,15 +3326,15 @@ mod tests { use bitcoin::blockdata::block::BlockHeader; use bitcoin::blockdata::script::{Script, Builder}; use bitcoin::blockdata::opcodes; - use bitcoin::blockdata::transaction::{Transaction, TxIn, TxOut, SigHashType}; + use bitcoin::blockdata::transaction::{Transaction, TxIn, TxOut, EcdsaSighashType}; use bitcoin::blockdata::transaction::OutPoint as BitcoinOutPoint; - use bitcoin::util::bip143; + use bitcoin::util::sighash; use bitcoin::hashes::Hash; use bitcoin::hashes::sha256::Hash as Sha256; use bitcoin::hashes::hex::FromHex; use bitcoin::hash_types::{BlockHash, Txid}; use bitcoin::network::constants::Network; - use bitcoin::secp256k1::key::{SecretKey,PublicKey}; + use bitcoin::secp256k1::{SecretKey,PublicKey}; use bitcoin::secp256k1::Secp256k1; use hex; @@ -3356,6 +3359,7 @@ mod tests { use util::ser::{ReadableArgs, Writeable}; use sync::{Arc, Mutex}; use io; + use bitcoin::Witness; use prelude::*; fn do_test_funding_spend_refuses_updates(use_local_txn: bool) { @@ -3609,24 +3613,27 @@ mod tests { transaction_output_index: Some($idx as u32), }; let redeem_script = if *$weight == WEIGHT_REVOKED_OUTPUT { chan_utils::get_revokeable_redeemscript(&pubkey, 256, &pubkey) } else { chan_utils::get_htlc_redeemscript_with_explicit_keys(&htlc, $opt_anchors, &pubkey, &pubkey, &pubkey) }; - let sighash = hash_to_message!(&$sighash_parts.signature_hash($idx, &redeem_script, $amount, SigHashType::All)[..]); - let sig = secp_ctx.sign(&sighash, &privkey); - $sighash_parts.access_witness($idx).push(sig.serialize_der().to_vec()); - $sighash_parts.access_witness($idx)[0].push(SigHashType::All as u8); - $sum_actual_sigs += $sighash_parts.access_witness($idx)[0].len(); + let sighash = hash_to_message!(&$sighash_parts.segwit_signature_hash($idx, &redeem_script, $amount, EcdsaSighashType::All).unwrap()[..]); + let sig = secp_ctx.sign_ecdsa(&sighash, &privkey); + let mut ser_sig = sig.serialize_der().to_vec(); + ser_sig.push(EcdsaSighashType::All as u8); + $sum_actual_sigs += ser_sig.len(); + let witness = $sighash_parts.witness_mut($idx).unwrap(); + witness.push(ser_sig); if *$weight == WEIGHT_REVOKED_OUTPUT { - $sighash_parts.access_witness($idx).push(vec!(1)); + witness.push(vec!(1)); } else if *$weight == weight_revoked_offered_htlc($opt_anchors) || *$weight == weight_revoked_received_htlc($opt_anchors) { - $sighash_parts.access_witness($idx).push(pubkey.clone().serialize().to_vec()); + witness.push(pubkey.clone().serialize().to_vec()); } else if *$weight == weight_received_htlc($opt_anchors) { - $sighash_parts.access_witness($idx).push(vec![0]); + witness.push(vec![0]); } else { - $sighash_parts.access_witness($idx).push(PaymentPreimage([1; 32]).0.to_vec()); + witness.push(PaymentPreimage([1; 32]).0.to_vec()); } - $sighash_parts.access_witness($idx).push(redeem_script.into_bytes()); - println!("witness[0] {}", $sighash_parts.access_witness($idx)[0].len()); - println!("witness[1] {}", $sighash_parts.access_witness($idx)[1].len()); - println!("witness[2] {}", $sighash_parts.access_witness($idx)[2].len()); + witness.push(redeem_script.into_bytes()); + let witness = witness.to_vec(); + println!("witness[0] {}", witness[0].len()); + println!("witness[1] {}", witness[1].len()); + println!("witness[2] {}", witness[2].len()); } } @@ -3645,24 +3652,24 @@ mod tests { }, script_sig: Script::new(), sequence: 0xfffffffd, - witness: Vec::new(), + witness: Witness::new(), }); } claim_tx.output.push(TxOut { script_pubkey: script_pubkey.clone(), value: 0, }); - let base_weight = claim_tx.get_weight(); + let base_weight = claim_tx.weight(); let inputs_weight = vec![WEIGHT_REVOKED_OUTPUT, weight_revoked_offered_htlc(opt_anchors), weight_revoked_offered_htlc(opt_anchors), weight_revoked_received_htlc(opt_anchors)]; let mut inputs_total_weight = 2; // count segwit flags { - let mut sighash_parts = bip143::SigHashCache::new(&mut claim_tx); + let mut sighash_parts = sighash::SighashCache::new(&mut claim_tx); for (idx, inp) in inputs_weight.iter().enumerate() { sign_input!(sighash_parts, idx, 0, inp, sum_actual_sigs, opt_anchors); inputs_total_weight += inp; } } - assert_eq!(base_weight + inputs_total_weight as usize, claim_tx.get_weight() + /* max_length_sig */ (73 * inputs_weight.len() - sum_actual_sigs)); + assert_eq!(base_weight + inputs_total_weight as usize, claim_tx.weight() + /* max_length_sig */ (73 * inputs_weight.len() - sum_actual_sigs)); } // Claim tx with 1 offered HTLCs, 3 received HTLCs @@ -3677,24 +3684,24 @@ mod tests { }, script_sig: Script::new(), sequence: 0xfffffffd, - witness: Vec::new(), + witness: Witness::new(), }); } claim_tx.output.push(TxOut { script_pubkey: script_pubkey.clone(), value: 0, }); - let base_weight = claim_tx.get_weight(); + let base_weight = claim_tx.weight(); let inputs_weight = vec![weight_offered_htlc(opt_anchors), weight_received_htlc(opt_anchors), weight_received_htlc(opt_anchors), weight_received_htlc(opt_anchors)]; let mut inputs_total_weight = 2; // count segwit flags { - let mut sighash_parts = bip143::SigHashCache::new(&mut claim_tx); + let mut sighash_parts = sighash::SighashCache::new(&mut claim_tx); for (idx, inp) in inputs_weight.iter().enumerate() { sign_input!(sighash_parts, idx, 0, inp, sum_actual_sigs, opt_anchors); inputs_total_weight += inp; } } - assert_eq!(base_weight + inputs_total_weight as usize, claim_tx.get_weight() + /* max_length_sig */ (73 * inputs_weight.len() - sum_actual_sigs)); + assert_eq!(base_weight + inputs_total_weight as usize, claim_tx.weight() + /* max_length_sig */ (73 * inputs_weight.len() - sum_actual_sigs)); } // Justice tx with 1 revoked HTLC-Success tx output @@ -3708,23 +3715,23 @@ mod tests { }, script_sig: Script::new(), sequence: 0xfffffffd, - witness: Vec::new(), + witness: Witness::new(), }); claim_tx.output.push(TxOut { script_pubkey: script_pubkey.clone(), value: 0, }); - let base_weight = claim_tx.get_weight(); + let base_weight = claim_tx.weight(); let inputs_weight = vec![WEIGHT_REVOKED_OUTPUT]; let mut inputs_total_weight = 2; // count segwit flags { - let mut sighash_parts = bip143::SigHashCache::new(&mut claim_tx); + let mut sighash_parts = sighash::SighashCache::new(&mut claim_tx); for (idx, inp) in inputs_weight.iter().enumerate() { sign_input!(sighash_parts, idx, 0, inp, sum_actual_sigs, opt_anchors); inputs_total_weight += inp; } } - assert_eq!(base_weight + inputs_total_weight as usize, claim_tx.get_weight() + /* max_length_isg */ (73 * inputs_weight.len() - sum_actual_sigs)); + assert_eq!(base_weight + inputs_total_weight as usize, claim_tx.weight() + /* max_length_isg */ (73 * inputs_weight.len() - sum_actual_sigs)); } }