@dignetwork/chia-block-listener 0.1.14 → 0.1.15

package/npm/darwin-arm64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dignetwork/chia-block-listener-darwin-arm64",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "repository": {
     "type": "git",
     "url": "https://github.com/DIG-Network/chia-block-listener"

package/npm/darwin-x64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dignetwork/chia-block-listener-darwin-x64",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "repository": {
     "type": "git",
     "url": "https://github.com/DIG-Network/chia-block-listener"

package/npm/linux-arm64-gnu/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dignetwork/chia-block-listener-linux-arm64-gnu",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "repository": {
     "type": "git",
     "url": "https://github.com/DIG-Network/chia-block-listener"

package/npm/linux-x64-gnu/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dignetwork/chia-block-listener-linux-x64-gnu",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "repository": {
     "type": "git",
     "url": "https://github.com/DIG-Network/chia-block-listener"

package/npm/win32-x64-msvc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dignetwork/chia-block-listener-win32-x64-msvc",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "repository": {
     "type": "git",
     "url": "https://github.com/DIG-Network/chia-block-listener"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dignetwork/chia-block-listener",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "main": "index.js",
   "types": "index.d.ts",
   "repository": {
@@ -61,10 +61,10 @@
     "@dignetwork/datalayer-driver": "^0.1.35"
   },
   "optionalDependencies": {
-    "@dignetwork/chia-block-listener-win32-x64-msvc": "0.1.14",
-    "@dignetwork/chia-block-listener-darwin-x64": "0.1.14",
-    "@dignetwork/chia-block-listener-linux-x64-gnu": "0.1.14",
-    "@dignetwork/chia-block-listener-darwin-arm64": "0.1.14",
-    "@dignetwork/chia-block-listener-linux-arm64-gnu": "0.1.14"
+    "@dignetwork/chia-block-listener-win32-x64-msvc": "0.1.15",
+    "@dignetwork/chia-block-listener-darwin-x64": "0.1.15",
+    "@dignetwork/chia-block-listener-linux-x64-gnu": "0.1.15",
+    "@dignetwork/chia-block-listener-darwin-arm64": "0.1.15",
+    "@dignetwork/chia-block-listener-linux-arm64-gnu": "0.1.15"
   }
 }

package/src/peer_pool.rs

@@ -16,7 +16,7 @@ use tokio::time::timeout;
 use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
 use tracing::{debug, error, info, warn};
 
-const RATE_LIMIT_MS: u64 = 50; // Aggressive rate limiting for maximum performance
+const RATE_LIMIT_MS: u64 = 500; // 500ms cooldown between peer usage
 const REQUEST_TIMEOUT_MS: u64 = 5000; // 5 second timeout for block requests (reduced from 10s)
 const CONNECTION_TIMEOUT_MS: u64 = 3000; // 3 second timeout for connections (reduced from 5s)
 
@@ -55,7 +55,8 @@ pub struct ChiaPeerPool {
 
 struct ChiaPeerPoolInner {
     peers: HashMap<String, PeerInfo>,
-    peer_ids: Vec<String>, // For round-robin
+    peer_ids: Vec<String>,    // For round-robin
+    round_robin_index: usize, // Track current position in round-robin
     highest_peak: Option<u32>,
 }
 
@@ -93,6 +94,7 @@ impl ChiaPeerPool {
         let inner = Arc::new(RwLock::new(ChiaPeerPoolInner {
             peers: HashMap::new(),
             peer_ids: Vec::new(),
+            round_robin_index: 0,
             highest_peak: None,
         }));
 
@@ -367,6 +369,10 @@ impl ChiaPeerPool {
             }
 
             guard.peer_ids.retain(|id| id != &peer_id);
+            // Adjust round_robin_index if needed
+            if guard.round_robin_index >= guard.peer_ids.len() && !guard.peer_ids.is_empty() {
+                guard.round_robin_index = 0;
+            }
             Ok(true)
         } else {
             Ok(false)
@@ -383,6 +389,7 @@ impl ChiaPeerPool {
         }
 
         guard.peer_ids.clear();
+        guard.round_robin_index = 0;
         Ok(())
     }
 
@@ -428,41 +435,43 @@ impl ChiaPeerPool {
                             if let Some(request) = request_queue.front() {
                                 match request {
                                     PoolRequest::GetBlockByHeight { .. } => {
-                                        // Find the best available peer (most recently successful)
+                                        // Round-robin peer selection with 500ms cooldown
                                         let now = Instant::now();
-                                        let mut best_peer = None;
-                                        let mut shortest_wait = Duration::from_secs(999);
-
-                                        // Check if we have a preferred peer and if it's available
-                                        // The preferred_peer logic is removed, so we just find the first available peer
-                                        for peer_id in &guard.peer_ids {
-                                            if let Some(peer_info) = guard.peers.get(peer_id) {
-                                                if peer_info.is_connected {
-                                                    let time_since_last_use = now.duration_since(peer_info.last_used);
-
-                                                    // Prefer peers that are immediately available
-                                                    if time_since_last_use >= Duration::from_millis(RATE_LIMIT_MS) {
-                                                        best_peer = Some(peer_id.clone());
-                                                        break;
-                                                    }
-
-                                                    // Track the peer that will be available soonest
-                                                    let wait_time = Duration::from_millis(RATE_LIMIT_MS) - time_since_last_use;
-                                                    if wait_time < shortest_wait {
-                                                        shortest_wait = wait_time;
-                                                        best_peer = Some(peer_id.clone());
+                                        let mut selected_peer = None;
+                                        let mut attempts = 0;
+                                        let total_peers = guard.peer_ids.len();
+
+                                        // Try to find an available peer using round-robin
+                                        while attempts < total_peers {
+                                            if !guard.peer_ids.is_empty() {
+                                                let peer_id = &guard.peer_ids[guard.round_robin_index];
+
+                                                if let Some(peer_info) = guard.peers.get(peer_id) {
+                                                    if peer_info.is_connected {
+                                                        let time_since_last_use = now.duration_since(peer_info.last_used);
+
+                                                        // Check if this peer is available (past cooldown)
+                                                        if time_since_last_use >= Duration::from_millis(RATE_LIMIT_MS) {
+                                                            selected_peer = Some(peer_id.clone());
+                                                            // Move to next peer for next request
+                                                            guard.round_robin_index = (guard.round_robin_index + 1) % total_peers;
+                                                            break;
+                                                        }
                                                     }
                                                 }
+
+                                                // Move to next peer and try again
+                                                guard.round_robin_index = (guard.round_robin_index + 1) % total_peers;
                                             }
+                                            attempts += 1;
                                         }
 
-                                        if let Some(peer_id) = best_peer {
+                                        if let Some(peer_id) = selected_peer {
                                             if let Some(peer_info) = guard.peers.get(&peer_id) {
                                                 let time_since_last_use = now.duration_since(peer_info.last_used);
 
-                                                // Only proceed if peer is available or wait time is very short
-                                                if time_since_last_use >= Duration::from_millis(RATE_LIMIT_MS) ||
-                                                   shortest_wait < Duration::from_millis(25) {
+                                                // Only proceed if peer is available (we already checked this in round-robin)
+                                                if time_since_last_use >= Duration::from_millis(RATE_LIMIT_MS) {
 
                                                     if let Some(request) = request_queue.pop_front() {
                                                         if let Some(peer_info) = guard.peers.get_mut(&peer_id) {
@@ -961,6 +970,10 @@ impl ChiaPeerPool {
                 let _ = worker_tx.send(WorkerRequest::Shutdown).await;
             }
             guard.peer_ids.retain(|id| id != &params.peer_id);
+            // Adjust round_robin_index if needed
+            if guard.round_robin_index >= guard.peer_ids.len() && !guard.peer_ids.is_empty() {
+                guard.round_robin_index = 0;
+            }
         }
 
         // Emit disconnected event