Gate SQLite behind a default feature flag

Make rusqlite an optional dependency behind the new "sqlite"
feature, which is enabled by default. This allows users who
use an alternative storage backend to avoid compiling the
bundled SQLite C library.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: benthecarman

Cargo.toml

@@ -24,7 +24,8 @@ codegen-units = 1   # Reduce number of codegen units to increase optimizations.
 panic = 'abort'     # Abort on panic
 
 [features]
-default = []
+default = ["sqlite"]
+sqlite = ["dep:rusqlite"]
 
 [dependencies]
 #lightning = { version = "0.2.0", features = ["std"] }
@@ -58,7 +59,7 @@ bdk_wallet = { version = "2.3.0", default-features = false, features = ["std", "
 
 bitreq = { version = "0.3", default-features = false, features = ["async-https", "json-using-serde"] }
 rustls = { version = "0.23", default-features = false }
-rusqlite = { version = "0.31.0", features = ["bundled"] }
+rusqlite = { version = "0.31.0", features = ["bundled"], optional = true }
 bitcoin = "0.32.7"
 bip39 = { version = "2.0.0", features = ["rand"] }
 bip21 = { version = "0.5", features = ["std"], default-features = false }

src/builder.rs

@@ -53,6 +53,9 @@ use crate::entropy::NodeEntropy;
 use crate::event::EventQueue;
 use crate::fee_estimator::OnchainFeeEstimator;
 use crate::gossip::GossipSource;
+#[cfg(feature = "sqlite")]
+use crate::io;
+#[cfg(feature = "sqlite")]
 use crate::io::sqlite_store::SqliteStore;
 use crate::io::utils::{
 	read_event_queue, read_external_pathfinding_scores_from_cache, read_network_graph,
@@ -61,7 +64,7 @@ use crate::io::utils::{
 };
 use crate::io::vss_store::VssStoreBuilder;
 use crate::io::{
-	self, PAYMENT_INFO_PERSISTENCE_PRIMARY_NAMESPACE, PAYMENT_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
+	PAYMENT_INFO_PERSISTENCE_PRIMARY_NAMESPACE, PAYMENT_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 	PENDING_PAYMENT_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 	PENDING_PAYMENT_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 };
@@ -616,6 +619,7 @@ impl NodeBuilder {
 
 	/// Builds a [`Node`] instance with a [`SqliteStore`] backend and according to the options
 	/// previously configured.
+	#[cfg(feature = "sqlite")]
 	pub fn build(&self, node_entropy: NodeEntropy) -> Result<Node, BuildError> {
 		let storage_dir_path = self.config.storage_dir_path.clone();
 		fs::create_dir_all(storage_dir_path.clone())
@@ -1083,6 +1087,7 @@ impl ArcedNodeBuilder {
 
 	/// Builds a [`Node`] instance with a [`SqliteStore`] backend and according to the options
 	/// previously configured.
+	#[cfg(feature = "sqlite")]
 	pub fn build(&self, node_entropy: Arc<NodeEntropy>) -> Result<Arc<Node>, BuildError> {
 		self.inner.read().unwrap().build(*node_entropy).map(Arc::new)
 	}

src/io/mod.rs

@@ -7,6 +7,7 @@
 
 //! Objects and traits for data persistence.
 
+#[cfg(feature = "sqlite")]
 pub mod sqlite_store;
 #[cfg(test)]
 pub(crate) mod test_utils;

tests/common/mod.rs

@@ -29,6 +29,7 @@ use electrsd::{corepc_node, ElectrsD};
 use electrum_client::ElectrumApi;
 use ldk_node::config::{AsyncPaymentsRole, Config, ElectrumSyncConfig, EsploraSyncConfig};
 use ldk_node::entropy::{generate_entropy_mnemonic, NodeEntropy};
+#[cfg(feature = "sqlite")]
 use ldk_node::io::sqlite_store::SqliteStore;
 use ldk_node::payment::{PaymentDirection, PaymentKind, PaymentStatus};
 use ldk_node::{
@@ -329,6 +330,7 @@ pub(crate) enum TestChainSource<'a> {
 #[derive(Clone, Copy)]
 pub(crate) enum TestStoreType {
 	TestSyncStore,
+	#[cfg(feature = "sqlite")]
 	Sqlite,
 }
 
@@ -486,6 +488,7 @@ pub(crate) fn setup_node(chain_source: &TestChainSource, config: TestConfig) ->
 			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 = "sqlite")]
 		TestStoreType::Sqlite => builder.build(config.node_entropy.into()).unwrap(),
 	};
 
@@ -1519,6 +1522,7 @@ struct TestSyncStoreInner {
 	serializer: RwLock<()>,
 	test_store: TestStore,
 	fs_store: FilesystemStore,
+	#[cfg(feature = "sqlite")]
 	sqlite_store: SqliteStore,
 }
 
@@ -1528,33 +1532,46 @@ impl TestSyncStoreInner {
 		let mut fs_dir = dest_dir.clone();
 		fs_dir.push("fs_store");
 		let fs_store = FilesystemStore::new(fs_dir);
+		#[cfg(feature = "sqlite")]
 		let mut sql_dir = dest_dir.clone();
+		#[cfg(feature = "sqlite")]
 		sql_dir.push("sqlite_store");
+		#[cfg(feature = "sqlite")]
 		let sqlite_store = SqliteStore::new(
 			sql_dir,
 			Some("test_sync_db".to_string()),
 			Some("test_sync_table".to_string()),
 		)
 		.unwrap();
 		let test_store = TestStore::new(false);
-		Self { serializer, fs_store, sqlite_store, test_store }
+		#[cfg(feature = "sqlite")]
+		{
+			return Self { serializer, fs_store, sqlite_store, test_store };
+		}
+		#[cfg(not(feature = "sqlite"))]
+		{
+			Self { serializer, fs_store, test_store }
+		}
 	}
 
 	fn do_list(
 		&self, primary_namespace: &str, secondary_namespace: &str,
 	) -> lightning::io::Result<Vec<String>> {
 		let fs_res = KVStoreSync::list(&self.fs_store, primary_namespace, secondary_namespace);
-		let sqlite_res =
-			KVStoreSync::list(&self.sqlite_store, primary_namespace, secondary_namespace);
+		#[cfg(feature = "sqlite")]
+		let sqlite_res = KVStoreSync::list(&self.sqlite_store, primary_namespace, secondary_namespace);
 		let test_res = KVStoreSync::list(&self.test_store, primary_namespace, secondary_namespace);
 
 		match fs_res {
 			Ok(mut list) => {
 				list.sort();
 
-				let mut sqlite_list = sqlite_res.unwrap();
-				sqlite_list.sort();
-				assert_eq!(list, sqlite_list);
+				#[cfg(feature = "sqlite")]
+				{
+					let mut sqlite_list = sqlite_res.unwrap();
+					sqlite_list.sort();
+					assert_eq!(list, sqlite_list);
+				}
 
 				let mut test_list = test_res.unwrap();
 				test_list.sort();
@@ -1563,6 +1580,7 @@ impl TestSyncStoreInner {
 				Ok(list)
 			},
 			Err(e) => {
+				#[cfg(feature = "sqlite")]
 				assert!(sqlite_res.is_err());
 				assert!(test_res.is_err());
 				Err(e)
@@ -1576,20 +1594,25 @@ impl TestSyncStoreInner {
 		let _guard = self.serializer.read().unwrap();
 
 		let fs_res = KVStoreSync::read(&self.fs_store, primary_namespace, secondary_namespace, key);
+		#[cfg(feature = "sqlite")]
 		let sqlite_res =
 			KVStoreSync::read(&self.sqlite_store, primary_namespace, secondary_namespace, key);
 		let test_res =
 			KVStoreSync::read(&self.test_store, primary_namespace, secondary_namespace, key);
 
 		match fs_res {
 			Ok(read) => {
+				#[cfg(feature = "sqlite")]
 				assert_eq!(read, sqlite_res.unwrap());
 				assert_eq!(read, test_res.unwrap());
 				Ok(read)
 			},
 			Err(e) => {
-				assert!(sqlite_res.is_err());
-				assert_eq!(e.kind(), unsafe { sqlite_res.unwrap_err_unchecked().kind() });
+				#[cfg(feature = "sqlite")]
+				{
+					assert!(sqlite_res.is_err());
+					assert_eq!(e.kind(), unsafe { sqlite_res.unwrap_err_unchecked().kind() });
+				}
 				assert!(test_res.is_err());
 				assert_eq!(e.kind(), unsafe { test_res.unwrap_err_unchecked().kind() });
 				Err(e)
@@ -1608,6 +1631,7 @@ impl TestSyncStoreInner {
 			key,
 			buf.clone(),
 		);
+		#[cfg(feature = "sqlite")]
 		let sqlite_res = KVStoreSync::write(
 			&self.sqlite_store,
 			primary_namespace,
@@ -1630,11 +1654,13 @@ impl TestSyncStoreInner {
 
 		match fs_res {
 			Ok(()) => {
+				#[cfg(feature = "sqlite")]
 				assert!(sqlite_res.is_ok());
 				assert!(test_res.is_ok());
 				Ok(())
 			},
 			Err(e) => {
+				#[cfg(feature = "sqlite")]
 				assert!(sqlite_res.is_err());
 				assert!(test_res.is_err());
 				Err(e)
@@ -1648,6 +1674,7 @@ impl TestSyncStoreInner {
 		let _guard = self.serializer.write().unwrap();
 		let fs_res =
 			KVStoreSync::remove(&self.fs_store, primary_namespace, secondary_namespace, key, lazy);
+		#[cfg(feature = "sqlite")]
 		let sqlite_res = KVStoreSync::remove(
 			&self.sqlite_store,
 			primary_namespace,
@@ -1670,11 +1697,13 @@ impl TestSyncStoreInner {
 
 		match fs_res {
 			Ok(()) => {
+				#[cfg(feature = "sqlite")]
 				assert!(sqlite_res.is_ok());
 				assert!(test_res.is_ok());
 				Ok(())
 			},
 			Err(e) => {
+				#[cfg(feature = "sqlite")]
 				assert!(sqlite_res.is_err());
 				assert!(test_res.is_err());
 				Err(e)

tests/integration_tests_rust.rs

@@ -5,6 +5,8 @@
 // http://opensource.org/licenses/MIT>, at your option. You may not use this file except in
 // accordance with one or both of these licenses.
 
+#![cfg(feature = "sqlite")]
+
 mod common;
 
 use std::collections::HashSet;

tests/reorg_test.rs

@@ -1,3 +1,5 @@
+#![cfg(feature = "sqlite")]
+
 mod common;
 use std::collections::HashMap;