Merge branch 'v0.42-dev' into refactor/peer-persistence

Author: ZocoLini

dash-spv/src/client/config.rs

@@ -2,7 +2,6 @@
 
 use std::net::SocketAddr;
 use std::path::PathBuf;
-use std::time::Duration;
 
 use dashcore::Network;
 // Serialization removed due to complex Address types
@@ -41,21 +40,6 @@ pub struct ClientConfig {
     /// Validation mode.
     pub validation_mode: ValidationMode,
 
-    /// BIP157 filter checkpoint interval.
-    pub filter_checkpoint_interval: u32,
-
-    /// Maximum headers per message.
-    pub max_headers_per_message: u32,
-
-    /// Connection timeout.
-    pub connection_timeout: Duration,
-
-    /// Message timeout.
-    pub message_timeout: Duration,
-
-    /// Sync timeout.
-    pub sync_timeout: Duration,
-
     /// Whether to enable filter syncing.
     pub enable_filters: bool,
 
@@ -65,22 +49,13 @@ pub struct ClientConfig {
     /// Maximum number of peers to connect to.
     pub max_peers: u32,
 
-    /// Whether to persist state to disk.
-    pub enable_persistence: bool,
-
     /// Log level for tracing.
     pub log_level: String,
 
     /// Optional user agent string to advertise in the P2P version message.
     /// If not set, a sensible default is used (includes crate version).
     pub user_agent: Option<String>,
 
-    /// Maximum concurrent filter requests (default: 8).
-    pub max_concurrent_filter_requests: usize,
-
-    /// Delay between filter requests in milliseconds (default: 50).
-    pub filter_request_delay_ms: u64,
-
     // Mempool configuration
     /// Enable tracking of unconfirmed (mempool) transactions.
     pub enable_mempool_tracking: bool,
@@ -100,58 +75,13 @@ pub struct ClientConfig {
     /// Whether to persist mempool transactions.
     pub persist_mempool: bool,
 
-    // Request control configuration
-    /// Maximum concurrent header requests (default: 1).
-    pub max_concurrent_headers_requests: Option<usize>,
-
-    /// Maximum concurrent masternode list requests (default: 1).
-    pub max_concurrent_mnlist_requests: Option<usize>,
-
-    /// Maximum concurrent CF header requests (default: 1).
-    pub max_concurrent_cfheaders_requests: Option<usize>,
-
-    /// Maximum concurrent block requests (default: 5).
-    pub max_concurrent_block_requests: Option<usize>,
-
-    /// Rate limit for header requests per second (default: 10.0).
-    pub headers_request_rate_limit: Option<f64>,
-
-    /// Rate limit for masternode list requests per second (default: 5.0).
-    pub mnlist_request_rate_limit: Option<f64>,
-
-    /// Rate limit for CF header requests per second (default: 10.0).
-    pub cfheaders_request_rate_limit: Option<f64>,
-
-    // CFHeaders flow control configuration
-    /// Maximum concurrent CFHeaders requests for parallel sync (default: 50).
-    pub max_concurrent_cfheaders_requests_parallel: usize,
-
-    /// Timeout for CFHeaders requests in seconds (default: 30).
-    pub cfheaders_request_timeout_secs: u64,
-
-    /// Maximum retry attempts for failed CFHeaders batches (default: 3).
-    pub max_cfheaders_retries: u32,
-
-    /// Rate limit for filter requests per second (default: 50.0).
-    pub filters_request_rate_limit: Option<f64>,
-
-    /// Rate limit for block requests per second (default: 10.0).
-    pub blocks_request_rate_limit: Option<f64>,
-
     /// Start syncing from a specific block height.
     /// The client will use the nearest checkpoint at or before this height.
     pub start_from_height: Option<u32>,
 
     /// Wallet creation time as Unix timestamp.
     /// Used to determine appropriate checkpoint for sync.
     pub wallet_creation_time: Option<u32>,
-
-    // QRInfo configuration (simplified per plan)
-    /// Request extra share data in QRInfo (default: false per DMLviewer.patch).
-    pub qr_info_extra_share: bool,
-
-    /// Timeout for QRInfo requests (default: 30 seconds).
-    pub qr_info_timeout: Duration,
 }
 
 impl Default for ClientConfig {
@@ -162,45 +92,20 @@ impl Default for ClientConfig {
             restrict_to_configured_peers: false,
             storage_path: None,
             validation_mode: ValidationMode::Full,
-            filter_checkpoint_interval: 1000,
-            max_headers_per_message: 2000,
-            connection_timeout: Duration::from_secs(30),
-            message_timeout: Duration::from_secs(60),
-            sync_timeout: Duration::from_secs(300),
             enable_filters: true,
             enable_masternodes: true,
             max_peers: 8,
-            enable_persistence: true,
             log_level: "info".to_string(),
             user_agent: None,
-            max_concurrent_filter_requests: 16,
-            filter_request_delay_ms: 0,
             // Mempool defaults
             enable_mempool_tracking: true,
             mempool_strategy: MempoolStrategy::FetchAll,
             max_mempool_transactions: 1000,
             mempool_timeout_secs: 3600, // 1 hour
             fetch_mempool_transactions: true,
             persist_mempool: false,
-            // Request control defaults
-            max_concurrent_headers_requests: None,
-            max_concurrent_mnlist_requests: None,
-            max_concurrent_cfheaders_requests: None,
-            max_concurrent_block_requests: None,
-            headers_request_rate_limit: None,
-            mnlist_request_rate_limit: None,
-            cfheaders_request_rate_limit: None,
-            filters_request_rate_limit: None,
-            blocks_request_rate_limit: None,
             start_from_height: None,
             wallet_creation_time: None,
-            // CFHeaders flow control defaults
-            max_concurrent_cfheaders_requests_parallel: 50,
-            cfheaders_request_timeout_secs: 30,
-            max_cfheaders_retries: 3,
-            // QRInfo defaults (simplified per plan)
-            qr_info_extra_share: false, // Matches DMLviewer.patch default
-            qr_info_timeout: Duration::from_secs(30),
         }
     }
 }
@@ -246,7 +151,6 @@ impl ClientConfig {
     /// Set storage path.
     pub fn with_storage_path(mut self, path: PathBuf) -> Self {
         self.storage_path = Some(path);
-        self.enable_persistence = true;
         self
     }
 
@@ -268,12 +172,6 @@ impl ClientConfig {
         self
     }
 
-    /// Set connection timeout.
-    pub fn with_connection_timeout(mut self, timeout: Duration) -> Self {
-        self.connection_timeout = timeout;
-        self
-    }
-
     /// Set log level.
     pub fn with_log_level(mut self, level: &str) -> Self {
         self.log_level = level.to_string();
@@ -287,18 +185,6 @@ impl ClientConfig {
         self
     }
 
-    /// Set maximum concurrent filter requests.
-    pub fn with_max_concurrent_filter_requests(mut self, max_requests: usize) -> Self {
-        self.max_concurrent_filter_requests = max_requests;
-        self
-    }
-
-    /// Set delay between filter requests.
-    pub fn with_filter_request_delay(mut self, delay_ms: u64) -> Self {
-        self.filter_request_delay_ms = delay_ms;
-        self
-    }
-
     /// Enable mempool tracking with specified strategy.
     pub fn with_mempool_tracking(mut self, strategy: MempoolStrategy) -> Self {
         self.enable_mempool_tracking = true;
@@ -330,38 +216,14 @@ impl ClientConfig {
         self
     }
 
-    /// Set whether to request extra share data in QRInfo.
-    pub fn with_qr_info_extra_share(mut self, enabled: bool) -> Self {
-        self.qr_info_extra_share = enabled;
-        self
-    }
-
-    /// Set QRInfo request timeout.
-    pub fn with_qr_info_timeout(mut self, timeout: Duration) -> Self {
-        self.qr_info_timeout = timeout;
-        self
-    }
-
     /// Validate the configuration.
     pub fn validate(&self) -> Result<(), String> {
         // Note: Empty peers list is now valid - DNS discovery will be used automatically
 
-        if self.max_headers_per_message == 0 {
-            return Err("max_headers_per_message must be > 0".to_string());
-        }
-
-        if self.filter_checkpoint_interval == 0 {
-            return Err("filter_checkpoint_interval must be > 0".to_string());
-        }
-
         if self.max_peers == 0 {
             return Err("max_peers must be > 0".to_string());
         }
 
-        if self.max_concurrent_filter_requests == 0 {
-            return Err("max_concurrent_filter_requests must be > 0".to_string());
-        }
-
         // Mempool validation
         if self.enable_mempool_tracking {
             if self.max_mempool_transactions == 0 {

dash-spv/src/client/config_test.rs

@@ -8,27 +8,17 @@ mod tests {
     use std::net::SocketAddr;
     use std::path::PathBuf;
 
-    use std::time::Duration;
-
     #[test]
     fn test_default_config() {
         let config = ClientConfig::default();
 
         assert_eq!(config.network, Network::Dash);
         assert!(config.peers.is_empty());
         assert_eq!(config.validation_mode, ValidationMode::Full);
-        assert_eq!(config.filter_checkpoint_interval, 1000);
-        assert_eq!(config.max_headers_per_message, 2000);
-        assert_eq!(config.connection_timeout, Duration::from_secs(30));
-        assert_eq!(config.message_timeout, Duration::from_secs(60));
-        assert_eq!(config.sync_timeout, Duration::from_secs(300));
         assert!(config.enable_filters);
         assert!(config.enable_masternodes);
         assert_eq!(config.max_peers, 8);
-        assert!(config.enable_persistence);
         assert_eq!(config.log_level, "info");
-        assert_eq!(config.max_concurrent_filter_requests, 16);
-        assert_eq!(config.filter_request_delay_ms, 0);
 
         // Mempool defaults
         assert!(config.enable_mempool_tracking);
@@ -62,23 +52,16 @@ mod tests {
         let config = ClientConfig::mainnet()
             .with_storage_path(path.clone())
             .with_validation_mode(ValidationMode::Basic)
-            .with_connection_timeout(Duration::from_secs(10))
             .with_log_level("debug")
-            .with_max_concurrent_filter_requests(32)
-            .with_filter_request_delay(100)
             .with_mempool_tracking(MempoolStrategy::BloomFilter)
             .with_max_mempool_transactions(500)
             .with_mempool_timeout(7200)
             .with_mempool_persistence(true)
             .with_start_height(100000);
 
         assert_eq!(config.storage_path, Some(path));
-        assert!(config.enable_persistence);
         assert_eq!(config.validation_mode, ValidationMode::Basic);
-        assert_eq!(config.connection_timeout, Duration::from_secs(10));
         assert_eq!(config.log_level, "debug");
-        assert_eq!(config.max_concurrent_filter_requests, 32);
-        assert_eq!(config.filter_request_delay_ms, 100);
 
         // Mempool settings
         assert!(config.enable_mempool_tracking);
@@ -117,30 +100,6 @@ mod tests {
         assert!(config.validate().is_ok());
     }
 
-    #[test]
-    fn test_validation_invalid_max_headers() {
-        let config = ClientConfig {
-            max_headers_per_message: 0,
-            ..Default::default()
-        };
-
-        let result = config.validate();
-        assert!(result.is_err());
-        assert_eq!(result.unwrap_err(), "max_headers_per_message must be > 0");
-    }
-
-    #[test]
-    fn test_validation_invalid_filter_checkpoint_interval() {
-        let config = ClientConfig {
-            filter_checkpoint_interval: 0,
-            ..Default::default()
-        };
-
-        let result = config.validate();
-        assert!(result.is_err());
-        assert_eq!(result.unwrap_err(), "filter_checkpoint_interval must be > 0");
-    }
-
     #[test]
     fn test_validation_invalid_max_peers() {
         let config = ClientConfig {
@@ -153,18 +112,6 @@ mod tests {
         assert_eq!(result.unwrap_err(), "max_peers must be > 0");
     }
 
-    #[test]
-    fn test_validation_invalid_max_concurrent_filter_requests() {
-        let config = ClientConfig {
-            max_concurrent_filter_requests: 0,
-            ..Default::default()
-        };
-
-        let result = config.validate();
-        assert!(result.is_err());
-        assert_eq!(result.unwrap_err(), "max_concurrent_filter_requests must be > 0");
-    }
-
     #[test]
     fn test_validation_invalid_mempool_config() {
         let config = ClientConfig {
@@ -193,21 +140,6 @@ mod tests {
 
     // Removed selective strategy validation test; Selective variant no longer exists
 
-    #[test]
-    fn test_request_control_defaults() {
-        let config = ClientConfig::default();
-
-        assert!(config.max_concurrent_headers_requests.is_none());
-        assert!(config.max_concurrent_mnlist_requests.is_none());
-        assert!(config.max_concurrent_cfheaders_requests.is_none());
-        assert!(config.max_concurrent_block_requests.is_none());
-        assert!(config.headers_request_rate_limit.is_none());
-        assert!(config.mnlist_request_rate_limit.is_none());
-        assert!(config.cfheaders_request_rate_limit.is_none());
-        assert!(config.filters_request_rate_limit.is_none());
-        assert!(config.blocks_request_rate_limit.is_none());
-    }
-
     #[test]
     fn test_wallet_creation_time() {
         let config = ClientConfig {

dash-spv/src/client/lifecycle.rs

@@ -324,7 +324,9 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,
                         // Update storage with chain state including sync_base_height
                         {
                             let mut storage = self.storage.lock().await;
-                            storage.store_headers(&[checkpoint_header]).await?;
+                            storage
+                                .store_headers_at_height(&[checkpoint_header], checkpoint.height)
+                                .await?;
                             storage
                                 .store_chain_state(&chain_state_for_storage)
                                 .await