Add ChannelManager::fail_htlc_backwards_with_reason

This function allows a user to specify the error code and
corresponding data to send to peers when failing back an HTLC.
This function is mentioned in Event::PaymentClaimable docs.
ChannelManager::get_htlc_fail_reason_from_failure_code was also
added to assist with this function.

Author: alecchendev

lightning/src/ln/channelmanager.rs

@@ -3511,31 +3511,48 @@ where
 			for htlc in sources.drain(..) {
 				let source = HTLCSource::PreviousHopData(htlc.prev_hop.clone());
 				let receiver = HTLCDestination::FailedPayment { payment_hash: *payment_hash };
+				let reason = self.get_htlc_fail_reason_from_failure_code(failure_code, &htlc);
+				self.fail_htlc_backwards_internal(&source, &payment_hash, &reason, receiver);
+			}
+		}
+	}
 
-				let reason = match failure_code {
-					FailureCode::TemporaryNodeFailure => HTLCFailReason::from_failure_code(*failure_code as u16),
-					FailureCode::RequiredNodeFeatureMissing => HTLCFailReason::from_failure_code(*failure_code as u16),
-					FailureCode::ExpiryTooSoon => {
-						let short_channel_id = htlc.prev_hop.short_channel_id;
-						let (counterparty_node_id, chan_id) = self.short_to_chan_info.read().unwrap().get(&short_channel_id).cloned().unwrap();
-						let per_peer_state = self.per_peer_state.read().unwrap();
-						let peer_state = per_peer_state.get(&counterparty_node_id).unwrap().lock().unwrap();
-						let chan = peer_state.channel_by_id.get(&chan_id).unwrap();
-						let channel_update = self.get_channel_update_for_onion(short_channel_id, chan).unwrap();
-						let mut channel_update_data = Vec::new();
-						(channel_update.serialized_length() as u16 + 2).write(&mut channel_update_data).expect("Writes cannot fail");
-						msgs::ChannelUpdate::TYPE.write(&mut channel_update_data).expect("Writes cannot fail");
-						channel_update.write(&mut channel_update_data).expect("Writes cannot fail");
-						HTLCFailReason::reason(*failure_code as u16, channel_update_data)
-					},
-					FailureCode::IncorrectOrUnknownPaymentDetails => {
-						let mut htlc_msat_height_data = htlc.value.to_be_bytes().to_vec();
-						htlc_msat_height_data.extend_from_slice(&self.best_block.read().unwrap().height().to_be_bytes());
-						HTLCFailReason::reason(*failure_code as u16, htlc_msat_height_data)
+	/// Gets error data to form an [`HTLCFailReason`] given a [`FailureCode`] and [`ClaimableHTLC`].
+	/// If something goes wrong while finding the necessary error data, this defaults to getting
+	/// error data for [`FailureCode::IncorrectOrUnknownPaymentDetails`].
+	fn get_htlc_fail_reason_from_failure_code(&self, failure_code: &FailureCode, htlc: &ClaimableHTLC) -> HTLCFailReason {
+		match failure_code {
+			FailureCode::TemporaryNodeFailure => HTLCFailReason::from_failure_code(*failure_code as u16),
+			FailureCode::RequiredNodeFeatureMissing => HTLCFailReason::from_failure_code(*failure_code as u16),
+			FailureCode::ExpiryTooSoon => {
+				let mut expiry_fail_reason = None;
+				let short_channel_id = htlc.prev_hop.short_channel_id;
+				let cp_node_chan_id = self.short_to_chan_info.read().unwrap().get(&short_channel_id).cloned();
+				if let Some((counterparty_node_id, chan_id)) = cp_node_chan_id {
+					let per_peer_state = self.per_peer_state.read().unwrap();
+					if let Some(peer_state) = per_peer_state.get(&counterparty_node_id) {
+						let peer_state = peer_state.lock().unwrap();
+						if let Some(chan) = peer_state.channel_by_id.get(&chan_id) {
+							if let Ok(channel_update) = self.get_channel_update_for_onion(short_channel_id, chan) {
+								let mut channel_update_data = Vec::new();
+								(channel_update.serialized_length() as u16 + 2).write(&mut channel_update_data).expect("Writes cannot fail");
+								msgs::ChannelUpdate::TYPE.write(&mut channel_update_data).expect("Writes cannot fail");
+								channel_update.write(&mut channel_update_data).expect("Writes cannot fail");
+								expiry_fail_reason = Some(HTLCFailReason::reason(*failure_code as u16, channel_update_data));
+							}
+						}
 					}
-				};
-
-				self.fail_htlc_backwards_internal(&source, &payment_hash, &reason, receiver);
+				}
+				if let Some(expiry_fail_reason) = expiry_fail_reason {
+					expiry_fail_reason
+				} else {
+					self.get_htlc_fail_reason_from_failure_code(&FailureCode::IncorrectOrUnknownPaymentDetails, htlc)
+				}
+			},
+			FailureCode::IncorrectOrUnknownPaymentDetails => {
+				let mut htlc_msat_height_data = htlc.value.to_be_bytes().to_vec();
+				htlc_msat_height_data.extend_from_slice(&self.best_block.read().unwrap().height().to_be_bytes());
+				HTLCFailReason::reason(*failure_code as u16, htlc_msat_height_data)
 			}
 		}
 	}

lightning/src/util/events.rs

@@ -491,10 +491,10 @@ pub enum Event {
 	/// [`ChannelManager::claim_funds`] with the preimage given in [`PaymentPurpose`].
 	///
 	/// Note that if the preimage is not known, you should call
-	/// [`ChannelManager::fail_htlc_backwards`] to free up resources for this HTLC and avoid
-	/// network congestion.
-	/// If you fail to call either [`ChannelManager::claim_funds`] or
-	/// [`ChannelManager::fail_htlc_backwards`] within the HTLC's timeout, the HTLC will be
+	/// [`ChannelManager::fail_htlc_backwards`] or [`ChannelManager::fail_htlc_backwards_with_reason`]
+	/// to free up resources for this HTLC and avoid network congestion.
+	/// If you fail to call either [`ChannelManager::claim_funds`], [`ChannelManager::fail_htlc_backwards`],
+	/// or [`ChannelManager::fail_htlc_backwards_with_reason`] within the HTLC's timeout, the HTLC will be
 	/// automatically failed.
 	///
 	/// # Note
@@ -506,6 +506,7 @@ pub enum Event {
 	///
 	/// [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds
 	/// [`ChannelManager::fail_htlc_backwards`]: crate::ln::channelmanager::ChannelManager::fail_htlc_backwards
+	/// [`ChannelManager::fail_htlc_backwards_with_reason`]: crate::ln::channelmanager::ChannelManager::fail_htlc_backwards_with_reason
 	PaymentClaimable {
 		/// The node that will receive the payment after it has been claimed.
 		/// This is useful to identify payments received via [phantom nodes].