f! docs

Author: wpaulino

lightning/src/chain/channelmonitor.rs

@@ -2378,11 +2378,11 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 					for htlc in htlcs {
 						match htlc {
 							ExternalHTLCClaim::SecondStage {
-								amount, per_commitment_number, redeem_script, preimage, counterparty_sig
+								amount_sats, per_commitment_number, redeem_script, preimage, counterparty_sig
 							} => htlc_descriptors.push(HTLCDescriptor::SecondStage {
 								channel_keys_id: self.channel_keys_id,
 								channel_value_satoshis: self.channel_value_satoshis,
-								amount,
+								amount_satoshis: amount_sats,
 								per_commitment_number,
 								redeem_script,
 								preimage,

lightning/src/util/events.rs

@@ -227,6 +227,37 @@ pub struct AnchorDescriptor {
 	pub outpoint: OutPoint,
 }
 
+#[cfg(anchors)]
+/// A descriptor used to sign for a commitment transaction's HTLC output.
+#[derive(Clone, Debug)]
+pub enum HTLCDescriptor {
+	/// A variant used to sign for HTLC inputs being spent by their pre-signed second-stage
+	/// transactions.
+	SecondStage {
+		/// A unique identifier used along with `channel_value_satoshis` to re-derive the
+		/// [`InMemorySigner`] required to sign `input`.
+		///
+		/// [`InMemorySigner`]: crate::chain::keysinterface::InMemorySigner
+		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
+		channel_value_satoshis: u64,
+		/// The amount in satoshis of the HTLC output in the commitment transaction.
+		amount_satoshis: u64,
+		/// The number of the commitment transaction in which the HTLC output lives.
+		per_commitment_number: u64,
+		/// The redeem script that satisfies the HTLC output script.
+		redeem_script: Script,
+		/// The preimage, if one exists, to claim the HTLC output with.
+		preimage: Option<PaymentPreimage>,
+		/// The counterparty's signature required to spend the HTLC output.
+		counterparty_sig: Signature
+	}
+}
+
 #[cfg(anchors)]
 /// Represents the different types of transactions, originating from LDK, to be bumped.
 #[derive(Clone, Debug)]
@@ -294,18 +325,16 @@ pub enum BumpTransactionEvent {
 	/// onchain. 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 enclosed `tx_template` to meet the target feerate. Consumers must ensure the
-	/// order of pre-existing inputs and outputs within `tx_template` are not changed, as it is
-	/// crucial to the validity of the transaction itself. Failure to meet the target feerate
-	/// decreases the confirmation odds of the transaction, possinly resulting in a loss of funds.
-	/// Once the transaction is amended to meet the target feerate, it must be signed for and
-	/// broadcast by the consumer of the event.
+	/// appended to the enclosed `tx_template` 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 is amended to meet 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 additional inputs added to `tx_template`.
 	/// To sign HTLC inputs, an [`InMemorySigner`] should be re-derived through
 	/// [`KeysManager::derive_channel_keys`] with the help of `channel_keys_id` and
-	/// `AnchorDescriptor::channel_value_satoshis`. Each HTLC input's signature can be computed
-	/// with [`InMemorySigner::sign_holder_htlc_transaction`], which can then be provided to
+	/// `channel_value_satoshis`. Each HTLC input's signature can be computed with
+	/// [`InMemorySigner::sign_holder_htlc_transaction`], which can then be provided to
 	/// [`build_htlc_input_witness`] along with the enclosed [`HTLCDescriptor`] to obtain the full
 	/// witness required to spend.
 	///
@@ -328,19 +357,6 @@ pub enum BumpTransactionEvent {
 	},
 }
 
-#[derive(Clone, Debug)]
-pub enum HTLCDescriptor {
-	SecondStage {
-		channel_keys_id: [u8; 32],
-		channel_value_satoshis: u64,
-		amount: u64,
-		per_commitment_number: u64,
-		redeem_script: Script,
-		preimage: Option<PaymentPreimage>,
-		counterparty_sig: Signature
-	}
-}
-
 /// An Event which you should probably take some action in response to.
 ///
 /// Note that while Writeable and Readable are implemented for Event, you probably shouldn't use