Add dedicated probing builder

Change cursor of top nodes from HighDegreeStrategy to use cac:
Create src/util.rs
Add probe HTLC maximal lower bound
Fix styling (config argument order), explicit Arc::clone instead of .clone()
Change tests open_channel to reuse existing code

Author: randomlogin

src/builder.rs

@@ -11,7 +11,7 @@ use std::default::Default;
 use std::path::PathBuf;
 use std::sync::atomic::AtomicU64;
 use std::sync::{Arc, Mutex, Once, RwLock};
-use std::time::{Duration, SystemTime};
+use std::time::SystemTime;
 use std::{fmt, fs};
 
 use bdk_wallet::template::Bip84;
@@ -48,8 +48,7 @@ use crate::config::{
 	default_user_config, may_announce_channel, AnnounceError, AsyncPaymentsRole,
 	BitcoindRestClientConfig, Config, ElectrumSyncConfig, EsploraSyncConfig, TorConfig,
 	DEFAULT_ESPLORA_SERVER_URL, DEFAULT_LOG_FILENAME, DEFAULT_LOG_LEVEL,
-	DEFAULT_MAX_PROBE_AMOUNT_MSAT, DEFAULT_MAX_PROBE_LOCKED_MSAT, DEFAULT_PROBING_INTERVAL_SECS,
-	MIN_PROBE_AMOUNT_MSAT,
+	DEFAULT_MAX_PROBE_AMOUNT_MSAT, MIN_PROBE_AMOUNT_MSAT,
 };
 use crate::connection::ConnectionManager;
 use crate::entropy::NodeEntropy;
@@ -155,38 +154,6 @@ impl std::fmt::Debug for LogWriterConfig {
 	}
 }
 
-#[cfg_attr(feature = "uniffi", allow(dead_code))]
-enum ProbingStrategyKind {
-	HighDegree { top_n: usize },
-	Random { max_hops: usize },
-	Custom(Arc<dyn probing::ProbingStrategy>),
-}
-
-struct ProbingStrategyConfig {
-	kind: ProbingStrategyKind,
-	interval: Duration,
-	max_locked_msat: u64,
-}
-
-impl fmt::Debug for ProbingStrategyConfig {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		let kind_str = match &self.kind {
-			ProbingStrategyKind::HighDegree { top_n } => {
-				format!("HighDegree {{ top_n: {} }}", top_n)
-			},
-			ProbingStrategyKind::Random { max_hops } => {
-				format!("Random {{ max_hops: {} }}", max_hops)
-			},
-			ProbingStrategyKind::Custom(_) => "Custom(<probing strategy>)".to_string(),
-		};
-		f.debug_struct("ProbingStrategyConfig")
-			.field("kind", &kind_str)
-			.field("interval", &self.interval)
-			.field("max_locked_msat", &self.max_locked_msat)
-			.finish()
-	}
-}
-
 /// An error encountered during building a [`Node`].
 ///
 /// [`Node`]: crate::Node
@@ -317,8 +284,7 @@ pub struct NodeBuilder {
 	runtime_handle: Option<tokio::runtime::Handle>,
 	pathfinding_scores_sync_config: Option<PathfindingScoresSyncConfig>,
 	recovery_mode: bool,
-	probing_strategy: Option<ProbingStrategyConfig>,
-	probing_diversity_penalty_msat: Option<u64>,
+	probing_config: Option<probing::ProbingConfig>,
 }
 
 impl NodeBuilder {
@@ -338,8 +304,7 @@ impl NodeBuilder {
 		let pathfinding_scores_sync_config = None;
 		let recovery_mode = false;
 		let async_payments_role = None;
-		let probing_strategy = None;
-		let probing_diversity_penalty_msat = None;
+		let probing_config = None;
 		Self {
 			config,
 			chain_data_source_config,
@@ -350,8 +315,7 @@ impl NodeBuilder {
 			async_payments_role,
 			pathfinding_scores_sync_config,
 			recovery_mode,
-			probing_strategy,
-			probing_diversity_penalty_msat,
+			probing_config,
 		}
 	}
 
@@ -657,87 +621,23 @@ impl NodeBuilder {
 		self
 	}
 
-	/// Configures background probing toward the highest-degree nodes in the network graph.
-	///
-	/// `top_n` controls how many of the most-connected nodes are cycled through.
-	#[cfg_attr(feature = "uniffi", allow(dead_code))]
-	pub fn set_high_degree_probing_strategy(&mut self, top_n: usize) -> &mut Self {
-		let kind = ProbingStrategyKind::HighDegree { top_n };
-		self.probing_strategy = Some(self.make_probing_config(kind));
-		self
-	}
-
-	/// Configures background probing via random graph walks of up to `max_hops` hops.
-	#[cfg_attr(feature = "uniffi", allow(dead_code))]
-	pub fn set_random_probing_strategy(&mut self, max_hops: usize) -> &mut Self {
-		let kind = ProbingStrategyKind::Random { max_hops };
-		self.probing_strategy = Some(self.make_probing_config(kind));
-		self
-	}
-
-	/// Configures a custom probing strategy for background channel probing.
-	///
-	/// When set, the node will periodically call [`probing::ProbingStrategy::next_probe`] and dispatch the
-	/// returned probe via the channel manager.
-	#[cfg_attr(feature = "uniffi", allow(dead_code))]
-	pub fn set_custom_probing_strategy(
-		&mut self, strategy: Arc<dyn probing::ProbingStrategy>,
-	) -> &mut Self {
-		let kind = ProbingStrategyKind::Custom(strategy);
-		self.probing_strategy = Some(self.make_probing_config(kind));
-		self
-	}
-
-	/// Overrides the interval between probe attempts. Only has effect if a probing strategy is set.
-	#[cfg_attr(feature = "uniffi", allow(dead_code))]
-	pub fn set_probing_interval(&mut self, interval: Duration) -> &mut Self {
-		if let Some(cfg) = &mut self.probing_strategy {
-			cfg.interval = interval;
-		}
-		self
-	}
-
-	/// Overrides the maximum millisatoshis that may be locked in in-flight probes at any time.
-	/// Only has effect if a probing strategy is set.
-	#[cfg_attr(feature = "uniffi", allow(dead_code))]
-	pub fn set_max_probe_locked_msat(&mut self, max_msat: u64) -> &mut Self {
-		if let Some(cfg) = &mut self.probing_strategy {
-			cfg.max_locked_msat = max_msat;
-		}
-		self
-	}
-
-	/// Sets the probing diversity penalty applied by the probabilistic scorer.
+	/// Configures background probing.
 	///
-	/// When set, the scorer will penalize channels that have been recently probed,
-	/// encouraging path diversity during background probing. The penalty decays
-	/// quadratically over 24 hours.
+	/// Use [`probing::ProbingConfig`] to build the configuration:
+	/// ```ignore
+	/// use ldk_node::probing::ProbingConfig;
 	///
-	/// This is only useful for probing strategies that route through the scorer
-	/// (e.g., [`probing::HighDegreeStrategy`]). Strategies that build paths manually
-	/// (e.g., [`probing::RandomStrategy`]) bypass the scorer entirely.
-	///
-	/// If unset, LDK's default of `0` (no penalty) is used.
-	#[cfg_attr(feature = "uniffi", allow(dead_code))]
-	pub fn set_probing_diversity_penalty_msat(&mut self, penalty_msat: u64) -> &mut Self {
-		self.probing_diversity_penalty_msat = Some(penalty_msat);
+	/// builder.set_probing_config(
+	///     ProbingConfig::high_degree(100)
+	///         .interval(Duration::from_secs(30))
+	///         .build()
+	/// );
+	/// ```
+	pub fn set_probing_config(&mut self, config: probing::ProbingConfig) -> &mut Self {
+		self.probing_config = Some(config);
 		self
 	}
 
-	#[cfg_attr(feature = "uniffi", allow(dead_code))]
-	fn make_probing_config(&self, kind: ProbingStrategyKind) -> ProbingStrategyConfig {
-		let existing = self.probing_strategy.as_ref();
-		ProbingStrategyConfig {
-			kind,
-			interval: existing
-				.map(|c| c.interval)
-				.unwrap_or(Duration::from_secs(DEFAULT_PROBING_INTERVAL_SECS)),
-			max_locked_msat: existing
-				.map(|c| c.max_locked_msat)
-				.unwrap_or(DEFAULT_MAX_PROBE_LOCKED_MSAT),
-		}
-	}
-
 	/// Builds a [`Node`] instance with a [`SqliteStore`] backend and according to the options
 	/// previously configured.
 	pub fn build(&self, node_entropy: NodeEntropy) -> Result<Node, BuildError> {
@@ -909,14 +809,13 @@ impl NodeBuilder {
 			self.gossip_source_config.as_ref(),
 			self.liquidity_source_config.as_ref(),
 			self.pathfinding_scores_sync_config.as_ref(),
+			self.probing_config.as_ref(),
 			self.async_payments_role,
 			self.recovery_mode,
 			seed_bytes,
 			runtime,
 			logger,
 			Arc::new(DynStoreWrapper(kv_store)),
-			self.probing_strategy.as_ref(),
-			self.probing_diversity_penalty_msat,
 		)
 	}
 }
@@ -1207,34 +1106,11 @@ impl ArcedNodeBuilder {
 		self.inner.write().unwrap().set_wallet_recovery_mode();
 	}
 
-	/// Configures background probing toward the highest-degree nodes in the network graph.
-	pub fn set_high_degree_probing_strategy(&self, top_n: usize) {
-		self.inner.write().unwrap().set_high_degree_probing_strategy(top_n);
-	}
-
-	/// Configures background probing via random graph walks of up to `max_hops` hops.
-	pub fn set_random_probing_strategy(&self, max_hops: usize) {
-		self.inner.write().unwrap().set_random_probing_strategy(max_hops);
-	}
-
-	/// Configures a custom probing strategy for background channel probing.
-	pub fn set_custom_probing_strategy(&self, strategy: Arc<dyn probing::ProbingStrategy>) {
-		self.inner.write().unwrap().set_custom_probing_strategy(strategy);
-	}
-
-	/// Overrides the interval between probe attempts.
-	pub fn set_probing_interval(&self, interval: Duration) {
-		self.inner.write().unwrap().set_probing_interval(interval);
-	}
-
-	/// Overrides the maximum millisatoshis that may be locked in in-flight probes at any time.
-	pub fn set_max_probe_locked_msat(&self, max_msat: u64) {
-		self.inner.write().unwrap().set_max_probe_locked_msat(max_msat);
-	}
-
-	/// Sets the probing diversity penalty applied by the probabilistic scorer.
-	pub fn set_probing_diversity_penalty_msat(&self, penalty_msat: u64) {
-		self.inner.write().unwrap().set_probing_diversity_penalty_msat(penalty_msat);
+	/// Configures background probing.
+	///
+	/// See [`probing::ProbingConfig`] for details.
+	pub fn set_probing_config(&self, config: probing::ProbingConfig) {
+		self.inner.write().unwrap().set_probing_config(config);
 	}
 
 	/// Builds a [`Node`] instance with a [`SqliteStore`] backend and according to the options
@@ -1380,9 +1256,9 @@ fn build_with_store_internal(
 	gossip_source_config: Option<&GossipSourceConfig>,
 	liquidity_source_config: Option<&LiquiditySourceConfig>,
 	pathfinding_scores_sync_config: Option<&PathfindingScoresSyncConfig>,
+	probing_config: Option<&probing::ProbingConfig>,
 	async_payments_role: Option<AsyncPaymentsRole>, recovery_mode: bool, seed_bytes: [u8; 64],
 	runtime: Arc<Runtime>, logger: Arc<Logger>, kv_store: Arc<DynStore>,
-	probing_config: Option<&ProbingStrategyConfig>, probing_diversity_penalty_msat: Option<u64>,
 ) -> Result<Node, BuildError> {
 	optionally_install_rustls_cryptoprovider();
 
@@ -1784,7 +1660,7 @@ fn build_with_store_internal(
 	}
 
 	let mut scoring_fee_params = ProbabilisticScoringFeeParameters::default();
-	if let Some(penalty) = probing_diversity_penalty_msat {
+	if let Some(penalty) = probing_config.and_then(|c| c.diversity_penalty_msat) {
 		scoring_fee_params.probing_diversity_penalty_msat = penalty;
 	}
 	let router = Arc::new(DefaultRouter::new(
@@ -2127,26 +2003,29 @@ fn build_with_store_internal(
 
 	let prober = probing_config.map(|probing_cfg| {
 		let strategy: Arc<dyn probing::ProbingStrategy> = match &probing_cfg.kind {
-			ProbingStrategyKind::HighDegree { top_n } => {
+			probing::ProbingStrategyKind::HighDegree { top_node_count } => {
 				Arc::new(probing::HighDegreeStrategy::new(
-					network_graph.clone(),
-					*top_n,
+					Arc::clone(&network_graph),
+					*top_node_count,
+					MIN_PROBE_AMOUNT_MSAT,
+					DEFAULT_MAX_PROBE_AMOUNT_MSAT,
+					probing_cfg.cooldown,
+				))
+			},
+			probing::ProbingStrategyKind::Random { max_hops } => {
+				Arc::new(probing::RandomStrategy::new(
+					Arc::clone(&network_graph),
+					Arc::clone(&channel_manager),
+					*max_hops,
 					MIN_PROBE_AMOUNT_MSAT,
 					DEFAULT_MAX_PROBE_AMOUNT_MSAT,
 				))
 			},
-			ProbingStrategyKind::Random { max_hops } => Arc::new(probing::RandomStrategy::new(
-				network_graph.clone(),
-				channel_manager.clone(),
-				*max_hops,
-				MIN_PROBE_AMOUNT_MSAT,
-				DEFAULT_MAX_PROBE_AMOUNT_MSAT,
-			)),
-			ProbingStrategyKind::Custom(s) => s.clone(),
+			probing::ProbingStrategyKind::Custom(s) => Arc::clone(s),
 		};
 		Arc::new(probing::Prober {
-			channel_manager: channel_manager.clone(),
-			logger: logger.clone(),
+			channel_manager: Arc::clone(&channel_manager),
+			logger: Arc::clone(&logger),
 			strategy,
 			interval: probing_cfg.interval,
 			liquidity_limit_multiplier: Some(config.probing_liquidity_limit_multiplier),

src/config.rs

@@ -28,6 +28,7 @@ const DEFAULT_LDK_WALLET_SYNC_INTERVAL_SECS: u64 = 30;
 const DEFAULT_FEE_RATE_CACHE_UPDATE_INTERVAL_SECS: u64 = 60 * 10;
 const DEFAULT_PROBING_LIQUIDITY_LIMIT_MULTIPLIER: u64 = 3;
 pub(crate) const DEFAULT_PROBING_INTERVAL_SECS: u64 = 10;
+pub(crate) const DEFAULT_PROBED_NODE_COOLDOWN_SECS: u64 = 60 * 60; // 1 hour
 pub(crate) const DEFAULT_MAX_PROBE_LOCKED_MSAT: u64 = 100_000_000; // 100k sats
 pub(crate) const MIN_PROBE_AMOUNT_MSAT: u64 = 1_000_000; // 1k sats
 pub(crate) const DEFAULT_MAX_PROBE_AMOUNT_MSAT: u64 = 10_000_000; // 10k sats

src/event.rs

@@ -9,7 +9,6 @@ use core::future::Future;
 use core::task::{Poll, Waker};
 use std::collections::VecDeque;
 use std::ops::Deref;
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
 
 use bitcoin::blockdata::locktime::absolute::LockTime;
@@ -53,6 +52,7 @@ use crate::payment::asynchronous::static_invoice_store::StaticInvoiceStore;
 use crate::payment::store::{
 	PaymentDetails, PaymentDetailsUpdate, PaymentDirection, PaymentKind, PaymentStatus,
 };
+use crate::probing::Prober;
 use crate::runtime::Runtime;
 use crate::types::{
 	CustomTlvRecord, DynStore, KeysManager, OnionMessenger, PaymentStore, Sweeper, Wallet,
@@ -516,7 +516,7 @@ where
 	static_invoice_store: Option<StaticInvoiceStore>,
 	onion_messenger: Arc<OnionMessenger>,
 	om_mailbox: Option<Arc<OnionMessageMailbox>>,
-	probe_locked_msat: Option<Arc<AtomicU64>>,
+	prober: Option<Arc<Prober>>,
 }
 
 impl<L: Deref + Clone + Sync + Send + 'static> EventHandler<L>
@@ -532,8 +532,7 @@ where
 		payment_store: Arc<PaymentStore>, peer_store: Arc<PeerStore<L>>,
 		keys_manager: Arc<KeysManager>, static_invoice_store: Option<StaticInvoiceStore>,
 		onion_messenger: Arc<OnionMessenger>, om_mailbox: Option<Arc<OnionMessageMailbox>>,
-		runtime: Arc<Runtime>, logger: L, config: Arc<Config>,
-		probe_locked_msat: Option<Arc<AtomicU64>>,
+		runtime: Arc<Runtime>, logger: L, config: Arc<Config>, prober: Option<Arc<Prober>>,
 	) -> Self {
 		Self {
 			event_queue,
@@ -553,7 +552,7 @@ where
 			static_invoice_store,
 			onion_messenger,
 			om_mailbox,
-			probe_locked_msat,
+			prober,
 		}
 	}
 
@@ -1140,19 +1139,13 @@ where
 			LdkEvent::PaymentPathSuccessful { .. } => {},
 			LdkEvent::PaymentPathFailed { .. } => {},
 			LdkEvent::ProbeSuccessful { path, .. } => {
-				if let Some(counter) = &self.probe_locked_msat {
-					let amount: u64 = path.hops.iter().map(|h| h.fee_msat).sum();
-					let _ = counter.fetch_update(Ordering::AcqRel, Ordering::Acquire, |v| {
-						Some(v.saturating_sub(amount))
-					});
+				if let Some(prober) = &self.prober {
+					prober.handle_probe_successful(&path);
 				}
 			},
 			LdkEvent::ProbeFailed { path, .. } => {
-				if let Some(counter) = &self.probe_locked_msat {
-					let amount: u64 = path.hops.iter().map(|h| h.fee_msat).sum();
-					let _ = counter.fetch_update(Ordering::AcqRel, Ordering::Acquire, |v| {
-						Some(v.saturating_sub(amount))
-					});
+				if let Some(prober) = &self.prober {
+					prober.handle_probe_failed(&path);
 				}
 			},
 			LdkEvent::HTLCHandlingFailed { failure_type, .. } => {