refactor: TcpConnection -> Peer and ConnectionPool -> PeerPool (#190)

Author: xdustinface

dash-spv/ARCHITECTURE.md

@@ -680,7 +680,7 @@ The network module handles all P2P communication with the Dash network.
 - Graceful shutdown
 
 **Complex Types Used**:
-- `HashMap<PeerId, Arc<TcpConnection>>` - **JUSTIFIED**: Efficient peer lookup
+- `HashMap<PeerId, Arc<Peer>>` - **JUSTIFIED**: Efficient peer lookup
 - Multiple tokio::sync primitives - **JUSTIFIED**: Complex concurrent operations
 
 **Critical Issues**:

dash-spv/CLAUDE.md

@@ -116,7 +116,7 @@ TCP-based networking with proper Dash protocol implementation:
 - **DNS-first peer discovery**: Automatically uses DNS seeds (`dnsseed.dash.org`, `testnet-seed.dashdot.io`) when no explicit peers are configured
 - **Immediate startup**: No delay for initial peer discovery (10-second delay only for subsequent searches)
 - **Exclusive mode**: When explicit peers are provided, uses only those peers (no DNS discovery)
-- Connection management via `TcpConnection`
+- Connection management via `Peer`
 - Handshake handling via `HandshakeManager`
 - Message routing via `MessageHandler`
 - Peer support via `PeerNetworkManager`

dash-spv/src/network/handshake.rs

@@ -12,7 +12,7 @@ use dashcore::Network;
 
 use crate::client::config::MempoolStrategy;
 use crate::error::{NetworkError, NetworkResult};
-use crate::network::connection::TcpConnection;
+use crate::network::peer::Peer;
 
 /// Handshake state.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -65,7 +65,7 @@ impl HandshakeManager {
     }
 
     /// Perform the handshake with a peer.
-    pub async fn perform_handshake(&mut self, connection: &mut TcpConnection) -> NetworkResult<()> {
+    pub async fn perform_handshake(&mut self, connection: &mut Peer) -> NetworkResult<()> {
         use tokio::time::{timeout, Duration};
 
         // Send version message
@@ -145,7 +145,7 @@ impl HandshakeManager {
     /// Handle a handshake message.
     async fn handle_handshake_message(
         &mut self,
-        connection: &mut TcpConnection,
+        connection: &mut Peer,
         message: NetworkMessage,
     ) -> NetworkResult<Option<HandshakeState>> {
         match message {
@@ -238,7 +238,7 @@ impl HandshakeManager {
     }
 
     /// Send version message.
-    async fn send_version(&mut self, connection: &mut TcpConnection) -> NetworkResult<()> {
+    async fn send_version(&mut self, connection: &mut Peer) -> NetworkResult<()> {
         let version_message = self.build_version_message(connection.peer_info().address)?;
         connection.send_message(NetworkMessage::Version(version_message)).await?;
         tracing::debug!("Sent version message");
@@ -309,7 +309,7 @@ impl HandshakeManager {
     }
 
     /// Negotiate headers2 support with the peer after handshake completion.
-    async fn negotiate_headers2(&self, connection: &mut TcpConnection) -> NetworkResult<()> {
+    async fn negotiate_headers2(&self, connection: &mut Peer) -> NetworkResult<()> {
         // Headers2 is currently disabled due to protocol compatibility issues
         // Always send SendHeaders regardless of peer support
         tracing::info!("Headers2 is disabled - sending SendHeaders only");

dash-spv/src/network/manager.rs

@@ -1,11 +1,11 @@
 //! Network layer for the Dash SPV client.
 
 pub mod addrv2;
-pub mod connection;
 pub mod constants;
 pub mod discovery;
 pub mod handshake;
 pub mod manager;
+pub mod peer;
 pub mod persist;
 pub mod pool;
 pub mod reputation;
@@ -23,9 +23,9 @@ use crate::error::NetworkResult;
 use dashcore::network::message::NetworkMessage;
 use dashcore::BlockHash;
 
-pub use connection::TcpConnection;
 pub use handshake::{HandshakeManager, HandshakeState};
 pub use manager::PeerNetworkManager;
+pub use peer::Peer;
 
 /// Network manager trait for abstracting network operations.
 #[async_trait]

dash-spv/src/network/mod.rs

@@ -1,4 +1,4 @@
-//! TCP connection management.
+//! Dash peer connection management.
 
 use std::collections::HashMap;
 use std::net::SocketAddr;
@@ -23,8 +23,8 @@ struct ConnectionState {
     framing_buffer: Vec<u8>,
 }
 
-/// TCP connection to a Dash peer
-pub struct TcpConnection {
+/// Dash P2P peer
+pub struct Peer {
     address: SocketAddr,
     // Use a single mutex to protect both the write stream and read buffer
     // This ensures no concurrent access to the underlying socket
@@ -38,23 +38,23 @@ pub struct TcpConnection {
     last_pong_received: Option<SystemTime>,
     pending_pings: HashMap<u64, SystemTime>, // nonce -> sent_time
     // Peer information from Version message
-    peer_version: Option<u32>,
-    peer_services: Option<u64>,
-    peer_user_agent: Option<String>,
-    peer_best_height: Option<u32>,
-    peer_relay: Option<bool>,
-    peer_prefers_headers2: bool,
-    peer_sent_sendheaders2: bool,
+    version: Option<u32>,
+    services: Option<u64>,
+    user_agent: Option<String>,
+    best_height: Option<u32>,
+    relay: Option<bool>,
+    prefers_headers2: bool,
+    sent_sendheaders2: bool,
     // Basic telemetry for resync events
     consecutive_resyncs: u32,
 }
 
-impl TcpConnection {
+impl Peer {
     /// Get the remote peer socket address.
     pub fn address(&self) -> SocketAddr {
         self.address
     }
-    /// Create a new TCP connection to the given address.
+    /// Create a new peer.
     pub fn new(address: SocketAddr, timeout: Duration, network: Network) -> Self {
         Self {
             address,
@@ -66,13 +66,13 @@ impl TcpConnection {
             last_ping_sent: None,
             last_pong_received: None,
             pending_pings: HashMap::new(),
-            peer_version: None,
-            peer_services: None,
-            peer_user_agent: None,
-            peer_best_height: None,
-            peer_relay: None,
-            peer_prefers_headers2: false,
-            peer_sent_sendheaders2: false,
+            version: None,
+            services: None,
+            user_agent: None,
+            best_height: None,
+            relay: None,
+            prefers_headers2: false,
+            sent_sendheaders2: false,
             consecutive_resyncs: 0,
         }
     }
@@ -113,13 +113,13 @@ impl TcpConnection {
             last_ping_sent: None,
             last_pong_received: None,
             pending_pings: HashMap::new(),
-            peer_version: None,
-            peer_services: None,
-            peer_user_agent: None,
-            peer_best_height: None,
-            peer_relay: None,
-            peer_prefers_headers2: false,
-            peer_sent_sendheaders2: false,
+            version: None,
+            services: None,
+            user_agent: None,
+            best_height: None,
+            relay: None,
+            prefers_headers2: false,
+            sent_sendheaders2: false,
             consecutive_resyncs: 0,
         })
     }
@@ -249,11 +249,11 @@ impl TcpConnection {
         }
 
         // All validations passed, update peer info
-        self.peer_version = Some(version_msg.version);
-        self.peer_services = Some(version_msg.services.as_u64());
-        self.peer_user_agent = Some(version_msg.user_agent.clone());
-        self.peer_best_height = Some(version_msg.start_height as u32);
-        self.peer_relay = Some(version_msg.relay);
+        self.version = Some(version_msg.version);
+        self.services = Some(version_msg.services.as_u64());
+        self.user_agent = Some(version_msg.user_agent.clone());
+        self.best_height = Some(version_msg.start_height as u32);
+        self.relay = Some(version_msg.relay);
 
         tracing::info!(
             "Updated peer info for {}: height={}, version={}, services={:?}",
@@ -690,11 +690,11 @@ impl TcpConnection {
             address: self.address,
             connected: self.is_connected(),
             last_seen: self.connected_at.unwrap_or(SystemTime::UNIX_EPOCH),
-            version: self.peer_version,
-            services: self.peer_services,
-            user_agent: self.peer_user_agent.clone(),
-            best_height: self.peer_best_height,
-            wants_dsq_messages: None, // We don't track this in TcpConnection yet
+            version: self.version,
+            services: self.services,
+            user_agent: self.user_agent.clone(),
+            best_height: self.best_height,
+            wants_dsq_messages: None, // We don't track this yet
             has_sent_headers2: false, // Will be tracked by the connection pool
         }
     }
@@ -803,20 +803,20 @@ impl TcpConnection {
 
     /// Set that peer prefers headers2.
     pub fn set_prefers_headers2(&mut self, prefers: bool) {
-        self.peer_prefers_headers2 = prefers;
+        self.prefers_headers2 = prefers;
         if prefers {
             tracing::info!("Peer {} prefers headers2 compression", self.address);
         }
     }
 
     /// Check if peer prefers headers2.
     pub fn prefers_headers2(&self) -> bool {
-        self.peer_prefers_headers2
+        self.prefers_headers2
     }
 
     /// Set that peer sent us SendHeaders2.
     pub fn set_peer_sent_sendheaders2(&mut self, sent: bool) {
-        self.peer_sent_sendheaders2 = sent;
+        self.sent_sendheaders2 = sent;
         if sent {
             tracing::info!(
                 "Peer {} sent SendHeaders2 - they will send compressed headers",
@@ -827,15 +827,15 @@ impl TcpConnection {
 
     /// Check if peer sent us SendHeaders2.
     pub fn peer_sent_sendheaders2(&self) -> bool {
-        self.peer_sent_sendheaders2
+        self.sent_sendheaders2
     }
 
     /// Check if we can request headers2 from this peer.
     pub fn can_request_headers2(&self) -> bool {
         // We can request headers2 if peer has the service flag for headers2 support
         // Note: We don't wait for SendHeaders2 from peer as that creates a race condition
         // during initial sync. The service flag is sufficient to know they support headers2.
-        if let Some(services) = self.peer_services {
+        if let Some(services) = self.services {
             dashcore::network::constants::ServiceFlags::from(services)
                 .has(dashcore::network::constants::NODE_HEADERS_COMPRESSED)
         } else {