Track HTLC resolving transaction to determine input index

Author: wpaulino

lightning/src/chain/channelmonitor.rs

@@ -643,6 +643,7 @@ struct IrrevocablyResolvedHTLC {
 	/// was not present in the confirmed commitment transaction), HTLC-Success, or HTLC-Timeout
 	/// transaction.
 	resolving_txid: Option<Txid>, // Added as optional, but always filled in, in 0.0.110
+	resolving_tx: Option<Transaction>,
 	/// Only set if the HTLC claim was ours using a payment preimage
 	payment_preimage: Option<PaymentPreimage>,
 }
@@ -658,6 +659,7 @@ impl Writeable for IrrevocablyResolvedHTLC {
 			(0, mapped_commitment_tx_output_idx, required),
 			(1, self.resolving_txid, option),
 			(2, self.payment_preimage, option),
+			(3, self.resolving_tx, option),
 		});
 		Ok(())
 	}
@@ -668,15 +670,18 @@ impl Readable for IrrevocablyResolvedHTLC {
 		let mut mapped_commitment_tx_output_idx = 0;
 		let mut resolving_txid = None;
 		let mut payment_preimage = None;
+		let mut resolving_tx = None;
 		read_tlv_fields!(reader, {
 			(0, mapped_commitment_tx_output_idx, required),
 			(1, resolving_txid, option),
 			(2, payment_preimage, option),
+			(3, resolving_tx, option),
 		});
 		Ok(Self {
 			commitment_tx_output_idx: if mapped_commitment_tx_output_idx == u32::max_value() { None } else { Some(mapped_commitment_tx_output_idx) },
 			resolving_txid,
 			payment_preimage,
+			resolving_tx,
 		})
 	}
 }
@@ -1510,24 +1515,24 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		let htlc_commitment_tx_output_idx =
 			if let Some(v) = htlc.transaction_output_index { v } else { return None; };
 
-		let mut htlc_spend_txid_opt = None;
+		let mut htlc_spend_tx_opt = None;
 		let mut holder_timeout_spend_pending = None;
 		let mut htlc_spend_pending = None;
 		let mut holder_delayed_output_pending = None;
 		for event in self.onchain_events_awaiting_threshold_conf.iter() {
 			match event.event {
 				OnchainEvent::HTLCUpdate { commitment_tx_output_idx, htlc_value_satoshis, .. }
 				if commitment_tx_output_idx == Some(htlc_commitment_tx_output_idx) => {
-					debug_assert!(htlc_spend_txid_opt.is_none());
-					htlc_spend_txid_opt = event.transaction.as_ref().map(|tx| tx.txid());
+					debug_assert!(htlc_spend_tx_opt.is_none());
+					htlc_spend_tx_opt = event.transaction.clone();
 					debug_assert!(holder_timeout_spend_pending.is_none());
 					debug_assert_eq!(htlc_value_satoshis.unwrap(), htlc.amount_msat / 1000);
 					holder_timeout_spend_pending = Some(event.confirmation_threshold());
 				},
 				OnchainEvent::HTLCSpendConfirmation { commitment_tx_output_idx, preimage, .. }
 				if commitment_tx_output_idx == htlc_commitment_tx_output_idx => {
-					debug_assert!(htlc_spend_txid_opt.is_none());
-					htlc_spend_txid_opt = event.transaction.as_ref().map(|tx| tx.txid());
+					debug_assert!(htlc_spend_tx_opt.is_none());
+					htlc_spend_tx_opt = event.transaction.clone();
 					debug_assert!(htlc_spend_pending.is_none());
 					htlc_spend_pending = Some((event.confirmation_threshold(), preimage.is_some()));
 				},
@@ -1542,20 +1547,22 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		}
 		let htlc_resolved = self.htlcs_resolved_on_chain.iter()
 			.find(|v| if v.commitment_tx_output_idx == Some(htlc_commitment_tx_output_idx) {
-				debug_assert!(htlc_spend_txid_opt.is_none());
-				htlc_spend_txid_opt = v.resolving_txid;
+				debug_assert!(htlc_spend_tx_opt.is_none());
+				htlc_spend_tx_opt = v.resolving_tx.clone();
 				true
 			} else { false });
 		debug_assert!(holder_timeout_spend_pending.is_some() as u8 + htlc_spend_pending.is_some() as u8 + htlc_resolved.is_some() as u8 <= 1);
 
+		let htlc_commitment_outpoint = BitcoinOutPoint::new(confirmed_txid.unwrap(), htlc_commitment_tx_output_idx);
 		let htlc_output_to_spend =
-			if let Some(txid) = htlc_spend_txid_opt {
-				debug_assert!(
-					self.onchain_tx_handler.channel_transaction_parameters.opt_anchors.is_none(),
-					"This code needs updating for anchors");
-				BitcoinOutPoint::new(txid, 0)
+			if let Some(ref tx) = htlc_spend_tx_opt {
+				let htlc_input_idx = tx.input.iter().enumerate()
+					.find(|(_, input)| input.previous_output == htlc_commitment_outpoint)
+					.map(|(idx, _)| idx as u32)
+					.unwrap();
+				BitcoinOutPoint::new(tx.txid(), htlc_input_idx)
 			} else {
-				BitcoinOutPoint::new(confirmed_txid.unwrap(), htlc_commitment_tx_output_idx)
+				htlc_commitment_outpoint
 			};
 		let htlc_output_spend_pending = self.onchain_tx_handler.is_output_spend_pending(&htlc_output_to_spend);
 
@@ -1578,9 +1585,9 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 					descriptor: SpendableOutputDescriptor::StaticOutput { .. }
 				} = &event.event {
 					if event.transaction.as_ref().map(|tx| tx.input.iter().any(|inp| {
-						if let Some(htlc_spend_txid) = htlc_spend_txid_opt {
-							Some(tx.txid()) == htlc_spend_txid_opt ||
-								inp.previous_output.txid == htlc_spend_txid
+						if let Some(ref htlc_spend_tx) = htlc_spend_tx_opt {
+							let htlc_spend_txid = htlc_spend_tx.txid();
+							tx.txid() == htlc_spend_txid || inp.previous_output.txid == htlc_spend_txid
 						} else {
 							Some(inp.previous_output.txid) == confirmed_txid &&
 								inp.previous_output.vout == htlc_commitment_tx_output_idx
@@ -3048,7 +3055,9 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 						htlc_value_satoshis,
 					}));
 					self.htlcs_resolved_on_chain.push(IrrevocablyResolvedHTLC {
-						commitment_tx_output_idx, resolving_txid: Some(entry.txid),
+						commitment_tx_output_idx,
+						resolving_txid: Some(entry.txid),
+						resolving_tx: entry.transaction,
 						payment_preimage: None,
 					});
 				},
@@ -3060,7 +3069,9 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 				},
 				OnchainEvent::HTLCSpendConfirmation { commitment_tx_output_idx, preimage, .. } => {
 					self.htlcs_resolved_on_chain.push(IrrevocablyResolvedHTLC {
-						commitment_tx_output_idx: Some(commitment_tx_output_idx), resolving_txid: Some(entry.txid),
+						commitment_tx_output_idx: Some(commitment_tx_output_idx),
+						resolving_txid: Some(entry.txid),
+						resolving_tx: entry.transaction,
 						payment_preimage: 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 of the HTLC output in the commitment transaction.
+		amount: 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)]
@@ -239,7 +270,7 @@ pub enum BumpTransactionEvent {
 	/// 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 broadcasted by the consumer of the event
+	/// 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.
 	///
@@ -328,19 +359,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