Generate ClaimEvent for HolderHTLCOutput inputs from anchor channels

Author: wpaulino

lightning/src/chain/channelmonitor.rs

@@ -2371,6 +2371,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 						pending_htlcs,
 					}));
 				},
+				_ => {},
 			}
 		}
 		ret

lightning/src/chain/onchaintx.rs

@@ -170,6 +170,18 @@ impl Writeable for Option<Vec<Option<(usize, Signature)>>> {
 	}
 }
 
+#[cfg(anchors)]
+pub(crate) enum ExternalHTLCClaim {
+	/// The claim commonly referred to as the pre-signed second-stage HTLC transaction.
+	SecondStage {
+		amount: u64,
+		per_commitment_number: u64,
+		redeem_script: Script,
+		preimage: Option<PaymentPreimage>,
+		counterparty_sig: Signature,
+	}
+}
+
 // Represents the different types of claims for which events are yielded externally to satisfy said
 // claims.
 #[cfg(anchors)]
@@ -181,6 +193,11 @@ pub(crate) enum ClaimEvent {
 		commitment_tx: Transaction,
 		anchor_output_idx: u32,
 	},
+	BumpHTLC {
+		target_feerate_sat_per_1000_weight: u32,
+		tx_template: Transaction,
+		htlcs: Vec<ExternalHTLCClaim>,
+	},
 }
 
 /// Represents the different ways an output can be claimed (i.e., spent to an address under our
@@ -472,15 +489,32 @@ impl<ChannelSigner: Sign> OnchainTxHandler<ChannelSigner> {
 		// didn't receive confirmation of it before, or not enough reorg-safe depth on top of it).
 		let new_timer = Some(cached_request.get_height_timer(cur_height));
 		if cached_request.is_malleable() {
+			#[cfg(anchors)]
+			if cached_request.requires_external_funding() {
+				let target_feerate_sat_per_1000_weight = cached_request
+					.compute_package_feerate(fee_estimator, ConfirmationTarget::HighPriority);
+				let (tx_template, htlcs) = cached_request.construct_malleable_package_with_external_funding(self);
+				return Some((
+					new_timer,
+					target_feerate_sat_per_1000_weight as u64,
+					OnchainClaim::Event(ClaimEvent::BumpHTLC {
+						target_feerate_sat_per_1000_weight,
+						tx_template,
+						htlcs,
+					}),
+				));
+			}
+
 			let predicted_weight = cached_request.package_weight(&self.destination_script);
-			if let Some((output_value, new_feerate)) =
-					cached_request.compute_package_output(predicted_weight, self.destination_script.dust_value().to_sat(), fee_estimator, logger) {
+			if let Some((output_value, new_feerate)) = cached_request.compute_package_output(
+				predicted_weight, self.destination_script.dust_value().to_sat(), fee_estimator, logger,
+			) {
 				assert!(new_feerate != 0);
 
 				let transaction = cached_request.finalize_malleable_package(self, output_value, self.destination_script.clone(), logger).unwrap();
 				log_trace!(logger, "...with timer {} and feerate {}", new_timer.unwrap(), new_feerate);
 				assert!(predicted_weight >= transaction.weight());
-				return Some((new_timer, new_feerate, OnchainClaim::Tx(transaction)))
+				return Some((new_timer, new_feerate, OnchainClaim::Tx(transaction)));
 			}
 		} else {
 			// Untractable packages cannot have their fees bumped through Replace-By-Fee. Some
@@ -536,7 +570,7 @@ impl<ChannelSigner: Sign> OnchainTxHandler<ChannelSigner> {
 					debug_assert!(false, "Only HolderFundingOutput inputs should be untractable and require external funding");
 					None
 				},
-			});
+			})
 		}
 		None
 	}
@@ -621,6 +655,7 @@ impl<ChannelSigner: Sign> OnchainTxHandler<ChannelSigner> {
 						log_info!(logger, "Yielding onchain event to spend inputs {:?}", req.outpoints());
 						let txid = match claim_event {
 							ClaimEvent::BumpCommitment { ref commitment_tx, .. } => commitment_tx.txid(),
+							ClaimEvent::BumpHTLC { ref tx_template, .. } => tx_template.txid(),
 						};
 						self.pending_claim_events.insert(txid, claim_event);
 						txid
@@ -646,14 +681,28 @@ impl<ChannelSigner: Sign> OnchainTxHandler<ChannelSigner> {
 						// outpoints to know if transaction is the original claim or a bumped one issued
 						// by us.
 						let mut set_equality = true;
-						if request.outpoints().len() != tx.input.len() {
-							set_equality = false;
-						} else {
-							for (claim_inp, tx_inp) in request.outpoints().iter().zip(tx.input.iter()) {
-								if **claim_inp != tx_inp.previous_output {
-									set_equality = false;
+						if !request.requires_external_funding() {
+							if request.outpoints().len() != tx.input.len() {
+								set_equality = false;
+							} else {
+								for (claim_inp, tx_inp) in request.outpoints().iter().zip(tx.input.iter()) {
+									if **claim_inp != tx_inp.previous_output {
+										set_equality = false;
+									}
 								}
 							}
+						} else {
+							let request_inputs = request.outpoints();
+							let mut input_set = HashSet::with_capacity(request_inputs.len());
+							for input in request_inputs {
+								let _ = input_set.insert(input);
+							}
+							for tx_input in &tx.input {
+								let _ = input_set.remove(&tx_input.previous_output);
+							}
+							if !input_set.is_empty() {
+								set_equality = false;
+							}
 						}
 
 						macro_rules! clean_claim_request_after_safety_delay {
@@ -956,6 +1005,40 @@ impl<ChannelSigner: Sign> OnchainTxHandler<ChannelSigner> {
 		htlc_tx
 	}
 
+	#[cfg(anchors)]
+	pub(crate) fn unsigned_htlc_tx(
+		&mut self, outp: &::bitcoin::OutPoint, preimage: &Option<PaymentPreimage>
+	) -> Option<(Transaction, ExternalHTLCClaim)> {
+		let find_htlc = |holder_commitment: &HolderCommitmentTransaction| -> Option<(Transaction, ExternalHTLCClaim)> {
+			let trusted_tx = holder_commitment.trust();
+			trusted_tx.htlcs().iter().enumerate()
+				.find(|(_, htlc)| if let Some(output_index) = htlc.transaction_output_index {
+					output_index == outp.vout
+				} else {
+					false
+				})
+				.map(|(htlc_idx, htlc)| {
+					let counterparty_htlc_sig = holder_commitment.counterparty_htlc_sigs[htlc_idx];
+					let htlc_tx = trusted_tx.unsigned_htlc_tx(
+						&self.channel_transaction_parameters.as_holder_broadcastable(), htlc_idx, preimage,
+					);
+					(htlc_tx, ExternalHTLCClaim::SecondStage {
+						amount: htlc.amount_msat / 1000,
+						per_commitment_number: trusted_tx.commitment_number(),
+						redeem_script: chan_utils::get_htlc_redeemscript_with_explicit_keys(
+							&htlc, self.opt_anchors(), &trusted_tx.keys().broadcaster_htlc_key,
+							&trusted_tx.keys().countersignatory_htlc_key, &trusted_tx.keys().revocation_key,
+						),
+						preimage: *preimage,
+						counterparty_sig: counterparty_htlc_sig,
+					})
+				})
+		};
+		// Check if the HTLC spends from the current holder commitment or the previous one otherwise.
+		find_htlc(&self.holder_commitment)
+			.or(self.prev_holder_commitment.as_ref().map(|c| find_htlc(c)).flatten())
+	}
+
 	pub(crate) fn opt_anchors(&self) -> bool {
 		self.channel_transaction_parameters.opt_anchors.is_some()
 	}

lightning/src/chain/package.rs

@@ -26,6 +26,8 @@ use crate::ln::chan_utils;
 use crate::ln::msgs::DecodeError;
 use crate::chain::chaininterface::{FeeEstimator, ConfirmationTarget, MIN_RELAY_FEE_SAT_PER_1000_WEIGHT};
 use crate::chain::keysinterface::Sign;
+#[cfg(anchors)]
+use crate::chain::onchaintx::ExternalHTLCClaim;
 use crate::chain::onchaintx::OnchainTxHandler;
 use crate::util::byte_utils;
 use crate::util::logger::Logger;
@@ -453,8 +455,13 @@ impl PackageSolvingData {
 	}
 	fn get_finalized_tx<Signer: Sign>(&self, outpoint: &BitcoinOutPoint, onchain_handler: &mut OnchainTxHandler<Signer>) -> Option<Transaction> {
 		match self {
-			PackageSolvingData::HolderHTLCOutput(ref outp) => { return onchain_handler.get_fully_signed_htlc_tx(outpoint, &outp.preimage); }
-			PackageSolvingData::HolderFundingOutput(ref outp) => { return Some(onchain_handler.get_fully_signed_holder_tx(&outp.funding_redeemscript)); }
+			PackageSolvingData::HolderHTLCOutput(ref outp) => {
+				debug_assert!(!outp.opt_anchors());
+				return onchain_handler.get_fully_signed_htlc_tx(outpoint, &outp.preimage);
+			}
+			PackageSolvingData::HolderFundingOutput(ref outp) => {
+				return Some(onchain_handler.get_fully_signed_holder_tx(&outp.funding_redeemscript));
+			}
 			_ => { panic!("API Error!"); }
 		}
 	}
@@ -654,6 +661,31 @@ impl PackageTemplate {
 		let output_weight = (8 + 1 + destination_script.len()) * WITNESS_SCALE_FACTOR;
 		inputs_weight + witnesses_weight + transaction_weight + output_weight
 	}
+	#[cfg(anchors)]
+	pub(crate) fn construct_malleable_package_with_external_funding<Signer: Sign>(
+		&self, onchain_handler: &mut OnchainTxHandler<Signer>,
+	) -> (Transaction, Vec<ExternalHTLCClaim>) {
+		debug_assert!(self.requires_external_funding());
+		let mut aggregate_tx = Transaction {
+			version: 2,
+			lock_time: PackedLockTime(self.package_timelock()),
+			input: Vec::with_capacity(self.inputs.len()),
+			output: Vec::with_capacity(self.inputs.len()),
+		};
+		let mut htlcs = Vec::with_capacity(self.inputs.len());
+		self.inputs.iter().for_each(|input| match input.1 {
+			PackageSolvingData::HolderHTLCOutput(ref outp) => {
+				debug_assert!(outp.opt_anchors());
+				onchain_handler.unsigned_htlc_tx(&input.0, &outp.preimage).map(|(mut htlc_tx, htlc)| {
+					aggregate_tx.input.push(htlc_tx.input.pop().unwrap());
+					aggregate_tx.output.push(htlc_tx.output.pop().unwrap());
+					htlcs.push(htlc)
+				});
+			}
+			_ => debug_assert!(false, "Expected HolderHTLCOutputs to not be aggregated with other input types"),
+		});
+		(aggregate_tx, htlcs)
+	}
 	pub(crate) fn finalize_malleable_package<L: Deref, Signer: Sign>(
 		&self, onchain_handler: &mut OnchainTxHandler<Signer>, value: u64, destination_script: Script, logger: &L
 	) -> Option<Transaction> where L::Target: Logger {

lightning/src/ln/chan_utils.rs

@@ -1532,8 +1532,12 @@ impl<'a> TrustedCommitmentTransaction<'a> {
 		Ok(ret)
 	}
 
-	/// Gets a signed HTLC transaction given a preimage (for !htlc.offered) and the holder HTLC transaction signature.
-	pub(crate) fn get_signed_htlc_tx(&self, channel_parameters: &DirectedChannelTransactionParameters, htlc_index: usize, counterparty_signature: &Signature, signature: &Signature, preimage: &Option<PaymentPreimage>) -> Transaction {
+	/// Builds the unsigned HTLC transaction for a HTLC with output index `htlc_index` within
+	/// the commitment transaction.
+	pub(crate) fn unsigned_htlc_tx(
+		&self, channel_parameters: &DirectedChannelTransactionParameters, htlc_index: usize,
+		preimage: &Option<PaymentPreimage>
+	) -> Transaction {
 		let inner = self.inner;
 		let keys = &inner.keys;
 		let txid = inner.built.txid;
@@ -1543,8 +1547,21 @@ impl<'a> TrustedCommitmentTransaction<'a> {
 		if !this_htlc.offered && preimage.is_none() { unreachable!(); }
 		// Further, we should never be provided the preimage for an HTLC-Timeout transaction.
 		if  this_htlc.offered && preimage.is_some() { unreachable!(); }
+		build_htlc_transaction(
+			&txid, inner.feerate_per_kw, channel_parameters.contest_delay(), &this_htlc,
+			self.opt_anchors(), &keys.broadcaster_delayed_payment_key, &keys.revocation_key,
+		)
+	}
 
-		let mut htlc_tx = build_htlc_transaction(&txid, inner.feerate_per_kw, channel_parameters.contest_delay(), &this_htlc, self.opt_anchors(), &keys.broadcaster_delayed_payment_key, &keys.revocation_key);
+	/// Gets a signed HTLC transaction given a preimage (for !htlc.offered) and the holder HTLC
+	/// transaction signature.
+	pub(crate) fn get_signed_htlc_tx(
+		&self, channel_parameters: &DirectedChannelTransactionParameters, htlc_index: usize,
+		counterparty_signature: &Signature, signature: &Signature, preimage: &Option<PaymentPreimage>
+	) -> Transaction {
+		let keys = &&self.inner.keys;
+		let this_htlc = &self.inner.htlcs[htlc_index];
+		let mut htlc_tx = self.unsigned_htlc_tx(channel_parameters, htlc_index, preimage);
 
 		let htlc_redeemscript = get_htlc_redeemscript_with_explicit_keys(&this_htlc, self.opt_anchors(), &keys.broadcaster_htlc_key, &keys.countersignatory_htlc_key, &keys.revocation_key);