Avoid duplicate fails from monitor events

In an upcoming commit, we'll fail back an HTLC early to preserve a
backwards channel in the event that a forward channel force close
doesn't confirm soon before the backwards channel's timeout. After
failing back, the forward channel may eventually confirm on-chain,
possibly generating another fail back event. Since we may have already
failed back this HTLC, before failing we check that the HTLC exists
and hasn't already been marked for failure.

Author: alecchendev

lightning/src/ln/channel.rs

@@ -2193,6 +2193,20 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 		self.context.channel_transaction_parameters.funding_outpoint.unwrap()
 	}
 
+	/// Returns whether an inbound HTLC on this channel has already been failed.
+	/// Returns None if the HTLC is not found.
+	pub fn check_inbound_htlc_failed(&self, htlc_id: u64) -> Option<bool> {
+		self.context.pending_inbound_htlcs.iter()
+			.find(|htlc| htlc.htlc_id == htlc_id)
+			.map(|htlc| match htlc.state {
+				InboundHTLCState::LocalRemoved(
+					InboundHTLCRemovalReason::FailRelay(_)
+					| InboundHTLCRemovalReason::FailMalformed(_)
+				) => true,
+				_ => false,
+			})
+	}
+
 	/// Claims an HTLC while we're disconnected from a peer, dropping the [`ChannelMonitorUpdate`]
 	/// entirely.
 	///

lightning/src/ln/channelmanager.rs

@@ -6131,10 +6131,28 @@ where
 							log_trace!(self.logger, "Claiming HTLC with preimage {} from our monitor", log_bytes!(preimage.0));
 							self.claim_funds_internal(htlc_update.source, preimage, htlc_update.htlc_value_satoshis.map(|v| v * 1000), true, funding_outpoint.to_channel_id());
 						} else {
-							log_trace!(self.logger, "Failing HTLC with hash {} from our monitor", log_bytes!(htlc_update.payment_hash.0));
-							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);
+							let mut already_failed = false;
+							if let HTLCSource::PreviousHopData(HTLCPreviousHopData { htlc_id, ref short_channel_id, .. }) = htlc_update.source {
+								let counterparty_and_channel_id = self.short_to_chan_info.read().unwrap()
+									.get(short_channel_id).map(|v| v.clone());
+								match counterparty_and_channel_id {
+									Some((counterparty_node_id, channel_id)) => {
+										let per_peer_state = self.per_peer_state.read().unwrap();
+										if let Some(peer_state_mutex) = per_peer_state.get(&counterparty_node_id) {
+											if let Some(chan) = peer_state_mutex.lock().unwrap().channel_by_id.get(&channel_id) {
+												already_failed = chan.check_inbound_htlc_failed(htlc_id).unwrap_or(true);
+											}
+										}
+									},
+									None => {},
+								}
+							}
+							if !already_failed {
+								log_trace!(self.logger, "Failing HTLC with hash {} from our monitor", log_bytes!(htlc_update.payment_hash.0));
+								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) |