@dignetwork/chia-block-listener 0.1.12 → 0.1.15

package/README.md

@@ -68,31 +68,6 @@ process.on('SIGINT', () => {
   process.exit(0)
 })
 ```
-
-## Recent Enhancements 🚀
-
-This library includes several powerful enhancements for production use:
-
-### Automatic Failover System
-- **Intelligent Retry Logic**: Automatically tries up to 3 different peers when block requests fail
-- **Smart Peer Selection**: Chooses the best available peer for each request based on response times
-- **Transparent Operation**: Failover happens automatically without user intervention
-
-### Enhanced Error Handling
-- **Protocol Error Detection**: Automatically detects and disconnects peers that refuse blocks or send invalid data
-- **Connection Health Monitoring**: Tracks peer connection health and removes problematic peers
-- **Error Classification**: Distinguishes between temporary issues and permanent peer problems
-
-### Performance Optimizations
-- **Aggressive Rate Limiting**: 50ms rate limiting per peer for maximum throughput
-- **Persistent Connections**: Reuses WebSocket connections for optimal performance
-- **Parallel Processing**: Efficient handling of multiple concurrent block requests
-
-### Developer Experience
-- **camelCase API**: All JavaScript methods use proper camelCase naming conventions
-- **Comprehensive Events**: Detailed event system for monitoring peer lifecycle and errors
-- **TypeScript Support**: Full type safety with complete TypeScript definitions
-
 ## API Reference
 
 ### ChiaBlockListener Class

package/index.d.ts

@@ -44,6 +44,11 @@ export interface CoinSpend {
   solution: string
   offset: number
 }
+export interface NewPeakHeightEvent {
+  oldPeak?: number | null
+  newPeak: number
+  peerId: string
+}
 export declare function initTracing(): void
 export declare class ChiaBlockListener {
   constructor()
@@ -51,7 +56,21 @@ export declare class ChiaBlockListener {
   disconnectPeer(peerId: string): boolean
   disconnectAllPeers(): void
   getConnectedPeers(): Array<string>
+  // Typed event method overloads
+
+  on(event: 'blockReceived', callback: (event: BlockReceivedEvent) => void): void
+
+  on(event: 'peerConnected', callback: (event: PeerConnectedEvent) => void): void
+
+  on(event: 'peerDisconnected', callback: (event: PeerDisconnectedEvent) => void): void
+
   on(event: string, callback: (...args: any[]) => any): void
+  off(event: 'blockReceived', callback: (event: BlockReceivedEvent) => void): void
+
+  off(event: 'peerConnected', callback: (event: PeerConnectedEvent) => void): void
+
+  off(event: 'peerDisconnected', callback: (event: PeerDisconnectedEvent) => void): void
+
   off(event: string, callback: (...args: any[]) => any): void
   getBlockByHeight(peerId: string, height: number): BlockReceivedEvent
   getBlocksRange(peerId: string, startHeight: number, endHeight: number): Array<BlockReceivedEvent>
@@ -64,6 +83,13 @@ export declare class ChiaPeerPool {
   shutdown(): Promise<void>
   getConnectedPeers(): Promise<Array<string>>
   getPeakHeight(): Promise<number | null>
+  // Typed event method overloads for ChiaPeerPool
+  on(event: 'peerConnected', callback: (event: PeerConnectedEvent) => void): void
+  on(event: 'peerDisconnected', callback: (event: PeerDisconnectedEvent) => void): void
+  on(event: 'newPeakHeight', callback: (event: NewPeakHeightEvent) => void): void
   on(event: string, callback: (...args: any[]) => any): void
+  off(event: 'peerConnected', callback: (event: PeerConnectedEvent) => void): void
+  off(event: 'peerDisconnected', callback: (event: PeerDisconnectedEvent) => void): void
+  off(event: 'newPeakHeight', callback: (event: NewPeakHeightEvent) => void): void
   off(event: string, callback: (...args: any[]) => any): void
 }

package/npm/darwin-arm64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dignetwork/chia-block-listener-darwin-arm64",
-  "version": "0.1.12",
+  "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.12",
+  "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.12",
+  "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.12",
+  "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.12",
+  "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.12",
+  "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.12",
-    "@dignetwork/chia-block-listener-darwin-x64": "0.1.12",
-    "@dignetwork/chia-block-listener-linux-x64-gnu": "0.1.12",
-    "@dignetwork/chia-block-listener-darwin-arm64": "0.1.12",
-    "@dignetwork/chia-block-listener-linux-arm64-gnu": "0.1.12"
+    "@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/scripts/post-build.js

@@ -28,43 +28,65 @@ function addTypedOverloads() {
       return;
     }
     
-    // Find the on and off method declarations and add overloads before them
-    const onMethodRegex = /(\s+)(on\(event: string, callback: \(\.\.\.args: any\[\]\) => any\): void)/;
-    const offMethodRegex = /(\s+)(off\(event: string, callback: \(\.\.\.args: any\[\]\) => any\): void)/;
+    // Add NewPeakHeightEvent interface if not present
+    if (!content.includes('NewPeakHeightEvent')) {
+      const insertPosition = content.indexOf('export declare function initTracing(): void');
+      if (insertPosition !== -1) {
+        const newInterface = `export interface NewPeakHeightEvent {
+  oldPeak?: number | null
+  newPeak: number
+  peerId: string
+}
+`;
+        content = content.substring(0, insertPosition) + newInterface + content.substring(insertPosition);
+        console.log('✅ Added NewPeakHeightEvent interface');
+      }
+    }
     
-    // Add typed overloads for 'on' method
-    if (onMethodRegex.test(content)) {
+    // Handle ChiaBlockListener events - find the class and add typed overloads
+    let blockListenerMatch = content.match(/(export declare class ChiaBlockListener \{[\s\S]*?)(\s+)(on\(event: string, callback: \(\.\.\.args: any\[\]\) => any\): void)/);
+    if (blockListenerMatch) {
+      const replacement = `${blockListenerMatch[1]}${blockListenerMatch[2]}// Typed event method overloads for ChiaBlockListener
+${blockListenerMatch[2]}on(event: 'blockReceived', callback: (event: BlockReceivedEvent) => void): void
+${blockListenerMatch[2]}on(event: 'peerConnected', callback: (event: PeerConnectedEvent) => void): void
+${blockListenerMatch[2]}on(event: 'peerDisconnected', callback: (event: PeerDisconnectedEvent) => void): void
+${blockListenerMatch[2]}${blockListenerMatch[3]}`;
+      content = content.replace(blockListenerMatch[0], replacement);
+      
+      // Also add off method overloads
       content = content.replace(
-        onMethodRegex,
-        `$1// Typed event method overloads
-$1on(event: 'blockReceived', callback: (event: BlockReceivedEvent) => void): void
-$1on(event: 'peerConnected', callback: (event: PeerConnectedEvent) => void): void
-$1on(event: 'peerDisconnected', callback: (event: PeerDisconnectedEvent) => void): void
-$1$2`
+        /(export declare class ChiaBlockListener \{[\s\S]*?)(\s+)(off\(event: string, callback: \(\.\.\.args: any\[\]\) => any\): void)/,
+        `$1$2off(event: 'blockReceived', callback: (event: BlockReceivedEvent) => void): void
+$2off(event: 'peerConnected', callback: (event: PeerConnectedEvent) => void): void
+$2off(event: 'peerDisconnected', callback: (event: PeerDisconnectedEvent) => void): void
+$2$3`
       );
-    } else {
-      console.error('❌ Could not find on() method in index.d.ts');
-      return;
     }
     
-    // Add typed overloads for 'off' method
-    if (offMethodRegex.test(content)) {
+    // Handle ChiaPeerPool events - find the class and add typed overloads
+    let peerPoolMatch = content.match(/(export declare class ChiaPeerPool \{[\s\S]*?)(\s+)(on\(event: string, callback: \(\.\.\.args: any\[\]\) => any\): void)/);
+    if (peerPoolMatch) {
+      const replacement = `${peerPoolMatch[1]}${peerPoolMatch[2]}// Typed event method overloads for ChiaPeerPool
+${peerPoolMatch[2]}on(event: 'peerConnected', callback: (event: PeerConnectedEvent) => void): void
+${peerPoolMatch[2]}on(event: 'peerDisconnected', callback: (event: PeerDisconnectedEvent) => void): void
+${peerPoolMatch[2]}on(event: 'newPeakHeight', callback: (event: NewPeakHeightEvent) => void): void
+${peerPoolMatch[2]}${peerPoolMatch[3]}`;
+      content = content.replace(peerPoolMatch[0], replacement);
+      
+      // Also add off method overloads
       content = content.replace(
-        offMethodRegex,
-        `$1off(event: 'blockReceived', callback: (event: BlockReceivedEvent) => void): void
-$1off(event: 'peerConnected', callback: (event: PeerConnectedEvent) => void): void
-$1off(event: 'peerDisconnected', callback: (event: PeerDisconnectedEvent) => void): void
-$1$2`
+        /(export declare class ChiaPeerPool \{[\s\S]*?)(\s+)(off\(event: string, callback: \(\.\.\.args: any\[\]\) => any\): void)/,
+        `$1$2off(event: 'peerConnected', callback: (event: PeerConnectedEvent) => void): void
+$2off(event: 'peerDisconnected', callback: (event: PeerDisconnectedEvent) => void): void
+$2off(event: 'newPeakHeight', callback: (event: NewPeakHeightEvent) => void): void
+$2$3`
       );
-    } else {
-      console.error('❌ Could not find off() method in index.d.ts');
-      return;
     }
     
     // Write the updated content back to the file
     fs.writeFileSync(indexDtsPath, content, 'utf8');
     
-    console.log('✅ Successfully added typed event method overloads to index.d.ts');
+    console.log('✅ Successfully added typed event method overloads for both ChiaBlockListener and ChiaPeerPool');
   } catch (error) {
     console.error('❌ Error adding typed overloads:', error.message);
     process.exit(1);

package/src/peer_pool.rs

@@ -6,6 +6,7 @@ use crate::peer::PeerConnection;
 use chia_generator_parser::{BlockParser, ParsedBlock};
 use chia_protocol::FullBlock;
 use hex::encode as hex_encode;
+use napi_derive::napi;
 use std::collections::{HashMap, VecDeque};
 use std::sync::Arc;
 use std::time::{Duration, Instant};
@@ -15,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)
 
@@ -24,9 +25,13 @@ pub type PeerDisconnectedCallback = Box<dyn Fn(PeerDisconnectedEvent) + Send + S
 pub type NewPeakHeightCallback = Box<dyn Fn(NewPeakHeightEvent) + Send + Sync + 'static>;
 
 #[derive(Debug, Clone)]
+#[napi(object)]
 pub struct NewPeakHeightEvent {
+    #[napi(js_name = "oldPeak")]
     pub old_peak: Option<u32>,
+    #[napi(js_name = "newPeak")]
     pub new_peak: u32,
+    #[napi(js_name = "peerId")]
     pub peer_id: String,
 }
 
@@ -50,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>,
 }
 
@@ -88,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,
         }));
 
@@ -362,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)
@@ -378,6 +389,7 @@ impl ChiaPeerPool {
         }
 
         guard.peer_ids.clear();
+        guard.round_robin_index = 0;
         Ok(())
     }
 
@@ -423,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) {
@@ -956,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