Check if HTLC is worth claiming onchain when failing from monitor event

In previous commits, we added a config flag to allow a user to control a
multiplier on a threshold for whether to fail back an HTLC early if
we're waiting on a downstream confirmation, depending on how much we'd
save if we ended up successfully claimed on-chain. This commit adds the
logic to calculate this threshold, and adds the check when failing HTLCs
back from monitor events (although this won't do anything until we
actually generate new monitor events for this situation in upcoming
commits).

Author: alecchendev

lightning/src/ln/channel.rs

@@ -2100,6 +2100,45 @@ impl<SP: Deref> Channel<SP> where
 		Ok(())
 	}
 
+	/// The total fee paid to close the channel and claim an HTLC-success transaction, accounting
+	/// for an added input (spending a P2WPKH) and P2WPKH output for fee bumping.
+	fn cost_to_claim_onchain<L: Deref>(&self, feerate_per_kw: u32, logger: &L) -> u64
+	where L::Target: Logger
+	{
+		let commitment_weight = if self.context.is_outbound() {
+			let keys = self.context.build_holder_transaction_keys(self.context.cur_holder_commitment_transaction_number);
+			let commitment_stats = self.context.build_commitment_transaction(self.context.cur_holder_commitment_transaction_number, &keys, true, true, logger);
+			commitment_stats.total_fee_sat
+		} else { 0 };
+
+		let htlc_weight = htlc_success_tx_weight(self.context.get_channel_type());
+		let p2wpkh_weight = 31 * 4;
+		let input_weight = 272; // Including witness, assuming it spends from a p2wpkh
+
+		let total_weight = commitment_weight + htlc_weight + p2wpkh_weight + input_weight;
+		let total_fee = feerate_per_kw as u64 * total_weight / 1000;
+		total_fee
+	}
+
+	/// Check whether we should risk letting this channel force-close while waiting
+	/// for a downstream HTLC resolution on-chain. See [`ChannelConfig::early_fail_multiplier`]
+	/// for more info.
+	pub(super) fn check_worth_upstream_closing<F: Deref, L: Deref>(
+		&self, htlc_id: u64, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L
+	) -> Option<bool>
+	where F::Target: FeeEstimator, L::Target: Logger
+	{
+		let feerate_per_kw = fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::HighPriority);
+		let htlc = self.context.pending_inbound_htlcs.iter().find(|htlc| htlc.htlc_id == htlc_id)?;
+		let total_fee = self.cost_to_claim_onchain(feerate_per_kw, logger);
+		let threshold = total_fee * self.context.config().early_fail_multiplier / 1_000_000;
+		if htlc.amount_msat / 1000 >= threshold {
+			Some(true)
+		} else {
+			Some(false)
+		}
+	}
+
 	#[inline]
 	fn get_closing_scriptpubkey(&self) -> Script {
 		// The shutdown scriptpubkey is set on channel opening when option_upfront_shutdown_script

lightning/src/ln/channelmanager.rs

@@ -4791,6 +4791,37 @@ where
 		}
 	}
 
+	/// Check whether we should risk letting an upstream channel force-close while waiting
+	/// for a downstream HTLC resolution on-chain. See [`ChannelConfig::early_fail_multiplier`]
+	/// for more info.
+	fn check_worth_upstream_closing(&self, source: &HTLCSource) -> bool {
+		let (short_channel_id, htlc_id) = match source {
+			HTLCSource::OutboundRoute { .. } => {
+				debug_assert!(false, "This should not be called on outbound HTLCs");
+				return false;
+			},
+			HTLCSource::PreviousHopData(HTLCPreviousHopData { ref short_channel_id, ref htlc_id, .. }) => {
+				(short_channel_id, htlc_id)
+			},
+		};
+		let (counterparty_node_id, channel_id) = match self.short_to_chan_info.read().unwrap().get(short_channel_id) {
+			Some((cp_id, chan_id)) => (cp_id.clone(), chan_id.clone()),
+			None => return false,
+		};
+		let per_peer_state = self.per_peer_state.read().unwrap();
+		let mut peer_state_lock = match per_peer_state.get(&counterparty_node_id) {
+			Some(peer_state_mutex) => peer_state_mutex.lock().unwrap(),
+			None => return false,
+		};
+		let peer_state = &mut *peer_state_lock;
+		let chan = match peer_state.channel_by_id.get(&channel_id) {
+			Some(chan) => chan,
+			None => return false,
+		};
+		chan.check_worth_upstream_closing(
+			*htlc_id, &self.fee_estimator, &self.logger).unwrap_or(false)
+	}
+
 	/// Fails an HTLC backwards to the sender of it to us.
 	/// Note that we do not assume that channels corresponding to failed HTLCs are still available.
 	fn fail_htlc_backwards_internal(&self, source: &HTLCSource, payment_hash: &PaymentHash, onion_error: &HTLCFailReason, destination: HTLCDestination) {
@@ -6338,10 +6369,12 @@ where
 							log_trace!(self.logger, "Claiming HTLC with preimage {} from our monitor", &preimage);
 							self.claim_funds_internal(htlc_update.source, preimage, htlc_update.htlc_value_satoshis.map(|v| v * 1000), true, funding_outpoint);
 						} else {
-							log_trace!(self.logger, "Failing HTLC with hash {} from our monitor", &htlc_update.payment_hash);
-							let receiver = HTLCDestination::NextHopChannel { node_id: counterparty_node_id, channel_id: funding_outpoint.to_channel_id() };
-							let reason = HTLCFailReason::from_failure_code(0x4000 | 8);
-							self.fail_htlc_backwards_internal(&htlc_update.source, &htlc_update.payment_hash, &reason, receiver);
+							if !htlc_update.awaiting_downstream_confirmation || !self.check_worth_upstream_closing(&htlc_update.source) {
+								log_trace!(self.logger, "Failing HTLC with hash {} from our monitor", &htlc_update.payment_hash);
+								let receiver = HTLCDestination::NextHopChannel { node_id: counterparty_node_id, channel_id: funding_outpoint.to_channel_id() };
+								let reason = HTLCFailReason::from_failure_code(0x4000 | 8);
+								self.fail_htlc_backwards_internal(&htlc_update.source, &htlc_update.payment_hash, &reason, receiver);
+							}
 						}
 					},
 					MonitorEvent::CommitmentTxConfirmed(funding_outpoint) |