refactor(dash-spv): Building storage from config

dash-spv-ffi/src/client.rs

@@ -147,35 +147,12 @@ pub unsafe extern "C" fn dash_spv_ffi_client_new(
         }
     };
 
-    let mut client_config = config.clone_inner();
-
-    let storage_path = client_config.storage_path.clone().unwrap_or_else(|| {
-        // Create a unique temporary directory if none was provided
-        static PATH_COUNTER: AtomicU64 = AtomicU64::new(0);
-
-        let mut path = std::env::temp_dir();
-        path.push("dash-spv");
-        path.push(
-            format!(
-                "{:?}-{}-{}",
-                client_config.network,
-                std::process::id(),
-                PATH_COUNTER.fetch_add(1, Ordering::Relaxed)
-            )
-            .to_lowercase(),
-        );
-        tracing::warn!(
-            "dash-spv FFI config missing storage path, falling back to temp dir {:?}",
-            path
-        );
-        path
-    });
-    client_config.storage_path = Some(storage_path.clone());
+    let client_config = config.clone_inner();
 
     let client_result = runtime.block_on(async move {
         // Construct concrete implementations for generics
         let network = dash_spv::network::PeerNetworkManager::new(&client_config).await;
-        let storage = DiskStorageManager::new(storage_path.clone()).await;
+        let storage = DiskStorageManager::new(&client_config).await;
         let wallet = key_wallet_manager::wallet_manager::WalletManager::<
             key_wallet::wallet::managed_wallet_info::ManagedWalletInfo,
         >::new(client_config.network);

dash-spv-ffi/src/config.rs

@@ -77,7 +77,7 @@ pub unsafe extern "C" fn dash_spv_ffi_config_set_data_dir(
     let config = unsafe { &mut *((*config).inner as *mut ClientConfig) };
     match CStr::from_ptr(path).to_str() {
         Ok(path_str) => {
-            config.storage_path = Some(path_str.into());
+            config.storage_path = path_str.into();
             FFIErrorCode::Success as i32
         }
         Err(e) => {
@@ -331,13 +331,7 @@ pub unsafe extern "C" fn dash_spv_ffi_config_get_data_dir(
     }
 
     let config = unsafe { &*((*config).inner as *const ClientConfig) };
-    match &config.storage_path {
-        Some(dir) => FFIString::new(&dir.to_string_lossy()),
-        None => FFIString {
-            ptr: std::ptr::null_mut(),
-            length: 0,
-        },
-    }
+    FFIString::new(&config.storage_path.to_string_lossy())
 }
 
 /// Destroys an FFIClientConfig and frees its memory

dash-spv-ffi/tests/test_wallet_manager.rs

@@ -11,7 +11,8 @@ mod tests {
         FFIError, FFINetwork, FFIWalletManager,
     };
     use key_wallet_manager::wallet_manager::WalletManager;
-    use std::ffi::CStr;
+    use std::ffi::{CStr, CString};
+    use tempfile::TempDir;
 
     #[test]
     fn test_get_wallet_manager() {
@@ -20,6 +21,12 @@ mod tests {
             let config = dash_spv_ffi_config_testnet();
             assert!(!config.is_null());
 
+            let temp_dir = TempDir::new().unwrap();
+            dash_spv_ffi_config_set_data_dir(
+                config,
+                CString::new(temp_dir.path().to_str().unwrap()).unwrap().as_ptr(),
+            );
+
             // Create a client
             let client = dash_spv_ffi_client_new(config);
             assert!(!client.is_null());
@@ -51,6 +58,12 @@ mod tests {
             let config = dash_spv_ffi_config_testnet();
             assert!(!config.is_null());
 
+            let temp_dir = TempDir::new().unwrap();
+            dash_spv_ffi_config_set_data_dir(
+                config,
+                CString::new(temp_dir.path().to_str().unwrap()).unwrap().as_ptr(),
+            );
+
             let client = dash_spv_ffi_client_new(config);
             assert!(!client.is_null());
 

dash-spv/benches/storage.rs

@@ -3,7 +3,7 @@ use std::time::Duration;
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use dash_spv::{
     storage::{BlockHeaderStorage, DiskStorageManager, StorageManager},
-    Hash,
+    ClientConfig, Hash,
 };
 use dashcore::{block::Version, BlockHash, CompactTarget, Header};
 use rand::{rngs::StdRng, Rng, SeedableRng};
@@ -34,7 +34,9 @@ fn bench_disk_storage(c: &mut Criterion) {
     c.bench_function("storage/disk/store", |b| {
         b.to_async(&rt).iter_batched(
             || async {
-                DiskStorageManager::new(TempDir::new().unwrap().path().to_path_buf()).await.unwrap()
+                let config =
+                    ClientConfig::testnet().with_storage_path(TempDir::new().unwrap().path());
+                DiskStorageManager::new(&config).await.unwrap()
             },
             |a| async {
                 let mut storage = a.await;
@@ -47,10 +49,10 @@ fn bench_disk_storage(c: &mut Criterion) {
         )
     });
 
-    let temp_dir = TempDir::new().unwrap();
+    let config = ClientConfig::testnet().with_storage_path(TempDir::new().unwrap().path());
 
     let mut storage = rt.block_on(async {
-        let mut storage = DiskStorageManager::new(temp_dir.path().to_path_buf()).await.unwrap();
+        let mut storage = DiskStorageManager::new(&config).await.unwrap();
 
         for chunk in headers.chunks(CHUNK_SIZE as usize) {
             storage.store_headers(chunk).await.unwrap();

dash-spv/examples/filter_sync.rs

@@ -22,13 +22,15 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     )?;
 
     // Create configuration with filter support
-    let config = ClientConfig::mainnet().without_masternodes(); // Skip masternode sync for this example
+    let config = ClientConfig::mainnet()
+        .with_storage_path("./.tmp/filter-sync-example-storage")
+        .without_masternodes(); // Skip masternode sync for this example
 
     // Create network manager
     let network_manager = PeerNetworkManager::new(&config).await?;
 
     // Create storage manager
-    let storage_manager = DiskStorageManager::new("./.tmp/filter-sync-example-storage").await?;
+    let storage_manager = DiskStorageManager::new(&config).await?;
 
     // Create wallet manager
     let wallet = Arc::new(RwLock::new(WalletManager::<ManagedWalletInfo>::new(config.network)));

dash-spv/examples/simple_sync.rs

@@ -17,14 +17,15 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // Create a simple configuration
     let config = ClientConfig::mainnet()
+        .with_storage_path("./.tmp/simple-sync-example-storage")
         .without_filters() // Skip filter sync for this example
         .without_masternodes(); // Skip masternode sync for this example
 
     // Create network manager
     let network_manager = PeerNetworkManager::new(&config).await?;
 
     // Create storage manager
-    let storage_manager = DiskStorageManager::new("./.tmp/simple-sync-example-storage").await?;
+    let storage_manager = DiskStorageManager::new(&config).await?;
 
     // Create wallet manager
     let wallet = Arc::new(RwLock::new(WalletManager::<ManagedWalletInfo>::new(config.network)));

dash-spv/examples/spv_with_wallet.rs

@@ -17,16 +17,15 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let _logging_guard = dash_spv::init_console_logging(LevelFilter::INFO)?;
 
     // Create SPV client configuration
-    let mut config = ClientConfig::testnet();
-    config.storage_path = Some("/tmp/dash-spv-example".into());
-    config.validation_mode = dash_spv::types::ValidationMode::Full;
-    config.enable_filters = true;
+    let config = ClientConfig::testnet()
+        .with_storage_path("./.tmp/spv-with-wallet-example-storage")
+        .with_validation_mode(dash_spv::ValidationMode::Full);
 
     // Create network manager
     let network_manager = PeerNetworkManager::new(&config).await?;
 
     // Create storage manager - use disk storage for persistence
-    let storage_manager = DiskStorageManager::new("./.tmp/spv-with-wallet-example-storage").await?;
+    let storage_manager = DiskStorageManager::new(&config).await?;
 
     // Create wallet manager
     let wallet = Arc::new(RwLock::new(WalletManager::<ManagedWalletInfo>::new(config.network)));

dash-spv/src/client/config.rs

@@ -34,8 +34,8 @@ pub struct ClientConfig {
     /// If no peers are configured, no outbound connections will be made.
     pub restrict_to_configured_peers: bool,
 
-    /// Optional path for persistent storage.
-    pub storage_path: Option<PathBuf>,
+    /// Path for persistent storage. Defaults to ./dash-spv-storage
+    pub storage_path: PathBuf,
 
     /// Validation mode.
     pub validation_mode: ValidationMode,
@@ -80,7 +80,7 @@ impl Default for ClientConfig {
             network: Network::Dash,
             peers: vec![],
             restrict_to_configured_peers: false,
-            storage_path: None,
+            storage_path: PathBuf::from("./dash-spv-storage"),
             validation_mode: ValidationMode::Full,
             enable_filters: true,
             enable_masternodes: true,
@@ -136,8 +136,8 @@ impl ClientConfig {
     }
 
     /// Set storage path.
-    pub fn with_storage_path(mut self, path: PathBuf) -> Self {
-        self.storage_path = Some(path);
+    pub fn with_storage_path(mut self, path: impl Into<PathBuf>) -> Self {
+        self.storage_path = path.into();
         self
     }
 
@@ -206,6 +206,13 @@ impl ClientConfig {
             );
         }
 
+        std::fs::create_dir_all(&self.storage_path).map_err(|e| {
+            format!(
+                "A valid storage path must be provided to the ClientConfig {:?}: {e}",
+                self.storage_path
+            )
+        })?;
+
         Ok(())
     }
 

dash-spv/src/client/config_test.rs

@@ -55,7 +55,7 @@ mod tests {
             .with_mempool_persistence(true)
             .with_start_height(100000);
 
-        assert_eq!(config.storage_path, Some(path));
+        assert_eq!(config.storage_path, path);
         assert_eq!(config.validation_mode, ValidationMode::Basic);
 
         // Mempool settings
@@ -88,12 +88,6 @@ mod tests {
         assert!(!config.enable_masternodes);
     }
 
-    #[test]
-    fn test_validation_valid_config() {
-        let config = ClientConfig::default();
-        assert!(config.validate().is_ok());
-    }
-
     #[test]
     fn test_validation_invalid_max_peers() {
         let config = ClientConfig {

dash-spv/src/client/mod.rs

@@ -64,12 +64,14 @@ mod message_handler_test;
 #[cfg(test)]
 mod tests {
     use super::{ClientConfig, DashSpvClient};
+    use crate::client::config::MempoolStrategy;
     use crate::storage::DiskStorageManager;
     use crate::{test_utils::MockNetworkManager, types::UnconfirmedTransaction};
-    use dashcore::{Address, Amount, Network, Transaction, TxOut};
+    use dashcore::{Address, Amount, Transaction, TxOut};
     use key_wallet::wallet::managed_wallet_info::ManagedWalletInfo;
     use key_wallet_manager::wallet_manager::WalletManager;
     use std::sync::Arc;
+    use tempfile::TempDir;
     use tokio::sync::RwLock;
 
     // Tests for get_mempool_balance function
@@ -80,13 +82,11 @@ mod tests {
 
     #[tokio::test]
     async fn client_exposes_shared_wallet_manager() {
-        let config = ClientConfig {
-            network: Network::Dash,
-            enable_filters: false,
-            enable_masternodes: false,
-            enable_mempool_tracking: false,
-            ..Default::default()
-        };
+        let config = ClientConfig::mainnet()
+            .without_filters()
+            .without_masternodes()
+            .with_mempool_tracking(MempoolStrategy::FetchAll)
+            .with_storage_path(TempDir::new().unwrap().path());
 
         let network_manager = MockNetworkManager::new();
         let storage =
@@ -108,17 +108,14 @@ mod tests {
         // This test validates the get_mempool_balance logic by directly testing
         // the balance calculation code using a mocked mempool state.
 
-        let config = ClientConfig {
-            network: Network::Testnet,
-            enable_filters: false,
-            enable_masternodes: false,
-            enable_mempool_tracking: true,
-            ..Default::default()
-        };
+        let config = ClientConfig::testnet()
+            .without_filters()
+            .without_masternodes()
+            .with_mempool_tracking(MempoolStrategy::FetchAll)
+            .with_storage_path(TempDir::new().unwrap().path());
 
         let network_manager = MockNetworkManager::new();
-        let storage =
-            DiskStorageManager::with_temp_dir().await.expect("Failed to create tmp storage");
+        let storage = DiskStorageManager::new(&config).await.expect("Failed to create tmp storage");
         let wallet = Arc::new(RwLock::new(WalletManager::<ManagedWalletInfo>::new(config.network)));
 
         let test_address = Address::dummy(config.network, 0);

dash-spv/src/lib.rs

@@ -26,11 +26,11 @@
 //! async fn main() -> Result<(), Box<dyn std::error::Error>> {
 //!     // Create configuration for mainnet
 //!     let config = ClientConfig::mainnet()
-//!         .with_storage_path("/path/to/data".into());
+//!         .with_storage_path("./.tmp/example-storage");
 //!
 //!     // Create the required components
 //!     let network = PeerNetworkManager::new(&config).await?;
-//!     let storage = DiskStorageManager::new("./.tmp/example-storage").await?;
+//!     let storage = DiskStorageManager::new(&config).await?;
 //!     let wallet = Arc::new(RwLock::new(WalletManager::<ManagedWalletInfo>::new(config.network)));
 //!
 //!     // Create and start the client

dash-spv/src/main.rs

@@ -320,13 +320,7 @@ async fn run() -> Result<(), Box<dyn std::error::Error>> {
         }
     };
 
-    let path = if let Some(path) = &config.storage_path {
-        path.clone()
-    } else {
-        "./.tmp/main-exec-storage".into()
-    };
-
-    let storage_manager = match dash_spv::storage::DiskStorageManager::new(path.clone()).await {
+    let storage_manager = match dash_spv::storage::DiskStorageManager::new(&config).await {
         Ok(sm) => sm,
         Err(e) => {
             eprintln!("Failed to create disk storage manager: {}", e);

dash-spv/src/network/manager.rs

@@ -76,7 +76,7 @@ impl PeerNetworkManager {
     /// Create a new peer network manager
     pub async fn new(config: &ClientConfig) -> Result<Self, Error> {
         let discovery = DnsDiscovery::new().await?;
-        let data_dir = config.storage_path.clone().unwrap_or_else(|| PathBuf::from("."));
+        let data_dir = config.storage_path.clone();
 
         let peer_store = PersistentPeerStorage::open(data_dir.clone()).await?;