X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fchain%2Fpackage.rs;h=4604a164cd634534169e46f0df40670f346172c3;hb=c4947acaec808ff3568e3c168ac942d9cfcdb9b0;hp=e8886e5a2aa49958fcac012529a3ae4160348230;hpb=a9534fe6b53ee5a35bcedb897f03804dc17f2d39;p=rust-lightning diff --git a/lightning/src/chain/package.rs b/lightning/src/chain/package.rs index e8886e5a..4604a164 100644 --- a/lightning/src/chain/package.rs +++ b/lightning/src/chain/package.rs @@ -25,7 +25,7 @@ use crate::ln::chan_utils::{TxCreationKeys, HTLCOutputInCommitment}; use crate::ln::chan_utils; use crate::ln::msgs::DecodeError; use crate::chain::chaininterface::{FeeEstimator, ConfirmationTarget, MIN_RELAY_FEE_SAT_PER_1000_WEIGHT}; -use crate::chain::keysinterface::WriteableEcdsaChannelSigner; +use crate::sign::WriteableEcdsaChannelSigner; #[cfg(anchors)] use crate::chain::onchaintx::ExternalHTLCClaim; use crate::chain::onchaintx::OnchainTxHandler; @@ -98,10 +98,11 @@ pub(crate) struct RevokedOutput { weight: u64, amount: u64, on_counterparty_tx_csv: u16, + is_counterparty_balance_on_anchors: Option<()>, } impl RevokedOutput { - pub(crate) fn build(per_commitment_point: PublicKey, counterparty_delayed_payment_base_key: PublicKey, counterparty_htlc_base_key: PublicKey, per_commitment_key: SecretKey, amount: u64, on_counterparty_tx_csv: u16) -> Self { + pub(crate) fn build(per_commitment_point: PublicKey, counterparty_delayed_payment_base_key: PublicKey, counterparty_htlc_base_key: PublicKey, per_commitment_key: SecretKey, amount: u64, on_counterparty_tx_csv: u16, is_counterparty_balance_on_anchors: bool) -> Self { RevokedOutput { per_commitment_point, counterparty_delayed_payment_base_key, @@ -109,7 +110,8 @@ impl RevokedOutput { per_commitment_key, weight: WEIGHT_REVOKED_OUTPUT, amount, - on_counterparty_tx_csv + on_counterparty_tx_csv, + is_counterparty_balance_on_anchors: if is_counterparty_balance_on_anchors { Some(()) } else { None } } } } @@ -122,6 +124,7 @@ impl_writeable_tlv_based!(RevokedOutput, { (8, weight, required), (10, amount, required), (12, on_counterparty_tx_csv, required), + (14, is_counterparty_balance_on_anchors, option) }); /// A struct to describe a revoked offered output and corresponding information to generate a @@ -460,13 +463,13 @@ impl PackageSolvingData { } } fn absolute_tx_timelock(&self, current_height: u32) -> u32 { - // We use `current_height + 1` as our default locktime to discourage fee sniping and because + // We use `current_height` as our default locktime to discourage fee sniping and because // transactions with it always propagate. let absolute_timelock = match self { - PackageSolvingData::RevokedOutput(_) => current_height + 1, - PackageSolvingData::RevokedHTLCOutput(_) => current_height + 1, - PackageSolvingData::CounterpartyOfferedHTLCOutput(_) => current_height + 1, - PackageSolvingData::CounterpartyReceivedHTLCOutput(ref outp) => cmp::max(outp.htlc.cltv_expiry, current_height + 1), + PackageSolvingData::RevokedOutput(_) => current_height, + PackageSolvingData::RevokedHTLCOutput(_) => current_height, + PackageSolvingData::CounterpartyOfferedHTLCOutput(_) => current_height, + PackageSolvingData::CounterpartyReceivedHTLCOutput(ref outp) => cmp::max(outp.htlc.cltv_expiry, current_height), // HTLC timeout/success transactions rely on a fixed timelock due to the counterparty's // signature. PackageSolvingData::HolderHTLCOutput(ref outp) => { @@ -475,10 +478,28 @@ impl PackageSolvingData { } outp.cltv_expiry }, - PackageSolvingData::HolderFundingOutput(_) => current_height + 1, + PackageSolvingData::HolderFundingOutput(_) => current_height, }; absolute_timelock } + + fn map_output_type_flags(&self) -> (PackageMalleability, bool) { + // Post-anchor, aggregation of outputs of different types is unsafe. See https://github.com/lightning/bolts/pull/803. + let (malleability, aggregable) = match self { + PackageSolvingData::RevokedOutput(RevokedOutput { is_counterparty_balance_on_anchors: Some(()), .. }) => { (PackageMalleability::Malleable, false) }, + PackageSolvingData::RevokedOutput(RevokedOutput { is_counterparty_balance_on_anchors: None, .. }) => { (PackageMalleability::Malleable, true) }, + PackageSolvingData::RevokedHTLCOutput(..) => { (PackageMalleability::Malleable, true) }, + PackageSolvingData::CounterpartyOfferedHTLCOutput(..) => { (PackageMalleability::Malleable, true) }, + PackageSolvingData::CounterpartyReceivedHTLCOutput(..) => { (PackageMalleability::Malleable, false) }, + PackageSolvingData::HolderHTLCOutput(ref outp) => if outp.opt_anchors() { + (PackageMalleability::Malleable, outp.preimage.is_some()) + } else { + (PackageMalleability::Untractable, false) + }, + PackageSolvingData::HolderFundingOutput(..) => { (PackageMalleability::Untractable, false) }, + }; + (malleability, aggregable) + } } impl_writeable_tlv_based_enum!(PackageSolvingData, ; @@ -491,8 +512,7 @@ impl_writeable_tlv_based_enum!(PackageSolvingData, ; ); /// A malleable package might be aggregated with other packages to save on fees. -/// A untractable package has been counter-signed and aggregable will break cached counterparty -/// signatures. +/// A untractable package has been counter-signed and aggregable will break cached counterparty signatures. #[derive(Clone, PartialEq, Eq)] pub(crate) enum PackageMalleability { Malleable, @@ -538,7 +558,7 @@ pub struct PackageTemplate { feerate_previous: u64, // Cache of next height at which fee-bumping and rebroadcast will be attempted. In // the future, we might abstract it to an observed mempool fluctuation. - height_timer: Option, + height_timer: u32, // Confirmation height of the claimed outputs set transaction. In case of reorg reaching // it, we wipe out and forget the package. height_original: u32, @@ -554,16 +574,16 @@ impl PackageTemplate { pub(crate) fn aggregable(&self) -> bool { self.aggregable } + pub(crate) fn previous_feerate(&self) -> u64 { + self.feerate_previous + } pub(crate) fn set_feerate(&mut self, new_feerate: u64) { self.feerate_previous = new_feerate; } - pub(crate) fn timer(&self) -> Option { - if let Some(ref timer) = self.height_timer { - return Some(*timer); - } - None + pub(crate) fn timer(&self) -> u32 { + self.height_timer } - pub(crate) fn set_timer(&mut self, new_timer: Option) { + pub(crate) fn set_timer(&mut self, new_timer: u32) { self.height_timer = new_timer; } pub(crate) fn outpoints(&self) -> Vec<&BitcoinOutPoint> { @@ -765,16 +785,23 @@ impl PackageTemplate { /// Returns value in satoshis to be included as package outgoing output amount and feerate /// which was used to generate the value. Will not return less than `dust_limit_sats` for the /// value. - pub(crate) fn compute_package_output(&self, predicted_weight: usize, dust_limit_sats: u64, fee_estimator: &LowerBoundedFeeEstimator, logger: &L) -> Option<(u64, u64)> - where F::Target: FeeEstimator, - L::Target: Logger, + pub(crate) fn compute_package_output( + &self, predicted_weight: usize, dust_limit_sats: u64, force_feerate_bump: bool, + fee_estimator: &LowerBoundedFeeEstimator, logger: &L, + ) -> Option<(u64, u64)> + where + F::Target: FeeEstimator, + L::Target: Logger, { debug_assert!(self.malleability == PackageMalleability::Malleable, "The package output is fixed for non-malleable packages"); let input_amounts = self.package_amount(); assert!(dust_limit_sats as i64 > 0, "Output script must be broadcastable/have a 'real' dust limit."); // If old feerate is 0, first iteration of this claim, use normal fee calculation if self.feerate_previous != 0 { - if let Some((new_fee, feerate)) = feerate_bump(predicted_weight, input_amounts, self.feerate_previous, fee_estimator, logger) { + if let Some((new_fee, feerate)) = feerate_bump( + predicted_weight, input_amounts, self.feerate_previous, force_feerate_bump, + fee_estimator, logger, + ) { return Some((cmp::max(input_amounts as i64 - new_fee as i64, dust_limit_sats as i64) as u64, feerate)); } } else { @@ -787,16 +814,19 @@ impl PackageTemplate { #[cfg(anchors)] /// Computes a feerate based on the given confirmation target. If a previous feerate was used, - /// and the new feerate is below it, we'll use a 25% increase of the previous feerate instead of - /// the new one. + /// the new feerate is below it, and `force_feerate_bump` is set, we'll use a 25% increase of + /// the previous feerate instead of the new feerate. pub(crate) fn compute_package_feerate( &self, fee_estimator: &LowerBoundedFeeEstimator, conf_target: ConfirmationTarget, + force_feerate_bump: bool, ) -> u32 where F::Target: FeeEstimator { let feerate_estimate = fee_estimator.bounded_sat_per_1000_weight(conf_target); if self.feerate_previous != 0 { // If old feerate inferior to actual one given back by Fee Estimator, use it to compute new fee... if feerate_estimate as u64 > self.feerate_previous { feerate_estimate + } else if !force_feerate_bump { + self.feerate_previous.try_into().unwrap_or(u32::max_value()) } else { // ...else just increase the previous feerate by 25% (because that's a nice number) (self.feerate_previous + (self.feerate_previous / 4)).try_into().unwrap_or(u32::max_value()) @@ -816,19 +846,8 @@ impl PackageTemplate { }).is_some() } - pub (crate) fn build_package(txid: Txid, vout: u32, input_solving_data: PackageSolvingData, soonest_conf_deadline: u32, aggregable: bool, height_original: u32) -> Self { - let malleability = match input_solving_data { - PackageSolvingData::RevokedOutput(..) => PackageMalleability::Malleable, - PackageSolvingData::RevokedHTLCOutput(..) => PackageMalleability::Malleable, - PackageSolvingData::CounterpartyOfferedHTLCOutput(..) => PackageMalleability::Malleable, - PackageSolvingData::CounterpartyReceivedHTLCOutput(..) => PackageMalleability::Malleable, - PackageSolvingData::HolderHTLCOutput(ref outp) => if outp.opt_anchors() { - PackageMalleability::Malleable - } else { - PackageMalleability::Untractable - }, - PackageSolvingData::HolderFundingOutput(..) => PackageMalleability::Untractable, - }; + pub (crate) fn build_package(txid: Txid, vout: u32, input_solving_data: PackageSolvingData, soonest_conf_deadline: u32, height_original: u32) -> Self { + let (malleability, aggregable) = PackageSolvingData::map_output_type_flags(&input_solving_data); let mut inputs = Vec::with_capacity(1); inputs.push((BitcoinOutPoint { txid, vout }, input_solving_data)); PackageTemplate { @@ -837,7 +856,7 @@ impl PackageTemplate { soonest_conf_deadline, aggregable, feerate_previous: 0, - height_timer: None, + height_timer: height_original, height_original, } } @@ -854,7 +873,7 @@ impl Writeable for PackageTemplate { (0, self.soonest_conf_deadline, required), (2, self.feerate_previous, required), (4, self.height_original, required), - (6, self.height_timer, option) + (6, self.height_timer, required) }); Ok(()) } @@ -870,18 +889,7 @@ impl Readable for PackageTemplate { inputs.push((outpoint, rev_outp)); } let (malleability, aggregable) = if let Some((_, lead_input)) = inputs.first() { - match lead_input { - PackageSolvingData::RevokedOutput(..) => { (PackageMalleability::Malleable, true) }, - PackageSolvingData::RevokedHTLCOutput(..) => { (PackageMalleability::Malleable, true) }, - PackageSolvingData::CounterpartyOfferedHTLCOutput(..) => { (PackageMalleability::Malleable, true) }, - PackageSolvingData::CounterpartyReceivedHTLCOutput(..) => { (PackageMalleability::Malleable, false) }, - PackageSolvingData::HolderHTLCOutput(ref outp) => if outp.opt_anchors() { - (PackageMalleability::Malleable, outp.preimage.is_some()) - } else { - (PackageMalleability::Untractable, false) - }, - PackageSolvingData::HolderFundingOutput(..) => { (PackageMalleability::Untractable, false) }, - } + PackageSolvingData::map_output_type_flags(&lead_input) } else { return Err(DecodeError::InvalidValue); }; let mut soonest_conf_deadline = 0; let mut feerate_previous = 0; @@ -893,13 +901,16 @@ impl Readable for PackageTemplate { (4, height_original, required), (6, height_timer, option), }); + if height_timer.is_none() { + height_timer = Some(height_original); + } Ok(PackageTemplate { inputs, malleability, soonest_conf_deadline, aggregable, feerate_previous, - height_timer, + height_timer: height_timer.unwrap(), height_original, }) } @@ -945,32 +956,47 @@ fn compute_fee_from_spent_amounts(input_amounts: u64, predic /// Attempt to propose a bumping fee for a transaction from its spent output's values and predicted /// weight. If feerates proposed by the fee-estimator have been increasing since last fee-bumping -/// attempt, use them. Otherwise, blindly bump the feerate by 25% of the previous feerate. We also -/// verify that those bumping heuristics respect BIP125 rules 3) and 4) and if required adjust -/// the new fee to meet the RBF policy requirement. -fn feerate_bump(predicted_weight: usize, input_amounts: u64, previous_feerate: u64, fee_estimator: &LowerBoundedFeeEstimator, logger: &L) -> Option<(u64, u64)> - where F::Target: FeeEstimator, - L::Target: Logger, +/// attempt, use them. If `force_feerate_bump` is set, we bump the feerate by 25% of the previous +/// feerate, or just use the previous feerate otherwise. If a feerate bump did happen, we also +/// verify that those bumping heuristics respect BIP125 rules 3) and 4) and if required adjust the +/// new fee to meet the RBF policy requirement. +fn feerate_bump( + predicted_weight: usize, input_amounts: u64, previous_feerate: u64, force_feerate_bump: bool, + fee_estimator: &LowerBoundedFeeEstimator, logger: &L, +) -> Option<(u64, u64)> +where + F::Target: FeeEstimator, + L::Target: Logger, { // If old feerate inferior to actual one given back by Fee Estimator, use it to compute new fee... - let new_fee = if let Some((new_fee, _)) = compute_fee_from_spent_amounts(input_amounts, predicted_weight, fee_estimator, logger) { - let updated_feerate = new_fee / (predicted_weight as u64 * 1000); - if updated_feerate > previous_feerate { - new_fee + let (new_fee, new_feerate) = if let Some((new_fee, new_feerate)) = compute_fee_from_spent_amounts(input_amounts, predicted_weight, fee_estimator, logger) { + if new_feerate > previous_feerate { + (new_fee, new_feerate) + } else if !force_feerate_bump { + let previous_fee = previous_feerate * (predicted_weight as u64) / 1000; + (previous_fee, previous_feerate) } else { // ...else just increase the previous feerate by 25% (because that's a nice number) - let new_fee = previous_feerate * (predicted_weight as u64) / 750; - if input_amounts <= new_fee { + let bumped_feerate = previous_feerate + (previous_feerate / 4); + let bumped_fee = bumped_feerate * (predicted_weight as u64) / 1000; + if input_amounts <= bumped_fee { log_warn!(logger, "Can't 25% bump new claiming tx, amount {} is too small", input_amounts); return None; } - new_fee + (bumped_fee, bumped_feerate) } } else { log_warn!(logger, "Can't new-estimation bump new claiming tx, amount {} is too small", input_amounts); return None; }; + // Our feerates should never decrease. If it hasn't changed though, we just need to + // rebroadcast/re-sign the previous claim. + debug_assert!(new_feerate >= previous_feerate); + if new_feerate == previous_feerate { + return Some((new_fee, new_feerate)); + } + let previous_fee = previous_feerate * (predicted_weight as u64) / 1000; let min_relay_fee = MIN_RELAY_FEE_SAT_PER_1000_WEIGHT * (predicted_weight as u64) / 1000; // BIP 125 Opt-in Full Replace-by-Fee Signaling @@ -1001,11 +1027,11 @@ mod tests { use bitcoin::secp256k1::Secp256k1; macro_rules! dumb_revk_output { - ($secp_ctx: expr) => { + ($secp_ctx: expr, $is_counterparty_balance_on_anchors: expr) => { { let dumb_scalar = SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap(); let dumb_point = PublicKey::from_secret_key(&$secp_ctx, &dumb_scalar); - PackageSolvingData::RevokedOutput(RevokedOutput::build(dumb_point, dumb_point, dumb_point, dumb_scalar, 0, 0)) + PackageSolvingData::RevokedOutput(RevokedOutput::build(dumb_point, dumb_point, dumb_point, dumb_scalar, 0, 0, $is_counterparty_balance_on_anchors)) } } } @@ -1049,10 +1075,10 @@ mod tests { fn test_package_differing_heights() { let txid = Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(); let secp_ctx = Secp256k1::new(); - let revk_outp = dumb_revk_output!(secp_ctx); + let revk_outp = dumb_revk_output!(secp_ctx, false); - let mut package_one_hundred = PackageTemplate::build_package(txid, 0, revk_outp.clone(), 1000, true, 100); - let package_two_hundred = PackageTemplate::build_package(txid, 1, revk_outp.clone(), 1000, true, 200); + let mut package_one_hundred = PackageTemplate::build_package(txid, 0, revk_outp.clone(), 1000, 100); + let package_two_hundred = PackageTemplate::build_package(txid, 1, revk_outp.clone(), 1000, 200); package_one_hundred.merge_package(package_two_hundred); } @@ -1061,11 +1087,11 @@ mod tests { fn test_package_untractable_merge_to() { let txid = Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(); let secp_ctx = Secp256k1::new(); - let revk_outp = dumb_revk_output!(secp_ctx); + let revk_outp = dumb_revk_output!(secp_ctx, false); let htlc_outp = dumb_htlc_output!(); - let mut untractable_package = PackageTemplate::build_package(txid, 0, revk_outp.clone(), 1000, true, 100); - let malleable_package = PackageTemplate::build_package(txid, 1, htlc_outp.clone(), 1000, true, 100); + let mut untractable_package = PackageTemplate::build_package(txid, 0, revk_outp.clone(), 1000, 100); + let malleable_package = PackageTemplate::build_package(txid, 1, htlc_outp.clone(), 1000, 100); untractable_package.merge_package(malleable_package); } @@ -1075,10 +1101,10 @@ mod tests { let txid = Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(); let secp_ctx = Secp256k1::new(); let htlc_outp = dumb_htlc_output!(); - let revk_outp = dumb_revk_output!(secp_ctx); + let revk_outp = dumb_revk_output!(secp_ctx, false); - let mut malleable_package = PackageTemplate::build_package(txid, 0, htlc_outp.clone(), 1000, true, 100); - let untractable_package = PackageTemplate::build_package(txid, 1, revk_outp.clone(), 1000, true, 100); + let mut malleable_package = PackageTemplate::build_package(txid, 0, htlc_outp.clone(), 1000, 100); + let untractable_package = PackageTemplate::build_package(txid, 1, revk_outp.clone(), 1000, 100); malleable_package.merge_package(untractable_package); } @@ -1087,10 +1113,11 @@ mod tests { fn test_package_noaggregation_to() { let txid = Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(); let secp_ctx = Secp256k1::new(); - let revk_outp = dumb_revk_output!(secp_ctx); + let revk_outp = dumb_revk_output!(secp_ctx, false); + let revk_outp_counterparty_balance = dumb_revk_output!(secp_ctx, true); - let mut noaggregation_package = PackageTemplate::build_package(txid, 0, revk_outp.clone(), 1000, false, 100); - let aggregation_package = PackageTemplate::build_package(txid, 1, revk_outp.clone(), 1000, true, 100); + let mut noaggregation_package = PackageTemplate::build_package(txid, 0, revk_outp_counterparty_balance.clone(), 1000, 100); + let aggregation_package = PackageTemplate::build_package(txid, 1, revk_outp.clone(), 1000, 100); noaggregation_package.merge_package(aggregation_package); } @@ -1099,10 +1126,11 @@ mod tests { fn test_package_noaggregation_from() { let txid = Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(); let secp_ctx = Secp256k1::new(); - let revk_outp = dumb_revk_output!(secp_ctx); + let revk_outp = dumb_revk_output!(secp_ctx, false); + let revk_outp_counterparty_balance = dumb_revk_output!(secp_ctx, true); - let mut aggregation_package = PackageTemplate::build_package(txid, 0, revk_outp.clone(), 1000, true, 100); - let noaggregation_package = PackageTemplate::build_package(txid, 1, revk_outp.clone(), 1000, false, 100); + let mut aggregation_package = PackageTemplate::build_package(txid, 0, revk_outp.clone(), 1000, 100); + let noaggregation_package = PackageTemplate::build_package(txid, 1, revk_outp_counterparty_balance.clone(), 1000, 100); aggregation_package.merge_package(noaggregation_package); } @@ -1111,11 +1139,11 @@ mod tests { fn test_package_empty() { let txid = Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(); let secp_ctx = Secp256k1::new(); - let revk_outp = dumb_revk_output!(secp_ctx); + let revk_outp = dumb_revk_output!(secp_ctx, false); - let mut empty_package = PackageTemplate::build_package(txid, 0, revk_outp.clone(), 1000, true, 100); + let mut empty_package = PackageTemplate::build_package(txid, 0, revk_outp.clone(), 1000, 100); empty_package.inputs = vec![]; - let package = PackageTemplate::build_package(txid, 1, revk_outp.clone(), 1000, true, 100); + let package = PackageTemplate::build_package(txid, 1, revk_outp.clone(), 1000, 100); empty_package.merge_package(package); } @@ -1124,11 +1152,11 @@ mod tests { fn test_package_differing_categories() { let txid = Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(); let secp_ctx = Secp256k1::new(); - let revk_outp = dumb_revk_output!(secp_ctx); + let revk_outp = dumb_revk_output!(secp_ctx, false); let counterparty_outp = dumb_counterparty_output!(secp_ctx, 0, false); - let mut revoked_package = PackageTemplate::build_package(txid, 0, revk_outp, 1000, true, 100); - let counterparty_package = PackageTemplate::build_package(txid, 1, counterparty_outp, 1000, true, 100); + let mut revoked_package = PackageTemplate::build_package(txid, 0, revk_outp, 1000, 100); + let counterparty_package = PackageTemplate::build_package(txid, 1, counterparty_outp, 1000, 100); revoked_package.merge_package(counterparty_package); } @@ -1136,13 +1164,13 @@ mod tests { fn test_package_split_malleable() { let txid = Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(); let secp_ctx = Secp256k1::new(); - let revk_outp_one = dumb_revk_output!(secp_ctx); - let revk_outp_two = dumb_revk_output!(secp_ctx); - let revk_outp_three = dumb_revk_output!(secp_ctx); + let revk_outp_one = dumb_revk_output!(secp_ctx, false); + let revk_outp_two = dumb_revk_output!(secp_ctx, false); + let revk_outp_three = dumb_revk_output!(secp_ctx, false); - let mut package_one = PackageTemplate::build_package(txid, 0, revk_outp_one, 1000, true, 100); - let package_two = PackageTemplate::build_package(txid, 1, revk_outp_two, 1000, true, 100); - let package_three = PackageTemplate::build_package(txid, 2, revk_outp_three, 1000, true, 100); + let mut package_one = PackageTemplate::build_package(txid, 0, revk_outp_one, 1000, 100); + let package_two = PackageTemplate::build_package(txid, 1, revk_outp_two, 1000, 100); + let package_three = PackageTemplate::build_package(txid, 2, revk_outp_three, 1000, 100); package_one.merge_package(package_two); package_one.merge_package(package_three); @@ -1165,7 +1193,7 @@ mod tests { let txid = Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(); let htlc_outp_one = dumb_htlc_output!(); - let mut package_one = PackageTemplate::build_package(txid, 0, htlc_outp_one, 1000, true, 100); + let mut package_one = PackageTemplate::build_package(txid, 0, htlc_outp_one, 1000, 100); let ret_split = package_one.split_package(&BitcoinOutPoint { txid, vout: 0}); assert!(ret_split.is_none()); } @@ -1174,15 +1202,12 @@ mod tests { fn test_package_timer() { let txid = Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(); let secp_ctx = Secp256k1::new(); - let revk_outp = dumb_revk_output!(secp_ctx); - - let mut package = PackageTemplate::build_package(txid, 0, revk_outp, 1000, true, 100); - let timer_none = package.timer(); - assert!(timer_none.is_none()); - package.set_timer(Some(100)); - if let Some(timer_some) = package.timer() { - assert_eq!(timer_some, 100); - } else { panic!() } + let revk_outp = dumb_revk_output!(secp_ctx, false); + + let mut package = PackageTemplate::build_package(txid, 0, revk_outp, 1000, 100); + assert_eq!(package.timer(), 100); + package.set_timer(101); + assert_eq!(package.timer(), 101); } #[test] @@ -1191,7 +1216,7 @@ mod tests { let secp_ctx = Secp256k1::new(); let counterparty_outp = dumb_counterparty_output!(secp_ctx, 1_000_000, false); - let package = PackageTemplate::build_package(txid, 0, counterparty_outp, 1000, true, 100); + let package = PackageTemplate::build_package(txid, 0, counterparty_outp, 1000, 100); assert_eq!(package.package_amount(), 1000); } @@ -1204,15 +1229,15 @@ mod tests { let weight_sans_output = (4 + 4 + 1 + 36 + 4 + 1 + 1 + 8 + 1) * WITNESS_SCALE_FACTOR + 2; { - let revk_outp = dumb_revk_output!(secp_ctx); - let package = PackageTemplate::build_package(txid, 0, revk_outp, 0, true, 100); + let revk_outp = dumb_revk_output!(secp_ctx, false); + let package = PackageTemplate::build_package(txid, 0, revk_outp, 0, 100); assert_eq!(package.package_weight(&Script::new()), weight_sans_output + WEIGHT_REVOKED_OUTPUT as usize); } { for &opt_anchors in [false, true].iter() { let counterparty_outp = dumb_counterparty_output!(secp_ctx, 1_000_000, opt_anchors); - let package = PackageTemplate::build_package(txid, 0, counterparty_outp, 1000, true, 100); + let package = PackageTemplate::build_package(txid, 0, counterparty_outp, 1000, 100); assert_eq!(package.package_weight(&Script::new()), weight_sans_output + weight_received_htlc(opt_anchors) as usize); } } @@ -1220,7 +1245,7 @@ mod tests { { for &opt_anchors in [false, true].iter() { let counterparty_outp = dumb_counterparty_offered_output!(secp_ctx, 1_000_000, opt_anchors); - let package = PackageTemplate::build_package(txid, 0, counterparty_outp, 1000, true, 100); + let package = PackageTemplate::build_package(txid, 0, counterparty_outp, 1000, 100); assert_eq!(package.package_weight(&Script::new()), weight_sans_output + weight_offered_htlc(opt_anchors) as usize); } }