f ensure we generate a freeing action even if fees are unknown

Author: TheBlueMatt

lightning/src/ln/channelmanager.rs

@@ -5595,71 +5595,70 @@ where
 				let claiming_chan_funding_outpoint = hop_data.outpoint;
 				let res = self.claim_funds_from_hop(hop_data, payment_preimage,
 					|htlc_claim_value_msat, definitely_duplicate| {
-						if let Some(forwarded_htlc_value) = forwarded_htlc_value_msat {
-							let fee_earned_msat = if let Some(claimed_htlc_value) = htlc_claim_value_msat {
-								Some(claimed_htlc_value - forwarded_htlc_value)
-							} else { None };
-
-							let chan_to_release =
-								if let Some(node_id) = next_channel_counterparty_node_id {
-									Some((node_id, next_channel_outpoint, completed_blocker))
-								} else {
-									// We can only get `None` here if we are processing a
-									// `ChannelMonitor`-originated event, in which case we
-									// don't care about ensuring we wake the downstream
-									// channel's monitor updating - the channel is already
-									// closed.
-									None
-								};
-
-							if definitely_duplicate && startup_replay {
-								// On startup we may get redundant claims which are related to
-								// monitor updates still in flight. In that case, we shouldn't
-								// immediately free, but instead let that monitor update complete
-								// in the background.
-								#[cfg(debug_assertions)] {
-									let background_events = self.pending_background_events.lock().unwrap();
-									// There should be a `BackgroundEvent` pending...
-									assert!(background_events.iter().any(|ev| {
-										match ev {
-											// to apply a monitor update that blocked channel,
-											BackgroundEvent::MonitorUpdateRegeneratedOnStartup {
-												funding_txo, ..
-											} => *funding_txo == claiming_chan_funding_outpoint,
-											// or the channel we'd unblock is already closed,
-											BackgroundEvent::ClosedMonitorUpdateRegeneratedOnStartup((funding_txo, ..))
-												=> *funding_txo == next_channel_outpoint,
-											// or the monitor update has completed and will unblock
-											// immediately once we get going.
-											BackgroundEvent::MonitorUpdatesComplete {
-												channel_id, ..
-											} =>
-												*channel_id == claiming_chan_funding_outpoint.to_channel_id(),
-										}
-									}), "{:?}", *background_events);
-								}
-								None
-							} else if definitely_duplicate {
-								if let Some(other_chan) = chan_to_release {
-									Some(MonitorUpdateCompletionAction::FreeOtherChannelImmediately {
-										downstream_counterparty_node_id: other_chan.0,
-										downstream_funding_outpoint: other_chan.1,
-										blocking_action: other_chan.2,
-									})
-								} else { None }
+						let chan_to_release =
+							if let Some(node_id) = next_channel_counterparty_node_id {
+								Some((node_id, next_channel_outpoint, completed_blocker))
 							} else {
-								Some(MonitorUpdateCompletionAction::EmitEventAndFreeOtherChannel {
-									event: events::Event::PaymentForwarded {
-										fee_earned_msat,
-										claim_from_onchain_tx: from_onchain,
-										prev_channel_id: Some(prev_outpoint.to_channel_id()),
-										next_channel_id: Some(next_channel_outpoint.to_channel_id()),
-										outbound_amount_forwarded_msat: forwarded_htlc_value_msat,
-									},
-									downstream_counterparty_and_funding_outpoint: chan_to_release,
-								})
+								// We can only get `None` here if we are processing a
+								// `ChannelMonitor`-originated event, in which case we
+								// don't care about ensuring we wake the downstream
+								// channel's monitor updating - the channel is already
+								// closed.
+								None
+							};
+
+						if definitely_duplicate && startup_replay {
+							// On startup we may get redundant claims which are related to
+							// monitor updates still in flight. In that case, we shouldn't
+							// immediately free, but instead let that monitor update complete
+							// in the background.
+							#[cfg(debug_assertions)] {
+								let background_events = self.pending_background_events.lock().unwrap();
+								// There should be a `BackgroundEvent` pending...
+								assert!(background_events.iter().any(|ev| {
+									match ev {
+										// to apply a monitor update that blocked channel,
+										BackgroundEvent::MonitorUpdateRegeneratedOnStartup {
+											funding_txo, ..
+										} => *funding_txo == claiming_chan_funding_outpoint,
+										// or the channel we'd unblock is already closed,
+										BackgroundEvent::ClosedMonitorUpdateRegeneratedOnStartup((funding_txo, ..))
+											=> *funding_txo == next_channel_outpoint,
+										// or the monitor update has completed and will unblock
+										// immediately once we get going.
+										BackgroundEvent::MonitorUpdatesComplete {
+											channel_id, ..
+										} =>
+											*channel_id == claiming_chan_funding_outpoint.to_channel_id(),
+									}
+								}), "{:?}", *background_events);
 							}
-						} else { None }
+							None
+						} else if definitely_duplicate {
+							if let Some(other_chan) = chan_to_release {
+								Some(MonitorUpdateCompletionAction::FreeOtherChannelImmediately {
+									downstream_counterparty_node_id: other_chan.0,
+									downstream_funding_outpoint: other_chan.1,
+									blocking_action: other_chan.2,
+								})
+							} else { None }
+						} else {
+							let fee_earned_msat = if let Some(forwarded_htlc_value) = forwarded_htlc_value_msat {
+								if let Some(claimed_htlc_value) = htlc_claim_value_msat {
+									Some(claimed_htlc_value - forwarded_htlc_value)
+								} else { None }
+							} else { None };
+							Some(MonitorUpdateCompletionAction::EmitEventAndFreeOtherChannel {
+								event: events::Event::PaymentForwarded {
+									fee_earned_msat,
+									claim_from_onchain_tx: from_onchain,
+									prev_channel_id: Some(prev_outpoint.to_channel_id()),
+									next_channel_id: Some(next_channel_outpoint.to_channel_id()),
+									outbound_amount_forwarded_msat: forwarded_htlc_value_msat,
+								},
+								downstream_counterparty_and_funding_outpoint: chan_to_release,
+							})
+						}
 					});
 				if let Err((pk, err)) = res {
 					let result: Result<(), _> = Err(err);