Start publishing PersistClaimInfo event.

Indicates that [`ClaimInfo`] may be durably persisted
to reduce `ChannelMonitor` in-memory size.

Author: TheBlueMatt

lightning/src/chain/chainmonitor.rs

@@ -841,6 +841,15 @@ where
 		self.event_notifier.notify();
 	}
 
+	#[cfg(any(test, feature = "_test_utils"))]
+	pub fn get_and_clear_claim_info_events(&self) -> Vec<events::Event> {
+		let mut res = Vec::new();
+		for (_, monitor) in self.monitors.read().unwrap().iter() {
+			res.append(&mut monitor.monitor.get_and_clear_claim_info_events());
+		}
+		res
+	}
+
 	#[cfg(any(test, feature = "_test_utils"))]
 	pub fn get_and_clear_pending_events(&self) -> Vec<events::Event> {
 		use crate::events::EventsProvider;

lightning/src/chain/channelmonitor.rs

@@ -2320,6 +2320,21 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitor<Signer> {
 		ret
 	}
 
+	#[cfg(any(test, feature = "_test_utils"))]
+	pub fn get_and_clear_claim_info_events(&self) -> Vec<Event> {
+		let mut res = Vec::new();
+		let mut inner = self.inner.lock().unwrap();
+		inner.pending_events.retain(|ev| {
+			if let Event::PersistClaimInfo { .. } = ev {
+				res.push(ev.clone());
+				false
+			} else {
+				true
+			}
+		});
+		res
+	}
+
 	/// Gets the counterparty's initial commitment transaction. The returned commitment
 	/// transaction is unsigned. This is intended to be called during the initial persistence of
 	/// the monitor (inside an implementation of [`Persist::persist_new_channel`]), to allow for
@@ -3557,6 +3572,13 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 				} else {
 					assert!(cfg!(fuzzing), "Commitment txids are unique outside of fuzzing, where hashes can collide");
 				}
+				let htlcs = funding.counterparty_claimable_outpoints.get(&txid).unwrap().iter().map(|(htlc, _)| htlc.clone()).collect();
+				self.pending_events.push(Event::PersistClaimInfo {
+					funding_txo: funding.funding_outpoint().into_bitcoin_outpoint(),
+					channel_id: self.channel_id,
+					claim_key: ClaimKey(txid),
+					claim_info: ClaimInfo { htlcs },
+				})
 			}
 		};
 		core::iter::once(&mut self.funding).chain(&mut self.pending_funding).for_each(prune_htlc_sources);

lightning/src/ln/chanmon_update_fail_tests.rs

@@ -94,6 +94,10 @@ fn test_monitor_and_persister_update_fail() {
 				(nodes[0].keys_manager, nodes[0].keys_manager),
 			)
 			.unwrap();
+			// Compare events separately since we don't ever persist [`Event::PersistClaimInfo`] event.
+			let events = monitor.get_and_clear_pending_events();
+			let new_events = new_monitor.get_and_clear_pending_events();
+			assert_eq!(new_events, events);
 			assert!(new_monitor == *monitor);
 			new_monitor
 		};
@@ -3546,7 +3550,7 @@ fn do_test_blocked_chan_preimage_release(completion_mode: BlockedUpdateComplMode
 
 	// The event processing should release the last RAA update.
 	// It should also generate the next update for nodes[2].
-	check_added_monitors(&nodes[1], 2);
+	check_added_monitors_with_claim_info_events(&nodes[1], 2, 1);
 	let mut bs_htlc_fulfill = get_htlc_update_msgs(&nodes[1], &node_c_id);
 	check_added_monitors(&nodes[1], 0);
 

lightning/src/ln/functional_test_utils.rs

@@ -11,7 +11,7 @@
 //! nodes for functional tests.
 
 use crate::blinded_path::payment::DummyTlvs;
-use crate::chain::channelmonitor::{ChannelMonitor, HTLC_FAIL_BACK_BUFFER};
+use crate::chain::channelmonitor::{ChannelMonitor, ChannelMonitorUpdateStep, HTLC_FAIL_BACK_BUFFER};
 use crate::chain::transaction::OutPoint;
 use crate::chain::{BestBlock, ChannelMonitorUpdateStatus, Confirm, Listen, Watch};
 use crate::events::bump_transaction::sync::BumpTransactionEventHandlerSync;
@@ -1267,11 +1267,72 @@ pub fn commit_tx_fee_msat(
 
 /// Check whether N channel monitor(s) have been added.
 pub fn check_added_monitors<CM: AChannelManager, H: NodeHolder<CM = CM>>(node: &H, count: usize) {
+	do_check_added_monitors(node, count, None);
+}
+
+pub fn check_added_monitors_with_claim_info_events<CM: AChannelManager, H: NodeHolder<CM = CM>>(
+	node: &H, count: usize, expected_claim_info_events: usize,
+) {
+	do_check_added_monitors(node, count, Some(expected_claim_info_events));
+}
+
+pub fn do_check_added_monitors<CM: AChannelManager, H: NodeHolder<CM = CM>>(
+	node: &H, count: usize, expected_claim_info_events: Option<usize>,
+) {
 	if let Some(chain_monitor) = node.chain_monitor() {
-		let mut added_monitors = chain_monitor.added_monitors.lock().unwrap();
+		let added_monitors = chain_monitor.added_monitors.lock().unwrap().split_off(0);
 		let n = added_monitors.len();
+		let mut channels_with_commitment_secrets = new_hash_set();
+		let commitment_secret_updates = added_monitors
+			.iter()
+			.map(|(channel_id, _, updates_opt)| {
+				if let Some(updates) = updates_opt {
+					let is_commitment_secret = |update: &&ChannelMonitorUpdateStep| {
+						matches!(update, ChannelMonitorUpdateStep::CommitmentSecret { .. })
+					};
+					let count = updates.updates.iter().filter(is_commitment_secret).count();
+					if count > 0 {
+						channels_with_commitment_secrets.insert(*channel_id);
+					}
+					count
+				} else {
+					0
+				}
+			})
+			.sum();
+		let mut added_claim_info_events: usize = 0;
+		if commitment_secret_updates > 0 {
+			let persist_claim_info_events =
+				chain_monitor.chain_monitor.get_and_clear_claim_info_events();
+			added_claim_info_events += persist_claim_info_events.len();
+
+			let mut seen_channel_fundings = new_hash_set();
+			let mut claim_info_channel_ids = new_hash_set();
+			for event in persist_claim_info_events {
+				match event {
+					Event::PersistClaimInfo { channel_id, funding_txo, claim_key, claim_info } => {
+						assert!(seen_channel_fundings.insert(funding_txo));
+						claim_info_channel_ids.insert(channel_id);
+						let mut persisted_claim_infos =
+							chain_monitor.persisted_claim_infos.lock().unwrap();
+						let persist_key = (channel_id, claim_key);
+						persisted_claim_infos.insert(persist_key, claim_info);
+					},
+					_ => panic!(),
+				}
+			}
+			assert_eq!(claim_info_channel_ids, channels_with_commitment_secrets);
+		}
+
+		if let Some(expected_claim_info_events) = expected_claim_info_events {
+			assert_eq!(added_claim_info_events, expected_claim_info_events);
+		} else {
+			// Each CommitmentSecret update produces one PersistClaimInfo event per
+			// active funding. For spliced channels with a pending funding, this means
+			// more claim info events than commitment secret updates.
+			assert!(added_claim_info_events >= commitment_secret_updates);
+		}
 		assert_eq!(n, count, "expected {} monitors to be added, not {}", count, n);
-		added_monitors.clear();
 	}
 }
 

lightning/src/ln/functional_tests.rs

@@ -7385,6 +7385,10 @@ pub fn test_update_err_monitor_lockdown() {
 				)
 				.unwrap()
 				.1;
+			// Compare events separately since we don't ever persist [`Event::PersistClaimInfo`] event.
+			let events = monitor.get_and_clear_pending_events();
+			let new_events = new_monitor.get_and_clear_pending_events();
+			assert_eq!(new_events, events);
 			assert!(new_monitor == *monitor);
 			new_monitor
 		};
@@ -7493,6 +7497,10 @@ pub fn test_concurrent_monitor_claim() {
 				)
 				.unwrap()
 				.1;
+			// Compare events separately since we don't ever persist [`Event::PersistClaimInfo`] event.
+			let events = monitor.get_and_clear_pending_events();
+			let new_events = new_monitor.get_and_clear_pending_events();
+			assert_eq!(new_events, events);
 			assert!(new_monitor == *monitor);
 			new_monitor
 		};
@@ -7543,6 +7551,10 @@ pub fn test_concurrent_monitor_claim() {
 				)
 				.unwrap()
 				.1;
+			// Compare events separately since we don't ever persist [`Event::PersistClaimInfo`] event.
+			let events = monitor.get_and_clear_pending_events();
+			let new_events = new_monitor.get_and_clear_pending_events();
+			assert_eq!(new_events, events);
 			assert!(new_monitor == *monitor);
 			new_monitor
 		};
@@ -10010,7 +10022,7 @@ fn do_test_multi_post_event_actions(do_reload: bool) {
 	// After the events are processed, the ChannelMonitorUpdates will be released and, upon their
 	// completion, we'll respond to nodes[1] with an RAA + CS.
 	get_revoke_commit_msgs(&nodes[0], &node_b_id);
-	check_added_monitors(&nodes[0], 3);
+	check_added_monitors_with_claim_info_events(&nodes[0], 3, 2);
 }
 
 #[xtest(feature = "_externalize_tests")]

lightning/src/util/test_utils.rs

@@ -17,7 +17,8 @@ use crate::chain::chaininterface::FEERATE_FLOOR_SATS_PER_KW;
 use crate::chain::chaininterface::{ConfirmationTarget, TransactionType};
 use crate::chain::chainmonitor::{ChainMonitor, Persist};
 use crate::chain::channelmonitor::{
-	ChannelMonitor, ChannelMonitorUpdate, ChannelMonitorUpdateStep, MonitorEvent,
+	ChannelMonitor, ChannelMonitorUpdate, ChannelMonitorUpdateStep, ClaimInfo, ClaimKey,
+	MonitorEvent,
 };
 use crate::chain::transaction::OutPoint;
 use crate::chain::WatchedOutput;
@@ -495,7 +496,8 @@ impl<T: chaininterface::BroadcasterInterface> SyncBroadcaster for T {}
 impl<T: Persist<TestChannelSigner>> SyncPersist for T {}
 
 pub struct TestChainMonitor<'a> {
-	pub added_monitors: Mutex<Vec<(ChannelId, ChannelMonitor<TestChannelSigner>)>>,
+	pub added_monitors:
+		Mutex<Vec<(ChannelId, ChannelMonitor<TestChannelSigner>, Option<ChannelMonitorUpdate>)>>,
 	pub monitor_updates: Mutex<HashMap<ChannelId, Vec<ChannelMonitorUpdate>>>,
 	pub latest_monitor_update_id: Mutex<HashMap<ChannelId, (u64, u64)>>,
 	pub chain_monitor: ChainMonitor<
@@ -507,6 +509,7 @@ pub struct TestChainMonitor<'a> {
 		&'a dyn SyncPersist,
 		&'a TestKeysInterface,
 	>,
+	pub persisted_claim_infos: Mutex<HashMap<(ChannelId, ClaimKey), ClaimInfo>>,
 	pub keys_manager: &'a TestKeysInterface,
 	/// If this is set to Some(), the next update_channel call (not watch_channel) must be a
 	/// ChannelForceClosed event for the given channel_id with should_broadcast set to the given
@@ -537,6 +540,7 @@ impl<'a> TestChainMonitor<'a> {
 				keys_manager,
 				keys_manager.get_peer_storage_key(),
 			),
+			persisted_claim_infos: Mutex::new(new_hash_map()),
 			keys_manager,
 			expect_channel_force_closed: Mutex::new(None),
 			expect_monitor_round_trip_fail: Mutex::new(None),
@@ -577,7 +581,7 @@ impl<'a> TestChainMonitor<'a> {
 			.lock()
 			.unwrap()
 			.insert(channel_id, (monitor.get_latest_update_id(), monitor.get_latest_update_id()));
-		self.added_monitors.lock().unwrap().push((channel_id, monitor));
+		self.added_monitors.lock().unwrap().push((channel_id, monitor, None));
 		self.chain_monitor.load_existing_monitor(channel_id, new_monitor)
 	}
 
@@ -611,7 +615,7 @@ impl<'a> chain::Watch<TestChannelSigner> for TestChainMonitor<'a> {
 			.lock()
 			.unwrap()
 			.insert(channel_id, (monitor.get_latest_update_id(), monitor.get_latest_update_id()));
-		self.added_monitors.lock().unwrap().push((channel_id, monitor));
+		self.added_monitors.lock().unwrap().push((channel_id, monitor, None));
 		self.chain_monitor.watch_channel(channel_id, new_monitor)
 	}
 
@@ -666,9 +670,12 @@ impl<'a> chain::Watch<TestChannelSigner> for TestChainMonitor<'a> {
 			assert_eq!(chan_id, channel_id);
 			assert!(new_monitor != *monitor);
 		} else {
-			assert!(new_monitor == *monitor);
+			let expected_monitor = monitor.clone();
+			// Compare without [`Event::PersistClaimInfo`] events since we don't persist them.
+			expected_monitor.get_and_clear_claim_info_events();
+			assert!(new_monitor == expected_monitor);
 		}
-		self.added_monitors.lock().unwrap().push((channel_id, new_monitor));
+		self.added_monitors.lock().unwrap().push((channel_id, new_monitor, Some(update.clone())));
 		update_res
 	}