Replace public FfiDynStore wrapper with dyn FfiDynStoreTrait

Accept foreign store trait objects directly in the
UniFFI builder API and adapt them internally to
DynStoreTrait via the existing Rust-side adapter.

This removes FfiDynStore from the public surface,
keeps DynStoreTrait as the internal store abstraction,
and updates Rust tests to bridge native stores via
DynStoreWrapper instead of the old public wrapper.

[Refactor(uniffi)]

Author: enigbe

bindings/ldk_node.udl

@@ -32,7 +32,27 @@ interface LogWriter {
 	void log(LogRecord record);
 };
 
-typedef interface FfiDynStore;
+[Trait, WithForeign]
+interface FfiDynStoreTrait {
+	[Throws=IOError, Async]
+	bytes read_async(string primary_namespace, string secondary_namespace, string key);
+	[Throws=IOError, Async]
+	void write_async(string primary_namespace, string secondary_namespace, string key, bytes buf);
+	[Throws=IOError, Async]
+	void remove_async(string primary_namespace, string secondary_namespace, string key, boolean lazy);
+	[Throws=IOError, Async]
+	sequence<string> list_async(string primary_namespace, string secondary_namespace);
+
+	[Throws=IOError]
+	bytes read(string primary_namespace, string secondary_namespace, string key);
+	[Throws=IOError]
+	void write(string primary_namespace, string secondary_namespace, string key, bytes buf);
+	[Throws=IOError]
+	void remove(string primary_namespace, string secondary_namespace, string key, boolean lazy);
+	[Throws=IOError]
+	sequence<string> list(string primary_namespace, string secondary_namespace);
+};
+
 
 interface Builder {
 	constructor();
@@ -60,8 +80,8 @@ interface Builder {
 	void set_tor_config(TorConfig tor_config);
 	[Throws=BuildError]
 	void set_node_alias(string node_alias);
-	void set_backup_store(FfiDynStore backup_store);
-	void set_ephemeral_store(FfiDynStore ephemeral_store);
+	void set_backup_store(FfiDynStoreTrait backup_store);
+	void set_ephemeral_store(FfiDynStoreTrait ephemeral_store);
 	[Throws=BuildError]
 	void set_async_payments_role(AsyncPaymentsRole? role);
 	void set_wallet_recovery_mode();
@@ -78,7 +98,7 @@ interface Builder {
 	[Throws=BuildError]
 	Node build_with_vss_store_and_header_provider(NodeEntropy node_entropy, string vss_url, string store_id, VssHeaderProvider header_provider);
 	[Throws=BuildError]
-	Node build_with_store(NodeEntropy node_entropy, FfiDynStore store);
+	Node build_with_store(NodeEntropy node_entropy, FfiDynStoreTrait store);
 };
 
 interface Node {
@@ -233,6 +253,8 @@ enum NodeError {
 	"InvalidLnurl",
 };
 
+typedef enum IOError;
+
 typedef dictionary NodeStatus;
 
 [Remote]

src/builder.rs

@@ -53,7 +53,7 @@ use crate::entropy::NodeEntropy;
 use crate::event::EventQueue;
 use crate::fee_estimator::OnchainFeeEstimator;
 #[cfg(feature = "uniffi")]
-use crate::ffi::FfiDynStore;
+use crate::ffi::{FfiDynStore, FfiDynStoreTrait};
 use crate::gossip::GossipSource;
 use crate::io::sqlite_store::SqliteStore;
 use crate::io::tier_store::TierStore;
@@ -1155,8 +1155,8 @@ impl ArcedNodeBuilder {
 	/// of all critical data written to the primary store.
 	///
 	/// Backup writes are non-blocking and do not affect primary store operation performance.
-	pub fn set_backup_store(&self, backup_store: Arc<FfiDynStore>) {
-		let store: Arc<DynStore> = Arc::new((*backup_store).clone());
+	pub fn set_backup_store(&self, backup_store: Arc<dyn FfiDynStoreTrait>) {
+		let store: Arc<DynStore> = Arc::new(FfiDynStore::from_store(backup_store));
 		self.inner.write().unwrap().set_backup_store(store);
 	}
 
@@ -1167,8 +1167,8 @@ impl ArcedNodeBuilder {
 	/// can be rebuilt if lost.
 	///
 	/// If not set, non-critical data will be stored in the primary store.
-	pub fn set_ephemeral_store(&self, ephemeral_store: Arc<FfiDynStore>) {
-		let store: Arc<DynStore> = Arc::new((*ephemeral_store).clone());
+	pub fn set_ephemeral_store(&self, ephemeral_store: Arc<dyn FfiDynStoreTrait>) {
+		let store: Arc<DynStore> = Arc::new(FfiDynStore::from_store(ephemeral_store));
 		self.inner.write().unwrap().set_ephemeral_store(store);
 	}
 
@@ -1309,9 +1309,9 @@ impl ArcedNodeBuilder {
 	/// [`set_ephemeral_store`]: Self::set_ephemeral_store
 	/// [`set_backup_store`]: Self::set_backup_store
 	pub fn build_with_store(
-		&self, node_entropy: Arc<NodeEntropy>, kv_store: Arc<FfiDynStore>,
+		&self, node_entropy: Arc<NodeEntropy>, kv_store: Arc<dyn FfiDynStoreTrait>,
 	) -> Result<Arc<Node>, BuildError> {
-		let store = kv_store as Arc<DynStore>;
+		let store: Arc<DynStore> = Arc::new(FfiDynStore::from_store(kv_store));
 		self.inner.read().unwrap().build_with_dynstore(*node_entropy, store).map(Arc::new)
 	}
 }

src/ffi/io.rs

@@ -132,7 +132,6 @@ impl std::fmt::Display for IOError {
 /// through the async interface.
 ///
 /// [`DynStoreTrait`]: crate::types::DynStoreTrait
-#[uniffi::export(with_foreign)]
 #[async_trait::async_trait]
 pub trait FfiDynStoreTrait: Send + Sync {
 	async fn read_async(
@@ -173,7 +172,7 @@ pub trait FfiDynStoreTrait: Send + Sync {
 /// the corresponding async operation on an internal runtime, which preserves the
 /// same ordering guarantees for both sync and async callers.
 #[derive(Clone, uniffi::Object)]
-pub struct FfiDynStore {
+pub(crate) struct FfiDynStore {
 	inner: Arc<FfiDynStoreInner>,
 	next_write_version: Arc<AtomicU64>,
 }
@@ -607,12 +606,6 @@ impl<T: SyncAndAsyncKVStore + Send + Sync + 'static> FfiDynStoreTrait for DynSto
 	}
 }
 
-impl<T: SyncAndAsyncKVStore + Send + Sync + 'static> From<T> for FfiDynStore {
-	fn from(store: T) -> Self {
-		Self::from_store(Arc::new(DynStoreWrapper(store)))
-	}
-}
-
 /// Returns the process-wide runtime used to bridge Rust-side synchronous
 /// `FfiDynStore` calls through the canonical async store path.
 fn ffi_dynstore_runtime() -> &'static tokio::runtime::Runtime {

src/lib.rs

@@ -142,7 +142,7 @@ use fee_estimator::{ConfirmationTarget, FeeEstimator, OnchainFeeEstimator};
 #[cfg(feature = "uniffi")]
 use ffi::*;
 #[cfg(feature = "uniffi")]
-pub use ffi::{FfiDynStore, FfiDynStoreTrait, IOError};
+pub use ffi::{FfiDynStoreTrait, IOError};
 use gossip::GossipSource;
 use graph::NetworkGraph;
 use io::utils::write_node_metrics;

tests/common/mod.rs

@@ -327,10 +327,10 @@ pub(crate) enum TestChainSource<'a> {
 }
 
 #[cfg(feature = "uniffi")]
-use ldk_node::FfiDynStore;
+use ldk_node::FfiDynStoreTrait;
 
 #[cfg(feature = "uniffi")]
-type TestDynStore = Arc<FfiDynStore>;
+type TestDynStore = Arc<dyn FfiDynStoreTrait>;
 #[cfg(not(feature = "uniffi"))]
 type TestDynStore = TestSyncStore;
 
@@ -400,10 +400,12 @@ pub(crate) fn create_tier_stores(base_path: PathBuf) -> (TestDynStore, TestDynSt
 
 	#[cfg(feature = "uniffi")]
 	{
+		use ldk_node::DynStoreWrapper;
+
 		(
-			Arc::new(FfiDynStore::from(primary)),
-			Arc::new(FfiDynStore::from(backup)),
-			Arc::new(FfiDynStore::from(ephemeral)),
+			Arc::new(DynStoreWrapper(primary)) as Arc<dyn FfiDynStoreTrait>,
+			Arc::new(DynStoreWrapper(backup)) as Arc<dyn FfiDynStoreTrait>,
+			Arc::new(DynStoreWrapper(ephemeral)) as Arc<dyn FfiDynStoreTrait>,
 		)
 	}
 	#[cfg(not(feature = "uniffi"))]
@@ -519,7 +521,9 @@ pub(crate) fn setup_node(chain_source: &TestChainSource, config: TestConfig) ->
 			let kv_store = TestSyncStore::new(config.node_config.storage_dir_path.into());
 			#[cfg(feature = "uniffi")]
 			{
-				let kv_store = Arc::new(FfiDynStore::from(kv_store));
+				use ldk_node::DynStoreWrapper;
+				let kv_store: Arc<dyn FfiDynStoreTrait> = Arc::new(DynStoreWrapper(kv_store));
+
 				builder.build_with_store(config.node_entropy.into(), kv_store).unwrap()
 			}
 			#[cfg(not(feature = "uniffi"))]
@@ -1770,8 +1774,13 @@ pub fn test_kv_read(
 ) -> Result<Vec<u8>, bitcoin::io::Error> {
 	#[cfg(feature = "uniffi")]
 	{
-		use ldk_node::DynStoreTrait;
-		DynStoreTrait::read(&**store, primary_ns, secondary_ns, key)
+		ldk_node::FfiDynStoreTrait::read(
+			&**store,
+			primary_ns.to_string(),
+			secondary_ns.to_string(),
+			key.to_string(),
+		)
+		.map_err(Into::into)
 	}
 	#[cfg(not(feature = "uniffi"))]
 	{
@@ -1784,8 +1793,8 @@ pub fn test_kv_list(
 ) -> Result<Vec<String>, bitcoin::io::Error> {
 	#[cfg(feature = "uniffi")]
 	{
-		use ldk_node::DynStoreTrait;
-		DynStoreTrait::list(&**store, primary_ns, secondary_ns)
+		ldk_node::FfiDynStoreTrait::list(&**store, primary_ns.to_string(), secondary_ns.to_string())
+			.map_err(Into::into)
 	}
 	#[cfg(not(feature = "uniffi"))]
 	{

tests/integration_tests_rust.rs

@@ -347,9 +347,11 @@ async fn start_stop_reinit() {
 	let node;
 	#[cfg(feature = "uniffi")]
 	{
-		use ldk_node::FfiDynStore;
+		use ldk_node::{DynStoreWrapper, FfiDynStoreTrait};
+
+		let test_sync_store: Arc<dyn FfiDynStoreTrait> =
+			Arc::new(DynStoreWrapper(test_sync_store.clone()));
 
-		let test_sync_store = Arc::new(FfiDynStore::from(test_sync_store.clone()));
 		node = builder.build_with_store(config.node_entropy.into(), test_sync_store).unwrap();
 	}
 	#[cfg(not(feature = "uniffi"))]
@@ -396,9 +398,10 @@ async fn start_stop_reinit() {
 	let reinitialized_node;
 	#[cfg(feature = "uniffi")]
 	{
-		use ldk_node::FfiDynStore;
+		use ldk_node::{DynStoreWrapper, FfiDynStoreTrait};
+
+		let test_sync_store: Arc<dyn FfiDynStoreTrait> = Arc::new(DynStoreWrapper(test_sync_store));
 
-		let test_sync_store = Arc::new(FfiDynStore::from(test_sync_store.clone()));
 		reinitialized_node =
 			builder.build_with_store(config.node_entropy.into(), test_sync_store).unwrap();
 	}