refactor: Drop unused code in dash-spv::network (#192)

Author: xdustinface

dash-spv/src/client/message_handler.rs

@@ -332,17 +332,9 @@ impl<
             }
             NetworkMessage::Ping(nonce) => {
                 tracing::debug!("Received ping with nonce {}", nonce);
-                // Automatically respond with pong
-                if let Err(e) = self.network.handle_ping(nonce).await {
-                    tracing::error!("Failed to send pong response: {}", e);
-                }
             }
             NetworkMessage::Pong(nonce) => {
                 tracing::debug!("Received pong with nonce {}", nonce);
-                // Validate the pong nonce
-                if let Err(e) = self.network.handle_pong(nonce) {
-                    tracing::warn!("Invalid pong received: {}", e);
-                }
             }
             NetworkMessage::CFilter(cfilter) => {
                 tracing::debug!("Received CFilter for block {}", cfilter.block_hash);

dash-spv/src/client/sync_coordinator.rs

@@ -127,21 +127,6 @@ impl<
             }
             drop(running);
 
-            // Check if we need to send a ping
-            if self.network.should_ping() {
-                match self.network.send_ping().await {
-                    Ok(nonce) => {
-                        tracing::trace!("Sent periodic ping with nonce {}", nonce);
-                    }
-                    Err(e) => {
-                        tracing::error!("Failed to send periodic ping: {}", e);
-                    }
-                }
-            }
-
-            // Clean up old pending pings
-            self.network.cleanup_old_pings();
-
             // Check if we have connected peers and start initial sync operations (once)
             if !initial_sync_started && self.network.peer_count() > 0 {
                 tracing::info!("🚀 Peers connected, starting initial sync operations...");

dash-spv/src/network/manager.rs

@@ -922,11 +922,6 @@ impl PeerNetworkManager {
         Ok(())
     }
 
-    /// Get the number of connected peers (async version).
-    pub async fn peer_count_async(&self) -> usize {
-        self.pool.peer_count().await
-    }
-
     /// Get reputation information for all peers
     pub async fn get_peer_reputations(&self) -> HashMap<SocketAddr, (i32, bool)> {
         let reputations = self.reputation_manager.get_all_reputations().await;
@@ -1230,74 +1225,6 @@ impl NetworkManager for PeerNetworkManager {
         })
     }
 
-    async fn send_ping(&mut self) -> NetworkResult<u64> {
-        // Send ping to all peers, return first nonce
-        let peers = self.pool.get_all_peers().await;
-
-        if peers.is_empty() {
-            return Err(NetworkError::ConnectionFailed("No connected peers".to_string()));
-        }
-
-        let (_, peer) = &peers[0];
-        let mut peer_guard = peer.write().await;
-        peer_guard.send_ping().await
-    }
-
-    async fn handle_ping(&mut self, _nonce: u64) -> NetworkResult<()> {
-        // This is handled in the peer reader
-        Ok(())
-    }
-
-    fn handle_pong(&mut self, _nonce: u64) -> NetworkResult<()> {
-        // This is handled in the peer reader
-        Ok(())
-    }
-
-    fn should_ping(&self) -> bool {
-        // Individual peers handle their own ping timing
-        false
-    }
-
-    fn cleanup_old_pings(&mut self) {
-        // Individual peers handle their own ping cleanup
-    }
-
-    fn get_message_sender(&self) -> mpsc::Sender<NetworkMessage> {
-        // Create a sender that routes messages to our internal send_message logic
-        let (tx, mut rx) = mpsc::channel(1000);
-        let pool = Arc::clone(&self.pool);
-
-        tokio::spawn(async move {
-            while let Some(message) = rx.recv().await {
-                // Route message through the peer network logic
-                // For sync messages that require consistent responses, send to only one peer
-                match &message {
-                    NetworkMessage::GetHeaders(_)
-                    | NetworkMessage::GetCFHeaders(_)
-                    | NetworkMessage::GetCFilters(_)
-                    | NetworkMessage::GetData(_) => {
-                        // Send to a single peer for sync messages including GetData for block downloads
-                        let peers = pool.get_all_peers().await;
-                        if let Some((_, peer)) = peers.first() {
-                            let mut peer_guard = peer.write().await;
-                            let _ = peer_guard.send_message(message).await;
-                        }
-                    }
-                    _ => {
-                        // Broadcast to all peers for other messages
-                        let peers = pool.get_all_peers().await;
-                        for (_, peer) in peers {
-                            let mut peer_guard = peer.write().await;
-                            let _ = peer_guard.send_message(message.clone()).await;
-                        }
-                    }
-                }
-            }
-        });
-
-        tx
-    }
-
     async fn get_peer_best_height(&self) -> NetworkResult<Option<u32>> {
         let peers = self.pool.get_all_peers().await;
 
@@ -1368,28 +1295,6 @@ impl NetworkManager for PeerNetworkManager {
         false
     }
 
-    async fn get_peers_with_service(
-        &self,
-        service_flags: dashcore::network::constants::ServiceFlags,
-    ) -> Vec<PeerInfo> {
-        let peers = self.pool.get_all_peers().await;
-        let mut matching_peers = Vec::new();
-
-        for (_, peer) in peers.iter() {
-            let peer_guard = peer.read().await;
-            let peer_info = peer_guard.peer_info();
-            if peer_info
-                .services
-                .map(|s| dashcore::network::constants::ServiceFlags::from(s).has(service_flags))
-                .unwrap_or(false)
-            {
-                matching_peers.push(peer_info);
-            }
-        }
-
-        matching_peers
-    }
-
     async fn has_headers2_peer(&self) -> bool {
         // Headers2 is currently disabled due to protocol compatibility issues
         // TODO: Fix headers2 decompression before re-enabling

dash-spv/src/network/mock.rs

@@ -9,7 +9,6 @@ use dashcore::{
     network::message::NetworkMessage, network::message_blockdata::GetHeadersMessage, BlockHash,
 };
 use dashcore_hashes::Hash;
-use tokio::sync::mpsc;
 
 use crate::error::{NetworkError, NetworkResult};
 use crate::types::PeerInfo;
@@ -21,21 +20,15 @@ pub struct MockNetworkManager {
     connected: bool,
     messages: VecDeque<NetworkMessage>,
     headers_chain: Vec<BlockHeader>,
-    message_sender: mpsc::Sender<NetworkMessage>,
-    message_receiver: mpsc::Receiver<NetworkMessage>,
 }
 
 impl MockNetworkManager {
     /// Create a new mock network manager
     pub fn new() -> Self {
-        let (message_sender, message_receiver) = mpsc::channel(1000);
-
         Self {
             connected: false,
             messages: VecDeque::new(),
             headers_chain: Vec::new(),
-            message_sender,
-            message_receiver,
         }
     }
 
@@ -139,11 +132,6 @@ impl NetworkManager for MockNetworkManager {
             return Err(NetworkError::NotConnected);
         }
 
-        // Check for messages in the receiver channel first
-        if let Ok(msg) = self.message_receiver.try_recv() {
-            return Ok(Some(msg));
-        }
-
         // Then check our internal queue
         Ok(self.messages.pop_front())
     }
@@ -178,28 +166,6 @@ impl NetworkManager for MockNetworkManager {
         }
     }
 
-    async fn send_ping(&mut self) -> NetworkResult<u64> {
-        Ok(1234567890)
-    }
-
-    async fn handle_ping(&mut self, _nonce: u64) -> NetworkResult<()> {
-        Ok(())
-    }
-
-    fn handle_pong(&mut self, _nonce: u64) -> NetworkResult<()> {
-        Ok(())
-    }
-
-    fn should_ping(&self) -> bool {
-        false
-    }
-
-    fn cleanup_old_pings(&mut self) {}
-
-    fn get_message_sender(&self) -> mpsc::Sender<NetworkMessage> {
-        self.message_sender.clone()
-    }
-
     async fn get_peer_best_height(&self) -> NetworkResult<Option<u32>> {
         Ok(Some(self.headers_chain.len() as u32))
     }
@@ -208,10 +174,6 @@ impl NetworkManager for MockNetworkManager {
         self.connected
     }
 
-    async fn get_peers_with_service(&self, _service_flags: ServiceFlags) -> Vec<PeerInfo> {
-        self.peer_info()
-    }
-
     async fn get_last_message_peer_id(&self) -> crate::types::PeerId {
         // For mock, always return PeerId(1) when connected
         if self.connected {

dash-spv/src/network/mod.rs

@@ -17,7 +17,6 @@ mod tests;
 pub mod mock;
 
 use async_trait::async_trait;
-use tokio::sync::mpsc;
 
 use crate::error::NetworkResult;
 use dashcore::network::message::NetworkMessage;
@@ -54,24 +53,6 @@ pub trait NetworkManager: Send + Sync {
     /// Get peer information.
     fn peer_info(&self) -> Vec<crate::types::PeerInfo>;
 
-    /// Send a ping message.
-    async fn send_ping(&mut self) -> NetworkResult<u64>;
-
-    /// Handle a received ping message by sending a pong.
-    async fn handle_ping(&mut self, nonce: u64) -> NetworkResult<()>;
-
-    /// Handle a received pong message.
-    fn handle_pong(&mut self, nonce: u64) -> NetworkResult<()>;
-
-    /// Check if we should send a ping (2 minute timeout).
-    fn should_ping(&self) -> bool;
-
-    /// Clean up old pending pings.
-    fn cleanup_old_pings(&mut self);
-
-    /// Get a message sender channel for sending messages from other components.
-    fn get_message_sender(&self) -> mpsc::Sender<NetworkMessage>;
-
     /// Get the best block height reported by connected peers.
     async fn get_peer_best_height(&self) -> NetworkResult<Option<u32>>;
 
@@ -81,12 +62,6 @@ pub trait NetworkManager: Send + Sync {
         service_flags: dashcore::network::constants::ServiceFlags,
     ) -> bool;
 
-    /// Get peers that support a specific service.
-    async fn get_peers_with_service(
-        &self,
-        service_flags: dashcore::network::constants::ServiceFlags,
-    ) -> Vec<crate::types::PeerInfo>;
-
     /// Check if any connected peer supports headers2 compression.
     async fn has_headers2_peer(&self) -> bool {
         self.has_peer_with_service(dashcore::network::constants::NODE_HEADERS_COMPRESSED).await

dash-spv/src/network/tests.rs

@@ -70,17 +70,6 @@ mod peer_network_manager_tests {
         }
     }
 
-    #[tokio::test]
-    async fn test_peer_network_manager_creation() {
-        let config = create_test_config();
-        let manager = PeerNetworkManager::new(&config).await.unwrap();
-
-        // Should start with zero peers
-        assert_eq!(manager.peer_count_async().await, 0);
-        // Note: is_connected() still uses sync approach, so we'll check async
-        assert_eq!(manager.peer_count_async().await, 0);
-    }
-
     #[tokio::test]
     async fn test_as_any_downcast() {
         let config = create_test_config();

dash-spv/tests/block_download_test.rs

@@ -97,29 +97,6 @@ impl NetworkManager for MockNetworkManager {
         vec![]
     }
 
-    async fn send_ping(&mut self) -> dash_spv::error::NetworkResult<u64> {
-        Ok(12345)
-    }
-
-    async fn handle_ping(&mut self, _nonce: u64) -> dash_spv::error::NetworkResult<()> {
-        Ok(())
-    }
-
-    fn handle_pong(&mut self, _nonce: u64) -> dash_spv::error::NetworkResult<()> {
-        Ok(())
-    }
-
-    fn should_ping(&self) -> bool {
-        false
-    }
-
-    fn cleanup_old_pings(&mut self) {}
-
-    fn get_message_sender(&self) -> tokio::sync::mpsc::Sender<NetworkMessage> {
-        let (tx, _rx) = tokio::sync::mpsc::channel(1);
-        tx
-    }
-
     async fn get_peer_best_height(&self) -> dash_spv::error::NetworkResult<Option<u32>> {
         Ok(Some(100))
     }
@@ -131,13 +108,6 @@ impl NetworkManager for MockNetworkManager {
         true
     }
 
-    async fn get_peers_with_service(
-        &self,
-        _service_flags: dashcore::network::constants::ServiceFlags,
-    ) -> Vec<dash_spv::types::PeerInfo> {
-        vec![]
-    }
-
     async fn get_last_message_peer_id(&self) -> dash_spv::types::PeerId {
         dash_spv::types::PeerId(1)
     }

dash-spv/tests/cfheader_gap_test.rs

@@ -208,29 +208,6 @@ async fn test_cfheader_restart_cooldown() {
             Vec::new()
         }
 
-        async fn send_ping(&mut self) -> NetworkResult<u64> {
-            Ok(0)
-        }
-
-        async fn handle_ping(&mut self, _nonce: u64) -> NetworkResult<()> {
-            Ok(())
-        }
-
-        fn handle_pong(&mut self, _nonce: u64) -> NetworkResult<()> {
-            Ok(())
-        }
-
-        fn should_ping(&self) -> bool {
-            false
-        }
-
-        fn cleanup_old_pings(&mut self) {}
-
-        fn get_message_sender(&self) -> tokio::sync::mpsc::Sender<NetworkMessage> {
-            let (tx, _rx) = tokio::sync::mpsc::channel(1);
-            tx
-        }
-
         async fn get_peer_best_height(&self) -> dash_spv::error::NetworkResult<Option<u32>> {
             Ok(Some(100))
         }
@@ -242,13 +219,6 @@ async fn test_cfheader_restart_cooldown() {
             true
         }
 
-        async fn get_peers_with_service(
-            &self,
-            _service_flags: dashcore::network::constants::ServiceFlags,
-        ) -> Vec<dash_spv::types::PeerInfo> {
-            vec![]
-        }
-
         async fn get_last_message_peer_id(&self) -> dash_spv::types::PeerId {
             dash_spv::types::PeerId(1)
         }