Add HighCapacityStrategy implementing ProbingStrategy

- Add `HighCapacityStrategy` that selects top-N
nodes by aggregate capacity from `NetworkGraph`.
- Add lightweight caching with configurable reuse
limit to avoid frequent graph scans.
- Wireable from builder via
`set_probing_service_with_high_capacity_strategy`

Author: moisesPompilio

src/builder.rs

@@ -66,7 +66,7 @@ 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::{ProbingService, ProbingStrategy};
+use crate::probing::{HighCapacityStrategy, ProbingService, ProbingStrategy};
 use crate::runtime::Runtime;
 use crate::tx_broadcaster::TransactionBroadcaster;
 use crate::types::{
@@ -144,6 +144,7 @@ struct ProbingServiceConfig {
 
 pub enum ProbingStrategyConfig {
 	Custom { strategy: Arc<dyn ProbingStrategy + Send + Sync> },
+	HighCapacity { max_targets_per_cycle: usize, target_cache_reuse_limit: usize },
 }
 
 impl fmt::Debug for ProbingStrategyConfig {
@@ -152,6 +153,14 @@ impl fmt::Debug for ProbingStrategyConfig {
 			Self::Custom { .. } => {
 				f.debug_struct("Custom").field("strategy", &"<ProbingStrategy>").finish()
 			},
+			Self::HighCapacity {
+				max_targets_per_cycle: max_targets,
+				target_cache_reuse_limit: max_reloads,
+			} => f
+				.debug_struct("HighCapacity")
+				.field("max_targets", max_targets)
+				.field("max_reloads", max_reloads)
+				.finish(),
 		}
 	}
 }
@@ -160,6 +169,13 @@ impl Clone for ProbingStrategyConfig {
 	fn clone(&self) -> Self {
 		match self {
 			Self::Custom { strategy } => Self::Custom { strategy: Arc::clone(strategy) },
+			Self::HighCapacity {
+				max_targets_per_cycle: max_targets,
+				target_cache_reuse_limit: max_reloads,
+			} => Self::HighCapacity {
+				max_targets_per_cycle: *max_targets,
+				target_cache_reuse_limit: *max_reloads,
+			},
 		}
 	}
 }
@@ -548,6 +564,33 @@ impl NodeBuilder {
 		self
 	}
 
+	/// Configures the probing service with the built-in high-capacity strategy.
+	///
+	/// Targets peers with the highest total channel capacity to assess liquidity
+	/// on the most significant network routes.
+	///
+	/// # Parameters
+	/// * `probing_interval_secs` - Seconds between probing cycles
+	/// * `probing_amount_msat` - Amount in milli-satoshis per probe
+	/// * `max_targets_per_cycle` - Maximum peers to probe each cycle
+	/// * `target_cache_reuse_limit` - Number of cycles to reuse targets before refreshing.
+	///   Acts as a cache: targets are reloaded from the network graph only after this many cycles,
+	///   reducing overhead while adapting to network changes.
+	pub fn set_probing_service_with_high_capacity_strategy(
+		&mut self, probing_interval_secs: u64, probing_amount_msat: u64,
+		max_targets_per_cycle: usize, target_cache_reuse_limit: usize,
+	) -> &mut Self {
+		self.probing_service_config = Some(ProbingServiceConfig {
+			probing_interval_secs,
+			probing_amount_msat,
+			strategy: ProbingStrategyConfig::HighCapacity {
+				max_targets_per_cycle,
+				target_cache_reuse_limit,
+			},
+		});
+		self
+	}
+
 	/// Sets the used storage directory path.
 	pub fn set_storage_dir_path(&mut self, storage_dir_path: String) -> &mut Self {
 		self.config.storage_dir_path = storage_dir_path;
@@ -1060,6 +1103,30 @@ impl ArcedNodeBuilder {
 		);
 	}
 
+	/// Configures the probing service with the built-in high-capacity strategy.
+	///
+	/// Targets peers with the highest total channel capacity to assess liquidity
+	/// on the most significant network routes.
+	///
+	/// # Parameters
+	/// * `probing_interval_secs` - Seconds between probing cycles
+	/// * `probing_amount_msat` - Amount in milli-satoshis per probe
+	/// * `max_targets_per_cycle` - Maximum peers to probe each cycle
+	/// * `target_cache_reuse_limit` - Number of cycles to reuse targets before refreshing.
+	///   Acts as a cache: targets are reloaded from the network graph only after this many cycles,
+	///   reducing overhead while adapting to network changes.
+	pub fn set_probing_service_with_high_capacity_strategy(
+		&self, probing_interval_secs: u64, probing_amount_msat: u64, max_targets_per_cycle: usize,
+		target_cache_reuse_limit: usize,
+	) {
+		self.inner.write().unwrap().set_probing_service_with_high_capacity_strategy(
+			probing_interval_secs,
+			probing_amount_msat,
+			max_targets_per_cycle,
+			target_cache_reuse_limit,
+		);
+	}
+
 	/// Sets the used storage directory path.
 	pub fn set_storage_dir_path(&self, storage_dir_path: String) {
 		self.inner.write().unwrap().set_storage_dir_path(storage_dir_path);
@@ -1854,6 +1921,14 @@ fn build_with_store_internal(
 	let probing_service = if let Some(pro_ser) = probing_service_config {
 		let strategy: Arc<dyn ProbingStrategy + Send + Sync> = match &pro_ser.strategy {
 			ProbingStrategyConfig::Custom { strategy } => Arc::clone(strategy),
+			ProbingStrategyConfig::HighCapacity {
+				max_targets_per_cycle: max_targets,
+				target_cache_reuse_limit: max_reloads,
+			} => Arc::new(HighCapacityStrategy::new(
+				Arc::clone(&network_graph),
+				*max_targets,
+				*max_reloads,
+			)),
 		};
 		Some(Arc::new(ProbingService::new(
 			pro_ser.probing_interval_secs,

src/graph.rs

@@ -17,6 +17,9 @@ use lightning::routing::gossip::RoutingFees;
 #[cfg(not(feature = "uniffi"))]
 use lightning::routing::gossip::{ChannelInfo, NodeInfo};
 
+use std::cmp::Reverse;
+use std::collections::{BinaryHeap, HashMap};
+
 use crate::types::Graph;
 
 /// Represents the network as nodes and channels between them.
@@ -48,6 +51,38 @@ impl NetworkGraph {
 	pub fn node(&self, node_id: &NodeId) -> Option<NodeInfo> {
 		self.inner.read_only().nodes().get(node_id).cloned().map(|n| n.into())
 	}
+
+	/// Selects nodes with the highest total channel capacity in the network.
+	pub fn select_highest_capacity_nodes(&self, quantity_nodes: usize) -> Vec<NodeId> {
+		// Calculate total capacity for each node by summing all their channel capacities
+		let node_capacities = self.inner.read_only().channels().unordered_iter().fold(
+			HashMap::new(),
+			|mut acc, (_, chan_info)| {
+				let cap = chan_info.capacity_sats.unwrap_or(0);
+				*acc.entry(chan_info.node_one).or_insert(0) += cap;
+				*acc.entry(chan_info.node_two).or_insert(0) += cap;
+				acc
+			},
+		);
+
+		// Use a min-heap to efficiently track the top N nodes by capacity
+		node_capacities
+			.into_iter()
+			.fold(BinaryHeap::with_capacity(quantity_nodes), |mut top_heap, (node_id, cap)| {
+				if top_heap.len() < quantity_nodes {
+					top_heap.push(Reverse((cap, node_id)));
+				} else if let Some(Reverse((min_cap, _))) = top_heap.peek() {
+					if cap > *min_cap {
+						top_heap.pop();
+						top_heap.push(Reverse((cap, node_id)));
+					}
+				}
+				top_heap
+			})
+			.into_iter()
+			.map(|Reverse((_, node_id))| node_id)
+			.collect()
+	}
 }
 
 /// Details about a channel (both directions).

src/probing.rs

@@ -1,11 +1,12 @@
 use bitcoin::secp256k1::PublicKey;
-use std::sync::{Arc, RwLock};
+use std::sync::{Arc, Mutex, RwLock};
 
 use crate::{
 	config::Config,
+	graph::NetworkGraph,
 	logger::{log_debug, log_error, LdkLogger, Logger},
 	payment::SpontaneousPayment,
-	types::{ChannelManager, KeysManager, PaymentStore},
+	types::{ChannelManager, Graph, KeysManager, PaymentStore},
 };
 
 /// Trait for probing strategies to select targets for liquidity assessment.
@@ -19,6 +20,70 @@ pub trait ProbingStrategy {
 	fn next_target(&self) -> Option<PublicKey>;
 }
 
+/// Simple strategy that selects targets based on highest channel capacity.
+pub struct HighCapacityStrategy {
+	network_graph: Arc<Graph>,
+	max_targets_per_cycle: usize,
+	target_cache_reuse_limit: usize,
+	targets: Mutex<Vec<PublicKey>>,
+	target_index: Mutex<usize>,
+	uses_since_load: Mutex<usize>,
+}
+
+impl HighCapacityStrategy {
+	pub fn new(network_graph: Arc<Graph>, max_targets: usize, max_reloads: usize) -> Self {
+		Self {
+			network_graph,
+			max_targets_per_cycle: max_targets,
+			target_cache_reuse_limit: max_reloads,
+			targets: Mutex::new(Vec::new()),
+			target_index: Mutex::new(0),
+			uses_since_load: Mutex::new(0),
+		}
+	}
+
+	fn network_graph(&self) -> NetworkGraph {
+		NetworkGraph::new(Arc::clone(&self.network_graph))
+	}
+}
+
+impl ProbingStrategy for HighCapacityStrategy {
+	fn load_targets(&self) {
+		let mut targets = self.targets.lock().unwrap();
+		let mut uses_since_load = self.uses_since_load.lock().unwrap();
+
+		if !targets.is_empty() && *uses_since_load < self.target_cache_reuse_limit {
+			*uses_since_load += 1;
+			return;
+		}
+
+		let network = self.network_graph();
+		let highest_capacity_nodes =
+			network.select_highest_capacity_nodes(self.max_targets_per_cycle);
+		*targets =
+			highest_capacity_nodes.iter().filter_map(|node_id| node_id.as_pubkey().ok()).collect();
+
+		let mut target_index = self.target_index.lock().unwrap();
+		*target_index = 0;
+		*uses_since_load = 0;
+	}
+
+	fn next_target(&self) -> Option<PublicKey> {
+		let mut target_index = self.target_index.lock().unwrap();
+		let targets = self.targets.lock().unwrap();
+
+		if *target_index < targets.len() {
+			let pk = targets[*target_index];
+			*target_index += 1;
+			Some(pk)
+		} else {
+			// reset index for next cycle
+			*target_index = 0;
+			None
+		}
+	}
+}
+
 /// Configuration for the probing service used to evaluate channel liquidity by sending pre-flight
 /// probes to peers and routes.
 pub struct ProbingService {