From de54ff061f804a4fd11a176240174208275d8131 Mon Sep 17 00:00:00 2001 From: Elias Rohrer Date: Thu, 19 Nov 2026 10:23:17 +0100 Subject: [PATCH 1/5] Expose Esplora headers setter in bindings `Builder::set_chain_source_esplora_with_headers` was only available to Rust users, so bindings users had no way to authenticate against an Esplora server that requires custom request headers. Export the method via UniFFI alongside the plain Esplora setter, as all of its arguments are already representable in the bindings. Co-Authored-By: HAL 9000 --- src/builder.rs | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/builder.rs b/src/builder.rs index a8cba83db3..28104cf1ae 100644 --- a/src/builder.rs +++ b/src/builder.rs @@ -1079,10 +1079,7 @@ impl Builder { ) { self.inner.write().expect("lock").set_chain_source_esplora(server_url, sync_config); } -} -#[cfg(all(feature = "uniffi", feature = "chain-esplora"))] -impl ArcedNodeBuilder { /// Configures the [`Node`] instance to source its chain data from the given Esplora server. /// /// The given `headers` will be included in all requests to the Esplora server, typically used for From 9ccdfcd8920e6e12c9953e70b3429c36616cc044 Mon Sep 17 00:00:00 2001 From: Elias Rohrer Date: Thu, 19 Nov 2026 10:24:13 +0100 Subject: [PATCH 2/5] Expose LSPS2 service setup in bindings `Builder::enable_liquidity_provider` was only available to Rust users, even though `LSPS2ServiceConfig` is already a UniFFI record. Bindings users could therefore construct the service configuration but had no way to hand it to the builder. Export the method via UniFFI next to the other liquidity setter. Co-Authored-By: HAL 9000 --- src/builder.rs | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/builder.rs b/src/builder.rs index 28104cf1ae..6c05dfbfea 100644 --- a/src/builder.rs +++ b/src/builder.rs @@ -1216,10 +1216,7 @@ impl Builder { trust_peer_0conf, ); } -} -#[cfg(feature = "uniffi")] -impl ArcedNodeBuilder { /// Configures the [`Node`] instance to provide an [LSPS2] service, issuing just-in-time /// channels to clients. /// From d68c6596210ad4bbb31adf8af292819f49a9e9b6 Mon Sep 17 00:00:00 2001 From: Elias Rohrer Date: Thu, 19 Nov 2026 10:25:17 +0100 Subject: [PATCH 3/5] Expose channel-pair stats aggregation in bindings `aggregate_channel_pair_stats` was only available to Rust users, so bindings users could list channel-pair forwarding buckets but had to reimplement the aggregation into cumulative totals themselves. Export it as a free function via UniFFI. Co-Authored-By: HAL 9000 --- src/payment/forwarding_store.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/payment/forwarding_store.rs b/src/payment/forwarding_store.rs index 86b7c814b8..f42ba89302 100644 --- a/src/payment/forwarding_store.rs +++ b/src/payment/forwarding_store.rs @@ -863,6 +863,7 @@ async fn aggregate_expired_forwarded_payments_at( /// [`bucket_start_timestamp`]: crate::payment::ChannelPairForwardingStats::bucket_start_timestamp /// [`bucket_size_secs`]: crate::payment::ChannelPairForwardingStats::bucket_size_secs /// [`aggregated_at_timestamp`]: crate::payment::ChannelPairForwardingStats::aggregated_at_timestamp +#[cfg_attr(feature = "uniffi", uniffi::export)] pub fn aggregate_channel_pair_stats( buckets: &[ChannelPairForwardingStats], ) -> Option { From def0831e7e78509d0179632dd0935fe31a25539f Mon Sep 17 00:00:00 2001 From: Elias Rohrer Date: Thu, 19 Nov 2026 10:28:08 +0100 Subject: [PATCH 4/5] Expose the prober in bindings `Node::prober` and `Prober::locked_msat` were only available to Rust users, so bindings users could configure background probing but had no way to observe how much liquidity is locked in in-flight probes. Make `Prober` a UniFFI object and export `locked_msat`. As bindings can't hold a borrowed reference, `Node::prober` hands out a shared handle when building with UniFFI. Co-Authored-By: HAL 9000 --- bindings/ldk_node.udl | 3 +++ src/lib.rs | 7 +++++++ src/probing.rs | 4 ++++ 3 files changed, 14 insertions(+) diff --git a/bindings/ldk_node.udl b/bindings/ldk_node.udl index febc94d91c..337e1c132b 100644 --- a/bindings/ldk_node.udl +++ b/bindings/ldk_node.udl @@ -73,6 +73,7 @@ interface Node { OnchainPayment onchain_payment(); Liquidity liquidity(); ForwardingAnalytics forwarding_analytics(); + Prober? prober(); [Throws=NodeError] void lnurl_auth(string lnurl); [Throws=NodeError] @@ -148,6 +149,8 @@ typedef interface Liquidity; typedef interface ForwardingAnalytics; +typedef interface Prober; + [Error] enum NodeError { "AlreadyRunning", diff --git a/src/lib.rs b/src/lib.rs index 97a179c95f..612940084c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1389,10 +1389,17 @@ impl Node { } /// Returns a reference to the [`Prober`], or `None` if no probing strategy is configured. + #[cfg(not(feature = "uniffi"))] pub fn prober(&self) -> Option<&Prober> { self.prober.as_deref() } + /// Returns the [`Prober`], or `None` if no probing strategy is configured. + #[cfg(feature = "uniffi")] + pub fn prober(&self) -> Option> { + self.prober.clone() + } + /// Retrieve a list of known channels. pub fn list_channels(&self) -> Vec { self.channel_manager diff --git a/src/probing.rs b/src/probing.rs index 42beda5301..3b2f280a01 100644 --- a/src/probing.rs +++ b/src/probing.rs @@ -806,6 +806,7 @@ impl ProbingStrategy for RandomWalkStrategy { } /// Periodically dispatches probes according to a [`ProbingStrategy`]. +#[cfg_attr(feature = "uniffi", derive(uniffi::Object))] pub struct Prober { pub(crate) channel_manager: Arc, pub(crate) logger: Arc, @@ -825,6 +826,7 @@ fn fmt_path(path: &lightning::routing::router::Path) -> String { .join(" -> ") } +#[cfg_attr(feature = "uniffi", uniffi::export)] impl Prober { /// Returns the total millisatoshis currently locked in in-flight probes. pub fn locked_msat(&self) -> u64 { @@ -843,7 +845,9 @@ impl Prober { }) .sum(); } +} +impl Prober { pub(crate) fn handle_background_probe_successful(&self, path: &Path, payment_id: PaymentId) { log_debug!( self.logger, From 832843a2dc5530ea620b5c462174c00404b0078b Mon Sep 17 00:00:00 2001 From: Elias Rohrer Date: Thu, 19 Nov 2026 10:30:27 +0100 Subject: [PATCH 5/5] Expose node features and color in bindings The bindings' `NodeAnnouncementInfo` dropped the announced feature bits and the node color when converting from LDK's type, so bindings users querying the network graph saw less than Rust users do. Carry both fields over, reusing the existing `NodeFeatures` object for the feature bits and passing the color as its three raw bytes. Co-Authored-By: HAL 9000 --- src/graph.rs | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/src/graph.rs b/src/graph.rs index a83318609f..6b1b8f5a15 100644 --- a/src/graph.rs +++ b/src/graph.rs @@ -152,9 +152,13 @@ impl From for NodeInfo { #[cfg(feature = "uniffi")] #[derive(Clone, Debug, PartialEq, Eq, uniffi::Record)] pub struct NodeAnnouncementInfo { + /// Protocol features the node announced support for. + pub features: Arc, /// When the last known update to the node state was issued. /// Value is opaque, as set in the announcement. pub last_update: u32, + /// Color assigned to the node, as three bytes holding the red, green, and blue components. + pub rgb: Vec, /// Moniker assigned to the node. /// May be invalid or malicious (eg control chars), /// should not be exposed to the user. @@ -167,9 +171,41 @@ pub struct NodeAnnouncementInfo { impl From for NodeAnnouncementInfo { fn from(value: lightning::routing::gossip::NodeAnnouncementInfo) -> Self { Self { + features: Arc::new(value.features().clone().into()), last_update: value.last_update(), + rgb: value.rgb().to_vec(), alias: value.alias().to_string(), addresses: value.addresses().iter().cloned().collect(), } } } + +#[cfg(all(test, feature = "uniffi"))] +mod tests { + use lightning::routing::gossip::{ + NodeAlias, NodeAnnouncementDetails, NodeAnnouncementInfo as LdkNodeAnnouncementInfo, + }; + use lightning_types::features::NodeFeatures as LdkNodeFeatures; + + use super::NodeAnnouncementInfo; + + #[test] + fn node_announcement_info_conversion_keeps_features_and_rgb() { + let mut features = LdkNodeFeatures::empty(); + features.set_keysend_optional(); + let rgb = [1, 2, 3]; + let ldk_info = LdkNodeAnnouncementInfo::Local(NodeAnnouncementDetails { + features: features.clone(), + last_update: 42, + rgb, + alias: NodeAlias([0; 32]), + addresses: Vec::new(), + }); + + let info: NodeAnnouncementInfo = ldk_info.into(); + + assert_eq!(info.features.inner, features); + assert_eq!(info.rgb, rgb.to_vec()); + assert_eq!(info.last_update, 42); + } +}