use bitcoin::secp256k1::key::{SecretKey,PublicKey};
use ln::PaymentPreimage;
-use ln::chan_utils::{TxCreationKeys, HTLCOutputInCommitment, HTLC_OUTPUT_IN_COMMITMENT_SIZE};
+use ln::chan_utils::{TxCreationKeys, HTLCOutputInCommitment};
use ln::chan_utils;
use ln::msgs::DecodeError;
use chain::chaininterface::{FeeEstimator, ConfirmationTarget, MIN_RELAY_FEE_SAT_PER_1000_WEIGHT};
use util::logger::Logger;
use util::ser::{Readable, Writer, Writeable};
-use std::cmp;
-use std::mem;
-use std::ops::Deref;
+use io;
+use prelude::*;
+use core::cmp;
+use core::mem;
+use core::ops::Deref;
const MAX_ALLOC_SIZE: usize = 64*1024;
// number_of_witness_elements + sig_length + revocation_sig + true_length + op_true + witness_script_length + witness_script
pub(crate) const WEIGHT_REVOKED_OUTPUT: u64 = 1 + 1 + 73 + 1 + 1 + 1 + 77;
+/// Height delay at which transactions are fee-bumped/rebroadcasted with a low priority.
+const LOW_FREQUENCY_BUMP_INTERVAL: u32 = 15;
+/// Height delay at which transactions are fee-bumped/rebroadcasted with a middle priority.
+const MIDDLE_FREQUENCY_BUMP_INTERVAL: u32 = 3;
+/// Height delay at which transactions are fee-bumped/rebroadcasted with a high priority.
+const HIGH_FREQUENCY_BUMP_INTERVAL: u32 = 1;
+
/// A struct to describe a revoked output and corresponding information to generate a solving
/// witness spending a commitment `to_local` output or a second-stage HTLC transaction output.
///
}
}
-impl_writeable!(RevokedOutput, 33*3 + 32 + 8 + 8 + 2, {
- per_commitment_point,
- counterparty_delayed_payment_base_key,
- counterparty_htlc_base_key,
- per_commitment_key,
- weight,
- amount,
- on_counterparty_tx_csv
+impl_writeable_tlv_based!(RevokedOutput, {
+ (0, per_commitment_point, required),
+ (2, counterparty_delayed_payment_base_key, required),
+ (4, counterparty_htlc_base_key, required),
+ (6, per_commitment_key, required),
+ (8, weight, required),
+ (10, amount, required),
+ (12, on_counterparty_tx_csv, required),
});
/// A struct to describe a revoked offered output and corresponding information to generate a
}
}
-impl_writeable!(RevokedHTLCOutput, 33*3 + 32 + 8 + 8 + HTLC_OUTPUT_IN_COMMITMENT_SIZE, {
- per_commitment_point,
- counterparty_delayed_payment_base_key,
- counterparty_htlc_base_key,
- per_commitment_key,
- weight,
- amount,
- htlc
+impl_writeable_tlv_based!(RevokedHTLCOutput, {
+ (0, per_commitment_point, required),
+ (2, counterparty_delayed_payment_base_key, required),
+ (4, counterparty_htlc_base_key, required),
+ (6, per_commitment_key, required),
+ (8, weight, required),
+ (10, amount, required),
+ (12, htlc, required),
});
/// A struct to describe a HTLC output on a counterparty commitment transaction.
}
}
-impl_writeable!(CounterpartyOfferedHTLCOutput, 33*3 + 32 + HTLC_OUTPUT_IN_COMMITMENT_SIZE, {
- per_commitment_point,
- counterparty_delayed_payment_base_key,
- counterparty_htlc_base_key,
- preimage,
- htlc
+impl_writeable_tlv_based!(CounterpartyOfferedHTLCOutput, {
+ (0, per_commitment_point, required),
+ (2, counterparty_delayed_payment_base_key, required),
+ (4, counterparty_htlc_base_key, required),
+ (6, preimage, required),
+ (8, htlc, required),
});
/// A struct to describe a HTLC output on a counterparty commitment transaction.
}
}
-impl_writeable!(CounterpartyReceivedHTLCOutput, 33*3 + HTLC_OUTPUT_IN_COMMITMENT_SIZE, {
- per_commitment_point,
- counterparty_delayed_payment_base_key,
- counterparty_htlc_base_key,
- htlc
+impl_writeable_tlv_based!(CounterpartyReceivedHTLCOutput, {
+ (0, per_commitment_point, required),
+ (2, counterparty_delayed_payment_base_key, required),
+ (4, counterparty_htlc_base_key, required),
+ (6, htlc, required),
});
/// A struct to describe a HTLC output on holder commitment transaction.
pub(crate) struct HolderHTLCOutput {
preimage: Option<PaymentPreimage>,
amount: u64,
+ /// Defaults to 0 for HTLC-Success transactions, which have no expiry
+ cltv_expiry: u32,
}
impl HolderHTLCOutput {
- pub(crate) fn build(preimage: Option<PaymentPreimage>, amount: u64) -> Self {
+ pub(crate) fn build_offered(amount: u64, cltv_expiry: u32) -> Self {
HolderHTLCOutput {
- preimage,
- amount
+ preimage: None,
+ amount,
+ cltv_expiry,
+ }
+ }
+
+ pub(crate) fn build_accepted(preimage: PaymentPreimage, amount: u64) -> Self {
+ HolderHTLCOutput {
+ preimage: Some(preimage),
+ amount,
+ cltv_expiry: 0,
}
}
}
-impl_writeable!(HolderHTLCOutput, 0, {
- preimage,
- amount
+impl_writeable_tlv_based!(HolderHTLCOutput, {
+ (0, amount, required),
+ (2, cltv_expiry, required),
+ (4, preimage, option)
});
/// A struct to describe the channel output on the funding transaction.
}
}
-impl_writeable!(HolderFundingOutput, 0, {
- funding_redeemscript
+impl_writeable_tlv_based!(HolderFundingOutput, {
+ (0, funding_redeemscript, required),
});
/// A wrapper encapsulating all in-protocol differing outputs types.
// Note: Currently, amounts of holder outputs spending witnesses aren't used
// as we can't malleate spending package to increase their feerate. This
// should change with the remaining anchor output patchset.
- PackageSolvingData::HolderHTLCOutput(..) => { 0 },
- PackageSolvingData::HolderFundingOutput(..) => { 0 },
+ PackageSolvingData::HolderHTLCOutput(..) => { unreachable!() },
+ PackageSolvingData::HolderFundingOutput(..) => { unreachable!() },
};
amt
}
// Note: Currently, weights of holder outputs spending witnesses aren't used
// as we can't malleate spending package to increase their feerate. This
// should change with the remaining anchor output patchset.
- PackageSolvingData::HolderHTLCOutput(..) => { debug_assert!(false); 0 },
- PackageSolvingData::HolderFundingOutput(..) => { debug_assert!(false); 0 },
+ PackageSolvingData::HolderHTLCOutput(..) => { unreachable!() },
+ PackageSolvingData::HolderFundingOutput(..) => { unreachable!() },
};
weight
}
_ => { panic!("API Error!"); }
}
}
-}
-
-impl Writeable for PackageSolvingData {
- fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
- match self {
- PackageSolvingData::RevokedOutput(ref revoked_outp) => {
- 0u8.write(writer)?;
- revoked_outp.write(writer)?;
- },
- PackageSolvingData::RevokedHTLCOutput(ref revoked_outp) => {
- 1u8.write(writer)?;
- revoked_outp.write(writer)?;
- },
- PackageSolvingData::CounterpartyOfferedHTLCOutput(ref counterparty_outp) => {
- 2u8.write(writer)?;
- counterparty_outp.write(writer)?;
- },
- PackageSolvingData::CounterpartyReceivedHTLCOutput(ref counterparty_outp) => {
- 3u8.write(writer)?;
- counterparty_outp.write(writer)?;
- },
- PackageSolvingData::HolderHTLCOutput(ref holder_outp) => {
- 4u8.write(writer)?;
- holder_outp.write(writer)?;
- },
- PackageSolvingData::HolderFundingOutput(ref funding_outp) => {
- 5u8.write(writer)?;
- funding_outp.write(writer)?;
- }
- }
- Ok(())
- }
-}
-
-impl Readable for PackageSolvingData {
- fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
- let byte = <u8 as Readable>::read(reader)?;
- let solving_data = match byte {
- 0 => {
- PackageSolvingData::RevokedOutput(Readable::read(reader)?)
- },
- 1 => {
- PackageSolvingData::RevokedHTLCOutput(Readable::read(reader)?)
- },
- 2 => {
- PackageSolvingData::CounterpartyOfferedHTLCOutput(Readable::read(reader)?)
- },
- 3 => {
- PackageSolvingData::CounterpartyReceivedHTLCOutput(Readable::read(reader)?)
- },
- 4 => {
- PackageSolvingData::HolderHTLCOutput(Readable::read(reader)?)
- },
- 5 => {
- PackageSolvingData::HolderFundingOutput(Readable::read(reader)?)
- }
- _ => return Err(DecodeError::UnknownVersion)
+ fn absolute_tx_timelock(&self, output_conf_height: u32) -> u32 {
+ // Get the absolute timelock at which this output can be spent given the height at which
+ // this output was confirmed. We use `output_conf_height + 1` as a safe default as we can
+ // be confirmed in the next block and transactions with time lock `current_height + 1`
+ // always propagate.
+ let absolute_timelock = match self {
+ PackageSolvingData::RevokedOutput(_) => output_conf_height + 1,
+ PackageSolvingData::RevokedHTLCOutput(_) => output_conf_height + 1,
+ PackageSolvingData::CounterpartyOfferedHTLCOutput(_) => output_conf_height + 1,
+ PackageSolvingData::CounterpartyReceivedHTLCOutput(ref outp) => cmp::max(outp.htlc.cltv_expiry, output_conf_height + 1),
+ PackageSolvingData::HolderHTLCOutput(ref outp) => cmp::max(outp.cltv_expiry, output_conf_height + 1),
+ PackageSolvingData::HolderFundingOutput(_) => output_conf_height + 1,
};
- Ok(solving_data)
+ absolute_timelock
}
}
+impl_writeable_tlv_based_enum!(PackageSolvingData, ;
+ (0, RevokedOutput),
+ (1, RevokedHTLCOutput),
+ (2, CounterpartyOfferedHTLCOutput),
+ (3, CounterpartyReceivedHTLCOutput),
+ (4, HolderHTLCOutput),
+ (5, HolderFundingOutput),
+);
+
/// 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.
pub(crate) fn aggregable(&self) -> bool {
self.aggregable
}
- pub(crate) fn feerate(&self) -> u64 {
- self.feerate_previous
- }
pub(crate) fn set_feerate(&mut self, new_feerate: u64) {
self.feerate_previous = new_feerate;
}
}
self.height_timer = cmp::min(self.height_timer, merge_from.height_timer);
}
- pub(crate) fn package_amount(&self) -> u64 {
+ /// Gets the amount of all outptus being spent by this package, only valid for malleable
+ /// packages.
+ fn package_amount(&self) -> u64 {
let mut amounts = 0;
for (_, outp) in self.inputs.iter() {
amounts += outp.amount();
}
amounts
}
+ pub(crate) fn package_timelock(&self) -> u32 {
+ self.inputs.iter().map(|(_, outp)| outp.absolute_tx_timelock(self.height_original))
+ .max().expect("There must always be at least one output to spend in a PackageTemplate")
+ }
pub(crate) fn package_weight(&self, destination_script: &Script) -> usize {
let mut inputs_weight = 0;
let mut witnesses_weight = 2; // count segwit flags
});
}
for (i, (outpoint, out)) in self.inputs.iter().enumerate() {
- log_trace!(logger, "Adding claiming input for outpoint {}:{}", outpoint.txid, outpoint.vout);
+ log_debug!(logger, "Adding claiming input for outpoint {}:{}", outpoint.txid, outpoint.vout);
if !out.finalize_input(&mut bumped_tx, i, onchain_handler) { return None; }
}
- log_trace!(logger, "Finalized transaction {} ready to broadcast", bumped_tx.txid());
+ log_debug!(logger, "Finalized transaction {} ready to broadcast", bumped_tx.txid());
return Some(bumped_tx);
},
PackageMalleability::Untractable => {
+ debug_assert_eq!(value, 0, "value is ignored for non-malleable packages, should be zero to ensure callsites are correct");
if let Some((outpoint, outp)) = self.inputs.first() {
if let Some(final_tx) = outp.get_finalized_tx(outpoint, onchain_handler) {
- log_trace!(logger, "Adding claiming input for outpoint {}:{}", outpoint.txid, outpoint.vout);
- log_trace!(logger, "Finalized transaction {} ready to broadcast", final_tx.txid());
+ log_debug!(logger, "Adding claiming input for outpoint {}:{}", outpoint.txid, outpoint.vout);
+ log_debug!(logger, "Finalized transaction {} ready to broadcast", final_tx.txid());
return Some(final_tx);
}
return None;
},
}
}
+ /// In LN, output claimed are time-sensitive, which means we have to spend them before reaching some timelock expiration. At in-channel
+ /// output detection, we generate a first version of a claim tx and associate to it a height timer. A height timer is an absolute block
+ /// height that once reached we should generate a new bumped "version" of the claim tx to be sure that we safely claim outputs before
+ /// that our counterparty can do so. If timelock expires soon, height timer is going to be scaled down in consequence to increase
+ /// frequency of the bump and so increase our bets of success.
+ pub(crate) fn get_height_timer(&self, current_height: u32) -> u32 {
+ if self.soonest_conf_deadline <= current_height + MIDDLE_FREQUENCY_BUMP_INTERVAL {
+ return current_height + HIGH_FREQUENCY_BUMP_INTERVAL
+ } else if self.soonest_conf_deadline - current_height <= LOW_FREQUENCY_BUMP_INTERVAL {
+ return current_height + MIDDLE_FREQUENCY_BUMP_INTERVAL
+ }
+ current_height + LOW_FREQUENCY_BUMP_INTERVAL
+ }
+
+ /// 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<F: Deref, L: Deref>(&self, predicted_weight: usize, dust_limit_sats: u64, fee_estimator: &F, 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) {
+ return Some((cmp::max(input_amounts as i64 - new_fee as i64, dust_limit_sats as i64) as u64, feerate));
+ }
+ } else {
+ if let Some((new_fee, feerate)) = compute_fee_from_spent_amounts(input_amounts, predicted_weight, fee_estimator, logger) {
+ return Some((cmp::max(input_amounts as i64 - new_fee as i64, dust_limit_sats as i64) as u64, feerate));
+ }
+ }
+ None
+ }
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 },
}
impl Writeable for PackageTemplate {
- fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+ fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
writer.write_all(&byte_utils::be64_to_array(self.inputs.len() as u64))?;
for (ref outpoint, ref rev_outp) in self.inputs.iter() {
outpoint.write(writer)?;
rev_outp.write(writer)?;
}
- self.soonest_conf_deadline.write(writer)?;
- self.feerate_previous.write(writer)?;
- self.height_timer.write(writer)?;
- self.height_original.write(writer)?;
+ write_tlv_fields!(writer, {
+ (0, self.soonest_conf_deadline, required),
+ (2, self.feerate_previous, required),
+ (4, self.height_original, required),
+ (6, self.height_timer, option)
+ });
Ok(())
}
}
impl Readable for PackageTemplate {
- fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+ fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
let inputs_count = <u64 as Readable>::read(reader)?;
let mut inputs: Vec<(BitcoinOutPoint, PackageSolvingData)> = Vec::with_capacity(cmp::min(inputs_count as usize, MAX_ALLOC_SIZE / 128));
for _ in 0..inputs_count {
PackageSolvingData::HolderFundingOutput(..) => { (PackageMalleability::Untractable, false) },
}
} else { return Err(DecodeError::InvalidValue); };
- let soonest_conf_deadline = Readable::read(reader)?;
- let feerate_previous = Readable::read(reader)?;
- let height_timer = Readable::read(reader)?;
- let height_original = Readable::read(reader)?;
+ let mut soonest_conf_deadline = 0;
+ let mut feerate_previous = 0;
+ let mut height_timer = None;
+ let mut height_original = 0;
+ read_tlv_fields!(reader, {
+ (0, soonest_conf_deadline, required),
+ (2, feerate_previous, required),
+ (4, height_original, required),
+ (6, height_timer, option),
+ });
Ok(PackageTemplate {
inputs,
malleability,
// ...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 {
- log_trace!(logger, "Can't 25% bump new claiming tx, amount {} is too small", input_amounts);
+ log_warn!(logger, "Can't 25% bump new claiming tx, amount {} is too small", input_amounts);
return None;
}
new_fee
}
} else {
- log_trace!(logger, "Can't new-estimation bump new claiming tx, amount {} is too small", input_amounts);
+ log_warn!(logger, "Can't new-estimation bump new claiming tx, amount {} is too small", input_amounts);
return None;
};
Some((new_fee, new_fee * 1000 / (predicted_weight as u64)))
}
-/// Deduce a new proposed fee from the claiming transaction output value.
-/// If the new proposed fee is superior to the consumed outpoint's value, burn everything in miner's
-/// fee to deter counterparties attacker.
-pub(crate) fn compute_output_value<F: Deref, L: Deref>(predicted_weight: usize, input_amounts: u64, previous_feerate: u64, fee_estimator: &F, logger: &L) -> Option<(u64, u64)>
- where F::Target: FeeEstimator,
- L::Target: Logger,
-{
- // If old feerate is 0, first iteration of this claim, use normal fee calculation
- if previous_feerate != 0 {
- if let Some((new_fee, feerate)) = feerate_bump(predicted_weight, input_amounts, previous_feerate, fee_estimator, logger) {
- // If new computed fee is superior at the whole claimable amount burn all in fees
- if new_fee > input_amounts {
- return Some((0, feerate));
- } else {
- return Some((input_amounts - new_fee, feerate));
+#[cfg(test)]
+mod tests {
+ use chain::package::{CounterpartyReceivedHTLCOutput, HolderHTLCOutput, PackageTemplate, PackageSolvingData, RevokedOutput, WEIGHT_REVOKED_OUTPUT};
+ use chain::Txid;
+ use ln::chan_utils::HTLCOutputInCommitment;
+ use ln::{PaymentPreimage, PaymentHash};
+
+ use bitcoin::blockdata::constants::WITNESS_SCALE_FACTOR;
+ use bitcoin::blockdata::script::Script;
+ use bitcoin::blockdata::transaction::OutPoint as BitcoinOutPoint;
+
+ use bitcoin::hashes::hex::FromHex;
+
+ use bitcoin::secp256k1::key::{PublicKey,SecretKey};
+ use bitcoin::secp256k1::Secp256k1;
+
+ macro_rules! dumb_revk_output {
+ ($secp_ctx: 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))
}
}
- } else {
- if let Some((new_fee, feerate)) = compute_fee_from_spent_amounts(input_amounts, predicted_weight, fee_estimator, logger) {
- return Some((input_amounts - new_fee, feerate));
+ }
+
+ macro_rules! dumb_counterparty_output {
+ ($secp_ctx: expr, $amt: expr) => {
+ {
+ let dumb_scalar = SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap();
+ let dumb_point = PublicKey::from_secret_key(&$secp_ctx, &dumb_scalar);
+ let hash = PaymentHash([1; 32]);
+ let htlc = HTLCOutputInCommitment { offered: true, amount_msat: $amt, cltv_expiry: 0, payment_hash: hash, transaction_output_index: None };
+ PackageSolvingData::CounterpartyReceivedHTLCOutput(CounterpartyReceivedHTLCOutput::build(dumb_point, dumb_point, dumb_point, htlc))
+ }
+ }
+ }
+
+ macro_rules! dumb_htlc_output {
+ () => {
+ {
+ let preimage = PaymentPreimage([2;32]);
+ PackageSolvingData::HolderHTLCOutput(HolderHTLCOutput::build_accepted(preimage, 0))
+ }
}
}
- None
+
+ #[test]
+ #[should_panic]
+ 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 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);
+ package_one_hundred.merge_package(package_two_hundred);
+ }
+
+ #[test]
+ #[should_panic]
+ 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 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);
+ untractable_package.merge_package(malleable_package);
+ }
+
+ #[test]
+ #[should_panic]
+ fn test_package_untractable_merge_from() {
+ 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 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);
+ malleable_package.merge_package(untractable_package);
+ }
+
+ #[test]
+ #[should_panic]
+ 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 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);
+ noaggregation_package.merge_package(aggregation_package);
+ }
+
+ #[test]
+ #[should_panic]
+ 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 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);
+ aggregation_package.merge_package(noaggregation_package);
+ }
+
+ #[test]
+ #[should_panic]
+ 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 mut empty_package = PackageTemplate::build_package(txid, 0, revk_outp.clone(), 1000, true, 100);
+ empty_package.inputs = vec![];
+ let package = PackageTemplate::build_package(txid, 1, revk_outp.clone(), 1000, true, 100);
+ empty_package.merge_package(package);
+ }
+
+ #[test]
+ #[should_panic]
+ 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 counterparty_outp = dumb_counterparty_output!(secp_ctx, 0);
+
+ 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);
+ revoked_package.merge_package(counterparty_package);
+ }
+
+ #[test]
+ 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 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);
+
+ package_one.merge_package(package_two);
+ package_one.merge_package(package_three);
+ assert_eq!(package_one.outpoints().len(), 3);
+
+ if let Some(split_package) = package_one.split_package(&BitcoinOutPoint { txid, vout: 1 }) {
+ // Packages attributes should be identical
+ assert!(split_package.is_malleable());
+ assert_eq!(split_package.soonest_conf_deadline, package_one.soonest_conf_deadline);
+ assert_eq!(split_package.aggregable, package_one.aggregable);
+ assert_eq!(split_package.feerate_previous, package_one.feerate_previous);
+ assert_eq!(split_package.height_timer, package_one.height_timer);
+ assert_eq!(split_package.height_original, package_one.height_original);
+ } else { panic!(); }
+ assert_eq!(package_one.outpoints().len(), 2);
+ }
+
+ #[test]
+ fn test_package_split_untractable() {
+ 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 ret_split = package_one.split_package(&BitcoinOutPoint { txid, vout: 0});
+ assert!(ret_split.is_none());
+ }
+
+ #[test]
+ 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!() }
+ }
+
+ #[test]
+ fn test_package_amounts() {
+ let txid = Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap();
+ let secp_ctx = Secp256k1::new();
+ let counterparty_outp = dumb_counterparty_output!(secp_ctx, 1_000_000);
+
+ let package = PackageTemplate::build_package(txid, 0, counterparty_outp, 1000, true, 100);
+ assert_eq!(package.package_amount(), 1000);
+ }
+
+ #[test]
+ fn test_package_weight() {
+ let txid = Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap();
+ let secp_ctx = Secp256k1::new();
+ let revk_outp = dumb_revk_output!(secp_ctx);
+
+ let package = PackageTemplate::build_package(txid, 0, revk_outp, 0, true, 100);
+ // (nVersion (4) + nLocktime (4) + count_tx_in (1) + prevout (36) + sequence (4) + script_length (1) + count_tx_out (1) + value (8) + var_int (1)) * WITNESS_SCALE_FACTOR
+ // + witness marker (2) + WEIGHT_REVOKED_OUTPUT
+ assert_eq!(package.package_weight(&Script::new()), (4 + 4 + 1 + 36 + 4 + 1 + 1 + 8 + 1) * WITNESS_SCALE_FACTOR + 2 + WEIGHT_REVOKED_OUTPUT as usize);
+ }
}
projects / rust-lightning / blobdiff