Store channel-associated events in monitor

Author: joostjager

lightning/src/chain/channelmonitor.rs

@@ -635,6 +635,9 @@ impl_writeable_tlv_based_enum_upgradable!(OnchainEvent,
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) enum ChannelMonitorUpdateStep {
+	EventGenerated {
+		event: Event,
+	},
 	LatestHolderCommitmentTXInfo {
 		commitment_tx: HolderCommitmentTransaction,
 		/// Note that LDK after 0.0.115 supports this only containing dust HTLCs (implying the
@@ -724,6 +727,7 @@ impl ChannelMonitorUpdateStep {
 			ChannelMonitorUpdateStep::RenegotiatedFunding { .. } => "RenegotiatedFunding",
 			ChannelMonitorUpdateStep::RenegotiatedFundingLocked { .. } => "RenegotiatedFundingLocked",
 			ChannelMonitorUpdateStep::ReleasePaymentComplete { .. } => "ReleasePaymentComplete",
+			ChannelMonitorUpdateStep::EventGenerated { .. } => "EventGenerated",
 		}
 	}
 }
@@ -778,6 +782,9 @@ impl_writeable_tlv_based_enum_upgradable!(ChannelMonitorUpdateStep,
 	(12, RenegotiatedFundingLocked) => {
 		(1, funding_txid, required),
 	},
+	(13, EventGenerated) => {
+		(0, event, upgradable_required),
+	}
 );
 
 /// Indicates whether the balance is derived from a cooperative close, a force-close
@@ -1283,6 +1290,7 @@ pub(crate) struct ChannelMonitorImpl<Signer: EcdsaChannelSigner> {
 	pending_monitor_events: Vec<MonitorEvent>,
 
 	pub(super) pending_events: Vec<Event>,
+	pub(super) pending_mgr_events: Vec<Event>,
 	pub(super) is_processing_pending_events: bool,
 
 	// Used to track on-chain events (i.e., transactions part of channels confirmed on chain) on
@@ -1961,6 +1969,7 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitor<Signer> {
 
 			payment_preimages: new_hash_map(),
 			pending_monitor_events: Vec::new(),
+			pending_mgr_events: Vec::new(),
 			pending_events: Vec::new(),
 			is_processing_pending_events: false,
 
@@ -4370,6 +4379,10 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 					log_trace!(logger, "HTLC {htlc:?} permanently and fully resolved");
 					self.htlcs_resolved_to_user.insert(*htlc);
 				},
+				ChannelMonitorUpdateStep::EventGenerated { event } => {
+					log_trace!(logger, "Updating ChannelMonitor with channel manager event: {:?}", event);
+					self.pending_mgr_events.push(event.clone());
+				},
 			}
 		}
 
@@ -4402,6 +4415,7 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 				ChannelMonitorUpdateStep::PaymentPreimage { .. } => {},
 				ChannelMonitorUpdateStep::ChannelForceClosed { .. } => {},
 				ChannelMonitorUpdateStep::ReleasePaymentComplete { .. } => {},
+    			ChannelMonitorUpdateStep::EventGenerated { .. } => {},
 			}
 		}
 
@@ -6644,6 +6658,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 		let mut alternative_funding_confirmed = None;
 		let mut is_manual_broadcast = RequiredWrapper(None);
 		let mut funding_seen_onchain = RequiredWrapper(None);
+		let mut pending_mgr_events = Some(Vec::new());
 		read_tlv_fields!(reader, {
 			(1, funding_spend_confirmed, option),
 			(3, htlcs_resolved_on_chain, optional_vec),
@@ -6666,6 +6681,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 			(34, alternative_funding_confirmed, option),
 			(35, is_manual_broadcast, (default_value, false)),
 			(37, funding_seen_onchain, (default_value, true)),
+			(38, pending_mgr_events, optional_vec),
 		});
 		// Note that `payment_preimages_with_info` was added (and is always written) in LDK 0.1, so
 		// we can use it to determine if this monitor was last written by LDK 0.1 or later.
@@ -6812,6 +6828,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 
 			payment_preimages,
 			pending_monitor_events: pending_monitor_events.unwrap(),
+			pending_mgr_events: pending_mgr_events.unwrap(),
 			pending_events,
 			is_processing_pending_events: false,
 

lightning/src/ln/channelmanager.rs

@@ -4575,16 +4575,42 @@ where
 		}
 
 		{
-			let mut pending_events = self.pending_events.lock().unwrap();
-			pending_events.push_back((events::Event::ChannelClosed {
+			let closed_event = (events::Event::ChannelClosed {
 				channel_id: shutdown_res.channel_id,
 				user_channel_id: shutdown_res.user_channel_id,
 				reason: shutdown_res.closure_reason,
 				counterparty_node_id: Some(shutdown_res.counterparty_node_id),
 				channel_capacity_sats: Some(shutdown_res.channel_capacity_satoshis),
 				channel_funding_txo: shutdown_res.channel_funding_txo,
 				last_local_balance_msat: Some(shutdown_res.last_local_balance_msat),
-			}, None));
+			}, None);
+
+			let mut per_peer_state = self.per_peer_state.write().unwrap();
+			let mut peer_state_lock = per_peer_state.
+				get_mut(&shutdown_res.counterparty_node_id)
+				.expect("We must always have a peer entry for a peer with which we have channels")
+				.lock().unwrap();
+			let peer_state = &mut *peer_state_lock;
+			let channel = peer_state
+				.channel_by_id.get_mut(&shutdown_res.channel_id)
+				.expect("We should only be finishing the closure of a channel which existed");
+			let funded_chan = channel.as_funded_mut()
+				.expect("We should only be finishing the closure of a funded channel here");
+
+			let update_id = funded_chan.get_latest_unblocked_monitor_update_id();
+			let monitor_update_step = ChannelMonitorUpdateStep::EventGenerated {
+				event: closed_event.0.clone(),
+			};
+			let monitor_update = ChannelMonitorUpdate {
+				update_id,
+				updates: vec![monitor_update_step],
+				channel_id: Some(shutdown_res.channel_id),
+			};
+			handle_new_monitor_update!(self, funded_chan.funding.get_funding_txo().unwrap(),
+						monitor_update, peer_state_lock, peer_state, per_peer_state, funded_chan);
+
+			let mut pending_events = self.pending_events.lock().unwrap();
+			pending_events.push_back(closed_event);
 
 			if let Some(splice_funding_failed) = shutdown_res.splice_funding_failed.take() {
 				pending_events.push_back((events::Event::SpliceFailed {