refactor: removed all use of dyn (#274)

Author: ZocoLini

dash-spv/src/chain/fork_detector.rs

@@ -29,11 +29,11 @@ impl ForkDetector {
     }
 
     /// Check if a header creates or extends a fork
-    pub fn check_header(
+    pub fn check_header<CS: ChainStorage>(
         &mut self,
         header: &BlockHeader,
         chain_state: &ChainState,
-        storage: &dyn ChainStorage,
+        storage: &CS,
     ) -> ForkDetectionResult {
         let header_hash = header.block_hash();
         let prev_hash = header.prev_blockhash;

dash-spv/src/chain/reorg.rs

@@ -78,22 +78,22 @@ impl ReorgManager {
     }
 
     /// Check if a fork has more work than the current chain and should trigger a reorg
-    pub fn should_reorganize(
+    pub fn should_reorganize<CS: ChainStorage>(
         &self,
         current_tip: &ChainTip,
         fork: &Fork,
-        storage: &dyn ChainStorage,
+        storage: &CS,
     ) -> Result<bool, String> {
         self.should_reorganize_with_chain_state(current_tip, fork, storage, None)
     }
 
     /// Check if a fork has more work than the current chain and should trigger a reorg
     /// This version is checkpoint-aware when chain_state is provided
-    pub fn should_reorganize_with_chain_state(
+    pub fn should_reorganize_with_chain_state<CS: ChainStorage>(
         &self,
         current_tip: &ChainTip,
         fork: &Fork,
-        storage: &dyn ChainStorage,
+        storage: &CS,
         chain_state: Option<&ChainState>,
     ) -> Result<bool, String> {
         // Check if fork has more work
@@ -178,10 +178,10 @@ impl ReorgManager {
     }
 
     /// Check if a block is chain-locked
-    pub fn is_chain_locked(
+    pub fn is_chain_locked<CS: ChainStorage>(
         &self,
         header: &BlockHeader,
-        storage: &dyn ChainStorage,
+        storage: &CS,
     ) -> Result<bool, String> {
         if let Some(ref chain_lock_mgr) = self.chain_lock_manager {
             // Get the height of this header

dash-spv/src/network/tests.rs

@@ -1,76 +1,5 @@
 //! Unit tests for network module
 
-#[cfg(test)]
-mod peer_network_manager_tests {
-    use crate::client::ClientConfig;
-    use crate::network::manager::PeerNetworkManager;
-    use crate::network::NetworkManager;
-    use dashcore::Network;
-    use std::time::Duration;
-    use tempfile::TempDir;
-
-    fn create_test_config() -> ClientConfig {
-        let temp_dir = TempDir::new().unwrap();
-        ClientConfig {
-            network: Network::Regtest,
-            peers: vec!["127.0.0.1:19899".parse().unwrap()],
-            restrict_to_configured_peers: false,
-            storage_path: Some(temp_dir.path().to_path_buf()),
-            validation_mode: crate::types::ValidationMode::Basic,
-            filter_checkpoint_interval: 1000,
-            max_headers_per_message: 2000,
-            connection_timeout: Duration::from_secs(5),
-            message_timeout: Duration::from_secs(30),
-            sync_timeout: Duration::from_secs(60),
-            enable_filters: false,
-            enable_masternodes: false,
-            max_peers: 3,
-            enable_persistence: false,
-            log_level: "info".to_string(),
-            filter_request_delay_ms: 0,
-            max_concurrent_filter_requests: 50,
-            max_concurrent_cfheaders_requests_parallel: 50,
-            cfheaders_request_timeout_secs: 30,
-            max_cfheaders_retries: 3,
-            // Mempool fields
-            enable_mempool_tracking: false,
-            mempool_strategy: crate::client::config::MempoolStrategy::BloomFilter,
-            max_mempool_transactions: 1000,
-            mempool_timeout_secs: 3600,
-            fetch_mempool_transactions: true,
-            persist_mempool: false,
-            // Request control fields
-            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,
-            // QRInfo fields
-            qr_info_extra_share: true,
-            qr_info_timeout: Duration::from_secs(30),
-            user_agent: None,
-        }
-    }
-
-    #[tokio::test]
-    async fn test_as_any_downcast() {
-        let config = create_test_config();
-        let manager = PeerNetworkManager::new(&config).await.unwrap();
-
-        // Test that we can downcast through the trait
-        let network_manager: &dyn NetworkManager = &manager;
-        let downcasted = network_manager.as_any().downcast_ref::<PeerNetworkManager>();
-
-        assert!(downcasted.is_some());
-    }
-}
-
 #[cfg(test)]
 mod peer_tests {
     use crate::network::peer::Peer;

dash-spv/src/storage/disk/state.rs

@@ -535,10 +535,6 @@ impl DiskStorageManager {
 
 #[async_trait]
 impl StorageManager for DiskStorageManager {
-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
-        self
-    }
-
     async fn store_headers(&mut self, headers: &[BlockHeader]) -> StorageResult<()> {
         self.store_headers(headers).await
     }

dash-spv/src/storage/memory.rs

@@ -52,10 +52,6 @@ impl MemoryStorageManager {
 
 #[async_trait]
 impl StorageManager for MemoryStorageManager {
-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
-        self
-    }
-
     async fn store_headers(&mut self, headers: &[BlockHeader]) -> StorageResult<()> {
         let initial_count = self.headers.len();
         tracing::debug!(

dash-spv/src/storage/mod.rs

@@ -7,7 +7,6 @@ pub mod sync_storage;
 pub mod types;
 
 use async_trait::async_trait;
-use std::any::Any;
 use std::collections::HashMap;
 use std::ops::Range;
 
@@ -101,8 +100,6 @@ pub trait ChainStorage: Send + Sync {
 /// at a time when using external synchronization, which naturally provides consistency.
 #[async_trait]
 pub trait StorageManager: Send + Sync {
-    /// Convert to Any for downcasting
-    fn as_any_mut(&mut self) -> &mut dyn Any;
     /// Store block headers.
     async fn store_headers(&mut self, headers: &[BlockHeader]) -> StorageResult<()>;
 
@@ -242,14 +239,3 @@ pub trait StorageManager: Send + Sync {
     /// Shutdown the storage manager
     async fn shutdown(&mut self) -> StorageResult<()>;
 }
-
-/// Helper trait to provide as_any_mut for all StorageManager implementations
-pub trait AsAnyMut {
-    fn as_any_mut(&mut self) -> &mut dyn Any;
-}
-
-impl<T: 'static> AsAnyMut for T {
-    fn as_any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-}

dash-spv/src/sync/filters/retry.rs

@@ -264,7 +264,7 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
     async fn handle_request_timeout(
         &mut self,
         range: (u32, u32),
-        _network: &mut dyn NetworkManager,
+        _network: &mut N,
         storage: &S,
     ) -> SyncResult<()> {
         let (start, end) = range;

dash-spv/src/sync/headers/manager.rs

@@ -256,21 +256,10 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
             }
         }
 
-        // Use the internal storage method if available (DiskStorageManager optimization)
-        if let Some(disk_storage) =
-            storage.as_any_mut().downcast_mut::<crate::storage::disk::DiskStorageManager>()
-        {
-            disk_storage
-                .store_headers(headers)
-                .await
-                .map_err(|e| SyncError::Storage(format!("Failed to store headers batch: {}", e)))?;
-        } else {
-            // Fallback to standard store_headers for other storage backends
-            storage
-                .store_headers(headers)
-                .await
-                .map_err(|e| SyncError::Storage(format!("Failed to store headers batch: {}", e)))?;
-        }
+        storage
+            .store_headers(headers)
+            .await
+            .map_err(|e| SyncError::Storage(format!("Failed to store headers batch: {}", e)))?;
 
         // Update Sync Progress
         let batch_size = headers.len() as u32;

dash-spv/src/sync/masternodes/manager.rs

@@ -126,7 +126,7 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
     /// Request QRInfo - simplified non-blocking implementation
     pub async fn request_qrinfo(
         &mut self,
-        network: &mut dyn NetworkManager,
+        network: &mut N,
         base_block_hash: BlockHash,
         block_hash: BlockHash,
     ) -> Result<(), String> {
@@ -215,7 +215,7 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
     /// Make QRInfo P2P request (simplified non-blocking)
     async fn request_qr_info(
         &mut self,
-        network: &mut dyn NetworkManager,
+        network: &mut N,
         known_block_hashes: Vec<BlockHash>,
         block_request_hash: BlockHash,
     ) -> Result<(), String> {
@@ -381,11 +381,7 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
     }
 
     /// Start masternode synchronization
-    pub async fn start_sync(
-        &mut self,
-        network: &mut dyn NetworkManager,
-        storage: &mut S,
-    ) -> SyncResult<bool> {
+    pub async fn start_sync(&mut self, network: &mut N, storage: &mut S) -> SyncResult<bool> {
         if self.sync_in_progress {
             return Err(SyncError::SyncInProgress);
         }
@@ -445,7 +441,7 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
         &mut self,
         diff: &MnListDiff,
         storage: &mut S,
-        _network: &mut dyn NetworkManager,
+        _network: &mut N,
     ) -> SyncResult<bool> {
         self.insert_mn_list_diff(diff, storage).await;
 
@@ -500,11 +496,7 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
     }
 
     /// Check for sync timeout
-    pub async fn check_sync_timeout(
-        &mut self,
-        storage: &mut dyn StorageManager,
-        network: &mut dyn NetworkManager,
-    ) -> SyncResult<()> {
+    pub async fn check_sync_timeout(&mut self, storage: &mut S, network: &mut N) -> SyncResult<()> {
         // Check if we're waiting for MnListDiff responses and have timed out
         if self.pending_mnlistdiff_requests > 0 {
             if let Some(wait_start) = self.mnlistdiff_wait_start {
@@ -625,7 +617,7 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
         &mut self,
         qr_info: QRInfo,
         storage: &mut S,
-        network: &mut dyn NetworkManager,
+        network: &mut N,
     ) {
         self.log_qrinfo_details(&qr_info, "📋 Masternode sync processing QRInfo (unified path)");
 
@@ -726,7 +718,7 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
         &mut self,
         qr_info: &QRInfo,
         storage: &mut S,
-        network: &mut dyn NetworkManager,
+        network: &mut N,
     ) -> Result<(), String> {
         tracing::info!(
             "🔗 Feeding QRInfo to engine and getting additional diffs for quorum validation"
@@ -807,7 +799,7 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
         &mut self,
         quorum_hashes: &std::collections::BTreeSet<QuorumHash>,
         storage: &mut S,
-        network: &mut dyn NetworkManager,
+        network: &mut N,
     ) -> Result<(), String> {
         use dashcore::network::message::NetworkMessage;
         use dashcore::network::message_sml::GetMnListDiff;

dash-spv/src/sync/transitions.rs

@@ -23,11 +23,11 @@ impl TransitionManager {
     }
 
     /// Check if we can transition from current phase to target phase
-    pub async fn can_transition_to(
+    pub async fn can_transition_to<S: StorageManager>(
         &self,
         current_phase: &SyncPhase,
         target_phase: &SyncPhase,
-        storage: &dyn StorageManager,
+        storage: &S,
     ) -> SyncResult<bool> {
         // Can't transition to the same phase
         if std::mem::discriminant(current_phase) == std::mem::discriminant(target_phase) {
@@ -168,11 +168,11 @@ impl TransitionManager {
     }
 
     /// Get the next phase based on current phase and configuration
-    pub async fn get_next_phase(
+    pub async fn get_next_phase<S: StorageManager, N: NetworkManager>(
         &self,
         current_phase: &SyncPhase,
-        storage: &dyn StorageManager,
-        network: &dyn NetworkManager,
+        storage: &S,
+        network: &N,
     ) -> SyncResult<Option<SyncPhase>> {
         match current_phase {
             SyncPhase::Idle => {
@@ -320,10 +320,10 @@ impl TransitionManager {
 
     // Helper methods for checking phase completion
 
-    async fn are_headers_complete(
+    async fn are_headers_complete<S: StorageManager>(
         &self,
         phase: &SyncPhase,
-        _storage: &dyn StorageManager,
+        _storage: &S,
     ) -> SyncResult<bool> {
         if let SyncPhase::DownloadingHeaders {
             received_empty_response,
@@ -337,10 +337,10 @@ impl TransitionManager {
         }
     }
 
-    async fn are_masternodes_complete(
+    async fn are_masternodes_complete<S: StorageManager>(
         &self,
         phase: &SyncPhase,
-        storage: &dyn StorageManager,
+        storage: &S,
     ) -> SyncResult<bool> {
         if let SyncPhase::DownloadingMnList {
             current_height,
@@ -364,10 +364,10 @@ impl TransitionManager {
         }
     }
 
-    async fn are_cfheaders_complete(
+    async fn are_cfheaders_complete<S: StorageManager>(
         &self,
         phase: &SyncPhase,
-        _storage: &dyn StorageManager,
+        _storage: &S,
     ) -> SyncResult<bool> {
         if let SyncPhase::DownloadingCFHeaders {
             current_height,
@@ -413,9 +413,9 @@ impl TransitionManager {
         false
     }
 
-    async fn create_cfheaders_phase(
+    async fn create_cfheaders_phase<S: StorageManager>(
         &self,
-        storage: &dyn StorageManager,
+        storage: &S,
     ) -> SyncResult<Option<SyncPhase>> {
         let header_tip = storage
             .get_tip_height()
@@ -440,9 +440,9 @@ impl TransitionManager {
         }))
     }
 
-    async fn create_fully_synced_phase(
+    async fn create_fully_synced_phase<S: StorageManager>(
         &self,
-        _storage: &dyn StorageManager,
+        _storage: &S,
     ) -> SyncResult<Option<SyncPhase>> {
         Ok(Some(SyncPhase::FullySynced {
             sync_completed_at: Instant::now(),