Add ProbingService with pluggable ProbingStrategy

- Add optional ProbingService to run periodic
probe payments for liquidity checks.
- Configure probing behavior by providing a
public `ProbingStrategy` trait implementation.
- Targets and selection logic are fully
customizable by the user via the trait (no fixed
target count is passed by the node).

Author: moisesPompilio

src/builder.rs

@@ -66,6 +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::runtime::Runtime;
 use crate::tx_broadcaster::TransactionBroadcaster;
 use crate::types::{
@@ -129,6 +130,40 @@ struct LiquiditySourceConfig {
 	lsps2_service: Option<LSPS2ServiceConfig>,
 }
 
+#[derive(Clone, Debug)]
+struct ProbingServiceConfig {
+	/// Time in seconds between consecutive probing attempts.
+	probing_interval_secs: u64,
+
+	/// Amount in milli-satoshis used for each probe.
+	probing_amount_msat: u64,
+
+	/// Configuration for the probing strategy as a shareable trait-object.
+	strategy: ProbingStrategyConfig,
+}
+
+pub enum ProbingStrategyConfig {
+	Custom { strategy: Arc<dyn ProbingStrategy + Send + Sync> },
+}
+
+impl fmt::Debug for ProbingStrategyConfig {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		match self {
+			Self::Custom { .. } => {
+				f.debug_struct("Custom").field("strategy", &"<ProbingStrategy>").finish()
+			},
+		}
+	}
+}
+
+impl Clone for ProbingStrategyConfig {
+	fn clone(&self) -> Self {
+		match self {
+			Self::Custom { strategy } => Self::Custom { strategy: Arc::clone(strategy) },
+		}
+	}
+}
+
 #[derive(Clone)]
 enum LogWriterConfig {
 	File { log_file_path: Option<String>, max_log_level: Option<LogLevel> },
@@ -253,6 +288,7 @@ pub struct NodeBuilder {
 	async_payments_role: Option<AsyncPaymentsRole>,
 	runtime_handle: Option<tokio::runtime::Handle>,
 	pathfinding_scores_sync_config: Option<PathfindingScoresSyncConfig>,
+	probing_service_config: Option<ProbingServiceConfig>,
 }
 
 impl NodeBuilder {
@@ -271,6 +307,7 @@ impl NodeBuilder {
 		let log_writer_config = None;
 		let runtime_handle = None;
 		let pathfinding_scores_sync_config = None;
+		let probing_service_config = None;
 		Self {
 			config,
 			entropy_source_config,
@@ -281,6 +318,7 @@ impl NodeBuilder {
 			runtime_handle,
 			async_payments_role: None,
 			pathfinding_scores_sync_config,
+			probing_service_config,
 		}
 	}
 
@@ -488,6 +526,28 @@ impl NodeBuilder {
 		self
 	}
 
+	/// Configures the probing service with a custom target selection strategy.
+	///
+	/// This allows full control over how probing targets are selected by providing
+	/// a custom implementation of the [`ProbingStrategy`] trait.
+	///
+	/// # Parameters
+	/// * `probing_interval_secs` - Seconds between probing cycles
+	/// * `probing_amount_msat` - Amount in milli-satoshis per probe
+	/// * `strategy` - Custom [`ProbingStrategy`] implementation
+	///
+	/// [`ProbingStrategy`]: crate::probing::ProbingStrategy
+	pub fn set_probing_service_with_custom_strategy<T: ProbingStrategy + Send + Sync + 'static>(
+		&mut self, probing_interval_secs: u64, probing_amount_msat: u64, strategy: T,
+	) -> &mut Self {
+		self.probing_service_config = Some(ProbingServiceConfig {
+			probing_interval_secs,
+			probing_amount_msat,
+			strategy: ProbingStrategyConfig::Custom { strategy: Arc::new(strategy) },
+		});
+		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;
@@ -744,6 +804,7 @@ impl NodeBuilder {
 			runtime,
 			logger,
 			Arc::new(vss_store),
+			self.probing_service_config.as_ref(),
 		)
 	}
 
@@ -778,6 +839,7 @@ impl NodeBuilder {
 			runtime,
 			logger,
 			kv_store,
+			self.probing_service_config.as_ref(),
 		)
 	}
 }
@@ -977,6 +1039,27 @@ impl ArcedNodeBuilder {
 		self.inner.write().unwrap().set_liquidity_provider_lsps2(service_config);
 	}
 
+	/// Configures the probing service with a custom target selection strategy.
+	///
+	/// This allows full control over how probing targets are selected by providing
+	/// a custom implementation of the [`ProbingStrategy`] trait.
+	///
+	/// # Parameters
+	/// * `probing_interval_secs` - Seconds between probing cycles
+	/// * `probing_amount_msat` - Amount in milli-satoshis per probe
+	/// * `strategy` - Custom [`ProbingStrategy`] implementation
+	///
+	/// [`ProbingStrategy`]: crate::probing::ProbingStrategy
+	pub fn set_probing_service_with_custom_strategy<T: ProbingStrategy + Send + Sync + 'static>(
+		&self, probing_interval_secs: u64, probing_amount_msat: u64, strategy: T,
+	) {
+		self.inner.write().unwrap().set_probing_service_with_custom_strategy(
+			probing_interval_secs,
+			probing_amount_msat,
+			strategy,
+		);
+	}
+
 	/// 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);
@@ -1142,6 +1225,7 @@ fn build_with_store_internal(
 	pathfinding_scores_sync_config: Option<&PathfindingScoresSyncConfig>,
 	async_payments_role: Option<AsyncPaymentsRole>, seed_bytes: [u8; 64], runtime: Arc<Runtime>,
 	logger: Arc<Logger>, kv_store: Arc<DynStore>,
+	probing_service_config: Option<&ProbingServiceConfig>,
 ) -> Result<Node, BuildError> {
 	optionally_install_rustls_cryptoprovider();
 
@@ -1767,6 +1851,25 @@ fn build_with_store_internal(
 
 	let pathfinding_scores_sync_url = pathfinding_scores_sync_config.map(|c| c.url.clone());
 
+	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),
+		};
+		Some(Arc::new(ProbingService::new(
+			pro_ser.probing_interval_secs,
+			pro_ser.probing_amount_msat,
+			Arc::clone(&strategy),
+			Arc::clone(&config),
+			Arc::clone(&logger),
+			Arc::clone(&channel_manager),
+			Arc::clone(&keys_manager),
+			Arc::clone(&is_running),
+			Arc::clone(&payment_store),
+		)))
+	} else {
+		None
+	};
+
 	Ok(Node {
 		runtime,
 		stop_sender,
@@ -1797,6 +1900,7 @@ fn build_with_store_internal(
 		node_metrics,
 		om_mailbox,
 		async_payments_role,
+		probing_service,
 	})
 }
 

src/lib.rs

@@ -96,6 +96,7 @@ pub mod logger;
 mod message_handler;
 pub mod payment;
 mod peer_store;
+mod probing;
 mod runtime;
 mod scoring;
 mod tx_broadcaster;
@@ -149,6 +150,8 @@ use payment::{
 	UnifiedQrPayment,
 };
 use peer_store::{PeerInfo, PeerStore};
+use probing::ProbingService;
+pub use probing::ProbingStrategy;
 use rand::Rng;
 use runtime::Runtime;
 use types::{
@@ -196,6 +199,7 @@ pub struct Node {
 	scorer: Arc<Mutex<Scorer>>,
 	peer_store: Arc<PeerStore<Arc<Logger>>>,
 	payment_store: Arc<PaymentStore>,
+	probing_service: Option<Arc<ProbingService>>,
 	is_running: Arc<RwLock<bool>>,
 	node_metrics: Arc<RwLock<NodeMetrics>>,
 	om_mailbox: Option<Arc<OnionMessageMailbox>>,
@@ -625,6 +629,32 @@ impl Node {
 			});
 		}
 
+		if let Some(probing_service) = self.probing_service.as_ref() {
+			let mut stop_probing_service = self.stop_sender.subscribe();
+			let probing_service = Arc::clone(probing_service);
+			let probing_logger = Arc::clone(&self.logger);
+
+			self.runtime.spawn_cancellable_background_task(async move {
+				let mut interval = tokio::time::interval(Duration::from_secs(
+					probing_service.probing_interval_secs,
+				));
+				loop {
+					tokio::select! {
+						_ = stop_probing_service.changed() => {
+							log_debug!(
+								probing_logger,
+								"Stopping probing service.",
+							);
+							return;
+						}
+						_ = interval.tick() => {
+							probing_service.handle_probing();
+						}
+					}
+				}
+			});
+		}
+
 		log_info!(self.logger, "Startup complete.");
 		*is_running_lock = true;
 		Ok(())

src/probing.rs

@@ -0,0 +1,89 @@
+use bitcoin::secp256k1::PublicKey;
+use std::sync::{Arc, RwLock};
+
+use crate::{
+	config::Config,
+	logger::{log_debug, log_error, LdkLogger, Logger},
+	payment::SpontaneousPayment,
+	types::{ChannelManager, KeysManager, PaymentStore},
+};
+
+/// Trait for probing strategies to select targets for liquidity assessment.
+pub trait ProbingStrategy {
+	/// Loads the targets to be used in the current probing cycle.
+	///
+	/// Called at the start of each probing cycle before sending probes.
+	fn load_targets(&self);
+
+	/// Returns the next target public key for probing, or None if no more targets are available.
+	fn next_target(&self) -> Option<PublicKey>;
+}
+
+/// Configuration for the probing service used to evaluate channel liquidity by sending pre-flight
+/// probes to peers and routes.
+pub struct ProbingService {
+	pub probing_interval_secs: u64,
+	probing_amount_msat: u64,
+	strategy: Arc<dyn ProbingStrategy + Send + Sync>,
+	config: Arc<Config>,
+	logger: Arc<Logger>,
+	channel_manager: Arc<ChannelManager>,
+	keys_manager: Arc<KeysManager>,
+	is_running: Arc<RwLock<bool>>,
+	payment_store: Arc<PaymentStore>,
+}
+
+impl ProbingService {
+	/// Creates a new probing service with the given configuration and dependencies.
+	pub fn new(
+		probing_interval_secs: u64, probing_amount_msat: u64,
+		strategy: Arc<dyn ProbingStrategy + Send + Sync>, config: Arc<Config>, logger: Arc<Logger>,
+		channel_manager: Arc<ChannelManager>, keys_manager: Arc<KeysManager>,
+		is_running: Arc<RwLock<bool>>, payment_store: Arc<PaymentStore>,
+	) -> Self {
+		Self {
+			probing_interval_secs,
+			probing_amount_msat,
+			strategy,
+			config,
+			logger,
+			channel_manager,
+			keys_manager,
+			is_running,
+			payment_store,
+		}
+	}
+
+	pub fn handle_probing(&self) {
+		self.strategy.load_targets();
+		loop {
+			if let Some(target) = self.strategy.next_target() {
+				let spontaneous_payment = self.spontaneous_payment();
+				match spontaneous_payment.send_probes(self.probing_amount_msat, target) {
+					Ok(_) => {
+						log_debug!(self.logger, "Probing service sent probe to target: {}", target)
+					},
+					Err(e) => log_error!(
+						self.logger,
+						"Probing service failed to send probe to target {}: {}",
+						target,
+						e
+					),
+				}
+			} else {
+				break;
+			}
+		}
+	}
+
+	fn spontaneous_payment(&self) -> SpontaneousPayment {
+		SpontaneousPayment::new(
+			Arc::clone(&self.channel_manager),
+			Arc::clone(&self.keys_manager),
+			Arc::clone(&self.payment_store),
+			Arc::clone(&self.config),
+			Arc::clone(&self.is_running),
+			Arc::clone(&self.logger),
+		)
+	}
+}