Add uniffi support for probing

Author: randomlogin

bindings/ldk_node.udl

@@ -13,6 +13,8 @@ typedef dictionary TorConfig;
 
 typedef interface NodeEntropy;
 
+typedef interface ProbingConfig;
+
 typedef enum WordCount;
 
 [Remote]
@@ -61,6 +63,7 @@ interface Builder {
 	[Throws=BuildError]
 	void set_async_payments_role(AsyncPaymentsRole? role);
 	void set_wallet_recovery_mode();
+	void set_probing_config(ProbingConfig config);
 	[Throws=BuildError]
 	Node build(NodeEntropy node_entropy);
 	[Throws=BuildError]

src/builder.rs

@@ -1111,8 +1111,8 @@ impl ArcedNodeBuilder {
 	/// Configures background probing.
 	///
 	/// See [`ProbingConfig`] for details.
-	pub fn set_probing_config(&self, config: ProbingConfig) {
-		self.inner.write().unwrap().set_probing_config(config);
+	pub fn set_probing_config(&self, config: Arc<ProbingConfig>) {
+		self.inner.write().unwrap().set_probing_config((*config).clone());
 	}
 
 	/// Builds a [`Node`] instance with a [`SqliteStore`] backend and according to the options

src/lib.rs

@@ -116,6 +116,8 @@ use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 #[cfg(cycle_tests)]
 use std::{any::Any, sync::Weak};
 
+#[cfg(feature = "uniffi")]
+use crate::probing::ProbingConfig;
 pub use balance::{BalanceDetails, LightningBalance, PendingSweepBalance};
 pub use bip39;
 pub use bitcoin;

src/probing.rs

@@ -58,6 +58,7 @@ pub(crate) enum ProbingStrategyKind {
 /// [`custom`]: Self::custom
 /// [`build`]: ProbingConfigBuilder::build
 #[derive(Clone)]
+#[cfg_attr(feature = "uniffi", derive(uniffi::Object))]
 pub struct ProbingConfig {
 	pub(crate) kind: ProbingStrategyKind,
 	pub(crate) interval: Duration,
@@ -108,6 +109,60 @@ impl ProbingConfig {
 	}
 }
 
+#[cfg(feature = "uniffi")]
+#[uniffi::export]
+impl ProbingConfig {
+	/// Creates a probing 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.
+	/// All other parameters are optional and fall back to sensible defaults when `None`.
+	#[uniffi::constructor]
+	pub fn new_high_degree(
+		top_node_count: u64, interval_secs: Option<u64>, max_locked_msat: Option<u64>,
+		diversity_penalty_msat: Option<u64>, cooldown_secs: Option<u64>,
+	) -> Self {
+		let mut builder = Self::high_degree(top_node_count as usize);
+		if let Some(secs) = interval_secs {
+			builder = builder.interval(Duration::from_secs(secs));
+		}
+		if let Some(msat) = max_locked_msat {
+			builder = builder.max_locked_msat(msat);
+		}
+		if let Some(penalty) = diversity_penalty_msat {
+			builder = builder.diversity_penalty_msat(penalty);
+		}
+		if let Some(secs) = cooldown_secs {
+			builder = builder.cooldown(Duration::from_secs(secs));
+		}
+		builder.build()
+	}
+
+	/// Creates a probing config that probes via random graph walks.
+	///
+	/// `max_hops` is the upper bound on the number of hops in a randomly constructed path.
+	/// All other parameters are optional and fall back to sensible defaults when `None`.
+	#[uniffi::constructor]
+	pub fn new_random_walk(
+		max_hops: u64, interval_secs: Option<u64>, max_locked_msat: Option<u64>,
+		diversity_penalty_msat: Option<u64>, cooldown_secs: Option<u64>,
+	) -> Self {
+		let mut builder = Self::random_walk(max_hops as usize);
+		if let Some(secs) = interval_secs {
+			builder = builder.interval(Duration::from_secs(secs));
+		}
+		if let Some(msat) = max_locked_msat {
+			builder = builder.max_locked_msat(msat);
+		}
+		if let Some(penalty) = diversity_penalty_msat {
+			builder = builder.diversity_penalty_msat(penalty);
+		}
+		if let Some(secs) = cooldown_secs {
+			builder = builder.cooldown(Duration::from_secs(secs));
+		}
+		builder.build()
+	}
+}
+
 /// Builder for [`ProbingConfig`].
 ///
 /// Created via [`ProbingConfig::high_degree`], [`ProbingConfig::random_walk`], or