Add Rust integration tests for tiered storage

Extend the Rust test harness to support tiered store configurations and
add integration coverage for routing data across primary, backup, and
ephemeral stores.

This introduces tier-store-aware test helpers, including support for
configuring separate stores per node and inspecting persisted data across
native and UniFFI-enabled test builds.

Add an integration test covering the tiered-storage channel lifecycle and
verifying that:
- durable node data is persisted to both the primary and backup stores
- ephemeral-routed data is stored in the ephemeral tier
- ephemeral data is not mirrored back into the durable tiers

Also update existing Rust test call sites and benchmark helpers to match
the new tier-store-aware setup APIs.

Author: enigbe

benches/payments.rs

@@ -127,6 +127,7 @@ fn payment_benchmark(c: &mut Criterion) {
 		true,
 		false,
 		common::TestStoreType::Sqlite,
+		common::TestStoreType::Sqlite,
 	);
 
 	let runtime =

tests/common/mod.rs

@@ -326,10 +326,23 @@ pub(crate) enum TestChainSource<'a> {
 	BitcoindRestSync(&'a BitcoinD),
 }
 
-#[derive(Clone, Copy)]
+#[cfg(feature = "uniffi")]
+use ldk_node::FfiDynStoreTrait;
+
+#[cfg(feature = "uniffi")]
+type TestDynStore = Arc<dyn FfiDynStoreTrait>;
+#[cfg(not(feature = "uniffi"))]
+type TestDynStore = TestSyncStore;
+
+#[derive(Clone)]
 pub(crate) enum TestStoreType {
 	TestSyncStore,
 	Sqlite,
+	TierStore {
+		primary: TestDynStore,
+		backup: Option<TestDynStore>,
+		ephemeral: Option<TestDynStore>,
+	},
 }
 
 impl Default for TestStoreType {
@@ -380,6 +393,27 @@ macro_rules! setup_builder {
 
 pub(crate) use setup_builder;
 
+pub(crate) fn create_tier_stores(base_path: PathBuf) -> (TestDynStore, TestDynStore, TestDynStore) {
+	let primary = TestSyncStore::new(base_path.join("primary"));
+	let backup = TestSyncStore::new(base_path.join("backup"));
+	let ephemeral = TestSyncStore::new(base_path.join("ephemeral"));
+
+	#[cfg(feature = "uniffi")]
+	{
+		use ldk_node::DynStoreWrapper;
+
+		(
+			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"))]
+	{
+		(primary, backup, ephemeral)
+	}
+}
+
 pub(crate) fn setup_two_nodes(
 	chain_source: &TestChainSource, allow_0conf: bool, anchor_channels: bool,
 	anchors_trusted_no_reserve: bool,
@@ -390,21 +424,22 @@ pub(crate) fn setup_two_nodes(
 		anchor_channels,
 		anchors_trusted_no_reserve,
 		TestStoreType::TestSyncStore,
+		TestStoreType::TestSyncStore,
 	)
 }
 
 pub(crate) fn setup_two_nodes_with_store(
 	chain_source: &TestChainSource, allow_0conf: bool, anchor_channels: bool,
-	anchors_trusted_no_reserve: bool, store_type: TestStoreType,
+	anchors_trusted_no_reserve: bool, store_type_a: TestStoreType, store_type_b: TestStoreType,
 ) -> (TestNode, TestNode) {
 	println!("== Node A ==");
 	let mut config_a = random_config(anchor_channels);
-	config_a.store_type = store_type;
+	config_a.store_type = store_type_a;
 	let node_a = setup_node(chain_source, config_a);
 
 	println!("\n== Node B ==");
 	let mut config_b = random_config(anchor_channels);
-	config_b.store_type = store_type;
+	config_b.store_type = store_type_b;
 	if allow_0conf {
 		config_b.node_config.trusted_peers_0conf.push(node_a.node_id());
 	}
@@ -484,9 +519,53 @@ pub(crate) fn setup_node(chain_source: &TestChainSource, config: TestConfig) ->
 	let node = match config.store_type {
 		TestStoreType::TestSyncStore => {
 			let kv_store = TestSyncStore::new(config.node_config.storage_dir_path.into());
-			builder.build_with_store(config.node_entropy.into(), kv_store).unwrap()
+			#[cfg(feature = "uniffi")]
+			{
+				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"))]
+			{
+				builder.build_with_store(config.node_entropy, kv_store).unwrap()
+			}
 		},
 		TestStoreType::Sqlite => builder.build(config.node_entropy.into()).unwrap(),
+		TestStoreType::TierStore { primary, backup, ephemeral } => {
+			if let Some(backup) = backup {
+				#[cfg(feature = "uniffi")]
+				{
+					builder.set_backup_store(backup);
+				}
+				#[cfg(not(feature = "uniffi"))]
+				{
+					use ldk_node::{DynStore, DynStoreWrapper};
+					let store: Arc<DynStore> = Arc::new(DynStoreWrapper(backup));
+					builder.set_backup_store(store);
+				}
+			}
+			if let Some(ephemeral) = ephemeral {
+				#[cfg(feature = "uniffi")]
+				{
+					builder.set_ephemeral_store(ephemeral);
+				}
+				#[cfg(not(feature = "uniffi"))]
+				{
+					use ldk_node::{DynStore, DynStoreWrapper};
+					let store: Arc<DynStore> = Arc::new(DynStoreWrapper(ephemeral));
+					builder.set_ephemeral_store(store);
+				}
+			}
+			#[cfg(feature = "uniffi")]
+			{
+				builder.build_with_store(config.node_entropy.into(), primary).unwrap()
+			}
+			#[cfg(not(feature = "uniffi"))]
+			{
+				builder.build_with_store(config.node_entropy, primary).unwrap()
+			}
+		},
 	};
 
 	if config.recovery_mode {
@@ -1709,3 +1788,36 @@ impl TestSyncStoreInner {
 		self.do_list(primary_namespace, secondary_namespace)
 	}
 }
+
+pub fn test_kv_read(
+	store: &TestDynStore, primary_ns: &str, secondary_ns: &str, key: &str,
+) -> Result<Vec<u8>, bitcoin::io::Error> {
+	#[cfg(feature = "uniffi")]
+	{
+		ldk_node::FfiDynStoreTrait::read(
+			&**store,
+			primary_ns.to_string(),
+			secondary_ns.to_string(),
+			key.to_string(),
+		)
+		.map_err(Into::into)
+	}
+	#[cfg(not(feature = "uniffi"))]
+	{
+		KVStoreSync::read(store, primary_ns, secondary_ns, key)
+	}
+}
+
+pub fn test_kv_list(
+	store: &TestDynStore, primary_ns: &str, secondary_ns: &str,
+) -> Result<Vec<String>, bitcoin::io::Error> {
+	#[cfg(feature = "uniffi")]
+	{
+		ldk_node::FfiDynStoreTrait::list(&**store, primary_ns.to_string(), secondary_ns.to_string())
+			.map_err(Into::into)
+	}
+	#[cfg(not(feature = "uniffi"))]
+	{
+		KVStoreSync::list(store, primary_ns, secondary_ns)
+	}
+}

tests/integration_tests_rust.rs

@@ -17,14 +17,15 @@ use bitcoin::hashes::Hash;
 use bitcoin::{Address, Amount, ScriptBuf, Txid};
 use common::logging::{init_log_logger, validate_log_entry, MultiNodeLogger, TestLogWriter};
 use common::{
-	bump_fee_and_broadcast, distribute_funds_unconfirmed, do_channel_full_cycle,
-	expect_channel_pending_event, expect_channel_ready_event, expect_channel_ready_events,
-	expect_event, expect_payment_claimable_event, expect_payment_received_event,
-	expect_payment_successful_event, expect_splice_pending_event, generate_blocks_and_wait,
-	generate_listening_addresses, open_channel, open_channel_push_amt, open_channel_with_all,
-	premine_and_distribute_funds, premine_blocks, prepare_rbf, random_chain_source, random_config,
-	setup_bitcoind_and_electrsd, setup_builder, setup_node, setup_two_nodes, splice_in_with_all,
-	wait_for_tx, TestChainSource, TestStoreType, TestSyncStore,
+	bump_fee_and_broadcast, create_tier_stores, distribute_funds_unconfirmed,
+	do_channel_full_cycle, expect_channel_pending_event, expect_channel_ready_event,
+	expect_channel_ready_events, expect_event, expect_payment_claimable_event,
+	expect_payment_received_event, expect_payment_successful_event, expect_splice_pending_event,
+	generate_blocks_and_wait, generate_listening_addresses, open_channel, open_channel_push_amt,
+	open_channel_with_all, premine_and_distribute_funds, premine_blocks, prepare_rbf,
+	random_chain_source, random_config, random_storage_path, setup_bitcoind_and_electrsd,
+	setup_builder, setup_node, setup_two_nodes, setup_two_nodes_with_store, splice_in_with_all,
+	test_kv_list, test_kv_read, wait_for_tx, TestChainSource, TestStoreType, TestSyncStore,
 };
 use electrsd::corepc_node::Node as BitcoinD;
 use electrsd::ElectrsD;
@@ -39,6 +40,11 @@ use ldk_node::{Builder, Event, NodeError};
 use lightning::ln::channelmanager::PaymentId;
 use lightning::routing::gossip::{NodeAlias, NodeId};
 use lightning::routing::router::RouteParametersConfig;
+use lightning::util::persist::{
+	CHANNEL_MANAGER_PERSISTENCE_KEY, CHANNEL_MANAGER_PERSISTENCE_PRIMARY_NAMESPACE,
+	CHANNEL_MANAGER_PERSISTENCE_SECONDARY_NAMESPACE, NETWORK_GRAPH_PERSISTENCE_KEY,
+	NETWORK_GRAPH_PERSISTENCE_PRIMARY_NAMESPACE, NETWORK_GRAPH_PERSISTENCE_SECONDARY_NAMESPACE,
+};
 use lightning_invoice::{Bolt11InvoiceDescription, Description};
 use lightning_types::payment::{PaymentHash, PaymentPreimage};
 use log::LevelFilter;
@@ -52,6 +58,106 @@ async fn channel_full_cycle() {
 		.await;
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+async fn channel_full_cycle_tier_store() {
+	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
+	let chain_source = random_chain_source(&bitcoind, &electrsd);
+	let (primary_a, backup_a, ephemeral_a) = create_tier_stores(random_storage_path());
+	let (primary_b, backup_b, ephemeral_b) = create_tier_stores(random_storage_path());
+
+	let (node_a, node_b) = setup_two_nodes_with_store(
+		&chain_source,
+		false,
+		true,
+		false,
+		TestStoreType::TierStore {
+			primary: primary_a.clone(),
+			backup: Some(backup_a.clone()),
+			ephemeral: Some(ephemeral_a.clone()),
+		},
+		TestStoreType::TierStore {
+			primary: primary_b,
+			backup: Some(backup_b),
+			ephemeral: Some(ephemeral_b),
+		},
+	);
+	do_channel_full_cycle(node_a, node_b, &bitcoind.client, &electrsd.client, false, true, false)
+		.await;
+
+	// Verify primary and backup both contain the same channel manager data.
+	let primary_channel_manager = test_kv_read(
+		&(primary_a.clone()),
+		CHANNEL_MANAGER_PERSISTENCE_PRIMARY_NAMESPACE,
+		CHANNEL_MANAGER_PERSISTENCE_SECONDARY_NAMESPACE,
+		CHANNEL_MANAGER_PERSISTENCE_KEY,
+	)
+	.expect("Primary should have channel manager data");
+	let backup_channel_manager = test_kv_read(
+		&(backup_a.clone()),
+		CHANNEL_MANAGER_PERSISTENCE_PRIMARY_NAMESPACE,
+		CHANNEL_MANAGER_PERSISTENCE_SECONDARY_NAMESPACE,
+		CHANNEL_MANAGER_PERSISTENCE_KEY,
+	)
+	.expect("Backup should have channel manager data");
+	assert_eq!(
+		primary_channel_manager, backup_channel_manager,
+		"Primary and backup should store identical channel manager data"
+	);
+
+	// Verify payment data is persisted in both primary and backup stores.
+	let primary_payments =
+		test_kv_list(&(primary_a.clone()), "payments", "").expect("Primary should list payments");
+	assert!(
+		!primary_payments.is_empty(),
+		"Primary should have payment entries after the full cycle"
+	);
+
+	let backup_payments =
+		test_kv_list(&(backup_a.clone()), "payments", "").expect("Backup should list payments");
+	assert!(!backup_payments.is_empty(), "Backup should have payment entries after the full cycle");
+
+	// Verify ephemeral store does not contain primary-backed critical data.
+	let ephemeral_channel_manager = test_kv_read(
+		&(ephemeral_a.clone()),
+		CHANNEL_MANAGER_PERSISTENCE_PRIMARY_NAMESPACE,
+		CHANNEL_MANAGER_PERSISTENCE_SECONDARY_NAMESPACE,
+		CHANNEL_MANAGER_PERSISTENCE_KEY,
+	);
+	assert!(ephemeral_channel_manager.is_err(), "Ephemeral should not have channel manager data");
+
+	let ephemeral_payments = test_kv_list(&(ephemeral_a.clone()), "payments", "");
+	assert!(
+		ephemeral_payments.is_err() || ephemeral_payments.unwrap().is_empty(),
+		"Ephemeral should not have payment data"
+	);
+
+	// Verify ephemeral-routed data is stored in the ephemeral store.
+	let ephemeral_network_graph = test_kv_read(
+		&(ephemeral_a.clone()),
+		NETWORK_GRAPH_PERSISTENCE_PRIMARY_NAMESPACE,
+		NETWORK_GRAPH_PERSISTENCE_SECONDARY_NAMESPACE,
+		NETWORK_GRAPH_PERSISTENCE_KEY,
+	);
+	assert!(ephemeral_network_graph.is_ok(), "Ephemeral should have network graph data");
+
+	// Verify ephemeral-routed data is not mirrored to primary or backup stores.
+	let primary_network_graph = test_kv_read(
+		&(primary_a.clone()),
+		NETWORK_GRAPH_PERSISTENCE_PRIMARY_NAMESPACE,
+		NETWORK_GRAPH_PERSISTENCE_SECONDARY_NAMESPACE,
+		NETWORK_GRAPH_PERSISTENCE_KEY,
+	);
+	assert!(primary_network_graph.is_err(), "Primary should not have ephemeral network graph data");
+
+	let backup_network_graph = test_kv_read(
+		&(backup_a.clone()),
+		NETWORK_GRAPH_PERSISTENCE_PRIMARY_NAMESPACE,
+		NETWORK_GRAPH_PERSISTENCE_SECONDARY_NAMESPACE,
+		NETWORK_GRAPH_PERSISTENCE_KEY,
+	);
+	assert!(backup_network_graph.is_err(), "Backup should not have ephemeral network graph data");
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 async fn channel_full_cycle_force_close() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
@@ -237,8 +343,20 @@ async fn start_stop_reinit() {
 	setup_builder!(builder, config.node_config);
 	builder.set_chain_source_esplora(esplora_url.clone(), Some(sync_config));
 
-	let node =
-		builder.build_with_store(config.node_entropy.into(), test_sync_store.clone()).unwrap();
+	let node;
+	#[cfg(feature = "uniffi")]
+	{
+		use ldk_node::{DynStoreWrapper, FfiDynStoreTrait};
+
+		let test_sync_store: Arc<dyn FfiDynStoreTrait> =
+			Arc::new(DynStoreWrapper(test_sync_store.clone()));
+
+		node = builder.build_with_store(config.node_entropy.into(), test_sync_store).unwrap();
+	}
+	#[cfg(not(feature = "uniffi"))]
+	{
+		node = builder.build_with_store(config.node_entropy, test_sync_store.clone()).unwrap();
+	}
 	node.start().unwrap();
 
 	let expected_node_id = node.node_id();
@@ -276,8 +394,21 @@ async fn start_stop_reinit() {
 	setup_builder!(builder, config.node_config);
 	builder.set_chain_source_esplora(esplora_url.clone(), Some(sync_config));
 
-	let reinitialized_node =
-		builder.build_with_store(config.node_entropy.into(), test_sync_store).unwrap();
+	let reinitialized_node;
+	#[cfg(feature = "uniffi")]
+	{
+		use ldk_node::{DynStoreWrapper, FfiDynStoreTrait};
+
+		let test_sync_store: Arc<dyn FfiDynStoreTrait> = Arc::new(DynStoreWrapper(test_sync_store));
+
+		reinitialized_node =
+			builder.build_with_store(config.node_entropy.into(), test_sync_store).unwrap();
+	}
+	#[cfg(not(feature = "uniffi"))]
+	{
+		reinitialized_node =
+			builder.build_with_store(config.node_entropy, test_sync_store).unwrap();
+	}
 	reinitialized_node.start().unwrap();
 	assert_eq!(reinitialized_node.node_id(), expected_node_id);