f dont assume v1 for already closed

Author: dunxen

lightning/src/ln/channelmanager.rs

@@ -10631,19 +10631,19 @@ where
 		let mut pending_background_events = Vec::new();
 		macro_rules! handle_in_flight_updates {
 			($counterparty_node_id: expr, $chan_in_flight_upds: expr, $funding_txo: expr,
-			 $channel_id: expr, $monitor: expr, $peer_state: expr, $logger: expr, $channel_info_log: expr
+			 $monitor: expr, $peer_state: expr, $logger: expr, $channel_info_log: expr
 			) => { {
 				let mut max_in_flight_update_id = 0;
 				$chan_in_flight_upds.retain(|upd| upd.update_id > $monitor.get_latest_update_id());
 				for update in $chan_in_flight_upds.iter() {
 					log_trace!($logger, "Replaying ChannelMonitorUpdate {} for {}channel {}",
-						update.update_id, $channel_info_log, &$channel_id);
+						update.update_id, $channel_info_log, &$monitor.channel_id());
 					max_in_flight_update_id = cmp::max(max_in_flight_update_id, update.update_id);
 					pending_background_events.push(
 						BackgroundEvent::MonitorUpdateRegeneratedOnStartup {
 							counterparty_node_id: $counterparty_node_id,
 							funding_txo: $funding_txo,
-							channel_id: $channel_id,
+							channel_id: $monitor.channel_id(),
 							update: update.clone(),
 						});
 				}
@@ -10654,7 +10654,7 @@ where
 					pending_background_events.push(
 						BackgroundEvent::MonitorUpdatesComplete {
 							counterparty_node_id: $counterparty_node_id,
-							channel_id: $channel_id,
+							channel_id: $monitor.channel_id(),
 						});
 				}
 				if $peer_state.in_flight_monitor_updates.insert($funding_txo, $chan_in_flight_upds).is_some() {
@@ -10675,15 +10675,14 @@ where
 					// Channels that were persisted have to be funded, otherwise they should have been
 					// discarded.
 					let funding_txo = chan.context.get_funding_txo().ok_or(DecodeError::InvalidValue)?;
-					let channel_id = chan.context.channel_id();
 					let monitor = args.channel_monitors.get(&funding_txo)
 						.expect("We already checked for monitor presence when loading channels");
 					let mut max_in_flight_update_id = monitor.get_latest_update_id();
 					if let Some(in_flight_upds) = &mut in_flight_monitor_updates {
 						if let Some(mut chan_in_flight_upds) = in_flight_upds.remove(&(*counterparty_id, funding_txo)) {
 							max_in_flight_update_id = cmp::max(max_in_flight_update_id,
 								handle_in_flight_updates!(*counterparty_id, chan_in_flight_upds,
-									funding_txo, channel_id, monitor, peer_state, logger, ""));
+									funding_txo, monitor, peer_state, logger, ""));
 						}
 					}
 					if chan.get_latest_unblocked_monitor_update_id() > max_in_flight_update_id {
@@ -10709,8 +10708,8 @@ where
 
 		if let Some(in_flight_upds) = in_flight_monitor_updates {
 			for ((counterparty_id, funding_txo), mut chan_in_flight_updates) in in_flight_upds {
-				let channel_id = funding_txo_to_channel_id.get(&funding_txo).copied().unwrap_or(ChannelId::v1_from_funding_outpoint(funding_txo));
-				let logger = WithContext::from(&args.logger, Some(counterparty_id), Some(channel_id));
+				let channel_id = funding_txo_to_channel_id.get(&funding_txo).copied();
+				let logger = WithContext::from(&args.logger, Some(counterparty_id), channel_id);
 				if let Some(monitor) = args.channel_monitors.get(&funding_txo) {
 					// Now that we've removed all the in-flight monitor updates for channels that are
 					// still open, we need to replay any monitor updates that are for closed channels,
@@ -10720,10 +10719,11 @@ where
 					});
 					let mut peer_state = peer_state_mutex.lock().unwrap();
 					handle_in_flight_updates!(counterparty_id, chan_in_flight_updates,
-						funding_txo, channel_id, monitor, peer_state, logger, "closed ");
+						funding_txo, monitor, peer_state, logger, "closed ");
 				} else {
 					log_error!(logger, "A ChannelMonitor is missing even though we have in-flight updates for it! This indicates a potentially-critical violation of the chain::Watch API!");
-					log_error!(logger, " The ChannelMonitor for channel {} is missing.", &channel_id);
+					log_error!(logger, " The ChannelMonitor for channel {} is missing.", if let Some(channel_id) =
+						channel_id { channel_id.to_string() } else { format!("with outpoint {}", funding_txo) } );
 					log_error!(logger, " The chain::Watch API *requires* that monitors are persisted durably before returning,");
 					log_error!(logger, " client applications must ensure that ChannelMonitor data is always available and the latest to avoid funds loss!");
 					log_error!(logger, " Without the latest ChannelMonitor we cannot continue without risking funds.");