Add probing service tests

Add integration tests that verify the probing service fires probes on
the configured interval and respects the locked-msat budget cap.
Shared helpers in tests/common are extended with probing-aware setup.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: randomlogin

bindings/ldk_node.udl

@@ -15,8 +15,6 @@ typedef interface NodeEntropy;
 
 typedef interface ProbingConfig;
 
-typedef interface ProbingConfigBuilder;
-
 typedef enum WordCount;
 
 [Remote]
@@ -36,6 +34,18 @@ interface LogWriter {
 	void log(LogRecord record);
 };
 
+interface ProbingConfigBuilder {
+	[Name=high_degree]
+	constructor(u64 top_node_count);
+	[Name=random_walk]
+	constructor(u64 max_hops);
+	void set_interval(u64 secs);
+	void set_max_locked_msat(u64 max_msat);
+	void set_diversity_penalty_msat(u64 penalty_msat);
+	void set_cooldown(u64 secs);
+	ProbingConfig build();
+};
+
 interface Builder {
 	constructor();
 	[Name=from_config]

src/builder.rs

@@ -76,7 +76,8 @@ use crate::message_handler::NodeCustomMessageHandler;
 use crate::payment::asynchronous::om_mailbox::OnionMessageMailbox;
 use crate::peer_store::PeerStore;
 use crate::probing::{
-	HighDegreeStrategy, Prober, ProbingConfig, ProbingStrategy, ProbingStrategyKind, RandomWalkStrategy,
+	HighDegreeStrategy, Prober, ProbingConfig, ProbingStrategy, ProbingStrategyKind,
+	RandomWalkStrategy,
 };
 use crate::runtime::{Runtime, RuntimeSpawner};
 use crate::tx_broadcaster::TransactionBroadcaster;
@@ -1188,7 +1189,7 @@ impl ArcedNodeBuilder {
 	///
 	/// [`ProbingConfigBuilder`]: crate::probing::ProbingConfigBuilder
 	pub fn set_probing_config(&self, config: Arc<ProbingConfig>) {
-		self.inner.write().unwrap().set_probing_config((*config).clone());
+		self.inner.write().expect("lock").set_probing_config((*config).clone());
 	}
 
 	/// Builds a [`Node`] instance with a [`SqliteStore`] backend and according to the options
@@ -1805,10 +1806,7 @@ fn build_with_store_internal(
 		},
 	}
 
-	let mut scoring_fee_params = ProbabilisticScoringFeeParameters::default();
-	if let Some(penalty) = probing_config.and_then(|c| c.diversity_penalty_msat) {
-		scoring_fee_params.probing_diversity_penalty_msat = penalty;
-	}
+	let scoring_fee_params = ProbabilisticScoringFeeParameters::default();
 	let router = Arc::new(DefaultRouter::new(
 		Arc::clone(&network_graph),
 		Arc::clone(&logger),
@@ -2172,10 +2170,23 @@ fn build_with_store_internal(
 	let prober = probing_config.map(|probing_cfg| {
 		let strategy: Arc<dyn ProbingStrategy> = match &probing_cfg.kind {
 			ProbingStrategyKind::HighDegree { top_node_count } => {
+				// Dedicated router for probing so the diversity penalty doesn't interfere
+				// with real payments; shares the scorer so probe results still train it.
+				let mut probing_fee_params = ProbabilisticScoringFeeParameters::default();
+				if let Some(penalty) = probing_cfg.diversity_penalty_msat {
+					probing_fee_params.probing_diversity_penalty_msat = penalty;
+				}
+				let probing_router = Arc::new(DefaultRouter::new(
+					Arc::clone(&network_graph),
+					Arc::clone(&logger),
+					Arc::clone(&keys_manager),
+					Arc::clone(&scorer),
+					probing_fee_params,
+				));
 				Arc::new(HighDegreeStrategy::new(
 					Arc::clone(&network_graph),
 					Arc::clone(&channel_manager),
-					Arc::clone(&router),
+					probing_router,
 					*top_node_count,
 					DEFAULT_MIN_PROBE_AMOUNT_MSAT,
 					DEFAULT_MAX_PROBE_AMOUNT_MSAT,

src/lib.rs

@@ -174,6 +174,8 @@ use payment::{
 	UnifiedPayment,
 };
 use peer_store::{PeerInfo, PeerStore};
+#[cfg(feature = "uniffi")]
+pub use probing::ArcedProbingConfigBuilder as ProbingConfigBuilder;
 use probing::{run_prober, Prober};
 use runtime::Runtime;
 pub use tokio;

src/probing.rs

@@ -266,56 +266,49 @@ impl ProbingConfigBuilder {
 	}
 }
 
-/// A UniFFI-compatible wrapper around [`ProbingConfigBuilder`] that uses interior mutability
-/// so it can be shared behind an `Arc` as required by the FFI object model.
+/// Builder for [`ProbingConfig`].
 ///
-/// Instances are produced by the constructors [`new_high_degree`] and [`new_random_walk`].
-/// The `set_*` methods override the defaults, and [`build`] yields the resulting
-/// [`ProbingConfig`].
+/// A new instance starts from one of two strategy constructors — [`high_degree`] or
+/// [`random_walk`] — and is finalized through [`build`]. Optional setters in between
+/// override the timing and liquidity defaults.
 ///
-/// [`new_high_degree`]: Self::new_high_degree
-/// [`new_random_walk`]: Self::new_random_walk
+/// [`high_degree`]: Self::high_degree
+/// [`random_walk`]: Self::random_walk
 /// [`build`]: Self::build
 #[cfg(feature = "uniffi")]
-#[derive(uniffi::Object)]
 pub struct ArcedProbingConfigBuilder {
 	inner: RwLock<ProbingConfigBuilder>,
 }
 
 #[cfg(feature = "uniffi")]
-#[uniffi::export]
 impl ArcedProbingConfigBuilder {
 	/// Start building a config that probes toward the highest-degree nodes in the graph.
 	///
 	/// `top_node_count` controls how many of the most-connected nodes are cycled through.
-	#[uniffi::constructor]
-	pub fn new_high_degree(top_node_count: u64) -> Arc<Self> {
-		Arc::new(Self {
-			inner: RwLock::new(ProbingConfigBuilder::high_degree(top_node_count as usize)),
-		})
+	pub fn high_degree(top_node_count: u64) -> Self {
+		Self { inner: RwLock::new(ProbingConfigBuilder::high_degree(top_node_count as usize)) }
 	}
 
 	/// Start building a config that probes via random graph walks.
 	///
 	/// `max_hops` is the upper bound on the number of hops in a randomly constructed path.
 	/// Values below `2` are clamped to `2`.
-	#[uniffi::constructor]
-	pub fn new_random_walk(max_hops: u64) -> Arc<Self> {
-		Arc::new(Self { inner: RwLock::new(ProbingConfigBuilder::random_walk(max_hops as usize)) })
+	pub fn random_walk(max_hops: u64) -> Self {
+		Self { inner: RwLock::new(ProbingConfigBuilder::random_walk(max_hops as usize)) }
 	}
 
 	/// Overrides the interval between probe attempts.
 	///
 	/// Defaults to 10 seconds.
 	pub fn set_interval(&self, secs: u64) {
-		self.inner.write().unwrap().interval(Duration::from_secs(secs));
+		self.inner.write().expect("lock").interval(Duration::from_secs(secs));
 	}
 
 	/// Overrides the maximum millisatoshis that may be locked in in-flight probes at any time.
 	///
 	/// Defaults to 100 000 000 msat (100k sats).
 	pub fn set_max_locked_msat(&self, max_msat: u64) {
-		self.inner.write().unwrap().max_locked_msat(max_msat);
+		self.inner.write().expect("lock").max_locked_msat(max_msat);
 	}
 
 	/// Sets the probing diversity penalty applied by the probabilistic scorer.
@@ -330,19 +323,19 @@ impl ArcedProbingConfigBuilder {
 	///
 	/// If unset, LDK's default of `0` (no penalty) is used.
 	pub fn set_diversity_penalty_msat(&self, penalty_msat: u64) {
-		self.inner.write().unwrap().diversity_penalty_msat(penalty_msat);
+		self.inner.write().expect("lock").diversity_penalty_msat(penalty_msat);
 	}
 
 	/// Sets how long a probed node stays ineligible before being probed again.
 	///
 	/// Only applies to [`HighDegreeStrategy`]. Defaults to 1 hour.
 	pub fn set_cooldown(&self, secs: u64) {
-		self.inner.write().unwrap().cooldown(Duration::from_secs(secs));
+		self.inner.write().expect("lock").cooldown(Duration::from_secs(secs));
 	}
 
 	/// Builds the [`ProbingConfig`].
 	pub fn build(&self) -> Arc<ProbingConfig> {
-		Arc::new(self.inner.read().unwrap().build())
+		Arc::new(self.inner.read().expect("lock").build())
 	}
 }
 
@@ -382,7 +375,7 @@ pub struct HighDegreeStrategy {
 	/// `path_value * liquidity_limit_multiplier`.
 	pub liquidity_limit_multiplier: u64,
 	/// Nodes probed recently, with the time they were last probed.
-	recently_probed: Mutex<HashMap<PublicKey, Instant>>,
+	recently_probed: Mutex<HashMap<NodeId, Instant>>,
 }
 
 impl HighDegreeStrategy {
@@ -414,13 +407,8 @@ impl ProbingStrategy for HighDegreeStrategy {
 	fn next_probe(&self) -> Option<Path> {
 		let graph = self.network_graph.read_only();
 
-		let mut nodes_by_degree: Vec<(PublicKey, usize)> = graph
-			.nodes()
-			.unordered_iter()
-			.filter_map(|(id, info)| {
-				PublicKey::try_from(*id).ok().map(|pubkey| (pubkey, info.channels.len()))
-			})
-			.collect();
+		let mut nodes_by_degree: Vec<(NodeId, usize)> =
+			graph.nodes().unordered_iter().map(|(id, info)| (*id, info.channels.len())).collect();
 
 		if nodes_by_degree.is_empty() {
 			return None;
@@ -438,21 +426,23 @@ impl ProbingStrategy for HighDegreeStrategy {
 		probed.retain(|_, probed_at| now.duration_since(*probed_at) < self.cooldown);
 
 		// If all top nodes are on cooldown, reset and start a new cycle.
-		let final_node = match nodes_by_degree[..top_node_count]
+		let final_node_id = match nodes_by_degree[..top_node_count]
 			.iter()
-			.find(|(pubkey, _)| !probed.contains_key(pubkey))
+			.find(|(node_id, _)| !probed.contains_key(node_id))
 		{
-			Some((pubkey, _)) => *pubkey,
+			Some((node_id, _)) => *node_id,
 			None => {
 				probed.clear();
 				nodes_by_degree[0].0
 			},
 		};
 
-		probed.insert(final_node, now);
+		probed.insert(final_node_id, now);
 		drop(probed);
 		drop(graph);
 
+		let final_node = PublicKey::try_from(final_node_id).ok()?;
+
 		let amount_msat = random_range(self.min_amount_msat, self.max_amount_msat);
 		let payment_params =
 			PaymentParameters::from_node_id(final_node, DEFAULT_MIN_FINAL_CLTV_EXPIRY_DELTA as u32);
@@ -471,6 +461,10 @@ impl ProbingStrategy for HighDegreeStrategy {
 
 		let path = route.paths.into_iter().next()?;
 
+		if path.hops.len() < 2 && path.blinded_tail.is_none() {
+			return None;
+		}
+
 		// Liquidity-limit check (mirrors send_preflight_probes): skip the path when the
 		// first-hop outbound liquidity is less than path_value * liquidity_limit_multiplier.
 		if let Some(first_hop_hop) = path.hops.first() {
@@ -711,6 +705,10 @@ impl RandomWalkStrategy {
 
 		hops.reverse();
 
+		if hops.len() < 2 {
+			return None;
+		}
+
 		// The first-hop HTLC carries amount_msat + all intermediate fees.
 		// Verify the total fits within our live outbound limit before returning.
 		let total_outgoing: u64 = hops.iter().map(|h| h.fee_msat).sum();
@@ -759,9 +757,12 @@ impl Prober {
 			.list_recent_payments()
 			.into_iter()
 			.filter_map(|p| match p {
-				RecentPaymentDetails::Pending { is_probe: true, total_msat, .. } => {
-					Some(total_msat)
-				},
+				RecentPaymentDetails::Pending {
+					is_probe: true,
+					total_msat,
+					pending_fee_msat,
+					..
+				} => Some(total_msat + pending_fee_msat.unwrap_or(0)),
 				_ => None,
 			})
 			.sum();