X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fevents%2Fbump_transaction.rs;h=1b019ba349e0ae8687a190b92ebd144fe164f6f9;hb=7c9463668a4f71663746e57bdb09ee6b91797d5a;hp=7c97e2d4c140003e190f5398b67d25e291193c5b;hpb=bc39da678eccbcb0ad53325fc294837b67eb7f89;p=rust-lightning diff --git a/lightning/src/events/bump_transaction.rs b/lightning/src/events/bump_transaction.rs index 7c97e2d4..1b019ba3 100644 --- a/lightning/src/events/bump_transaction.rs +++ b/lightning/src/events/bump_transaction.rs @@ -7,31 +7,37 @@ // You may not use this file except in accordance with one or both of these // licenses. -//! Utitilies for bumping transactions originating from [`super::Event`]s. +//! Utilities for bumping transactions originating from [`Event`]s. +//! +//! [`Event`]: crate::events::Event -use core::convert::TryInto; +use alloc::collections::BTreeMap; use core::ops::Deref; -use crate::chain::chaininterface::BroadcasterInterface; +use crate::chain::chaininterface::{BroadcasterInterface, fee_for_weight}; use crate::chain::ClaimId; -use crate::sign::{ChannelSigner, EcdsaChannelSigner, SignerProvider}; use crate::io_extras::sink; -use crate::ln::PaymentPreimage; +use crate::ln::channel::ANCHOR_OUTPUT_VALUE_SATOSHI; use crate::ln::chan_utils; use crate::ln::chan_utils::{ ANCHOR_INPUT_WITNESS_WEIGHT, HTLC_SUCCESS_INPUT_ANCHOR_WITNESS_WEIGHT, - HTLC_TIMEOUT_INPUT_ANCHOR_WITNESS_WEIGHT, ChannelTransactionParameters, HTLCOutputInCommitment + HTLC_TIMEOUT_INPUT_ANCHOR_WITNESS_WEIGHT, HTLCOutputInCommitment }; -use crate::events::Event; -use crate::prelude::HashMap; +use crate::prelude::*; +use crate::sign::{ + ChannelDerivationParameters, HTLCDescriptor, SignerProvider, P2WPKH_WITNESS_WEIGHT +}; +use crate::sign::ecdsa::{EcdsaChannelSigner, WriteableEcdsaChannelSigner}; use crate::sync::Mutex; use crate::util::logger::Logger; -use bitcoin::{OutPoint, PackedLockTime, PubkeyHash, Sequence, Script, Transaction, Txid, TxIn, TxOut, Witness, WPubkeyHash}; +use bitcoin::{OutPoint, PubkeyHash, Sequence, ScriptBuf, Transaction, TxIn, TxOut, Witness, WPubkeyHash}; use bitcoin::blockdata::constants::WITNESS_SCALE_FACTOR; +use bitcoin::blockdata::locktime::absolute::LockTime; use bitcoin::consensus::Encodable; +use bitcoin::psbt::PartiallySignedTransaction; use bitcoin::secp256k1; -use bitcoin::secp256k1::{PublicKey, Secp256k1}; +use bitcoin::secp256k1::Secp256k1; use bitcoin::secp256k1::ecdsa::Signature; const EMPTY_SCRIPT_SIG_WEIGHT: u64 = 1 /* empty script_sig */ * WITNESS_SCALE_FACTOR as u64; @@ -40,121 +46,61 @@ const BASE_INPUT_SIZE: u64 = 32 /* txid */ + 4 /* vout */ + 4 /* sequence */; const BASE_INPUT_WEIGHT: u64 = BASE_INPUT_SIZE * WITNESS_SCALE_FACTOR as u64; -// TODO: Define typed abstraction over feerates to handle their conversions. -fn compute_feerate_sat_per_1000_weight(fee_sat: u64, weight: u64) -> u32 { - (fee_sat * 1000 / weight).try_into().unwrap_or(u32::max_value()) -} -const fn fee_for_weight(feerate_sat_per_1000_weight: u32, weight: u64) -> u64 { - ((feerate_sat_per_1000_weight as u64 * weight) + 1000 - 1) / 1000 -} - /// A descriptor used to sign for a commitment transaction's anchor output. #[derive(Clone, Debug, PartialEq, Eq)] pub struct AnchorDescriptor { - /// A unique identifier used along with `channel_value_satoshis` to re-derive the - /// [`InMemorySigner`] required to sign `input`. - /// - /// [`InMemorySigner`]: crate::sign::InMemorySigner - pub channel_keys_id: [u8; 32], - /// The value in satoshis of the channel we're attempting to spend the anchor output of. This is - /// used along with `channel_keys_id` to re-derive the [`InMemorySigner`] required to sign - /// `input`. - /// - /// [`InMemorySigner`]: crate::sign::InMemorySigner - pub channel_value_satoshis: u64, + /// The parameters required to derive the signer for the anchor input. + pub channel_derivation_parameters: ChannelDerivationParameters, /// The transaction input's outpoint corresponding to the commitment transaction's anchor /// output. pub outpoint: OutPoint, } -/// A descriptor used to sign for a commitment transaction's HTLC output. -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct HTLCDescriptor { - /// A unique identifier used along with `channel_value_satoshis` to re-derive the - /// [`InMemorySigner`] required to sign `input`. - /// - /// [`InMemorySigner`]: crate::sign::InMemorySigner - pub channel_keys_id: [u8; 32], - /// The value in satoshis of the channel we're attempting to spend the anchor output of. This is - /// used along with `channel_keys_id` to re-derive the [`InMemorySigner`] required to sign - /// `input`. - /// - /// [`InMemorySigner`]: crate::sign::InMemorySigner - pub channel_value_satoshis: u64, - /// The necessary channel parameters that need to be provided to the re-derived - /// [`InMemorySigner`] through [`ChannelSigner::provide_channel_parameters`]. - /// - /// [`InMemorySigner`]: crate::sign::InMemorySigner - /// [`ChannelSigner::provide_channel_parameters`]: crate::sign::ChannelSigner::provide_channel_parameters - pub channel_parameters: ChannelTransactionParameters, - /// The txid of the commitment transaction in which the HTLC output lives. - pub commitment_txid: Txid, - /// The number of the commitment transaction in which the HTLC output lives. - pub per_commitment_number: u64, - /// The details of the HTLC as it appears in the commitment transaction. - pub htlc: HTLCOutputInCommitment, - /// The preimage, if `Some`, to claim the HTLC output with. If `None`, the timeout path must be - /// taken. - pub preimage: Option, - /// The counterparty's signature required to spend the HTLC output. - pub counterparty_sig: Signature -} +impl AnchorDescriptor { + /// Returns the UTXO to be spent by the anchor input, which can be obtained via + /// [`Self::unsigned_tx_input`]. + pub fn previous_utxo(&self) -> TxOut { + TxOut { + script_pubkey: self.witness_script().to_v0_p2wsh(), + value: ANCHOR_OUTPUT_VALUE_SATOSHI, + } + } -impl HTLCDescriptor { - /// Returns the unsigned transaction input spending the HTLC output in the commitment + /// Returns the unsigned transaction input spending the anchor output in the commitment /// transaction. pub fn unsigned_tx_input(&self) -> TxIn { - chan_utils::build_htlc_input(&self.commitment_txid, &self.htlc, true /* opt_anchors */) + TxIn { + previous_output: self.outpoint.clone(), + script_sig: ScriptBuf::new(), + sequence: Sequence::ENABLE_RBF_NO_LOCKTIME, + witness: Witness::new(), + } } - /// Returns the delayed output created as a result of spending the HTLC output in the commitment - /// transaction. - pub fn tx_output( - &self, per_commitment_point: &PublicKey, secp: &Secp256k1 - ) -> TxOut { - let channel_params = self.channel_parameters.as_holder_broadcastable(); - let broadcaster_keys = channel_params.broadcaster_pubkeys(); - let counterparty_keys = channel_params.countersignatory_pubkeys(); - let broadcaster_delayed_key = chan_utils::derive_public_key( - secp, per_commitment_point, &broadcaster_keys.delayed_payment_basepoint - ); - let counterparty_revocation_key = chan_utils::derive_public_revocation_key( - secp, per_commitment_point, &counterparty_keys.revocation_basepoint - ); - chan_utils::build_htlc_output( - 0 /* feerate_per_kw */, channel_params.contest_delay(), &self.htlc, true /* opt_anchors */, - false /* use_non_zero_fee_anchors */, &broadcaster_delayed_key, &counterparty_revocation_key - ) + /// Returns the witness script of the anchor output in the commitment transaction. + pub fn witness_script(&self) -> ScriptBuf { + let channel_params = self.channel_derivation_parameters.transaction_parameters.as_holder_broadcastable(); + chan_utils::get_anchor_redeemscript(&channel_params.broadcaster_pubkeys().funding_pubkey) } - /// Returns the witness script of the HTLC output in the commitment transaction. - pub fn witness_script( - &self, per_commitment_point: &PublicKey, secp: &Secp256k1 - ) -> Script { - let channel_params = self.channel_parameters.as_holder_broadcastable(); - let broadcaster_keys = channel_params.broadcaster_pubkeys(); - let counterparty_keys = channel_params.countersignatory_pubkeys(); - let broadcaster_htlc_key = chan_utils::derive_public_key( - secp, per_commitment_point, &broadcaster_keys.htlc_basepoint - ); - let counterparty_htlc_key = chan_utils::derive_public_key( - secp, per_commitment_point, &counterparty_keys.htlc_basepoint - ); - let counterparty_revocation_key = chan_utils::derive_public_revocation_key( - secp, per_commitment_point, &counterparty_keys.revocation_basepoint - ); - chan_utils::get_htlc_redeemscript_with_explicit_keys( - &self.htlc, true /* opt_anchors */, &broadcaster_htlc_key, &counterparty_htlc_key, - &counterparty_revocation_key, - ) + /// Returns the fully signed witness required to spend the anchor output in the commitment + /// transaction. + pub fn tx_input_witness(&self, signature: &Signature) -> Witness { + let channel_params = self.channel_derivation_parameters.transaction_parameters.as_holder_broadcastable(); + chan_utils::build_anchor_input_witness(&channel_params.broadcaster_pubkeys().funding_pubkey, signature) } - /// Returns the fully signed witness required to spend the HTLC output in the commitment - /// transaction. - pub fn tx_input_witness(&self, signature: &Signature, witness_script: &Script) -> Witness { - chan_utils::build_htlc_input_witness( - signature, &self.counterparty_sig, &self.preimage, witness_script, true /* opt_anchors */ - ) + /// Derives the channel signer required to sign the anchor input. + pub fn derive_channel_signer(&self, signer_provider: &SP) -> S + where + SP::Target: SignerProvider + { + let mut signer = signer_provider.derive_channel_signer( + self.channel_derivation_parameters.value_satoshis, + self.channel_derivation_parameters.keys_id, + ); + signer.provide_channel_parameters(&self.channel_derivation_parameters.transaction_parameters); + signer } } @@ -174,12 +120,11 @@ pub enum BumpTransactionEvent { /// broadcast first, as the child anchor transaction depends on it. /// /// The consumer should be able to sign for any of the additional inputs included within the - /// child anchor transaction. To sign its anchor input, an [`InMemorySigner`] should be - /// re-derived through [`KeysManager::derive_channel_keys`] with the help of - /// [`AnchorDescriptor::channel_keys_id`] and [`AnchorDescriptor::channel_value_satoshis`]. The - /// anchor input signature can be computed with [`EcdsaChannelSigner::sign_holder_anchor_input`], - /// which can then be provided to [`build_anchor_input_witness`] along with the `funding_pubkey` - /// to obtain the full witness required to spend. + /// child anchor transaction. To sign its anchor input, an [`EcdsaChannelSigner`] should be + /// re-derived through [`AnchorDescriptor::derive_channel_signer`]. The anchor input signature + /// can be computed with [`EcdsaChannelSigner::sign_holder_anchor_input`], which can then be + /// provided to [`build_anchor_input_witness`] along with the `funding_pubkey` to obtain the + /// full witness required to spend. /// /// It is possible to receive more than one instance of this event if a valid child anchor /// transaction is never broadcast or is but not with a sufficient fee to be mined. Care should @@ -198,9 +143,8 @@ pub enum BumpTransactionEvent { /// an empty `pending_htlcs`), confirmation of the commitment transaction can be considered to /// be not urgent. /// - /// [`InMemorySigner`]: crate::sign::InMemorySigner - /// [`KeysManager::derive_channel_keys`]: crate::sign::KeysManager::derive_channel_keys - /// [`EcdsaChannelSigner::sign_holder_anchor_input`]: crate::sign::EcdsaChannelSigner::sign_holder_anchor_input + /// [`EcdsaChannelSigner`]: crate::sign::ecdsa::EcdsaChannelSigner + /// [`EcdsaChannelSigner::sign_holder_anchor_input`]: crate::sign::ecdsa::EcdsaChannelSigner::sign_holder_anchor_input /// [`build_anchor_input_witness`]: crate::ln::chan_utils::build_anchor_input_witness ChannelClose { /// The unique identifier for the claim of the anchor output in the commitment transaction. @@ -237,11 +181,11 @@ pub enum BumpTransactionEvent { /// broadcast by the consumer of the event. /// /// The consumer should be able to sign for any of the non-HTLC inputs added to the resulting - /// HTLC transaction. To sign HTLC inputs, an [`InMemorySigner`] should be re-derived through - /// [`KeysManager::derive_channel_keys`] with the help of `channel_keys_id` and - /// `channel_value_satoshis`. Each HTLC input's signature can be computed with - /// [`EcdsaChannelSigner::sign_holder_htlc_transaction`], which can then be provided to - /// [`HTLCDescriptor::tx_input_witness`] to obtain the fully signed witness required to spend. + /// HTLC transaction. To sign HTLC inputs, an [`EcdsaChannelSigner`] should be re-derived + /// through [`HTLCDescriptor::derive_channel_signer`]. Each HTLC input's signature can be + /// computed with [`EcdsaChannelSigner::sign_holder_htlc_transaction`], which can then be + /// provided to [`HTLCDescriptor::tx_input_witness`] to obtain the fully signed witness required + /// to spend. /// /// It is possible to receive more than one instance of this event if a valid HTLC transaction /// is never broadcast or is but not with a sufficient fee to be mined. Care should be taken by @@ -253,10 +197,8 @@ pub enum BumpTransactionEvent { /// longer able to commit external confirmed funds to the HTLC transaction or the fee committed /// to the HTLC transaction is greater in value than the HTLCs being claimed. /// - /// [`InMemorySigner`]: crate::sign::InMemorySigner - /// [`KeysManager::derive_channel_keys`]: crate::sign::KeysManager::derive_channel_keys - /// [`EcdsaChannelSigner::sign_holder_htlc_transaction`]: crate::sign::EcdsaChannelSigner::sign_holder_htlc_transaction - /// [`HTLCDescriptor::tx_input_witness`]: HTLCDescriptor::tx_input_witness + /// [`EcdsaChannelSigner`]: crate::sign::ecdsa::EcdsaChannelSigner + /// [`EcdsaChannelSigner::sign_holder_htlc_transaction`]: crate::sign::ecdsa::EcdsaChannelSigner::sign_holder_htlc_transaction HTLCResolution { /// The unique identifier for the claim of the HTLCs in the confirmed commitment /// transaction. @@ -271,16 +213,19 @@ pub enum BumpTransactionEvent { /// by the same transaction. htlc_descriptors: Vec, /// The locktime required for the resulting HTLC transaction. - tx_lock_time: PackedLockTime, + tx_lock_time: LockTime, }, } /// An input that must be included in a transaction when performing coin selection through /// [`CoinSelectionSource::select_confirmed_utxos`]. It is guaranteed to be a SegWit input, so it /// must have an empty [`TxIn::script_sig`] when spent. +#[derive(Clone, Debug, Hash, PartialOrd, Ord, PartialEq, Eq)] pub struct Input { /// The unique identifier of the input. pub outpoint: OutPoint, + /// The UTXO being spent by the input. + pub previous_utxo: TxOut, /// The upper-bound weight consumed by the input's full [`TxIn::script_sig`] and /// [`TxIn::witness`], each with their lengths included, required to satisfy the output's /// script. @@ -289,7 +234,7 @@ pub struct Input { /// An unspent transaction output that is available to spend resulting from a successful /// [`CoinSelection`] attempt. -#[derive(Clone, Debug)] +#[derive(Clone, Debug, Hash, PartialOrd, Ord, PartialEq, Eq)] pub struct Utxo { /// The unique identifier of the output. pub outpoint: OutPoint, @@ -302,12 +247,6 @@ pub struct Utxo { } impl Utxo { - const P2WPKH_WITNESS_WEIGHT: u64 = 1 /* num stack items */ + - 1 /* sig length */ + - 73 /* sig including sighash flag */ + - 1 /* pubkey length */ + - 33 /* pubkey */; - /// Returns a `Utxo` with the `satisfaction_weight` estimate for a legacy P2PKH output. pub fn new_p2pkh(outpoint: OutPoint, value: u64, pubkey_hash: &PubkeyHash) -> Self { let script_sig_size = 1 /* script_sig length */ + @@ -319,7 +258,7 @@ impl Utxo { outpoint, output: TxOut { value, - script_pubkey: Script::new_p2pkh(pubkey_hash), + script_pubkey: ScriptBuf::new_p2pkh(pubkey_hash), }, satisfaction_weight: script_sig_size * WITNESS_SCALE_FACTOR as u64 + 1 /* empty witness */, } @@ -335,9 +274,9 @@ impl Utxo { outpoint, output: TxOut { value, - script_pubkey: Script::new_p2sh(&Script::new_v0_p2wpkh(pubkey_hash).script_hash()), + script_pubkey: ScriptBuf::new_p2sh(&ScriptBuf::new_v0_p2wpkh(pubkey_hash).script_hash()), }, - satisfaction_weight: script_sig_size * WITNESS_SCALE_FACTOR as u64 + Self::P2WPKH_WITNESS_WEIGHT, + satisfaction_weight: script_sig_size * WITNESS_SCALE_FACTOR as u64 + P2WPKH_WITNESS_WEIGHT, } } @@ -347,24 +286,25 @@ impl Utxo { outpoint, output: TxOut { value, - script_pubkey: Script::new_v0_p2wpkh(pubkey_hash), + script_pubkey: ScriptBuf::new_v0_p2wpkh(pubkey_hash), }, - satisfaction_weight: EMPTY_SCRIPT_SIG_WEIGHT + Self::P2WPKH_WITNESS_WEIGHT, + satisfaction_weight: EMPTY_SCRIPT_SIG_WEIGHT + P2WPKH_WITNESS_WEIGHT, } } } /// The result of a successful coin selection attempt for a transaction requiring additional UTXOs /// to cover its fees. +#[derive(Clone, Debug)] pub struct CoinSelection { /// The set of UTXOs (with at least 1 confirmation) to spend and use within a transaction /// requiring additional fees. - confirmed_utxos: Vec, + pub confirmed_utxos: Vec, /// An additional output tracking whether any change remained after coin selection. This output /// should always have a value above dust for its given `script_pubkey`. It should not be /// spent until the transaction it belongs to confirms to ensure mempool descendant limits are /// not met. This implies no other party should be able to spend it except us. - change_output: Option, + pub change_output: Option, } /// An abstraction over a bitcoin wallet that can perform coin selection over a set of UTXOs and can @@ -399,12 +339,15 @@ pub trait CoinSelectionSource { /// which UTXOs to double spend is left to the implementation, but it must strive to keep the /// set of other claims being double spent to a minimum. fn select_confirmed_utxos( - &self, claim_id: ClaimId, must_spend: &[Input], must_pay_to: &[TxOut], + &self, claim_id: ClaimId, must_spend: Vec, must_pay_to: &[TxOut], target_feerate_sat_per_1000_weight: u32, ) -> Result; /// Signs and provides the full witness for all inputs within the transaction known to the /// trait (i.e., any provided via [`CoinSelectionSource::select_confirmed_utxos`]). - fn sign_tx(&self, tx: &mut Transaction) -> Result<(), ()>; + /// + /// If your wallet does not support signing PSBTs you can call `psbt.extract_tx()` to get the + /// unsigned transaction and then sign it with your wallet. + fn sign_psbt(&self, psbt: PartiallySignedTransaction) -> Result; } /// An alternative to [`CoinSelectionSource`] that can be implemented and used along [`Wallet`] to @@ -414,29 +357,41 @@ pub trait WalletSource { fn list_confirmed_utxos(&self) -> Result, ()>; /// Returns a script to use for change above dust resulting from a successful coin selection /// attempt. - fn get_change_script(&self) -> Result; + fn get_change_script(&self) -> Result; /// Signs and provides the full [`TxIn::script_sig`] and [`TxIn::witness`] for all inputs within /// the transaction known to the wallet (i.e., any provided via /// [`WalletSource::list_confirmed_utxos`]). - fn sign_tx(&self, tx: &mut Transaction) -> Result<(), ()>; + /// + /// If your wallet does not support signing PSBTs you can call `psbt.extract_tx()` to get the + /// unsigned transaction and then sign it with your wallet. + fn sign_psbt(&self, psbt: PartiallySignedTransaction) -> Result; } /// A wrapper over [`WalletSource`] that implements [`CoinSelection`] by preferring UTXOs that would /// avoid conflicting double spends. If not enough UTXOs are available to do so, conflicting double /// spends may happen. -pub struct Wallet where W::Target: WalletSource { +pub struct Wallet +where + W::Target: WalletSource, + L::Target: Logger +{ source: W, + logger: L, // TODO: Do we care about cleaning this up once the UTXOs have a confirmed spend? We can do so // by checking whether any UTXOs that exist in the map are no longer returned in // `list_confirmed_utxos`. locked_utxos: Mutex>, } -impl Wallet where W::Target: WalletSource { +impl Wallet +where + W::Target: WalletSource, + L::Target: Logger +{ /// Returns a new instance backed by the given [`WalletSource`] that serves as an implementation /// of [`CoinSelectionSource`]. - pub fn new(source: W) -> Self { - Self { source, locked_utxos: Mutex::new(HashMap::new()) } + pub fn new(source: W, logger: L) -> Self { + Self { source, logger, locked_utxos: Mutex::new(HashMap::new()) } } /// Performs coin selection on the set of UTXOs obtained from @@ -450,17 +405,18 @@ impl Wallet where W::Target: WalletSource { fn select_confirmed_utxos_internal( &self, utxos: &[Utxo], claim_id: ClaimId, force_conflicting_utxo_spend: bool, tolerate_high_network_feerates: bool, target_feerate_sat_per_1000_weight: u32, - preexisting_tx_weight: u64, target_amount_sat: u64, + preexisting_tx_weight: u64, input_amount_sat: u64, target_amount_sat: u64, ) -> Result { let mut locked_utxos = self.locked_utxos.lock().unwrap(); let mut eligible_utxos = utxos.iter().filter_map(|utxo| { if let Some(utxo_claim_id) = locked_utxos.get(&utxo.outpoint) { if *utxo_claim_id != claim_id && !force_conflicting_utxo_spend { + log_trace!(self.logger, "Skipping UTXO {} to prevent conflicting spend", utxo.outpoint); return None; } } let fee_to_spend_utxo = fee_for_weight( - target_feerate_sat_per_1000_weight, BASE_INPUT_WEIGHT as u64 + utxo.satisfaction_weight, + target_feerate_sat_per_1000_weight, BASE_INPUT_WEIGHT + utxo.satisfaction_weight, ); let should_spend = if tolerate_high_network_feerates { utxo.output.value > fee_to_spend_utxo @@ -470,12 +426,13 @@ impl Wallet where W::Target: WalletSource { if should_spend { Some((utxo, fee_to_spend_utxo)) } else { + log_trace!(self.logger, "Skipping UTXO {} due to dust proximity after spend", utxo.outpoint); None } }).collect::>(); eligible_utxos.sort_unstable_by_key(|(utxo, _)| utxo.output.value); - let mut selected_amount = 0; + let mut selected_amount = input_amount_sat; let mut total_fees = fee_for_weight(target_feerate_sat_per_1000_weight, preexisting_tx_weight); let mut selected_utxos = Vec::new(); for (utxo, fee_to_spend_utxo) in eligible_utxos { @@ -487,6 +444,8 @@ impl Wallet where W::Target: WalletSource { selected_utxos.push(utxo.clone()); } if selected_amount < target_amount_sat + total_fees { + log_debug!(self.logger, "Insufficient funds to meet target feerate {} sat/kW", + target_feerate_sat_per_1000_weight); return Err(()); } for utxo in &selected_utxos { @@ -503,6 +462,7 @@ impl Wallet where W::Target: WalletSource { ); let change_output_amount = remaining_amount.saturating_sub(change_output_fee); let change_output = if change_output_amount < change_script.dust_value().to_sat() { + log_debug!(self.logger, "Coin selection attempt did not yield change output"); None } else { Some(TxOut { script_pubkey: change_script, value: change_output_amount }) @@ -515,9 +475,13 @@ impl Wallet where W::Target: WalletSource { } } -impl CoinSelectionSource for Wallet where W::Target: WalletSource { +impl CoinSelectionSource for Wallet +where + W::Target: WalletSource, + L::Target: Logger +{ fn select_confirmed_utxos( - &self, claim_id: ClaimId, must_spend: &[Input], must_pay_to: &[TxOut], + &self, claim_id: ClaimId, must_spend: Vec, must_pay_to: &[TxOut], target_feerate_sat_per_1000_weight: u32, ) -> Result { let utxos = self.source.list_confirmed_utxos()?; @@ -531,11 +495,14 @@ impl CoinSelectionSource for Wallet where W::Target: WalletSource { let preexisting_tx_weight = 2 /* segwit marker & flag */ + total_input_weight + ((BASE_TX_SIZE + total_output_size) * WITNESS_SCALE_FACTOR as u64); + let input_amount_sat: u64 = must_spend.iter().map(|input| input.previous_utxo.value).sum(); let target_amount_sat = must_pay_to.iter().map(|output| output.value).sum(); let do_coin_selection = |force_conflicting_utxo_spend: bool, tolerate_high_network_feerates: bool| { + log_debug!(self.logger, "Attempting coin selection targeting {} sat/kW (force_conflicting_utxo_spend = {}, tolerate_high_network_feerates = {})", + target_feerate_sat_per_1000_weight, force_conflicting_utxo_spend, tolerate_high_network_feerates); self.select_confirmed_utxos_internal( &utxos, claim_id, force_conflicting_utxo_spend, tolerate_high_network_feerates, - target_feerate_sat_per_1000_weight, preexisting_tx_weight, target_amount_sat, + target_feerate_sat_per_1000_weight, preexisting_tx_weight, input_amount_sat, target_amount_sat, ) }; do_coin_selection(false, false) @@ -544,14 +511,16 @@ impl CoinSelectionSource for Wallet where W::Target: WalletSource { .or_else(|_| do_coin_selection(true, true)) } - fn sign_tx(&self, tx: &mut Transaction) -> Result<(), ()> { - self.source.sign_tx(tx) + fn sign_psbt(&self, psbt: PartiallySignedTransaction) -> Result { + self.source.sign_psbt(psbt) } } /// A handler for [`Event::BumpTransaction`] events that sources confirmed UTXOs from a /// [`CoinSelectionSource`] to fee bump transactions via Child-Pays-For-Parent (CPFP) or /// Replace-By-Fee (RBF). +/// +/// [`Event::BumpTransaction`]: crate::events::Event::BumpTransaction pub struct BumpTransactionEventHandler where B::Target: BroadcasterInterface, @@ -574,6 +543,8 @@ where L::Target: Logger, { /// Returns a new instance capable of handling [`Event::BumpTransaction`] events. + /// + /// [`Event::BumpTransaction`]: crate::events::Event::BumpTransaction pub fn new(broadcaster: B, utxo_source: C, signer_provider: SP, logger: L) -> Self { Self { broadcaster, @@ -585,181 +556,238 @@ where } /// Updates a transaction with the result of a successful coin selection attempt. - fn process_coin_selection(&self, tx: &mut Transaction, mut coin_selection: CoinSelection) { - for utxo in coin_selection.confirmed_utxos.drain(..) { + fn process_coin_selection(&self, tx: &mut Transaction, coin_selection: &CoinSelection) { + for utxo in coin_selection.confirmed_utxos.iter() { tx.input.push(TxIn { previous_output: utxo.outpoint, - script_sig: Script::new(), + script_sig: ScriptBuf::new(), sequence: Sequence::ZERO, witness: Witness::new(), }); } - if let Some(change_output) = coin_selection.change_output.take() { + if let Some(change_output) = coin_selection.change_output.clone() { tx.output.push(change_output); } else if tx.output.is_empty() { // We weren't provided a change output, likely because the input set was a perfect // match, but we still need to have at least one output in the transaction for it to be // considered standard. We choose to go with an empty OP_RETURN as it is the cheapest // way to include a dummy output. + log_debug!(self.logger, "Including dummy OP_RETURN output since an output is needed and a change output was not provided"); tx.output.push(TxOut { value: 0, - script_pubkey: Script::new_op_return(&[]), + script_pubkey: ScriptBuf::new_op_return(&[]), }); } } - /// Returns an unsigned transaction spending an anchor output of the commitment transaction, and - /// any additional UTXOs sourced, to bump the commitment transaction's fee. - fn build_anchor_tx( - &self, claim_id: ClaimId, target_feerate_sat_per_1000_weight: u32, - commitment_tx: &Transaction, anchor_descriptor: &AnchorDescriptor, - ) -> Result { + /// Handles a [`BumpTransactionEvent::ChannelClose`] event variant by producing a fully-signed + /// transaction spending an anchor output of the commitment transaction to bump its fee and + /// broadcasts them to the network as a package. + fn handle_channel_close( + &self, claim_id: ClaimId, package_target_feerate_sat_per_1000_weight: u32, + commitment_tx: &Transaction, commitment_tx_fee_sat: u64, anchor_descriptor: &AnchorDescriptor, + ) -> Result<(), ()> { + // Our commitment transaction already has fees allocated to it, so we should take them into + // account. We do so by pretending the commitment tranasction's fee and weight are part of + // the anchor input. + let mut anchor_utxo = anchor_descriptor.previous_utxo(); + anchor_utxo.value += commitment_tx_fee_sat; let must_spend = vec![Input { outpoint: anchor_descriptor.outpoint, - satisfaction_weight: commitment_tx.weight() as u64 + ANCHOR_INPUT_WITNESS_WEIGHT + EMPTY_SCRIPT_SIG_WEIGHT, + previous_utxo: anchor_utxo, + satisfaction_weight: commitment_tx.weight().to_wu() + ANCHOR_INPUT_WITNESS_WEIGHT + EMPTY_SCRIPT_SIG_WEIGHT, }]; - let coin_selection = self.utxo_source.select_confirmed_utxos( - claim_id, &must_spend, &[], target_feerate_sat_per_1000_weight, + #[cfg(debug_assertions)] + let must_spend_amount = must_spend.iter().map(|input| input.previous_utxo.value).sum::(); + + log_debug!(self.logger, "Peforming coin selection for commitment package (commitment and anchor transaction) targeting {} sat/kW", + package_target_feerate_sat_per_1000_weight); + let coin_selection: CoinSelection = self.utxo_source.select_confirmed_utxos( + claim_id, must_spend, &[], package_target_feerate_sat_per_1000_weight, )?; - let mut tx = Transaction { + let mut anchor_tx = Transaction { version: 2, - lock_time: PackedLockTime::ZERO, // TODO: Use next best height. - input: vec![TxIn { - previous_output: anchor_descriptor.outpoint, - script_sig: Script::new(), - sequence: Sequence::ZERO, - witness: Witness::new(), - }], + lock_time: LockTime::ZERO, // TODO: Use next best height. + input: vec![anchor_descriptor.unsigned_tx_input()], output: vec![], }; - self.process_coin_selection(&mut tx, coin_selection); - Ok(tx) - } - /// Handles a [`BumpTransactionEvent::ChannelClose`] event variant by producing a fully-signed - /// transaction spending an anchor output of the commitment transaction to bump its fee and - /// broadcasts them to the network as a package. - fn handle_channel_close( - &self, claim_id: ClaimId, package_target_feerate_sat_per_1000_weight: u32, - commitment_tx: &Transaction, commitment_tx_fee_sat: u64, anchor_descriptor: &AnchorDescriptor, - ) -> Result<(), ()> { - // Compute the feerate the anchor transaction must meet to meet the overall feerate for the - // package (commitment + anchor transactions). - let commitment_tx_sat_per_1000_weight: u32 = compute_feerate_sat_per_1000_weight( - commitment_tx_fee_sat, commitment_tx.weight() as u64, - ); - if commitment_tx_sat_per_1000_weight >= package_target_feerate_sat_per_1000_weight { - // If the commitment transaction already has a feerate high enough on its own, broadcast - // it as is without a child. - self.broadcaster.broadcast_transactions(&[&commitment_tx]); - return Ok(()); + #[cfg(debug_assertions)] + let total_satisfaction_weight = ANCHOR_INPUT_WITNESS_WEIGHT + EMPTY_SCRIPT_SIG_WEIGHT + + coin_selection.confirmed_utxos.iter().map(|utxo| utxo.satisfaction_weight).sum::(); + #[cfg(debug_assertions)] + let total_input_amount = must_spend_amount + + coin_selection.confirmed_utxos.iter().map(|utxo| utxo.output.value).sum::(); + + self.process_coin_selection(&mut anchor_tx, &coin_selection); + let anchor_txid = anchor_tx.txid(); + + // construct psbt + let mut anchor_psbt = PartiallySignedTransaction::from_unsigned_tx(anchor_tx).unwrap(); + // add witness_utxo to anchor input + anchor_psbt.inputs[0].witness_utxo = Some(anchor_descriptor.previous_utxo()); + // add witness_utxo to remaining inputs + for (idx, utxo) in coin_selection.confirmed_utxos.into_iter().enumerate() { + // add 1 to skip the anchor input + let index = idx + 1; + debug_assert_eq!(anchor_psbt.unsigned_tx.input[index].previous_output, utxo.outpoint); + if utxo.output.script_pubkey.is_witness_program() { + anchor_psbt.inputs[index].witness_utxo = Some(utxo.output); + } } - let mut anchor_tx = self.build_anchor_tx( - claim_id, package_target_feerate_sat_per_1000_weight, commitment_tx, anchor_descriptor, - )?; - debug_assert_eq!(anchor_tx.output.len(), 1); + debug_assert_eq!(anchor_psbt.unsigned_tx.output.len(), 1); + #[cfg(debug_assertions)] + let unsigned_tx_weight = anchor_psbt.unsigned_tx.weight().to_wu() - (anchor_psbt.unsigned_tx.input.len() as u64 * EMPTY_SCRIPT_SIG_WEIGHT); - self.utxo_source.sign_tx(&mut anchor_tx)?; - let signer = self.signer_provider.derive_channel_signer( - anchor_descriptor.channel_value_satoshis, anchor_descriptor.channel_keys_id, - ); + log_debug!(self.logger, "Signing anchor transaction {}", anchor_txid); + anchor_tx = self.utxo_source.sign_psbt(anchor_psbt)?; + + let signer = anchor_descriptor.derive_channel_signer(&self.signer_provider); let anchor_sig = signer.sign_holder_anchor_input(&anchor_tx, 0, &self.secp)?; - anchor_tx.input[0].witness = - chan_utils::build_anchor_input_witness(&signer.pubkeys().funding_pubkey, &anchor_sig); + anchor_tx.input[0].witness = anchor_descriptor.tx_input_witness(&anchor_sig); + + #[cfg(debug_assertions)] { + let signed_tx_weight = anchor_tx.weight().to_wu(); + let expected_signed_tx_weight = unsigned_tx_weight + total_satisfaction_weight; + // Our estimate should be within a 1% error margin of the actual weight and we should + // never underestimate. + assert!(expected_signed_tx_weight >= signed_tx_weight && + expected_signed_tx_weight - (expected_signed_tx_weight / 100) <= signed_tx_weight); + + let expected_package_fee = fee_for_weight(package_target_feerate_sat_per_1000_weight, + signed_tx_weight + commitment_tx.weight().to_wu()); + let package_fee = total_input_amount - + anchor_tx.output.iter().map(|output| output.value).sum::(); + // Our fee should be within a 5% error margin of the expected fee based on the + // feerate and transaction weight and we should never pay less than required. + let fee_error_margin = expected_package_fee * 5 / 100; + assert!(package_fee >= expected_package_fee && + package_fee - fee_error_margin <= expected_package_fee); + } + log_info!(self.logger, "Broadcasting anchor transaction {} to bump channel close with txid {}", + anchor_txid, commitment_tx.txid()); self.broadcaster.broadcast_transactions(&[&commitment_tx, &anchor_tx]); Ok(()) } - /// Returns an unsigned, fee-bumped HTLC transaction, along with the set of signers required to - /// fulfill the witness for each HTLC input within it. - fn build_htlc_tx( + /// Handles a [`BumpTransactionEvent::HTLCResolution`] event variant by producing a + /// fully-signed, fee-bumped HTLC transaction that is broadcast to the network. + fn handle_htlc_resolution( &self, claim_id: ClaimId, target_feerate_sat_per_1000_weight: u32, - htlc_descriptors: &[HTLCDescriptor], tx_lock_time: PackedLockTime, - ) -> Result<(Transaction, HashMap<[u8; 32], ::Signer>), ()> { - let mut tx = Transaction { + htlc_descriptors: &[HTLCDescriptor], tx_lock_time: LockTime, + ) -> Result<(), ()> { + let mut htlc_tx = Transaction { version: 2, lock_time: tx_lock_time, input: vec![], output: vec![], }; - // Unfortunately, we need to derive the signer for each HTLC ahead of time to obtain its - // input. - let mut signers = HashMap::new(); let mut must_spend = Vec::with_capacity(htlc_descriptors.len()); for htlc_descriptor in htlc_descriptors { - let signer = signers.entry(htlc_descriptor.channel_keys_id) - .or_insert_with(|| - self.signer_provider.derive_channel_signer( - htlc_descriptor.channel_value_satoshis, htlc_descriptor.channel_keys_id, - ) - ); - let per_commitment_point = signer.get_per_commitment_point( - htlc_descriptor.per_commitment_number, &self.secp - ); - let htlc_input = htlc_descriptor.unsigned_tx_input(); must_spend.push(Input { outpoint: htlc_input.previous_output.clone(), + previous_utxo: htlc_descriptor.previous_utxo(&self.secp), satisfaction_weight: EMPTY_SCRIPT_SIG_WEIGHT + if htlc_descriptor.preimage.is_some() { HTLC_SUCCESS_INPUT_ANCHOR_WITNESS_WEIGHT } else { HTLC_TIMEOUT_INPUT_ANCHOR_WITNESS_WEIGHT }, }); - tx.input.push(htlc_input); - let htlc_output = htlc_descriptor.tx_output(&per_commitment_point, &self.secp); - tx.output.push(htlc_output); + htlc_tx.input.push(htlc_input); + let htlc_output = htlc_descriptor.tx_output(&self.secp); + htlc_tx.output.push(htlc_output); } - let coin_selection = self.utxo_source.select_confirmed_utxos( - claim_id, &must_spend, &tx.output, target_feerate_sat_per_1000_weight, - )?; - self.process_coin_selection(&mut tx, coin_selection); - Ok((tx, signers)) - } + log_debug!(self.logger, "Peforming coin selection for HTLC transaction targeting {} sat/kW", + target_feerate_sat_per_1000_weight); - /// Handles a [`BumpTransactionEvent::HTLCResolution`] event variant by producing a - /// fully-signed, fee-bumped HTLC transaction that is broadcast to the network. - fn handle_htlc_resolution( - &self, claim_id: ClaimId, target_feerate_sat_per_1000_weight: u32, - htlc_descriptors: &[HTLCDescriptor], tx_lock_time: PackedLockTime, - ) -> Result<(), ()> { - let (mut htlc_tx, signers) = self.build_htlc_tx( - claim_id, target_feerate_sat_per_1000_weight, htlc_descriptors, tx_lock_time, + #[cfg(debug_assertions)] + let must_spend_satisfaction_weight = + must_spend.iter().map(|input| input.satisfaction_weight).sum::(); + #[cfg(debug_assertions)] + let must_spend_amount = must_spend.iter().map(|input| input.previous_utxo.value).sum::(); + + let coin_selection: CoinSelection = self.utxo_source.select_confirmed_utxos( + claim_id, must_spend, &htlc_tx.output, target_feerate_sat_per_1000_weight, )?; - self.utxo_source.sign_tx(&mut htlc_tx)?; + #[cfg(debug_assertions)] + let total_satisfaction_weight = must_spend_satisfaction_weight + + coin_selection.confirmed_utxos.iter().map(|utxo| utxo.satisfaction_weight).sum::(); + #[cfg(debug_assertions)] + let total_input_amount = must_spend_amount + + coin_selection.confirmed_utxos.iter().map(|utxo| utxo.output.value).sum::(); + + self.process_coin_selection(&mut htlc_tx, &coin_selection); + + // construct psbt + let mut htlc_psbt = PartiallySignedTransaction::from_unsigned_tx(htlc_tx).unwrap(); + // add witness_utxo to htlc inputs + for (i, htlc_descriptor) in htlc_descriptors.iter().enumerate() { + debug_assert_eq!(htlc_psbt.unsigned_tx.input[i].previous_output, htlc_descriptor.outpoint()); + htlc_psbt.inputs[i].witness_utxo = Some(htlc_descriptor.previous_utxo(&self.secp)); + } + // add witness_utxo to remaining inputs + for (idx, utxo) in coin_selection.confirmed_utxos.into_iter().enumerate() { + // offset to skip the htlc inputs + let index = idx + htlc_descriptors.len(); + debug_assert_eq!(htlc_psbt.unsigned_tx.input[index].previous_output, utxo.outpoint); + if utxo.output.script_pubkey.is_witness_program() { + htlc_psbt.inputs[index].witness_utxo = Some(utxo.output); + } + } + + #[cfg(debug_assertions)] + let unsigned_tx_weight = htlc_psbt.unsigned_tx.weight().to_wu() - (htlc_psbt.unsigned_tx.input.len() as u64 * EMPTY_SCRIPT_SIG_WEIGHT); + + log_debug!(self.logger, "Signing HTLC transaction {}", htlc_psbt.unsigned_tx.txid()); + htlc_tx = self.utxo_source.sign_psbt(htlc_psbt)?; + + let mut signers = BTreeMap::new(); for (idx, htlc_descriptor) in htlc_descriptors.iter().enumerate() { - let signer = signers.get(&htlc_descriptor.channel_keys_id).unwrap(); - let htlc_sig = signer.sign_holder_htlc_transaction( - &htlc_tx, idx, htlc_descriptor, &self.secp - )?; - let per_commitment_point = signer.get_per_commitment_point( - htlc_descriptor.per_commitment_number, &self.secp - ); - let witness_script = htlc_descriptor.witness_script(&per_commitment_point, &self.secp); + let signer = signers.entry(htlc_descriptor.channel_derivation_parameters.keys_id) + .or_insert_with(|| htlc_descriptor.derive_channel_signer(&self.signer_provider)); + let htlc_sig = signer.sign_holder_htlc_transaction(&htlc_tx, idx, htlc_descriptor, &self.secp)?; + let witness_script = htlc_descriptor.witness_script(&self.secp); htlc_tx.input[idx].witness = htlc_descriptor.tx_input_witness(&htlc_sig, &witness_script); } + #[cfg(debug_assertions)] { + let signed_tx_weight = htlc_tx.weight().to_wu(); + let expected_signed_tx_weight = unsigned_tx_weight + total_satisfaction_weight; + // Our estimate should be within a 1% error margin of the actual weight and we should + // never underestimate. + assert!(expected_signed_tx_weight >= signed_tx_weight && + expected_signed_tx_weight - (expected_signed_tx_weight / 100) <= signed_tx_weight); + + let expected_signed_tx_fee = fee_for_weight(target_feerate_sat_per_1000_weight, signed_tx_weight); + let signed_tx_fee = total_input_amount - + htlc_tx.output.iter().map(|output| output.value).sum::(); + // Our fee should be within a 5% error margin of the expected fee based on the + // feerate and transaction weight and we should never pay less than required. + let fee_error_margin = expected_signed_tx_fee * 5 / 100; + assert!(signed_tx_fee >= expected_signed_tx_fee && + signed_tx_fee - fee_error_margin <= expected_signed_tx_fee); + } + + log_info!(self.logger, "Broadcasting {}", log_tx!(htlc_tx)); self.broadcaster.broadcast_transactions(&[&htlc_tx]); Ok(()) } - /// Handles all variants of [`BumpTransactionEvent`], immediately returning otherwise. - pub fn handle_event(&self, event: &Event) { - let event = if let Event::BumpTransaction(event) = event { - event - } else { - return; - }; + /// Handles all variants of [`BumpTransactionEvent`]. + pub fn handle_event(&self, event: &BumpTransactionEvent) { match event { BumpTransactionEvent::ChannelClose { claim_id, package_target_feerate_sat_per_1000_weight, commitment_tx, - anchor_descriptor, commitment_tx_fee_satoshis, .. + commitment_tx_fee_satoshis, anchor_descriptor, .. } => { + log_info!(self.logger, "Handling channel close bump (claim_id = {}, commitment_txid = {})", + log_bytes!(claim_id.0), commitment_tx.txid()); if let Err(_) = self.handle_channel_close( *claim_id, *package_target_feerate_sat_per_1000_weight, commitment_tx, *commitment_tx_fee_satoshis, anchor_descriptor, @@ -771,6 +799,8 @@ where BumpTransactionEvent::HTLCResolution { claim_id, target_feerate_sat_per_1000_weight, htlc_descriptors, tx_lock_time, } => { + log_info!(self.logger, "Handling HTLC bump (claim_id = {}, htlcs_to_claim = {})", + log_bytes!(claim_id.0), log_iter!(htlc_descriptors.iter().map(|d| d.outpoint()))); if let Err(_) = self.handle_htlc_resolution( *claim_id, *target_feerate_sat_per_1000_weight, htlc_descriptors, *tx_lock_time, ) {