mirrors/rust-lightning
1
0
Fork 0
mirror of https://github.com/lightningdevkit/rust-lightning.git synced 2025-01-19 05:43:55 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add new sub-module for BumpTransactionEvent

Browse Source 
Its accompanying event handler will also live here.
This commit is contained in:
Wilmer Paulino 2023-03-07 14:20:31 -08:00
parent ca9ca75f08
commit 174e16426a
No known key found for this signature in database
GPG Key ID: 634FE5FC544DCA31
6 changed files with 241 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lightning/src/chain/channelmonitor.rs
View File

@ -53,7 +53,7 @@ use crate::util::ser::{Readable, ReadableArgs, RequiredWrapper, MaybeReadable, U
use crate::util::byte_utils;
use crate::events::Event;
#[cfg(anchors)]
use crate::events::{AnchorDescriptor, HTLCDescriptor, BumpTransactionEvent};
use crate::events::bump_transaction::{AnchorDescriptor, HTLCDescriptor, BumpTransactionEvent};
use crate::prelude::*;
use core::{cmp, mem};

2
lightning/src/chain/keysinterface.rs
View File

@ -36,7 +36,7 @@ use crate::util::crypto::{hkdf_extract_expand_twice, sign};
use crate::util::ser::{Writeable, Writer, Readable};
use crate::chain::transaction::OutPoint;
#[cfg(anchors)]
use crate::events::HTLCDescriptor;
use crate::events::bump_transaction::HTLCDescriptor;
use crate::ln::channel::ANCHOR_OUTPUT_VALUE_SATOSHI;
use crate::ln::{chan_utils, PaymentPreimage};
use crate::ln::chan_utils::{HTLCOutputInCommitment, make_funding_redeemscript, ChannelPublicKeys, HolderCommitmentTransaction, ChannelTransactionParameters, CommitmentTransaction, ClosingTransaction};

231
lightning/src/events/bump_transaction.rs Normal file
View File

@ -0,0 +1,231 @@
// This file is Copyright its original authors, visible in version control
// history.
//
// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// 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.
use crate::ln::PaymentPreimage;
use crate::ln::chan_utils;
use crate::ln::chan_utils::{ChannelTransactionParameters, HTLCOutputInCommitment};
use bitcoin::{OutPoint, PackedLockTime, Script, Transaction, Txid, TxIn, TxOut, Witness};
use bitcoin::secp256k1;
use bitcoin::secp256k1::{PublicKey, Secp256k1};
use bitcoin::secp256k1::ecdsa::Signature;
/// 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::chain::keysinterface::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::chain::keysinterface::InMemorySigner
pub channel_value_satoshis: u64,
/// 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::chain::keysinterface::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::chain::keysinterface::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::chain::keysinterface::InMemorySigner
/// [`ChannelSigner::provide_channel_parameters`]: crate::chain::keysinterface::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<PaymentPreimage>,
/// The counterparty's signature required to spend the HTLC output.
pub counterparty_sig: Signature
}
impl HTLCDescriptor {
/// Returns the unsigned transaction input spending the HTLC 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 */)
}
/// Returns the delayed output created as a result of spending the HTLC output in the commitment
/// transaction.
pub fn tx_output<C: secp256k1::Signing + secp256k1::Verification>(
&self, per_commitment_point: &PublicKey, secp: &Secp256k1<C>
) -> 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 HTLC output in the commitment transaction.
pub fn witness_script<C: secp256k1::Signing + secp256k1::Verification>(
&self, per_commitment_point: &PublicKey, secp: &Secp256k1<C>
) -> 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 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 */
)
}
}
/// Represents the different types of transactions, originating from LDK, to be bumped.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum BumpTransactionEvent {
/// Indicates that a channel featuring anchor outputs is to be closed by broadcasting the local
/// commitment transaction. Since commitment transactions have a static feerate pre-agreed upon,
/// they may need additional fees to be attached through a child transaction using the popular
/// [Child-Pays-For-Parent](https://bitcoinops.org/en/topics/cpfp) fee bumping technique. This
/// child transaction must include the anchor input described within `anchor_descriptor` along
/// with additional inputs to meet the target feerate. Failure to meet the target feerate
/// decreases the confirmation odds of the transaction package (which includes the commitment
/// and child anchor transactions), possibly resulting in a loss of funds. Once the transaction
/// is constructed, it must be fully signed for and broadcast by the consumer of the event
/// along with the `commitment_tx` enclosed. Note that the `commitment_tx` must always be
/// 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.
///
/// 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
/// be taken by the consumer of the event to ensure any future iterations of the child anchor
/// transaction adhere to the [Replace-By-Fee
/// rules](https://github.com/bitcoin/bitcoin/blob/master/doc/policy/mempool-replacements.md)
/// for fee bumps to be accepted into the mempool, and eventually the chain. As the frequency of
/// these events is not user-controlled, users may ignore/drop the event if they are no longer
/// able to commit external confirmed funds to the child anchor transaction.
///
/// The set of `pending_htlcs` on the commitment transaction to be broadcast can be inspected to
/// determine whether a significant portion of the channel's funds are allocated to HTLCs,
/// enabling users to make their own decisions regarding the importance of the commitment
/// transaction's confirmation. Note that this is not required, but simply exists as an option
/// for users to override LDK's behavior. On commitments with no HTLCs (indicated by those with
/// an empty `pending_htlcs`), confirmation of the commitment transaction can be considered to
/// be not urgent.
///
/// [`InMemorySigner`]: crate::chain::keysinterface::InMemorySigner
/// [`KeysManager::derive_channel_keys`]: crate::chain::keysinterface::KeysManager::derive_channel_keys
/// [`EcdsaChannelSigner::sign_holder_anchor_input`]: crate::chain::keysinterface::EcdsaChannelSigner::sign_holder_anchor_input
/// [`build_anchor_input_witness`]: crate::ln::chan_utils::build_anchor_input_witness
ChannelClose {
/// The target feerate that the transaction package, which consists of the commitment
/// transaction and the to-be-crafted child anchor transaction, must meet.
package_target_feerate_sat_per_1000_weight: u32,
/// The channel's commitment transaction to bump the fee of. This transaction should be
/// broadcast along with the anchor transaction constructed as a result of consuming this
/// event.
commitment_tx: Transaction,
/// The absolute fee in satoshis of the commitment transaction. This can be used along the
/// with weight of the commitment transaction to determine its feerate.
commitment_tx_fee_satoshis: u64,
/// The descriptor to sign the anchor input of the anchor transaction constructed as a
/// result of consuming this event.
anchor_descriptor: AnchorDescriptor,
/// The set of pending HTLCs on the commitment transaction that need to be resolved once the
/// commitment transaction confirms.
pending_htlcs: Vec<HTLCOutputInCommitment>,
},
/// Indicates that a channel featuring anchor outputs has unilaterally closed on-chain by a
/// holder commitment transaction and its HTLC(s) need to be resolved on-chain. With the
/// zero-HTLC-transaction-fee variant of anchor outputs, the pre-signed HTLC
/// transactions have a zero fee, thus requiring additional inputs and/or outputs to be attached
/// for a timely confirmation within the chain. These additional inputs and/or outputs must be
/// appended to the resulting HTLC transaction to meet the target feerate. Failure to meet the
/// target feerate decreases the confirmation odds of the transaction, possibly resulting in a
/// loss of funds. Once the transaction meets the target feerate, it must be signed for and
/// 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.
///
/// 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
/// the consumer of the event to ensure any future iterations of the HTLC transaction adhere to
/// the [Replace-By-Fee
/// rules](https://github.com/bitcoin/bitcoin/blob/master/doc/policy/mempool-replacements.md)
/// for fee bumps to be accepted into the mempool, and eventually the chain. As the frequency of
/// these events is not user-controlled, users may ignore/drop the event if either they are no
/// 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::chain::keysinterface::InMemorySigner
/// [`KeysManager::derive_channel_keys`]: crate::chain::keysinterface::KeysManager::derive_channel_keys
/// [`EcdsaChannelSigner::sign_holder_htlc_transaction`]: crate::chain::keysinterface::EcdsaChannelSigner::sign_holder_htlc_transaction
/// [`HTLCDescriptor::tx_input_witness`]: HTLCDescriptor::tx_input_witness
HTLCResolution {
/// The target feerate that the resulting HTLC transaction must meet.
target_feerate_sat_per_1000_weight: u32,
/// The set of pending HTLCs on the confirmed commitment that need to be claimed, preferably
/// by the same transaction.
htlc_descriptors: Vec<HTLCDescriptor>,
},
}

230
lightning/src/events/mod.rs
View File

@ -14,9 +14,13 @@
//! future, as well as generate and broadcast funding transactions handle payment preimages and a
//! few other things.
use crate::chain::keysinterface::SpendableOutputDescriptor;
#[cfg(anchors)]
use crate::ln::chan_utils::{self, ChannelTransactionParameters, HTLCOutputInCommitment};
pub mod bump_transaction;
#[cfg(anchors)]
pub use bump_transaction::BumpTransactionEvent;
use crate::chain::keysinterface::SpendableOutputDescriptor;
use crate::ln::channelmanager::{InterceptId, PaymentId};
use crate::ln::channel::FUNDING_CONF_DEADLINE_BLOCKS;
use crate::ln::features::ChannelTypeFeatures;
@ -29,16 +33,10 @@ use crate::util::string::UntrustedString;
use crate::routing::router::{RouteHop, RouteParameters};
use bitcoin::{PackedLockTime, Transaction};
#[cfg(anchors)]
use bitcoin::{OutPoint, Txid, TxIn, TxOut, Witness};
use bitcoin::blockdata::script::Script;
use bitcoin::hashes::Hash;
use bitcoin::hashes::sha256::Hash as Sha256;
use bitcoin::secp256k1::PublicKey;
#[cfg(anchors)]
use bitcoin::secp256k1::{self, Secp256k1};
#[cfg(anchors)]
use bitcoin::secp256k1::ecdsa::Signature;
use crate::io;
use crate::prelude::*;
use core::time::Duration;
@ -256,222 +254,6 @@ impl_writeable_tlv_based_enum_upgradable!(HTLCDestination,
},
);
#[cfg(anchors)]
/// 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::chain::keysinterface::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::chain::keysinterface::InMemorySigner
pub channel_value_satoshis: u64,
/// The transaction input's outpoint corresponding to the commitment transaction's anchor
/// output.
pub outpoint: OutPoint,
}
#[cfg(anchors)]
/// 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::chain::keysinterface::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::chain::keysinterface::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::chain::keysinterface::InMemorySigner
/// [`ChannelSigner::provide_channel_parameters`]: crate::chain::keysinterface::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<PaymentPreimage>,
/// The counterparty's signature required to spend the HTLC output.
pub counterparty_sig: Signature
}
#[cfg(anchors)]
impl HTLCDescriptor {
/// Returns the unsigned transaction input spending the HTLC 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 */)
}
/// Returns the delayed output created as a result of spending the HTLC output in the commitment
/// transaction.
pub fn tx_output<C: secp256k1::Signing + secp256k1::Verification>(
&self, per_commitment_point: &PublicKey, secp: &Secp256k1<C>
) -> 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 HTLC output in the commitment transaction.
pub fn witness_script<C: secp256k1::Signing + secp256k1::Verification>(
&self, per_commitment_point: &PublicKey, secp: &Secp256k1<C>
) -> 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 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 */
)
}
}
#[cfg(anchors)]
/// Represents the different types of transactions, originating from LDK, to be bumped.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum BumpTransactionEvent {
/// Indicates that a channel featuring anchor outputs is to be closed by broadcasting the local
/// commitment transaction. Since commitment transactions have a static feerate pre-agreed upon,
/// they may need additional fees to be attached through a child transaction using the popular
/// [Child-Pays-For-Parent](https://bitcoinops.org/en/topics/cpfp) fee bumping technique. This
/// child transaction must include the anchor input described within `anchor_descriptor` along
/// with additional inputs to meet the target feerate. Failure to meet the target feerate
/// decreases the confirmation odds of the transaction package (which includes the commitment
/// and child anchor transactions), possibly resulting in a loss of funds. Once the transaction
/// is constructed, it must be fully signed for and broadcast by the consumer of the event
/// along with the `commitment_tx` enclosed. Note that the `commitment_tx` must always be
/// 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.
///
/// 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
/// be taken by the consumer of the event to ensure any future iterations of the child anchor
/// transaction adhere to the [Replace-By-Fee
/// rules](https://github.com/bitcoin/bitcoin/blob/master/doc/policy/mempool-replacements.md)
/// for fee bumps to be accepted into the mempool, and eventually the chain. As the frequency of
/// these events is not user-controlled, users may ignore/drop the event if they are no longer
/// able to commit external confirmed funds to the child anchor transaction.
///
/// The set of `pending_htlcs` on the commitment transaction to be broadcast can be inspected to
/// determine whether a significant portion of the channel's funds are allocated to HTLCs,
/// enabling users to make their own decisions regarding the importance of the commitment
/// transaction's confirmation. Note that this is not required, but simply exists as an option
/// for users to override LDK's behavior. On commitments with no HTLCs (indicated by those with
/// an empty `pending_htlcs`), confirmation of the commitment transaction can be considered to
/// be not urgent.
///
/// [`InMemorySigner`]: crate::chain::keysinterface::InMemorySigner
/// [`KeysManager::derive_channel_keys`]: crate::chain::keysinterface::KeysManager::derive_channel_keys
/// [`EcdsaChannelSigner::sign_holder_anchor_input`]: crate::chain::keysinterface::EcdsaChannelSigner::sign_holder_anchor_input
/// [`build_anchor_input_witness`]: crate::ln::chan_utils::build_anchor_input_witness
ChannelClose {
/// The target feerate that the transaction package, which consists of the commitment
/// transaction and the to-be-crafted child anchor transaction, must meet.
package_target_feerate_sat_per_1000_weight: u32,
/// The channel's commitment transaction to bump the fee of. This transaction should be
/// broadcast along with the anchor transaction constructed as a result of consuming this
/// event.
commitment_tx: Transaction,
/// The absolute fee in satoshis of the commitment transaction. This can be used along the
/// with weight of the commitment transaction to determine its feerate.
commitment_tx_fee_satoshis: u64,
/// The descriptor to sign the anchor input of the anchor transaction constructed as a
/// result of consuming this event.
anchor_descriptor: AnchorDescriptor,
/// The set of pending HTLCs on the commitment transaction that need to be resolved once the
/// commitment transaction confirms.
pending_htlcs: Vec<HTLCOutputInCommitment>,
},
/// Indicates that a channel featuring anchor outputs has unilaterally closed on-chain by a
/// holder commitment transaction and its HTLC(s) need to be resolved on-chain. With the
/// zero-HTLC-transaction-fee variant of anchor outputs, the pre-signed HTLC
/// transactions have a zero fee, thus requiring additional inputs and/or outputs to be attached
/// for a timely confirmation within the chain. These additional inputs and/or outputs must be
/// appended to the resulting HTLC transaction to meet the target feerate. Failure to meet the
/// target feerate decreases the confirmation odds of the transaction, possibly resulting in a
/// loss of funds. Once the transaction meets the target feerate, it must be signed for and
/// 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.
///
/// 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
/// the consumer of the event to ensure any future iterations of the HTLC transaction adhere to
/// the [Replace-By-Fee
/// rules](https://github.com/bitcoin/bitcoin/blob/master/doc/policy/mempool-replacements.md)
/// for fee bumps to be accepted into the mempool, and eventually the chain. As the frequency of
/// these events is not user-controlled, users may ignore/drop the event if either they are no
/// 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::chain::keysinterface::InMemorySigner
/// [`KeysManager::derive_channel_keys`]: crate::chain::keysinterface::KeysManager::derive_channel_keys
/// [`EcdsaChannelSigner::sign_holder_htlc_transaction`]: crate::chain::keysinterface::EcdsaChannelSigner::sign_holder_htlc_transaction
/// [`HTLCDescriptor::tx_input_witness`]: HTLCDescriptor::tx_input_witness
HTLCResolution {
/// The target feerate that the resulting HTLC transaction must meet.
target_feerate_sat_per_1000_weight: u32,
/// The set of pending HTLCs on the confirmed commitment that need to be claimed, preferably
/// by the same transaction.
htlc_descriptors: Vec<HTLCDescriptor>,
},
}
/// Will be used in [`Event::HTLCIntercepted`] to identify the next hop in the HTLC's path.
/// Currently only used in serialization for the sake of maintaining compatibility. More variants
/// will be added for general-purpose HTLC forward intercepts as well as trampoline forward

2
lightning/src/ln/monitor_tests.rs
View File

@ -17,7 +17,7 @@ use crate::chain::channelmonitor::{ANTI_REORG_DELAY, Balance};
use crate::chain::transaction::OutPoint;
use crate::chain::chaininterface::LowerBoundedFeeEstimator;
#[cfg(anchors)]
use crate::events::BumpTransactionEvent;
use crate::events::bump_transaction::BumpTransactionEvent;
use crate::events::{Event, MessageSendEvent, MessageSendEventsProvider, ClosureReason, HTLCDestination};
use crate::ln::channel;
#[cfg(anchors)]

2
lightning/src/util/enforcing_trait_impls.rs
View File

@ -24,7 +24,7 @@ use bitcoin::secp256k1;
use bitcoin::secp256k1::{SecretKey, PublicKey};
use bitcoin::secp256k1::{Secp256k1, ecdsa::Signature};
#[cfg(anchors)]
use crate::events::HTLCDescriptor;
use crate::events::bump_transaction::HTLCDescriptor;
use crate::util::ser::{Writeable, Writer};
use crate::io::Error;