Enforce successful initial wallet sync and make sync interval configurable

So far we'd immediately start background syncing upon `start()` which
would work fine, except when these initial syncs failed, in which case
we'd use our fallback fee. This might lead to being disconnected
from peers as our fallback values are likely out of current fee ranges.

To mitigate this we here simply enforce that the initial syncs in
`start()` are successful and hence we'd at least once got a recent fee
estimation update.

Moreover, we make the background syncing intervals configurable, however
enforcing a floor of 10 seconds.

Author: tnull

bindings/ldk_node.udl

@@ -7,6 +7,8 @@ dictionary Config {
 	Network network;
 	NetAddress? listening_address;
 	u32 default_cltv_expiry_delta;
+	u64 onchain_wallet_sync_interval_secs;
+	u64 wallet_sync_interval_secs;
 	LogLevel log_level;
 };
 

src/lib.rs

@@ -112,7 +112,7 @@ use types::{
 pub use types::{ChannelDetails, ChannelId, PeerDetails, UserChannelId};
 use wallet::Wallet;
 
-use logger::{log_error, log_info, FilesystemLogger, Logger};
+use logger::{log_error, log_info, log_trace, FilesystemLogger, Logger};
 
 use lightning::chain::keysinterface::EntropySource;
 use lightning::chain::{chainmonitor, BestBlock, Confirm, Watch};
@@ -167,9 +167,15 @@ const BDK_CLIENT_STOP_GAP: usize = 20;
 // The number of concurrent requests made against the API provider.
 const BDK_CLIENT_CONCURRENCY: u8 = 8;
 
+// The default time in-between LDK wallet sync attempts.
+const DEFAULT_BDK_WALLET_SYNC_INTERVAL_SECS: u64 = 60;
+
 // The timeout after which we abandon retrying failed payments.
 const LDK_PAYMENT_RETRY_TIMEOUT: Duration = Duration::from_secs(10);
 
+// The default time in-between LDK wallet sync attempts.
+const DEFAULT_LDK_WALLET_SYNC_INTERVAL_SECS: u64 = 20;
+
 // The time in-between peer reconnection attempts.
 const PEER_RECONNECTION_INTERVAL: Duration = Duration::from_secs(10);
 
@@ -195,6 +201,14 @@ pub struct Config {
 	pub listening_address: Option<NetAddress>,
 	/// The default CLTV expiry delta to be used for payments.
 	pub default_cltv_expiry_delta: u32,
+	/// The time in-between background sync attempts of the onchain wallet, in seconds.
+	///
+	/// **Note:** A minimum of 10 seconds is always enforced.
+	pub onchain_wallet_sync_interval_secs: u64,
+	/// The time in-between background sync attempts of the LDK wallet, in seconds.
+	///
+	/// **Note:** A minimum of 10 seconds is always enforced.
+	pub wallet_sync_interval_secs: u64,
 	/// The level at which we log messages.
 	///
 	/// Any messages below this level will be excluded from the logs.
@@ -209,6 +223,8 @@ impl Default for Config {
 			network: Network::Regtest,
 			listening_address: Some("0.0.0.0:9735".parse().unwrap()),
 			default_cltv_expiry_delta: 144,
+			onchain_wallet_sync_interval_secs: DEFAULT_BDK_WALLET_SYNC_INTERVAL_SECS,
+			wallet_sync_interval_secs: DEFAULT_LDK_WALLET_SYNC_INTERVAL_SECS,
 			log_level: LogLevel::Debug,
 		}
 	}
@@ -729,31 +745,38 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 
 		let runtime = tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap();
 
-		let event_handler = Arc::new(EventHandler::new(
-			Arc::clone(&self.wallet),
-			Arc::clone(&self.event_queue),
-			Arc::clone(&self.channel_manager),
-			Arc::clone(&self.network_graph),
-			Arc::clone(&self.keys_manager),
-			Arc::clone(&self.payment_store),
-			Arc::clone(&self.runtime),
-			Arc::clone(&self.logger),
-			Arc::clone(&self.config),
-		));
-
 		// Setup wallet sync
 		let wallet = Arc::clone(&self.wallet);
-		let tx_sync = Arc::clone(&self.tx_sync);
-		let sync_cman = Arc::clone(&self.channel_manager);
-		let sync_cmon = Arc::clone(&self.chain_monitor);
 		let sync_logger = Arc::clone(&self.logger);
 		let mut stop_sync = self.stop_receiver.clone();
 
+		runtime.block_on(async move {
+			let now = Instant::now();
+			match wallet.sync().await {
+				Ok(()) => {
+					log_info!(
+						sync_logger,
+						"Initial sync of on-chain wallet finished in {}ms.",
+						now.elapsed().as_millis()
+					);
+					Ok(())
+				}
+				Err(e) => {
+					log_error!(sync_logger, "Initial sync of on-chain wallet failed: {}", e,);
+					Err(e)
+				}
+			}
+		})?;
+
+		let sync_logger = Arc::clone(&self.logger);
+		let wallet = Arc::clone(&self.wallet);
 		std::thread::spawn(move || {
 			tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap().block_on(
 				async move {
-					let mut interval = tokio::time::interval(Duration::from_secs(30));
+					let interval_secs = DEFAULT_BDK_WALLET_SYNC_INTERVAL_SECS.max(10);
+					let mut interval = tokio::time::interval(Duration::from_secs(interval_secs));
 					interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+					interval.reset();
 					loop {
 						let now = Instant::now();
 						tokio::select! {
@@ -762,7 +785,7 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 							}
 							_ = interval.tick() => {
 								match wallet.sync().await {
-									Ok(()) => log_info!(
+									Ok(()) => log_trace!(
 										sync_logger,
 										"Background sync of on-chain wallet finished in {}ms.",
 										now.elapsed().as_millis()
@@ -782,6 +805,68 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 			);
 		});
 
+		let tx_sync = Arc::clone(&self.tx_sync);
+		let sync_cman = Arc::clone(&self.channel_manager);
+		let sync_cmon = Arc::clone(&self.chain_monitor);
+		let sync_logger = Arc::clone(&self.logger);
+		runtime.block_on(async move {
+			let now = Instant::now();
+			let confirmables = vec![
+				&*sync_cman as &(dyn Confirm + Sync + Send),
+				&*sync_cmon as &(dyn Confirm + Sync + Send),
+			];
+			match tx_sync.sync(confirmables).await {
+				Ok(()) => {
+					log_info!(
+						sync_logger,
+						"Initial sync of Lightning wallet finished in {}ms.",
+						now.elapsed().as_millis()
+					);
+					Ok(())
+				}
+				Err(e) => {
+					log_error!(sync_logger, "Initial sync of Lightning wallet failed: {}", e);
+					Err(e)
+				}
+			}
+		})?;
+
+		let tx_sync = Arc::clone(&self.tx_sync);
+		let sync_cman = Arc::clone(&self.channel_manager);
+		let sync_cmon = Arc::clone(&self.chain_monitor);
+		let sync_logger = Arc::clone(&self.logger);
+		let mut stop_sync = self.stop_receiver.clone();
+		runtime.spawn(async move {
+			let interval_secs = DEFAULT_LDK_WALLET_SYNC_INTERVAL_SECS.max(10);
+			let mut interval = tokio::time::interval(Duration::from_secs(interval_secs));
+			interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+			interval.reset();
+			loop {
+				let now = Instant::now();
+				tokio::select! {
+					_ = stop_sync.changed() => {
+						return;
+					}
+					_ = interval.tick() => {
+						let confirmables = vec![
+							&*sync_cman as &(dyn Confirm + Sync + Send),
+							&*sync_cmon as &(dyn Confirm + Sync + Send),
+						];
+						match tx_sync.sync(confirmables).await {
+							Ok(()) => log_trace!(
+								sync_logger,
+								"Background sync of Lightning wallet finished in {}ms.",
+								now.elapsed().as_millis()
+								),
+							Err(e) => {
+								log_error!(sync_logger, "Background sync of Lightning wallet failed: {}", e)
+							}
+						}
+					}
+				}
+			}
+		});
+
 		if self.gossip_source.is_rgs() {
 			let gossip_source = Arc::clone(&self.gossip_source);
 			let gossip_sync_store = Arc::clone(&self.kv_store);
@@ -799,7 +884,7 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 							let now = Instant::now();
 							match gossip_source.update_rgs_snapshot().await {
 								Ok(updated_timestamp) => {
-									log_info!(
+									log_trace!(
 										gossip_sync_logger,
 										"Background sync of RGS gossip data finished in {}ms.",
 										now.elapsed().as_millis()
@@ -823,37 +908,6 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 			});
 		}
 
-		let sync_logger = Arc::clone(&self.logger);
-		let mut stop_sync = self.stop_receiver.clone();
-		runtime.spawn(async move {
-			let mut interval = tokio::time::interval(Duration::from_secs(10));
-			interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
-			loop {
-				let now = Instant::now();
-				tokio::select! {
-					_ = stop_sync.changed() => {
-						return;
-					}
-					_ = interval.tick() => {
-						let confirmables = vec![
-							&*sync_cman as &(dyn Confirm + Sync + Send),
-							&*sync_cmon as &(dyn Confirm + Sync + Send),
-						];
-						match tx_sync.sync(confirmables).await {
-							Ok(()) => log_info!(
-								sync_logger,
-								"Background sync of Lightning wallet finished in {}ms.",
-								now.elapsed().as_millis()
-								),
-							Err(e) => {
-								log_error!(sync_logger, "Background sync of Lightning wallet failed: {}", e)
-							}
-						}
-					}
-				}
-			}
-		});
-
 		if let Some(listening_address) = &self.config.listening_address {
 			// Setup networking
 			let peer_manager_connection_handler = Arc::clone(&self.peer_manager);
@@ -987,6 +1041,18 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 			}
 		});
 
+		let event_handler = Arc::new(EventHandler::new(
+			Arc::clone(&self.wallet),
+			Arc::clone(&self.event_queue),
+			Arc::clone(&self.channel_manager),
+			Arc::clone(&self.network_graph),
+			Arc::clone(&self.keys_manager),
+			Arc::clone(&self.payment_store),
+			Arc::clone(&self.runtime),
+			Arc::clone(&self.logger),
+			Arc::clone(&self.config),
+		));
+
 		// Setup background processing
 		let background_persister = Arc::clone(&self.kv_store);
 		let background_event_handler = Arc::clone(&event_handler);

src/test/functional_tests.rs

@@ -375,9 +375,10 @@ fn onchain_spend_receive() {
 
 #[test]
 fn sign_verify_msg() {
-	let (_, electrsd) = setup_bitcoind_and_electrsd();
+	let (_bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let esplora_url = electrsd.esplora_url.as_ref().unwrap();
-	let node = Builder::from_config(random_config(esplora_url)).build();
+	let config = random_config(esplora_url);
+	let node = Builder::from_config(config).build();
 
 	node.start().unwrap();