refactor: move get_peer_best_height into PeerPool

dash-spv/src/client/sync_coordinator.rs

@@ -219,13 +219,8 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,
                         storage.get_tip_height().await.unwrap_or(0)
                     };
                     let current_height = current_tip_height;
-                    let peer_best = self
-                        .network
-                        .get_peer_best_height()
-                        .await
-                        .ok()
-                        .flatten()
-                        .unwrap_or(current_height);
+                    let peer_best =
+                        self.network.get_peer_best_height().await.unwrap_or(current_height);
 
                     // Calculate headers downloaded this second
                     if current_tip_height > last_height {
@@ -298,13 +293,8 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,
 
                 {
                     // Build and emit a fresh DetailedSyncProgress snapshot reflecting current filter progress
-                    let peer_best = self
-                        .network
-                        .get_peer_best_height()
-                        .await
-                        .ok()
-                        .flatten()
-                        .unwrap_or(abs_header_height);
+                    let peer_best =
+                        self.network.get_peer_best_height().await.unwrap_or(abs_header_height);
 
                     let phase_snapshot = self.sync_manager.current_phase().clone();
                     let status_display = self.create_status_display().await;

dash-spv/src/network/manager.rs

@@ -28,6 +28,7 @@ use async_trait::async_trait;
 use dashcore::network::constants::ServiceFlags;
 use dashcore::network::message::NetworkMessage;
 use dashcore::network::message_headers2::CompressionState;
+use dashcore::prelude::CoreBlockHeight;
 use dashcore::Network;
 use tokio::sync::mpsc::UnboundedReceiver;
 use tokio_util::sync::CancellationToken;
@@ -1205,45 +1206,8 @@ impl NetworkManager for PeerNetworkManager {
         self.connected_peer_count.load(Ordering::Relaxed)
     }
 
-    async fn get_peer_best_height(&self) -> NetworkResult<Option<u32>> {
-        let peers = self.pool.get_all_peers().await;
-
-        if peers.is_empty() {
-            log::debug!("get_peer_best_height: No peers available");
-            return Ok(None);
-        }
-
-        let mut best_height = 0u32;
-        let mut peer_count = 0;
-
-        for (addr, peer) in peers.iter() {
-            let peer_guard = peer.read().await;
-
-            peer_count += 1;
-
-            if let Some(peer_height) = peer_guard.best_height() {
-                if peer_height > 0 {
-                    best_height = best_height.max(peer_height);
-                    log::debug!(
-                        "get_peer_best_height: Updated best_height to {} from peer {}",
-                        best_height,
-                        addr
-                    );
-                }
-            }
-        }
-
-        log::debug!(
-            "get_peer_best_height: Checked {} peers, best_height: {}",
-            peer_count,
-            best_height
-        );
-
-        if best_height > 0 {
-            Ok(Some(best_height))
-        } else {
-            Ok(None)
-        }
+    async fn get_peer_best_height(&self) -> Option<CoreBlockHeight> {
+        self.pool.get_best_height().await
     }
 
     async fn has_peer_with_service(&self, service_flags: ServiceFlags) -> bool {

dash-spv/src/network/mod.rs

@@ -17,6 +17,7 @@ mod tests;
 use crate::error::NetworkResult;
 use async_trait::async_trait;
 use dashcore::network::message::NetworkMessage;
+use dashcore::prelude::CoreBlockHeight;
 use dashcore::BlockHash;
 pub use handshake::{HandshakeManager, HandshakeState};
 pub use manager::PeerNetworkManager;
@@ -51,7 +52,7 @@ pub trait NetworkManager: Send + Sync + 'static {
     fn peer_count(&self) -> usize;
 
     /// Get the best block height reported by connected peers.
-    async fn get_peer_best_height(&self) -> NetworkResult<Option<u32>>;
+    async fn get_peer_best_height(&self) -> Option<CoreBlockHeight>;
 
     /// Check if any connected peer supports a specific service.
     async fn has_peer_with_service(

dash-spv/src/network/peer.rs

@@ -125,6 +125,10 @@ impl Peer {
         })
     }
 
+    pub fn version(&self) -> Option<u32> {
+        self.version
+    }
+
     pub fn best_height(&self) -> Option<u32> {
         self.best_height
     }

dash-spv/src/network/pool.rs

@@ -1,14 +1,14 @@
 //! Peer pool for managing multiple peer connections
 
+use crate::error::{NetworkError, SpvError as Error};
+use crate::network::constants::{MAX_PEERS, MIN_PEERS};
+use crate::network::peer::Peer;
+use dashcore::prelude::CoreBlockHeight;
 use std::collections::{HashMap, HashSet};
 use std::net::SocketAddr;
 use std::sync::Arc;
 use tokio::sync::RwLock;
 
-use crate::error::{NetworkError, SpvError as Error};
-use crate::network::constants::{MAX_PEERS, MIN_PEERS};
-use crate::network::peer::Peer;
-
 /// Pool for managing multiple peer instances
 pub struct PeerPool {
     /// Active peers mapped by address
@@ -100,6 +100,54 @@ impl PeerPool {
         self.peers.read().await.keys().copied().collect()
     }
 
+    pub async fn get_best_height(&self) -> Option<CoreBlockHeight> {
+        let peers = self.get_all_peers().await;
+
+        if peers.is_empty() {
+            log::debug!("get_peer_best_height: No peers available");
+            return None;
+        }
+
+        let mut best_height = 0u32;
+        let mut peer_count = 0;
+
+        for (addr, peer) in peers.iter() {
+            let peer_guard = peer.read().await;
+            peer_count += 1;
+
+            log::debug!(
+                "get_peer_best_height: Peer {} - best_height: {:?}, version: {:?}, connected: {}",
+                addr,
+                peer_guard.best_height(),
+                peer_guard.version(),
+                peer_guard.is_connected(),
+            );
+
+            if let Some(peer_height) = peer_guard.best_height() {
+                if peer_height > 0 {
+                    best_height = best_height.max(peer_height);
+                    log::debug!(
+                        "get_peer_best_height: Updated best_height to {} from peer {}",
+                        best_height,
+                        addr
+                    );
+                }
+            }
+        }
+
+        log::debug!(
+            "get_peer_best_height: Checked {} peers, best_height: {}",
+            peer_count,
+            best_height
+        );
+
+        if best_height > 0 {
+            Some(best_height)
+        } else {
+            None
+        }
+    }
+
     /// Check if we need more peers
     pub async fn needs_more_peers(&self) -> bool {
         self.peer_count().await < MIN_PEERS

dash-spv/src/test_utils/network.rs

@@ -1,6 +1,7 @@
 use crate::error::{NetworkError, NetworkResult};
 use crate::network::{Message, MessageDispatcher, MessageType, NetworkManager};
 use async_trait::async_trait;
+use dashcore::prelude::CoreBlockHeight;
 use dashcore::{
     block::Header as BlockHeader, network::constants::ServiceFlags,
     network::message::NetworkMessage, network::message_blockdata::GetHeadersMessage, BlockHash,
@@ -19,6 +20,7 @@ pub struct MockNetworkManager {
     connected: bool,
     connected_peer: SocketAddr,
     headers_chain: Vec<BlockHeader>,
+    peer_best_height: Option<u32>,
     message_dispatcher: MessageDispatcher,
     sent_messages: Vec<NetworkMessage>,
 }
@@ -30,6 +32,7 @@ impl MockNetworkManager {
             connected: true,
             connected_peer: SocketAddr::new(std::net::Ipv4Addr::LOCALHOST.into(), 9999),
             headers_chain: Vec::new(),
+            peer_best_height: None,
             message_dispatcher: MessageDispatcher::default(),
             sent_messages: Vec::new(),
         }
@@ -152,8 +155,8 @@ impl NetworkManager for MockNetworkManager {
         }
     }
 
-    async fn get_peer_best_height(&self) -> NetworkResult<Option<u32>> {
-        Ok(Some(self.headers_chain.len() as u32))
+    async fn get_peer_best_height(&self) -> Option<CoreBlockHeight> {
+        self.peer_best_height
     }
 
     async fn has_peer_with_service(&self, _service_flags: ServiceFlags) -> bool {