Demacro forwarding_channel_not_found

joostjager · joostjager · commit 79ef5651bc56 · 2025-07-24T16:21:45.000+02:00
diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
@@ -6393,137 +6393,155 @@ where
 		should_persist
 	}
 
-	fn process_forward_htlcs(
-		&self, short_chan_id: u64, pending_forwards: &mut Vec<HTLCForwardInfo>,
-		failed_forwards: &mut Vec<FailedHTLCForward>,
+	/// Fail the list of provided HTLC forwards because the channel they were to be forwarded over does no longer exist.
+	#[rustfmt::skip]
+	fn forwarding_channel_not_found(
+		&self, forward_infos: impl Iterator<Item = HTLCForwardInfo>, short_chan_id: u64,
+		forwarding_counterparty: Option<PublicKey>, failed_forwards: &mut Vec<FailedHTLCForward>,
 		phantom_receives: &mut Vec<PerSourcePendingForward>,
 	) {
-		let mut forwarding_counterparty = None;
-		macro_rules! forwarding_channel_not_found {
-			($forward_infos: expr) => {
-				for forward_info in $forward_infos {
-					match forward_info {
-						HTLCForwardInfo::AddHTLC(PendingAddHTLCInfo {
-							prev_short_channel_id, prev_htlc_id, prev_channel_id, prev_funding_outpoint,
-							prev_user_channel_id, prev_counterparty_node_id, forward_info: PendingHTLCInfo {
-								routing, incoming_shared_secret, payment_hash, outgoing_amt_msat,
-								outgoing_cltv_value, ..
-							}
-						}) => {
-							let cltv_expiry = routing.incoming_cltv_expiry();
-							macro_rules! failure_handler {
-								($msg: expr, $reason: expr, $err_data: expr, $phantom_ss: expr, $next_hop_unknown: expr) => {
-									let logger = WithContext::from(&self.logger, forwarding_counterparty, Some(prev_channel_id), Some(payment_hash));
-									log_info!(logger, "Failed to accept/forward incoming HTLC: {}", $msg);
-
-									let htlc_source = HTLCSource::PreviousHopData(HTLCPreviousHopData {
-										short_channel_id: prev_short_channel_id,
-										user_channel_id: Some(prev_user_channel_id),
-										channel_id: prev_channel_id,
-										outpoint: prev_funding_outpoint,
-										counterparty_node_id: prev_counterparty_node_id,
-										htlc_id: prev_htlc_id,
-										incoming_packet_shared_secret: incoming_shared_secret,
-										phantom_shared_secret: $phantom_ss,
-										blinded_failure: routing.blinded_failure(),
-										cltv_expiry,
-									});
+		for forward_info in forward_infos {
+			match forward_info {
+				HTLCForwardInfo::AddHTLC(PendingAddHTLCInfo {
+					prev_short_channel_id, prev_htlc_id, prev_channel_id, prev_funding_outpoint,
+					prev_user_channel_id, prev_counterparty_node_id, forward_info: PendingHTLCInfo {
+						routing, incoming_shared_secret, payment_hash, outgoing_amt_msat,
+						outgoing_cltv_value, ..
+					}
+				}) => {
+					let cltv_expiry = routing.incoming_cltv_expiry();
+					macro_rules! failure_handler {
+						($msg: expr, $reason: expr, $err_data: expr, $phantom_ss: expr, $next_hop_unknown: expr) => {
+							let logger = WithContext::from(&self.logger, forwarding_counterparty, Some(prev_channel_id), Some(payment_hash));
+							log_info!(logger, "Failed to accept/forward incoming HTLC: {}", $msg);
+
+							let htlc_source = HTLCSource::PreviousHopData(HTLCPreviousHopData {
+								short_channel_id: prev_short_channel_id,
+								user_channel_id: Some(prev_user_channel_id),
+								channel_id: prev_channel_id,
+								outpoint: prev_funding_outpoint,
+								counterparty_node_id: prev_counterparty_node_id,
+								htlc_id: prev_htlc_id,
+								incoming_packet_shared_secret: incoming_shared_secret,
+								phantom_shared_secret: $phantom_ss,
+								blinded_failure: routing.blinded_failure(),
+								cltv_expiry,
+							});
 
-									let reason = if $next_hop_unknown {
-										HTLCHandlingFailureType::InvalidForward { requested_forward_scid: short_chan_id }
-									} else {
-										HTLCHandlingFailureType::Receive{ payment_hash }
-									};
+							let reason = if $next_hop_unknown {
+								HTLCHandlingFailureType::InvalidForward { requested_forward_scid: short_chan_id }
+							} else {
+								HTLCHandlingFailureType::Receive{ payment_hash }
+							};
 
-									failed_forwards.push((htlc_source, payment_hash,
-										HTLCFailReason::reason($reason, $err_data),
-										reason
-									));
-									continue;
-								}
-							}
-							macro_rules! fail_forward {
-								($msg: expr, $reason: expr, $err_data: expr, $phantom_ss: expr) => {
-									{
-										failure_handler!($msg, $reason, $err_data, $phantom_ss, true);
-									}
-								}
+							failed_forwards.push((htlc_source, payment_hash,
+								HTLCFailReason::reason($reason, $err_data),
+								reason
+							));
+							continue;
+						}
+					}
+					macro_rules! fail_forward {
+						($msg: expr, $reason: expr, $err_data: expr, $phantom_ss: expr) => {
+							{
+								failure_handler!($msg, $reason, $err_data, $phantom_ss, true);
 							}
-							macro_rules! failed_payment {
-								($msg: expr, $reason: expr, $err_data: expr, $phantom_ss: expr) => {
-									{
-										failure_handler!($msg, $reason, $err_data, $phantom_ss, false);
-									}
-								}
+						}
+					}
+					macro_rules! failed_payment {
+						($msg: expr, $reason: expr, $err_data: expr, $phantom_ss: expr) => {
+							{
+								failure_handler!($msg, $reason, $err_data, $phantom_ss, false);
 							}
-							if let PendingHTLCRouting::Forward { ref onion_packet, .. } = routing {
-								let phantom_pubkey_res = self.node_signer.get_node_id(Recipient::PhantomNode);
-								if phantom_pubkey_res.is_ok() && fake_scid::is_valid_phantom(&self.fake_scid_rand_bytes, short_chan_id, &self.chain_hash) {
-									let decode_res = onion_utils::decode_next_payment_hop(
-										Recipient::PhantomNode, &onion_packet.public_key.unwrap(), &onion_packet.hop_data,
-										onion_packet.hmac, payment_hash, None, &*self.node_signer
-									);
-									let next_hop = match decode_res {
-										Ok(res) => res,
-										Err(onion_utils::OnionDecodeErr::Malformed { err_msg, reason }) => {
-											let sha256_of_onion = Sha256::hash(&onion_packet.hop_data).to_byte_array();
-											// In this scenario, the phantom would have sent us an
-											// `update_fail_malformed_htlc`, meaning here we encrypt the error as
-											// if it came from us (the second-to-last hop) but contains the sha256
-											// of the onion.
-											failed_payment!(err_msg, reason, sha256_of_onion.to_vec(), None);
-										},
-										Err(onion_utils::OnionDecodeErr::Relay { err_msg, reason, shared_secret, .. }) => {
-											let phantom_shared_secret = shared_secret.secret_bytes();
-											failed_payment!(err_msg, reason, Vec::new(), Some(phantom_shared_secret));
-										},
-									};
-									let phantom_shared_secret = next_hop.shared_secret().secret_bytes();
-									let current_height: u32 = self.best_block.read().unwrap().height;
-									let create_res = create_recv_pending_htlc_info(next_hop,
-										incoming_shared_secret, payment_hash, outgoing_amt_msat,
-										outgoing_cltv_value, Some(phantom_shared_secret), false, None,
-										current_height);
-									match create_res
-									{
-										Ok(info) => phantom_receives.push((
-											prev_short_channel_id, prev_counterparty_node_id, prev_funding_outpoint,
-											prev_channel_id, prev_user_channel_id, vec![(info, prev_htlc_id)]
-										)),
-										Err(InboundHTLCErr { reason, err_data, msg }) => failed_payment!(msg, reason, err_data, Some(phantom_shared_secret))
-									}
-								} else {
-									fail_forward!(format!("Unknown short channel id {} for forward HTLC", short_chan_id),
-									LocalHTLCFailureReason::UnknownNextPeer, Vec::new(), None);
-								}
-							} else {
-								fail_forward!(format!("Unknown short channel id {} for forward HTLC", short_chan_id),
-								LocalHTLCFailureReason::UnknownNextPeer, Vec::new(), None);
+						}
+					}
+					if let PendingHTLCRouting::Forward { ref onion_packet, .. } = routing {
+						let phantom_pubkey_res = self.node_signer.get_node_id(Recipient::PhantomNode);
+						if phantom_pubkey_res.is_ok() && fake_scid::is_valid_phantom(&self.fake_scid_rand_bytes, short_chan_id, &self.chain_hash) {
+							let decode_res = onion_utils::decode_next_payment_hop(
+								Recipient::PhantomNode, &onion_packet.public_key.unwrap(), &onion_packet.hop_data,
+								onion_packet.hmac, payment_hash, None, &*self.node_signer
+							);
+							let next_hop = match decode_res {
+								Ok(res) => res,
+								Err(onion_utils::OnionDecodeErr::Malformed { err_msg, reason }) => {
+									let sha256_of_onion = Sha256::hash(&onion_packet.hop_data).to_byte_array();
+									// In this scenario, the phantom would have sent us an
+									// `update_fail_malformed_htlc`, meaning here we encrypt the error as
+									// if it came from us (the second-to-last hop) but contains the sha256
+									// of the onion.
+									failed_payment!(err_msg, reason, sha256_of_onion.to_vec(), None);
+								},
+								Err(onion_utils::OnionDecodeErr::Relay { err_msg, reason, shared_secret, .. }) => {
+									let phantom_shared_secret = shared_secret.secret_bytes();
+									failed_payment!(err_msg, reason, Vec::new(), Some(phantom_shared_secret));
+								},
+							};
+							let phantom_shared_secret = next_hop.shared_secret().secret_bytes();
+							let current_height: u32 = self.best_block.read().unwrap().height;
+							let create_res = create_recv_pending_htlc_info(next_hop,
+								incoming_shared_secret, payment_hash, outgoing_amt_msat,
+								outgoing_cltv_value, Some(phantom_shared_secret), false, None,
+								current_height);
+							match create_res
+							{
+								Ok(info) => phantom_receives.push((
+									prev_short_channel_id, prev_counterparty_node_id, prev_funding_outpoint,
+									prev_channel_id, prev_user_channel_id, vec![(info, prev_htlc_id)]
+								)),
+								Err(InboundHTLCErr { reason, err_data, msg }) => failed_payment!(msg, reason, err_data, Some(phantom_shared_secret))
 							}
-						},
-						HTLCForwardInfo::FailHTLC { .. } | HTLCForwardInfo::FailMalformedHTLC { .. } => {
-							// Channel went away before we could fail it. This implies
-							// the channel is now on chain and our counterparty is
-							// trying to broadcast the HTLC-Timeout, but that's their
-							// problem, not ours.
+						} else {
+							fail_forward!(format!("Unknown short channel id {} for forward HTLC", short_chan_id),
+							LocalHTLCFailureReason::UnknownNextPeer, Vec::new(), None);
 						}
+					} else {
+						fail_forward!(format!("Unknown short channel id {} for forward HTLC", short_chan_id),
+						LocalHTLCFailureReason::UnknownNextPeer, Vec::new(), None);
 					}
+				},
+				HTLCForwardInfo::FailHTLC { .. } | HTLCForwardInfo::FailMalformedHTLC { .. } => {
+					// Channel went away before we could fail it. This implies
+					// the channel is now on chain and our counterparty is
+					// trying to broadcast the HTLC-Timeout, but that's their
+					// problem, not ours.
 				}
 			}
 		}
+	}
+
+	fn process_forward_htlcs(
+		&self, short_chan_id: u64, pending_forwards: &mut Vec<HTLCForwardInfo>,
+		failed_forwards: &mut Vec<FailedHTLCForward>,
+		phantom_receives: &mut Vec<PerSourcePendingForward>,
+	) {
+		let mut forwarding_counterparty = None;
+
 		let chan_info_opt = self.short_to_chan_info.read().unwrap().get(&short_chan_id).cloned();
 		let (counterparty_node_id, forward_chan_id) = match chan_info_opt {
 			Some((cp_id, chan_id)) => (cp_id, chan_id),
 			None => {
-				forwarding_channel_not_found!(pending_forwards.drain(..));
+				self.forwarding_channel_not_found(
+					pending_forwards.drain(..),
+					short_chan_id,
+					forwarding_counterparty,
+					failed_forwards,
+					phantom_receives,
+				);
 				return;
 			},
 		};
 		forwarding_counterparty = Some(counterparty_node_id);
 		let per_peer_state = self.per_peer_state.read().unwrap();
 		let peer_state_mutex_opt = per_peer_state.get(&counterparty_node_id);
 		if peer_state_mutex_opt.is_none() {
-			forwarding_channel_not_found!(pending_forwards.drain(..));
+			self.forwarding_channel_not_found(
+				pending_forwards.drain(..),
+				short_chan_id,
+				forwarding_counterparty,
+				failed_forwards,
+				phantom_receives,
+			);
 			return;
 		}
 		let mut peer_state_lock = peer_state_mutex_opt.unwrap().lock().unwrap();
@@ -6618,7 +6636,13 @@ where
 							} else {
 								let fwd_iter =
 									core::iter::once(forward_info).chain(draining_pending_forwards);
-								forwarding_channel_not_found!(fwd_iter);
+								self.forwarding_channel_not_found(
+									fwd_iter,
+									short_chan_id,
+									forwarding_counterparty,
+									failed_forwards,
+									phantom_receives,
+								);
 								break;
 							}
 						},
@@ -6673,8 +6697,12 @@ where
 								failure_type,
 							));
 						} else {
-							forwarding_channel_not_found!(
-								core::iter::once(forward_info).chain(draining_pending_forwards)
+							self.forwarding_channel_not_found(
+								core::iter::once(forward_info).chain(draining_pending_forwards),
+								short_chan_id,
+								forwarding_counterparty,
+								failed_forwards,
+								phantom_receives,
 							);
 							break;
 						}
@@ -6694,8 +6722,12 @@ where
 						log_trace!(logger, "Failing HTLC back to channel with short id {} (backward HTLC ID {}) after delay", short_chan_id, htlc_id);
 						Some((chan.queue_fail_htlc(htlc_id, err_packet.clone(), &&logger), htlc_id))
 					} else {
-						forwarding_channel_not_found!(
-							core::iter::once(forward_info).chain(draining_pending_forwards)
+						self.forwarding_channel_not_found(
+							core::iter::once(forward_info).chain(draining_pending_forwards),
+							short_chan_id,
+							forwarding_counterparty,
+							failed_forwards,
+							phantom_receives,
 						);
 						break;
 					}
@@ -6716,8 +6748,12 @@ where
 						);
 						Some((res, htlc_id))
 					} else {
-						forwarding_channel_not_found!(
-							core::iter::once(forward_info).chain(draining_pending_forwards)
+						self.forwarding_channel_not_found(
+							core::iter::once(forward_info).chain(draining_pending_forwards),
+							short_chan_id,
+							forwarding_counterparty,
+							failed_forwards,
+							phantom_receives,
 						);
 						break;
 					}
