f Update fees upon sync, rather than every request

Author: tnull

src/wallet.rs

@@ -26,7 +26,7 @@ where
 	// A BDK on-chain wallet.
 	inner: Mutex<bdk::Wallet<D>>,
 	// A cache storing the most recently retrieved fee rate estimations.
-	fee_rate_cache: Mutex<HashMap<ConfirmationTarget, FeeRate>>,
+	fee_rate_cache: RwLock<HashMap<ConfirmationTarget, FeeRate>>,
 	tokio_runtime: RwLock<Option<Arc<tokio::runtime::Runtime>>>,
 	logger: Arc<FilesystemLogger>,
 }
@@ -39,18 +39,26 @@ where
 		blockchain: EsploraBlockchain, wallet: bdk::Wallet<D>, logger: Arc<FilesystemLogger>,
 	) -> Self {
 		let inner = Mutex::new(wallet);
-		let fee_rate_cache = Mutex::new(HashMap::new());
+		let fee_rate_cache = RwLock::new(HashMap::new());
 		let tokio_runtime = RwLock::new(None);
 		Self { blockchain, inner, fee_rate_cache, tokio_runtime, logger }
 	}
 
 	pub(crate) async fn sync(&self) -> Result<(), Error> {
+		match self.update_fee_estimates().await {
+			Ok(()) => (),
+			Err(e) => {
+				log_error!(self.logger, "Fee estimation error: {}", e);
+				return Err(e);
+			}
+		}
+
 		let sync_options = SyncOptions { progress: None };
 		match self.inner.lock().unwrap().sync(&self.blockchain, sync_options).await {
 			Ok(()) => Ok(()),
 			Err(e) => {
 				log_error!(self.logger, "Wallet sync error: {}", e);
-				Err(e)?
+				Err(From::from(e))
 			}
 		}
 	}
@@ -63,6 +71,36 @@ where
 		*self.tokio_runtime.write().unwrap() = None;
 	}
 
+	pub(crate) async fn update_fee_estimates(&self) -> Result<(), Error> {
+		let mut locked_fee_rate_cache = self.fee_rate_cache.write().unwrap();
+
+		let confirmation_targets = vec![
+			ConfirmationTarget::Background,
+			ConfirmationTarget::Normal,
+			ConfirmationTarget::HighPriority,
+		];
+		for target in confirmation_targets {
+			let num_blocks = num_blocks_from_conf_target(target);
+
+			let est_fee_rate = self.blockchain.estimate_fee(num_blocks).await;
+
+			match est_fee_rate {
+				Ok(rate) => {
+					locked_fee_rate_cache.insert(target, rate);
+					log_trace!(
+						self.logger,
+						"Fee rate estimation updated: {} sats/kwu",
+						rate.fee_wu(1000)
+					);
+				}
+				Err(e) => {
+					log_error!(self.logger, "Failed to update fee rate estimation: {}", e);
+				}
+			}
+		}
+		Ok(())
+	}
+
 	pub(crate) fn create_funding_transaction(
 		&self, output_script: &Script, value_sats: u64, confirmation_target: ConfirmationTarget,
 	) -> Result<Transaction, Error> {
@@ -111,41 +149,12 @@ where
 	}
 
 	fn estimate_fee_rate(&self, confirmation_target: ConfirmationTarget) -> FeeRate {
-		let mut locked_fee_rate_cache = self.fee_rate_cache.lock().unwrap();
-		let num_blocks = num_blocks_from_conf_target(confirmation_target);
+		let locked_fee_rate_cache = self.fee_rate_cache.read().unwrap();
 
 		// We'll fall back on this, if we really don't have any other information.
 		let fallback_rate = fallback_fee_from_conf_target(confirmation_target);
 
-		let locked_runtime = self.tokio_runtime.read().unwrap();
-		if locked_runtime.as_ref().is_none() {
-			log_error!(self.logger, "Failed to update fee rate estimation: No runtime.");
-			unreachable!("Failed to broadcast transaction: No runtime.");
-		}
-
-		let est_fee_rate = tokio::task::block_in_place(move || {
-			locked_runtime
-				.as_ref()
-				.unwrap()
-				.handle()
-				.block_on(async move { self.blockchain.estimate_fee(num_blocks).await })
-		});
-
-		match est_fee_rate {
-			Ok(rate) => {
-				locked_fee_rate_cache.insert(confirmation_target, rate);
-				log_trace!(
-					self.logger,
-					"Fee rate estimation updated: {} sats/kwu",
-					rate.fee_wu(1000)
-				);
-				rate
-			}
-			Err(e) => {
-				log_error!(self.logger, "Failed to update fee rate estimation: {}", e);
-				*locked_fee_rate_cache.get(&confirmation_target).unwrap_or(&fallback_rate)
-			}
-		}
+		*locked_fee_rate_cache.get(&confirmation_target).unwrap_or(&fallback_rate)
 	}
 }