Periodically archive fully-resolved channel monitors

Previously, LDK was very conservative and kept channel monitors around
~forever or until the user manually decided to prune them. Recently it
introduced the `ChainMonitor::archive_fully_resolved_monitors` method,
which we now call periodically: every time a wallet sync succeeds, we
check whether the latest archival height is 6 blocks in the past and
call `archive_fully_resolved_monitors`.

As this is not permanently persisted, we will always try to archive any
pruned monitors when the first background sync after fresh
initialization succeeds, ensuring we call it regularly also on
short-lived sessions, e.g, on mobile.

Author: tnull

src/builder.rs

@@ -980,6 +980,7 @@ fn build_with_store_internal(
 	let latest_fee_rate_cache_update_timestamp = Arc::new(RwLock::new(None));
 	let latest_rgs_snapshot_timestamp = Arc::new(RwLock::new(None));
 	let latest_node_announcement_broadcast_timestamp = Arc::new(RwLock::new(None));
+	let latest_channel_monitor_archival_height = Arc::new(RwLock::new(None));
 
 	Ok(Node {
 		runtime,
@@ -1011,6 +1012,7 @@ fn build_with_store_internal(
 		latest_fee_rate_cache_update_timestamp,
 		latest_rgs_snapshot_timestamp,
 		latest_node_announcement_broadcast_timestamp,
+		latest_channel_monitor_archival_height,
 	})
 }
 

src/config.rs

@@ -29,6 +29,9 @@ pub(crate) const DEFAULT_ESPLORA_SERVER_URL: &str = "https://blockstream.info/ap
 // The timeout after which we abandon retrying failed payments.
 pub(crate) const LDK_PAYMENT_RETRY_TIMEOUT: Duration = Duration::from_secs(10);
 
+// The interval (in block height) after which we archive pruned channel monitors.
+pub(crate) const LDK_CHANNEL_MONITOR_ARCHIVAL_INTERVAL: u32 = 6;
+
 // The time in-between peer reconnection attempts.
 pub(crate) const PEER_RECONNECTION_INTERVAL: Duration = Duration::from_secs(10);
 

src/lib.rs

@@ -122,8 +122,8 @@ pub use builder::BuildError;
 pub use builder::NodeBuilder as Builder;
 
 use config::{
-	NODE_ANN_BCAST_INTERVAL, PEER_RECONNECTION_INTERVAL, RGS_SYNC_INTERVAL,
-	WALLET_SYNC_INTERVAL_MINIMUM_SECS,
+	LDK_CHANNEL_MONITOR_ARCHIVAL_INTERVAL, NODE_ANN_BCAST_INTERVAL, PEER_RECONNECTION_INTERVAL,
+	RGS_SYNC_INTERVAL, WALLET_SYNC_INTERVAL_MINIMUM_SECS,
 };
 use connection::ConnectionManager;
 use event::{EventHandler, EventQueue};
@@ -197,6 +197,7 @@ pub struct Node {
 	latest_fee_rate_cache_update_timestamp: Arc<RwLock<Option<u64>>>,
 	latest_rgs_snapshot_timestamp: Arc<RwLock<Option<u64>>>,
 	latest_node_announcement_broadcast_timestamp: Arc<RwLock<Option<u64>>>,
+	latest_channel_monitor_archival_height: Arc<RwLock<Option<u32>>>,
 }
 
 impl Node {
@@ -342,10 +343,13 @@ impl Node {
 
 		let tx_sync = Arc::clone(&self.tx_sync);
 		let sync_cman = Arc::clone(&self.channel_manager);
+		let archive_cman = Arc::clone(&self.channel_manager);
 		let sync_cmon = Arc::clone(&self.chain_monitor);
+		let archive_cmon = Arc::clone(&self.chain_monitor);
 		let sync_sweeper = Arc::clone(&self.output_sweeper);
 		let sync_logger = Arc::clone(&self.logger);
 		let sync_wallet_timestamp = Arc::clone(&self.latest_wallet_sync_timestamp);
+		let sync_monitor_archival_height = Arc::clone(&self.latest_channel_monitor_archival_height);
 		let mut stop_sync = self.stop_sender.subscribe();
 		let wallet_sync_interval_secs =
 			self.config.wallet_sync_interval_secs.max(WALLET_SYNC_INTERVAL_MINIMUM_SECS);
@@ -375,6 +379,12 @@ impl Node {
 								let unix_time_secs_opt =
 									SystemTime::now().duration_since(UNIX_EPOCH).ok().map(|d| d.as_secs());
 								*sync_wallet_timestamp.write().unwrap() = unix_time_secs_opt;
+
+								periodically_archive_fully_resolved_monitors(
+									Arc::clone(&archive_cman),
+									Arc::clone(&archive_cmon),
+									Arc::clone(&sync_monitor_archival_height)
+								);
 							}
 							Err(e) => {
 								log_error!(sync_logger, "Background sync of Lightning wallet failed: {}", e)
@@ -1077,14 +1087,17 @@ impl Node {
 		let wallet = Arc::clone(&self.wallet);
 		let tx_sync = Arc::clone(&self.tx_sync);
 		let sync_cman = Arc::clone(&self.channel_manager);
+		let archive_cman = Arc::clone(&self.channel_manager);
 		let sync_cmon = Arc::clone(&self.chain_monitor);
+		let archive_cmon = Arc::clone(&self.chain_monitor);
 		let sync_sweeper = Arc::clone(&self.output_sweeper);
 		let sync_logger = Arc::clone(&self.logger);
 		let confirmables = vec![
 			&*sync_cman as &(dyn Confirm + Sync + Send),
 			&*sync_cmon as &(dyn Confirm + Sync + Send),
 			&*sync_sweeper as &(dyn Confirm + Sync + Send),
 		];
+		let sync_monitor_archival_height = Arc::clone(&self.latest_channel_monitor_archival_height);
 
 		tokio::task::block_in_place(move || {
 			tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap().block_on(
@@ -1112,6 +1125,12 @@ impl Node {
 								"Sync of Lightning wallet finished in {}ms.",
 								now.elapsed().as_millis()
 							);
+
+							periodically_archive_fully_resolved_monitors(
+								archive_cman,
+								archive_cmon,
+								sync_monitor_archival_height,
+							);
 							Ok(())
 						},
 						Err(e) => {
@@ -1358,3 +1377,19 @@ pub struct NodeStatus {
 	/// Will be `None` if we have no public channels or we haven't broadcasted since the [`Node`] was initialized.
 	pub latest_node_announcement_broadcast_timestamp: Option<u64>,
 }
+
+fn periodically_archive_fully_resolved_monitors(
+	channel_manager: Arc<ChannelManager>, chain_monitor: Arc<ChainMonitor>,
+	latest_channel_monitor_archival_height: Arc<RwLock<Option<u32>>>,
+) {
+	let mut latest_archival_height_lock = latest_channel_monitor_archival_height.write().unwrap();
+	let cur_height = channel_manager.current_best_block().height;
+	let should_archive = latest_archival_height_lock
+		.as_ref()
+		.map_or(true, |h| cur_height >= h + LDK_CHANNEL_MONITOR_ARCHIVAL_INTERVAL);
+
+	if should_archive {
+		chain_monitor.archive_fully_resolved_channel_monitors();
+		*latest_archival_height_lock = Some(cur_height);
+	}
+}