Fix probing budget accounting and remove Probe::Destination

The locked_msat budget tracking was broken for Destination probes:
send_spontaneous_preflight_probes only returns (PaymentHash, PaymentId)
without exposing the actual paths or per-hop amounts. This meant we
locked amount_msat at send time but released amount+fees per path in
ProbeSuccessful/ProbeFailed events, causing a systematic mismatch.

Fix by removing Probe::Destination entirely. Strategies now return a
fully constructed Path, and run_prober always uses send_probe(path),
locking and releasing the same path.hops.sum(fee_msat) on both sides.

HighDegreeStrategy now calls Router::find_route directly and applies the
liquidity-limit check itself, mirroring send_preflight_probes.

Other fixes in this commit:
- Fix RandomStrategy fee calculation: compute proportional fees on the
forwarded amount (delivery + downstream fees), not just delivery
- Fix HighDegreeStrategy doc
- Fix random_range overflow when max - min == u64::MAX
- Add doc warning about scorer_channel_liquidity being O(scorer size)
- Make probing module public, import objects directly in builder.rs
- Reorder EventHandler fields (prober after om_mailbox)

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

Author: randomlogin

src/builder.rs

@@ -75,7 +75,9 @@ use crate::logger::{log_error, LdkLogger, LogLevel, LogWriter, Logger};
 use crate::message_handler::NodeCustomMessageHandler;
 use crate::payment::asynchronous::om_mailbox::OnionMessageMailbox;
 use crate::peer_store::PeerStore;
-use crate::probing;
+use crate::probing::{
+	HighDegreeStrategy, Prober, ProbingConfig, ProbingStrategy, ProbingStrategyKind, RandomStrategy,
+};
 use crate::runtime::{Runtime, RuntimeSpawner};
 use crate::tx_broadcaster::TransactionBroadcaster;
 use crate::types::{
@@ -284,7 +286,7 @@ pub struct NodeBuilder {
 	runtime_handle: Option<tokio::runtime::Handle>,
 	pathfinding_scores_sync_config: Option<PathfindingScoresSyncConfig>,
 	recovery_mode: bool,
-	probing_config: Option<probing::ProbingConfig>,
+	probing_config: Option<ProbingConfig>,
 }
 
 impl NodeBuilder {
@@ -623,7 +625,7 @@ impl NodeBuilder {
 
 	/// Configures background probing.
 	///
-	/// Use [`probing::ProbingConfig`] to build the configuration:
+	/// Use [`ProbingConfig`] to build the configuration:
 	/// ```ignore
 	/// use ldk_node::probing::ProbingConfig;
 	///
@@ -633,7 +635,7 @@ impl NodeBuilder {
 	///         .build()
 	/// );
 	/// ```
-	pub fn set_probing_config(&mut self, config: probing::ProbingConfig) -> &mut Self {
+	pub fn set_probing_config(&mut self, config: ProbingConfig) -> &mut Self {
 		self.probing_config = Some(config);
 		self
 	}
@@ -1108,8 +1110,8 @@ impl ArcedNodeBuilder {
 
 	/// Configures background probing.
 	///
-	/// See [`probing::ProbingConfig`] for details.
-	pub fn set_probing_config(&self, config: probing::ProbingConfig) {
+	/// See [`ProbingConfig`] for details.
+	pub fn set_probing_config(&self, config: ProbingConfig) {
 		self.inner.write().unwrap().set_probing_config(config);
 	}
 
@@ -1256,9 +1258,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<&ProbingConfig>, async_payments_role: Option<AsyncPaymentsRole>,
+	recovery_mode: bool, seed_bytes: [u8; 64], runtime: Arc<Runtime>, logger: Arc<Logger>,
+	kv_store: Arc<DynStore>,
 ) -> Result<Node, BuildError> {
 	optionally_install_rustls_cryptoprovider();
 
@@ -2002,33 +2004,33 @@ fn build_with_store_internal(
 	}
 
 	let prober = probing_config.map(|probing_cfg| {
-		let strategy: Arc<dyn probing::ProbingStrategy> = match &probing_cfg.kind {
-			probing::ProbingStrategyKind::HighDegree { top_node_count } => {
-				Arc::new(probing::HighDegreeStrategy::new(
+		let strategy: Arc<dyn ProbingStrategy> = match &probing_cfg.kind {
+			ProbingStrategyKind::HighDegree { top_node_count } => {
+				Arc::new(HighDegreeStrategy::new(
 					Arc::clone(&network_graph),
+					Arc::clone(&channel_manager),
+					Arc::clone(&router),
 					*top_node_count,
 					MIN_PROBE_AMOUNT_MSAT,
 					DEFAULT_MAX_PROBE_AMOUNT_MSAT,
 					probing_cfg.cooldown,
+					config.probing_liquidity_limit_multiplier,
 				))
 			},
-			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,
-				))
-			},
-			probing::ProbingStrategyKind::Custom(s) => Arc::clone(s),
+			ProbingStrategyKind::Random { max_hops } => Arc::new(RandomStrategy::new(
+				Arc::clone(&network_graph),
+				Arc::clone(&channel_manager),
+				*max_hops,
+				MIN_PROBE_AMOUNT_MSAT,
+				DEFAULT_MAX_PROBE_AMOUNT_MSAT,
+			)),
+			ProbingStrategyKind::Custom(s) => Arc::clone(s),
 		};
-		Arc::new(probing::Prober {
+		Arc::new(Prober {
 			channel_manager: Arc::clone(&channel_manager),
 			logger: Arc::clone(&logger),
 			strategy,
 			interval: probing_cfg.interval,
-			liquidity_limit_multiplier: Some(config.probing_liquidity_limit_multiplier),
 			max_locked_msat: probing_cfg.max_locked_msat,
 			locked_msat: Arc::new(AtomicU64::new(0)),
 		})

src/event.rs

@@ -510,13 +510,13 @@ where
 	payment_store: Arc<PaymentStore>,
 	peer_store: Arc<PeerStore<L>>,
 	keys_manager: Arc<KeysManager>,
-	runtime: Arc<Runtime>,
-	logger: L,
-	config: Arc<Config>,
 	static_invoice_store: Option<StaticInvoiceStore>,
 	onion_messenger: Arc<OnionMessenger>,
 	om_mailbox: Option<Arc<OnionMessageMailbox>>,
 	prober: Option<Arc<Prober>>,
+	runtime: Arc<Runtime>,
+	logger: L,
+	config: Arc<Config>,
 }
 
 impl<L: Deref + Clone + Sync + Send + 'static> EventHandler<L>
@@ -532,7 +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>, prober: Option<Arc<Prober>>,
+		prober: Option<Arc<Prober>>, runtime: Arc<Runtime>, logger: L, config: Arc<Config>,
 	) -> Self {
 		Self {
 			event_queue,
@@ -546,13 +546,13 @@ where
 			payment_store,
 			peer_store,
 			keys_manager,
-			logger,
-			runtime,
-			config,
 			static_invoice_store,
 			onion_messenger,
 			om_mailbox,
 			prober,
+			runtime,
+			logger,
+			config,
 		}
 	}
 

src/lib.rs

@@ -101,7 +101,7 @@ pub mod logger;
 mod message_handler;
 pub mod payment;
 mod peer_store;
-mod probing;
+pub mod probing;
 mod runtime;
 mod scoring;
 mod tx_broadcaster;
@@ -172,10 +172,7 @@ use payment::{
 	UnifiedPayment,
 };
 use peer_store::{PeerInfo, PeerStore};
-pub use probing::{
-	HighDegreeStrategy, Probe, Prober, ProbingConfig, ProbingConfigBuilder, ProbingStrategy,
-	RandomStrategy,
-};
+use probing::{run_prober, Prober};
 use runtime::Runtime;
 pub use tokio;
 use types::{
@@ -245,7 +242,7 @@ pub struct Node {
 	om_mailbox: Option<Arc<OnionMessageMailbox>>,
 	async_payments_role: Option<AsyncPaymentsRole>,
 	hrn_resolver: Arc<HRNResolver>,
-	prober: Option<Arc<probing::Prober>>,
+	prober: Option<Arc<Prober>>,
 	#[cfg(cycle_tests)]
 	_leak_checker: LeakChecker,
 }
@@ -597,16 +594,16 @@ impl Node {
 			static_invoice_store,
 			Arc::clone(&self.onion_messenger),
 			self.om_mailbox.clone(),
+			self.prober.clone(),
 			Arc::clone(&self.runtime),
 			Arc::clone(&self.logger),
 			Arc::clone(&self.config),
-			self.prober.clone(),
 		));
 
 		if let Some(prober) = self.prober.clone() {
 			let stop_rx = self.stop_sender.subscribe();
 			self.runtime.spawn_cancellable_background_task(async move {
-				probing::run_prober(prober, stop_rx).await;
+				run_prober(prober, stop_rx).await;
 			});
 		}
 
@@ -1090,8 +1087,9 @@ impl Node {
 	/// Returns the scorer's estimated `(min, max)` liquidity range for the given channel in the
 	/// direction toward `target`, or `None` if the scorer has no data for that channel.
 	///
-	/// Works by serializing the `CombinedScorer` (which writes `local_only_scorer`) and
-	/// deserializing it as a plain `ProbabilisticScorer` to call `estimated_channel_liquidity_range`.
+	/// **Warning:** This is expensive — O(scorer size) per call. It works by serializing the
+	/// entire `CombinedScorer` and deserializing it as a plain `ProbabilisticScorer` to access
+	/// `estimated_channel_liquidity_range`. Intended for testing and debugging, not hot paths.
 	pub fn scorer_channel_liquidity(&self, scid: u64, target: PublicKey) -> Option<(u64, u64)> {
 		use lightning::routing::scoring::{
 			ProbabilisticScorer, ProbabilisticScoringDecayParameters,