Periodically archive fully resolved channel monitors

src/builder.rs

@@ -979,6 +979,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,
@@ -1010,6 +1011,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

@@ -30,6 +30,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 retry archiving fully resolved channel monitors.
+pub(crate) const RESOLVED_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,7 +122,8 @@ pub use builder::BuildError;
 pub use builder::NodeBuilder as Builder;
 
 use config::{
-	NODE_ANN_BCAST_INTERVAL, PEER_RECONNECTION_INTERVAL, RGS_SYNC_INTERVAL,
+	NODE_ANN_BCAST_INTERVAL, PEER_RECONNECTION_INTERVAL,
+	RESOLVED_CHANNEL_MONITOR_ARCHIVAL_INTERVAL, RGS_SYNC_INTERVAL,
 	WALLET_SYNC_INTERVAL_MINIMUM_SECS,
 };
 use connection::ConnectionManager;
@@ -198,6 +199,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 {
@@ -343,10 +345,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);
@@ -376,6 +381,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)
@@ -1113,7 +1124,8 @@ impl Node {
  }
 	}
 
-	/// Manually sync the LDK and BDK wallets with the current chain state.
+	/// Manually sync the LDK and BDK wallets with the current chain state and update the fee rate
+	/// cache.
 	///
 	/// **Note:** The wallets are regularly synced in the background, which is configurable via
 	/// [`Config::onchain_wallet_sync_interval_secs`] and [`Config::wallet_sync_interval_secs`].
@@ -1128,14 +1140,22 @@ 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 fee_estimator = Arc::clone(&self.fee_estimator);
  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_wallet_timestamp = Arc::clone(&self.latest_wallet_sync_timestamp);
+ let sync_fee_rate_update_timestamp =
+ Arc::clone(&self.latest_fee_rate_cache_update_timestamp);
+ let sync_onchain_wallet_timestamp = Arc::clone(&self.latest_onchain_wallet_sync_timestamp);
+ 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(
@@ -1148,13 +1168,38 @@ impl Node {
  "Sync of on-chain wallet finished in {}ms.",
  now.elapsed().as_millis()
  );
+ let unix_time_secs_opt = SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .ok()
+ .map(|d| d.as_secs());
+ *sync_onchain_wallet_timestamp.write().unwrap() = unix_time_secs_opt;
  },
  Err(e) => {
  log_error!(sync_logger, "Sync of on-chain wallet failed: {}", e);
  return Err(e);
  },
  };
 
+ let now = Instant::now();
+ match fee_estimator.update_fee_estimates().await {
+ Ok(()) => {
+ log_info!(
+ sync_logger,
+ "Fee rate cache update finished in {}ms.",
+ now.elapsed().as_millis()
+ );
+ let unix_time_secs_opt = SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .ok()
+ .map(|d| d.as_secs());
+ *sync_fee_rate_update_timestamp.write().unwrap() = unix_time_secs_opt;
+ },
+ Err(e) => {
+ log_error!(sync_logger, "Fee rate cache update failed: {}", e,);
+ return Err(e);
+ },
+ }
+
  let now = Instant::now();
  match tx_sync.sync(confirmables).await {
  Ok(()) => {
@@ -1163,6 +1208,18 @@ impl Node {
  "Sync of Lightning wallet finished in {}ms.",
  now.elapsed().as_millis()
  );
+
+ 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(
+ archive_cman,
+ archive_cmon,
+ sync_monitor_archival_height,
+ );
  Ok(())
  },
  Err(e) => {
@@ -1486,3 +1543,19 @@ pub(crate) fn total_anchor_channels_reserve_sats(
  * anchor_channels_config.per_channel_reserve_sats
 	})
 }
+
+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 + RESOLVED_CHANNEL_MONITOR_ARCHIVAL_INTERVAL);
+
+	if should_archive {
+ chain_monitor.archive_fully_resolved_channel_monitors();
+ *latest_archival_height_lock = Some(cur_height);
+	}
+}