probing: change uniffi docs to be as ordinary

Uniffi documentation is equal to the documentation for "ordinary" code.

Also we add a `scorer` reference to `HighDegreeStrategy`, so it doesn't
apply global fee penalties and probing node can make a payments which
would take "best" routes.

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

@@ -78,7 +78,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;
@@ -1821,10 +1822,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),
@@ -2202,10 +2200,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,42 +266,35 @@ 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.
@@ -759,9 +752,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();

tests/probing_tests.rs

@@ -6,6 +6,10 @@
 //      Verifies locked_msat rises when a probe is dispatched and returns
 //      to zero once the probe resolves.
 //
+//   locked_msat_accounts_for_routing_fees
+//      Asserts the exact locked_msat (delivered amount + per-hop fee) for a single
+//      in-flight probe, proving fees are tracked and not just the delivered amount.
+//
 //   exhausted_probe_budget_blocks_new_probes
 //      Samples locked_msat across multiple probe cycles and asserts it never
 //      exceeds the configured max_locked_msat budget cap.
@@ -200,6 +204,93 @@ async fn probe_budget_increments_and_decrements() {
 	node_c.stop().unwrap();
 }
 
+/// Verifies that `locked_msat` accounts for routing fees, not just the delivered amount:
+/// a probe along A→B→C locks `delivered amount + per-hop fee` on the first-hop channel.
+///
+/// The budget is sized to exactly one probe's worth, so at most one probe is in flight and
+/// the observed `locked_msat` is deterministic. The existing budget test only checks that it
+/// is non-zero; this asserts the precise value, which a fees-excluded accounting would miss.
+#[tokio::test(flavor = "multi_thread")]
+async fn locked_msat_accounts_for_routing_fees() {
+	// First hop carries the delivered amount plus this per-hop fee (see `build_probe_path`).
+	const FIRST_HOP_FEE_MSAT: u64 = 1000;
+	const LOCKED_PER_PROBE_MSAT: u64 = PROBE_AMOUNT_MSAT + FIRST_HOP_FEE_MSAT;
+
+	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
+	let chain_source = random_chain_source(&bitcoind, &electrsd);
+
+	let node_b = setup_node(&chain_source, random_config(false));
+	let node_c = setup_node(&chain_source, random_config(false));
+
+	let mut config_a = random_config(false);
+	let strategy = FixedPathStrategy::new();
+	config_a.probing = Some(
+		ProbingConfigBuilder::custom(strategy.clone())
+			.interval(Duration::from_millis(PROBING_INTERVAL_MILLISECONDS))
+			// Budget for exactly one in-flight probe so locked_msat is deterministic.
+			.max_locked_msat(LOCKED_PER_PROBE_MSAT)
+			.build(),
+	);
+	let node_a = setup_node(&chain_source, config_a);
+
+	let addr_a = node_a.onchain_payment().new_address().unwrap();
+	let addr_b = node_b.onchain_payment().new_address().unwrap();
+	premine_and_distribute_funds(
+		&bitcoind.client,
+		&electrsd.client,
+		vec![addr_a, addr_b],
+		Amount::from_sat(2_000_000),
+	)
+	.await;
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+
+	open_channel(&node_a, &node_b, 1_000_000, true, &electrsd).await;
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 1).await;
+	node_b.sync_wallets().unwrap();
+	open_channel(&node_b, &node_c, 1_000_000, true, &electrsd).await;
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6).await;
+
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+	node_c.sync_wallets().unwrap();
+
+	expect_channel_ready_event!(node_a, node_b.node_id());
+	expect_event!(node_b, ChannelReady);
+	expect_event!(node_b, ChannelReady);
+	expect_event!(node_c, ChannelReady);
+
+	strategy.set_path(build_probe_path(&node_a, &node_b, &node_c, PROBE_AMOUNT_MSAT));
+	wait_for_channel_ready_to_send(&node_a, &node_b, LOCKED_PER_PROBE_MSAT).await;
+	wait_for_channel_ready_to_send(&node_b, &node_c, PROBE_AMOUNT_MSAT).await;
+	strategy.start_probing();
+
+	// Capture locked_msat the moment the first probe goes in flight. With a single-probe
+	// budget the value is only ever 0 or exactly one probe's worth, so the first non-zero
+	// reading is the full first-hop HTLC.
+	let locked = tokio::time::timeout(Duration::from_secs(30), async {
+		loop {
+			let locked = node_a.prober().unwrap().locked_msat();
+			if locked > 0 {
+				break locked;
+			}
+			tokio::time::sleep(Duration::from_millis(100)).await;
+		}
+	})
+	.await
+	.expect("locked_msat never increased — no probe was dispatched");
+
+	assert_eq!(
+		locked, LOCKED_PER_PROBE_MSAT,
+		"locked_msat must equal the delivered amount plus routing fees, not just the delivered amount"
+	);
+
+	strategy.stop_probing();
+	node_a.stop().unwrap();
+	node_b.stop().unwrap();
+	node_c.stop().unwrap();
+}
+
 /// Verifies that `locked_msat` is restored after the node is stopped and restarted
 /// while a probe is still in flight.
 ///