Skip to content

chore: cleanup unused config parameters #346

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
xdustinface merged 1 commit into from
Jan 8, 2026
Merged

chore: cleanup unused config parameters #346

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
138 changes: 0 additions & 138 deletions dash-spv/src/client/config.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down Expand Up @@ -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,

Expand All @@ -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,
Expand All @@ -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 {
Expand All @@ -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),
}
}
}
Expand Down Expand Up @@ -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
}

Expand All @@ -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();
Expand All @@ -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;
Expand Down Expand Up @@ -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 {
Expand Down
68 changes: 0 additions & 68 deletions dash-spv/src/client/config_test.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand Down Expand Up @@ -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);
Expand Down Expand Up @@ -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 {
Expand All @@ -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 {
Expand Down Expand Up @@ -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 {
Expand Down
16 changes: 7 additions & 9 deletions dash-spv/src/sync/filters/manager.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,15 +3,15 @@
//! This module contains the FilterSyncManager struct and high-level coordination logic
//! that delegates to specialized sub-modules for headers, downloads, matching, etc.

use dashcore::{hash_types::FilterHeader, network::message_filter::CFHeaders, BlockHash};
use dashcore_hashes::{sha256d, Hash};
use std::collections::{HashMap, HashSet, VecDeque};

use crate::client::ClientConfig;
use crate::error::{SyncError, SyncResult};
use crate::network::NetworkManager;
use crate::storage::StorageManager;
use crate::types::SharedFilterHeights;
use dashcore::{hash_types::FilterHeader, network::message_filter::CFHeaders, BlockHash};
use dashcore_hashes::{sha256d, Hash};
use std::collections::{HashMap, HashSet, VecDeque};
use std::time::Duration;

// Import types and constants from the types module
use super::types::*;
Expand Down Expand Up @@ -110,15 +110,13 @@ impl<S: StorageManager, N: NetworkManager> FilterSyncManager<S, N> {
pending_cfheader_requests: VecDeque::new(),
active_cfheader_requests: HashMap::new(),
cfheader_retry_counts: HashMap::new(),
max_cfheader_retries: config.max_cfheaders_retries,
max_cfheader_retries: 3,
received_cfheader_batches: HashMap::new(),
next_cfheader_height_to_process: 0,
max_concurrent_cfheader_requests: config.max_concurrent_cfheaders_requests_parallel,
cfheader_request_timeout: std::time::Duration::from_secs(
config.cfheaders_request_timeout_secs,
),
max_concurrent_cfheader_requests: 50,
_phantom_s: std::marker::PhantomData,
_phantom_n: std::marker::PhantomData,
cfheader_request_timeout: Duration::from_secs(30),
}
}

Expand Down
Loading
Loading