Add probing tests

There are 3 probing tests:
- check that probing lock liquidity amount changes
- test that new probes are not fired if the max locked liquidity is
  reached (for example if on of the nodes goes down)
- probing perfomance test which sets up 4 probing nodes (random
  strategy, high-degree without penalty, high-degree with penalty,
  control node without probing). A network of several nodes is set up;
  these nodes make payments to one another and probing nodes observe
  their behaviour. Next the scorer estimates are printed out.

Scorer channel estimates are exposed for the purposes of the test.

Scoring parameters (probing penalty) is exposed to be set up during node
builiding.

Random probing strategy constructs the maximal possible route (up to the
set limit) instead of failing when the next hop is not possible to
construct.

Author: randomlogin

src/builder.rs

@@ -30,7 +30,6 @@ use lightning::routing::gossip::NodeAlias;
 use lightning::routing::router::DefaultRouter;
 use lightning::routing::scoring::{
 	CombinedScorer, ProbabilisticScorer, ProbabilisticScoringDecayParameters,
-	ProbabilisticScoringFeeParameters,
 };
 use lightning::sign::{EntropySource, NodeSigner};
 use lightning::util::config::HTLCInterceptionFlags;
@@ -1551,7 +1550,7 @@ fn build_with_store_internal(
 		},
 	}
 
-	let scoring_fee_params = ProbabilisticScoringFeeParameters::default();
+	let scoring_fee_params = config.scoring_fee_params.clone();
 	let router = Arc::new(DefaultRouter::new(
 		Arc::clone(&network_graph),
 		Arc::clone(&logger),

src/config.rs

@@ -15,6 +15,7 @@ use bitcoin::Network;
 use lightning::ln::msgs::SocketAddress;
 use lightning::routing::gossip::NodeAlias;
 use lightning::routing::router::RouteParametersConfig;
+use lightning::routing::scoring::ProbabilisticScoringFeeParameters;
 use lightning::util::config::{
 	ChannelConfig as LdkChannelConfig, MaxDustHTLCExposure as LdkMaxDustHTLCExposure, UserConfig,
 };
@@ -131,9 +132,11 @@ pub(crate) const HRN_RESOLUTION_TIMEOUT_SECS: u64 = 5;
 /// | `log_level`                            | Debug              |
 /// | `anchor_channels_config`               | Some(..)           |
 /// | `route_parameters`                   | None               |
+/// | `scoring_fee_params`                   | See [`ProbabilisticScoringFeeParameters`] |
 ///
-/// See [`AnchorChannelsConfig`] and [`RouteParametersConfig`] for more information regarding their
-/// respective default values.
+/// See [`AnchorChannelsConfig`], [`RouteParametersConfig`], and
+/// [`ProbabilisticScoringFeeParameters`] for more information regarding their respective default
+/// values.
 ///
 /// [`Node`]: crate::Node
 pub struct Config {
@@ -195,6 +198,12 @@ pub struct Config {
 	/// **Note:** If unset, default parameters will be used, and you will be able to override the
 	/// parameters on a per-payment basis in the corresponding method calls.
 	pub route_parameters: Option<RouteParametersConfig>,
+	/// Parameters for the probabilistic scorer used when computing payment routes.
+	///
+	/// These correspond to [`ProbabilisticScoringFeeParameters`] in LDK. If unset, LDK defaults
+	/// are used. Notably, [`ProbabilisticScoringFeeParameters::probing_diversity_penalty_msat`]
+	/// should be set to a non-zero value for some of the probing strategies.
+	pub scoring_fee_params: ProbabilisticScoringFeeParameters,
 }
 
 impl Default for Config {
@@ -209,6 +218,7 @@ impl Default for Config {
 			anchor_channels_config: Some(AnchorChannelsConfig::default()),
 			route_parameters: None,
 			node_alias: None,
+			scoring_fee_params: ProbabilisticScoringFeeParameters::default(),
 		}
 	}
 }

src/lib.rs

@@ -1050,9 +1050,35 @@ impl Node {
 		self.prober.as_ref().map(|p| p.locked_msat.load(std::sync::atomic::Ordering::Relaxed))
 	}
 
-    /// Gives access to the scorer; needed to valuate the probing tests.
-    #[cfg(test)]
-    pub fn scorer(&self) -> &Arc<Mutex<Scorer>> { &self.scorer }
+	/// 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`.
+	pub fn scorer_channel_liquidity(
+		&self, scid: u64, target: PublicKey,
+	) -> Option<(u64, u64)> {
+		use lightning::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringDecayParameters};
+		use lightning::util::ser::{ReadableArgs, Writeable};
+
+		let target_node_id = lightning::routing::gossip::NodeId::from_pubkey(&target);
+
+		let bytes = {
+			let scorer = self.scorer.lock().unwrap();
+			let mut buf = Vec::new();
+			scorer.write(&mut buf).ok()?;
+			buf
+		};
+
+		let decay_params = ProbabilisticScoringDecayParameters::default();
+		let prob_scorer = ProbabilisticScorer::read(
+			&mut &bytes[..],
+			(decay_params, Arc::clone(&self.network_graph), Arc::clone(&self.logger)),
+		)
+		.ok()?;
+
+		prob_scorer.estimated_channel_liquidity_range(scid, &target_node_id)
+	}
 
 
 	/// Retrieve a list of known channels.

src/probing.rs

@@ -63,7 +63,6 @@ impl ProbingStrategy for HighDegreeStrategy {
         let graph = self.network_graph.read_only();
 
         // Collect (pubkey, channel_count) for all nodes.
-        // wtf it does why we need to iterate here and then sort? maybe we can go just once?
         let mut nodes_by_degree: Vec<(PublicKey, usize)> = graph
             .nodes()
             .unordered_iter()
@@ -76,8 +75,6 @@ impl ProbingStrategy for HighDegreeStrategy {
             return None;
         }
 
-        // Most-connected first.
-        // wtf it does
         nodes_by_degree.sort_unstable_by(|a, b| b.1.cmp(&a.1));
 
         let top_n = self.top_n.min(nodes_by_degree.len());
@@ -137,37 +134,30 @@ impl RandomStrategy {
     /// Tries to build a path for the given cursor value and hop count. Returns `None` if the
     /// local node has no usable channels, or the walk terminates before reaching `target_hops`.
     fn try_build_path(&self, cursor: usize, target_hops: usize, amount_msat: u64) -> Option<Path> {
-        // Collect confirmed, usable channels: (scid, peer_pubkey).
-        let our_channels: Vec<(u64, PublicKey)> = self
-            .channel_manager
-            .list_channels()
-            .into_iter()
-            .filter_map(|c| {
-                if c.is_usable {
-                    c.short_channel_id.map(|scid| (scid, c.counterparty.node_id))
-                } else {
-                    None
-                }
-            })
-            .collect();
+        let initial_channels =
+            self.channel_manager.list_channels().into_iter().filter(|c|
+                c.is_usable && c.short_channel_id.is_some()).collect::<Vec<_>>();
 
-        if our_channels.is_empty() {
+        if initial_channels.is_empty() {
             return None;
         }
 
         let graph = self.network_graph.read_only();
-        let (our_scid, peer_pubkey) = our_channels[cursor % our_channels.len()];
-        let peer_node_id = NodeId::from_pubkey(&peer_pubkey);
+        let first_hop = &initial_channels[cursor % initial_channels.len()];
+        let first_hop_scid = first_hop.short_channel_id.unwrap();
+        let next_peer_pubkey = first_hop.counterparty.node_id;
+        let next_peer_node_id = NodeId::from_pubkey(&next_peer_pubkey);
 
-        // Walk the graph: each entry is (node_id, arrived_via_scid, pubkey).
-        // We start by having "arrived at peer via our_scid".
-        let mut visited: Vec<(NodeId, u64, PublicKey)> =
-            vec![(peer_node_id, our_scid, peer_pubkey)];
+        // Track the tightest HTLC limit across all hops to cap the probe amount.
+        // The first hop limit comes from our live channel state; subsequent hops use htlc_maximum_msat from the gossip channel update.
+        let mut route_least_htlc_upper_bound = first_hop.next_outbound_htlc_limit_msat;
 
-        let mut prev_scid = our_scid;
-        let mut current_node_id = peer_node_id;
+        // Walk the graph: each entry is (node_id, arrived_via_scid, pubkey); first entry is set:
+        let mut route: Vec<(NodeId, u64, PublicKey)> = vec![(next_peer_node_id, first_hop_scid, next_peer_pubkey)];
+
+        let mut prev_scid = first_hop_scid;
+        let mut current_node_id = next_peer_node_id;
 
-        //wtf the real amount of hops is -1 of target?
         for hop_idx in 1..target_hops {
             let node_info = match graph.node(&current_node_id) {
                 Some(n) => n,
@@ -187,46 +177,48 @@ impl RandomStrategy {
                 None => break,
             };
 
-            // Determine direction and fetch the channel-update.
-            let (update, next_node_id) = if next_channel.node_one == current_node_id {
-                match next_channel.one_to_two.as_ref() {
-                    Some(u) => (u, next_channel.node_two),
-                    None => break,
-                }
-            } else if next_channel.node_two == current_node_id {
-                match next_channel.two_to_one.as_ref() {
-                    Some(u) => (u, next_channel.node_one),
-                    None => break,
-                }
-            } else {
+            // as_directed_from validates that current_node_id is a channel endpoint and that
+            // both direction updates are present; effective_capacity covers both htlc_maximum_msat
+            // and funding capacity.
+            let Some((directed, next_node_id)) = next_channel.as_directed_from(&current_node_id)
+            else {
                 break;
             };
+            // Retrieve the direction-specific update via the public ChannelInfo fields.
+            // Safe to unwrap: as_directed_from already checked both directions are Some.
+            let update = if directed.source() == &next_channel.node_one {
+                next_channel.one_to_two.as_ref().unwrap()
+            } else {
+                next_channel.two_to_one.as_ref().unwrap()
+            };
 
             if !update.enabled {
                 break;
             }
 
-            let next_pubkey = match PublicKey::try_from(next_node_id) {
+            route_least_htlc_upper_bound = route_least_htlc_upper_bound.min(update.htlc_maximum_msat);
+
+            let next_pubkey = match PublicKey::try_from(*next_node_id) {
                 Ok(pk) => pk,
                 Err(_) => break,
             };
 
-            visited.push((next_node_id, next_scid, next_pubkey));
+            route.push((*next_node_id, next_scid, next_pubkey));
             prev_scid = next_scid;
-            current_node_id = next_node_id;
+            current_node_id = *next_node_id;
         }
 
-        // Require the full requested depth; shorter walks are uninformative.
-        if visited.len() < target_hops {
+        let amount_msat = amount_msat.min(route_least_htlc_upper_bound); //cap probe amount
+        if amount_msat < self.min_amount_msat {
             return None;
         }
 
         // Assemble hops.
-        // For hop i: fee and CLTV are determined by the *next* channel (what visited[i]
+        // For hop i: fee and CLTV are determined by the *next* channel (what route[i]
         // will charge to forward onward).  For the last hop they are amount_msat and zero expiry delta.
-        let mut hops = Vec::with_capacity(visited.len());
-        for i in 0..visited.len() {
-            let (node_id, via_scid, pubkey) = visited[i];
+        let mut hops = Vec::with_capacity(route.len());
+        for i in 0..route.len() {
+            let (node_id, via_scid, pubkey) = route[i];
 
             let channel_info = graph.channel(via_scid)?;
 
@@ -235,22 +227,22 @@ impl RandomStrategy {
                 .and_then(|n| n.announcement_info.as_ref().map(|a| a.features().clone()))
                 .unwrap_or_else(NodeFeatures::empty);
 
-            let (fee_msat, cltv_expiry_delta) = if i + 1 < visited.len() {
-                // Intermediate hop: look up the next channel's update from node_id.
-                let (_next_node_id, next_scid, _) = visited[i + 1];
-                let next_channel = graph.channel(next_scid)?;
-                let update = if next_channel.node_one == node_id {
-                    next_channel.one_to_two.as_ref()?
+            let (fee_msat, cltv_expiry_delta) =
+                if i + 1 < route.len() { // non-final hop
+                    let (_, next_scid, _) = route[i + 1];
+                    let next_channel = graph.channel(next_scid)?;
+                    let (directed, _) = next_channel.as_directed_from(&node_id)?;
+                    let update = if directed.source() == &next_channel.node_one {
+                        next_channel.one_to_two.as_ref().unwrap()
+                    } else {
+                        next_channel.two_to_one.as_ref().unwrap()
+                    };
+                    let fee = update.fees.base_msat as u64 + (amount_msat * update.fees.proportional_millionths as u64 / 1_000_000);
+                    (fee, update.cltv_expiry_delta as u32)
                 } else {
-                    next_channel.two_to_one.as_ref()?
+                    // Final hop: fee_msat carries the delivery amount; cltv delta is zero.
+                    (amount_msat, 0)
                 };
-                let fee = update.fees.base_msat as u64
-                    + (amount_msat * update.fees.proportional_millionths as u64 / 1_000_000);
-                (fee, update.cltv_expiry_delta as u32)
-            } else {
-                // Final hop.
-                (amount_msat, 0)
-            };
 
             hops.push(RouteHop {
                 pubkey,
@@ -263,6 +255,13 @@ impl RandomStrategy {
             });
         }
 
+        // 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();
+        if total_outgoing > first_hop.next_outbound_htlc_limit_msat {
+            return None;
+        }
+
         Some(Path { hops, blinded_tail: None })
     }
 }

tests/common/mod.rs

@@ -684,6 +684,41 @@ pub async fn open_channel(
 	open_channel_push_amt(node_a, node_b, funding_amount_sat, None, should_announce, electrsd).await
 }
 
+/// Like [`open_channel`] but skips the `wait_for_tx` electrum check so that
+/// multiple channels can be opened back-to-back before any blocks are mined.
+/// The caller is responsible for mining blocks and confirming the funding txs.
+pub async fn open_channel_no_electrum_wait(
+	node_a: &TestNode, node_b: &TestNode, funding_amount_sat: u64, should_announce: bool,
+) -> OutPoint {
+	if should_announce {
+		node_a
+			.open_announced_channel(
+				node_b.node_id(),
+				node_b.listening_addresses().unwrap().first().unwrap().clone(),
+				funding_amount_sat,
+				None,
+				None,
+			)
+			.unwrap();
+	} else {
+		node_a
+			.open_channel(
+				node_b.node_id(),
+				node_b.listening_addresses().unwrap().first().unwrap().clone(),
+				funding_amount_sat,
+				None,
+				None,
+			)
+			.unwrap();
+	}
+	assert!(node_a.list_peers().iter().find(|c| { c.node_id == node_b.node_id() }).is_some());
+
+	let funding_txo_a = expect_channel_pending_event!(node_a, node_b.node_id());
+	let funding_txo_b = expect_channel_pending_event!(node_b, node_a.node_id());
+	assert_eq!(funding_txo_a, funding_txo_b);
+	funding_txo_a
+}
+
 pub async fn open_channel_push_amt(
 	node_a: &TestNode, node_b: &TestNode, funding_amount_sat: u64, push_amount_msat: Option<u64>,
 	should_announce: bool, electrsd: &ElectrsD,