@dignetwork/chia-block-listener 0.1.8 → 0.1.11

package/.yarnrc.yml

@@ -1 +1 @@
-nodeLinker: node-modules 
+nodeLinker: node-modules

package/README.md

@@ -10,6 +10,7 @@ A high-performance Chia blockchain listener for Node.js, built with Rust and NAP
 - **Event-Driven Architecture**: TypeScript-friendly event system with full type safety
 - **Transaction Analysis**: Parse CLVM puzzles and solutions from coin spends
 - **Historical Block Access**: Retrieve blocks by height or ranges
+- **Connection Pool**: ChiaPeerPool provides automatic load balancing and rate limiting for historical queries
 - **Cross-platform Support**: Works on Windows, macOS, and Linux (x64 and ARM64)
 - **TypeScript Support**: Complete TypeScript definitions with IntelliSense
 
@@ -33,11 +34,11 @@ const listener = new ChiaBlockListener()
 // Listen for block events
 listener.on('blockReceived', (block) => {
   console.log(`New block received: ${block.height}`)
-  console.log(`Header hash: ${block.header_hash}`)
+  console.log(`Header hash: ${block.headerHash}`)
   console.log(`Timestamp: ${new Date(block.timestamp * 1000)}`)
-  console.log(`Coin additions: ${block.coin_additions.length}`)
-  console.log(`Coin removals: ${block.coin_removals.length}`)
-  console.log(`Coin spends: ${block.coin_spends.length}`)
+  console.log(`Coin additions: ${block.coinAdditions.length}`)
+  console.log(`Coin removals: ${block.coinRemovals.length}`)
+  console.log(`Coin spends: ${block.coinSpends.length}`)
 })
 
 // Listen for peer connection events
@@ -127,6 +128,80 @@ Retrieves a range of blocks from a connected peer.
 
 **Returns:** An array of `BlockReceivedEvent` objects
 
+### ChiaPeerPool Class
+
+The `ChiaPeerPool` provides a managed pool of peer connections for retrieving historical blocks with automatic load balancing and rate limiting.
+
+#### Constructor
+
+```javascript
+const pool = new ChiaPeerPool()
+```
+
+Creates a new peer pool instance with built-in rate limiting (500ms per peer).
+
+#### Methods
+
+##### `addPeer(host, port, networkId): Promise<string>`
+
+Adds a peer to the connection pool.
+
+**Parameters:**
+- `host` (string): The hostname or IP address of the Chia node
+- `port` (number): The port number (typically 8444 for mainnet)
+- `networkId` (string): The network identifier ('mainnet', 'testnet', etc.)
+
+**Returns:** A Promise that resolves to a unique peer ID string
+
+##### `getBlockByHeight(height): Promise<BlockReceivedEvent>`
+
+Retrieves a specific block by height using automatic peer selection and load balancing.
+
+**Parameters:**
+- `height` (number): The block height to retrieve
+
+**Returns:** A Promise that resolves to a `BlockReceivedEvent` object
+
+##### `removePeer(peerId): Promise<boolean>`
+
+Removes a peer from the pool.
+
+**Parameters:**
+- `peerId` (string): The peer ID to remove
+
+**Returns:** A Promise that resolves to `true` if the peer was removed, `false` otherwise
+
+##### `shutdown(): Promise<void>`
+
+Shuts down the pool and disconnects all peers.
+
+##### `getConnectedPeers(): Promise<string[]>`
+
+Gets the list of currently connected peer IDs.
+
+**Returns:** Array of peer ID strings (format: "host:port")
+
+##### `getPeakHeight(): Promise<number | null>`
+
+Gets the highest blockchain peak height seen across all connected peers.
+
+**Returns:** The highest peak height as a number, or null if no peaks have been received yet
+
+##### `on(event, callback): void`
+
+Registers an event handler for pool events.
+
+**Parameters:**
+- `event` (string): The event name ('peerConnected' or 'peerDisconnected')
+- `callback` (function): The event handler function
+
+##### `off(event, callback): void`
+
+Removes an event handler.
+
+**Parameters:**
+- `event` (string): The event name to stop listening for
+
 ### Events
 
 The `ChiaBlockListener` emits the following events:
@@ -149,6 +224,28 @@ Fired when a peer connection is lost.
 
 **Callback:** `(event: PeerDisconnectedEvent) => void`
 
+### ChiaPeerPool Events
+
+The `ChiaPeerPool` emits the following events:
+
+#### `peerConnected`
+
+Fired when a peer is successfully added to the pool.
+
+**Callback:** `(event: PeerConnectedEvent) => void`
+
+#### `peerDisconnected`
+
+Fired when a peer is removed from the pool or disconnects.
+
+**Callback:** `(event: PeerDisconnectedEvent) => void`
+
+#### `newPeakHeight`
+
+Fired when a new highest blockchain peak is discovered.
+
+**Callback:** `(event: NewPeakHeightEvent) => void`
+
 ### Event Data Types
 
 #### `BlockReceivedEvent`
@@ -190,6 +287,16 @@ interface PeerDisconnectedEvent {
 }
 ```
 
+#### `NewPeakHeightEvent`
+
+```typescript
+interface NewPeakHeightEvent {
+  oldPeak: number | null  // Previous highest peak (null if first peak)
+  newPeak: number        // New highest peak height
+  peerId: string         // Peer that discovered this peak
+}
+```
+
 #### `CoinRecord`
 
 ```typescript
@@ -211,14 +318,181 @@ interface CoinSpend {
 }
 ```
 
+## ChiaPeerPool Usage
+
+The `ChiaPeerPool` is designed for efficiently retrieving historical blocks with automatic load balancing across multiple peers.
+
+### Basic Usage
+
+```javascript
+const { ChiaPeerPool, initTracing } = require('@dignetwork/chia-block-listener')
+
+async function main() {
+  // Initialize tracing
+  initTracing()
+  
+  // Create a peer pool
+  const pool = new ChiaPeerPool()
+  
+  // Listen for pool events
+  pool.on('peerConnected', (event) => {
+    console.log(`Peer connected to pool: ${event.peerId}`)
+  })
+  
+  pool.on('peerDisconnected', (event) => {
+    console.log(`Peer disconnected from pool: ${event.peerId}`)
+  })
+  
+  pool.on('newPeakHeight', (event) => {
+    console.log(`New blockchain peak detected!`)
+    console.log(`  Previous: ${event.oldPeak || 'None'}`)
+    console.log(`  New: ${event.newPeak}`)
+    console.log(`  Discovered by: ${event.peerId}`)
+  })
+  
+  // Add multiple peers
+  await pool.addPeer('node1.chia.net', 8444, 'mainnet')
+  await pool.addPeer('node2.chia.net', 8444, 'mainnet')
+  await pool.addPeer('node3.chia.net', 8444, 'mainnet')
+  
+  // Fetch blocks with automatic load balancing
+  const block1 = await pool.getBlockByHeight(5000000)
+  const block2 = await pool.getBlockByHeight(5000001)
+  const block3 = await pool.getBlockByHeight(5000002)
+  
+  console.log(`Block ${block1.height}: ${block1.coinSpends.length} spends`)
+  console.log(`Block ${block2.height}: ${block2.coinSpends.length} spends`)
+  console.log(`Block ${block3.height}: ${block3.coinSpends.length} spends`)
+  
+  // Shutdown the pool
+  await pool.shutdown()
+}
+
+main().catch(console.error)
+```
+
+### Advanced Pool Features
+
+#### Rate Limiting
+
+The pool automatically enforces a 500ms rate limit per peer to prevent overwhelming any single node:
+
+```javascript
+// Rapid requests are automatically queued and distributed
+const promises = []
+for (let i = 5000000; i < 5000100; i++) {
+  promises.push(pool.getBlockByHeight(i))
+}
+
+// All requests will be processed efficiently across all peers
+const blocks = await Promise.all(promises)
+console.log(`Retrieved ${blocks.length} blocks`)
+```
+
+#### Dynamic Peer Management
+
+```javascript
+// Monitor pool health
+const peers = await pool.getConnectedPeers()
+console.log(`Active peers in pool: ${peers.length}`)
+
+// Remove underperforming peers
+if (slowPeer) {
+  await pool.removePeer(slowPeer)
+  console.log('Removed slow peer from pool')
+}
+
+// Add new peers dynamically
+if (peers.length < 3) {
+  await pool.addPeer('backup-node.chia.net', 8444, 'mainnet')
+}
+```
+
+#### Error Handling
+
+```javascript
+try {
+  const block = await pool.getBlockByHeight(5000000)
+  console.log(`Retrieved block ${block.height}`)
+} catch (error) {
+  console.error('Failed to retrieve block:', error)
+  
+  // The pool will automatically try other peers
+  // You can also add more peers if needed
+  const peers = await pool.getConnectedPeers()
+  if (peers.length === 0) {
+    console.log('No peers available, adding new ones...')
+    await pool.addPeer('node1.chia.net', 8444, 'mainnet')
+  }
+}
+```
+
+#### Peak Height Tracking
+
+```javascript
+// Monitor blockchain sync progress
+const pool = new ChiaPeerPool()
+
+// Track peak changes
+let currentPeak = null
+pool.on('newPeakHeight', (event) => {
+  currentPeak = event.newPeak
+  const progress = event.oldPeak 
+    ? `+${event.newPeak - event.oldPeak} blocks` 
+    : 'Initial peak'
+  console.log(`Peak update: ${event.newPeak} (${progress})`)
+})
+
+// Add peers
+await pool.addPeer('node1.chia.net', 8444, 'mainnet')
+await pool.addPeer('node2.chia.net', 8444, 'mainnet')
+
+// Check current peak
+const peak = await pool.getPeakHeight()
+console.log(`Current highest peak: ${peak || 'None yet'}`)
+
+// Fetch some blocks to trigger peak updates
+await pool.getBlockByHeight(5000000)
+await pool.getBlockByHeight(5100000)
+await pool.getBlockByHeight(5200000)
+
+// Monitor sync status
+setInterval(async () => {
+  const peak = await pool.getPeakHeight()
+  if (peak) {
+    const estimatedCurrent = 5200000 + Math.floor((Date.now() / 1000 - 1700000000) / 18.75)
+    const syncPercentage = (peak / estimatedCurrent * 100).toFixed(2)
+    console.log(`Sync status: ${syncPercentage}% (peak: ${peak})`)
+  }
+}, 60000) // Check every minute
+```
+
+### When to Use ChiaPeerPool vs ChiaBlockListener
+
+- **Use ChiaPeerPool when:**
+  - You need to fetch historical blocks
+  - You want automatic load balancing across multiple peers
+  - You're making many block requests and need rate limiting
+  - You don't need real-time block notifications
+
+- **Use ChiaBlockListener when:**
+  - You need real-time notifications of new blocks
+  - You want to monitor the blockchain as it grows
+  - You need to track specific addresses or puzzle hashes in real-time
+  - You're building applications that react to blockchain events
+
+Both classes can be used together in the same application for different purposes.
+
 ## TypeScript Usage
 
 ```typescript
 import { 
   ChiaBlockListener, 
+  ChiaPeerPool,
   BlockReceivedEvent, 
   PeerConnectedEvent, 
   PeerDisconnectedEvent,
+  NewPeakHeightEvent,
   CoinRecord,
   CoinSpend,
   initTracing,
@@ -279,6 +553,29 @@ async function getHistoricalBlocks() {
 // Get event type constants
 const eventTypes = getEventTypes()
 console.log('Available events:', eventTypes)
+
+// TypeScript support for ChiaPeerPool
+const pool = new ChiaPeerPool()
+
+// Type-safe event handling
+pool.on('peerConnected', (event: PeerConnectedEvent) => {
+  console.log(`Pool peer connected: ${event.peerId}`)
+})
+
+pool.on('newPeakHeight', (event: NewPeakHeightEvent) => {
+  console.log(`New peak: ${event.oldPeak} → ${event.newPeak}`)
+})
+
+// Async/await with proper typing
+async function fetchHistoricalData() {
+  const block: BlockReceivedEvent = await pool.getBlockByHeight(5000000)
+  const peers: string[] = await pool.getConnectedPeers()
+  const peak: number | null = await pool.getPeakHeight()
+  
+  console.log(`Block ${block.height} has ${block.coinSpends.length} spends`)
+  console.log(`Pool has ${peers.length} active peers`)
+  console.log(`Current peak: ${peak || 'No peak yet'}`)
+}
 ```
 
 ## Advanced Usage

package/crate/chia-generator-parser/src/parser.rs

@@ -1,9 +1,6 @@
 use crate::{
     error::{GeneratorParserError, Result},
-    types::{
-        BlockHeightInfo, CoinInfo, CoinSpendInfo, GeneratorAnalysis, GeneratorBlockInfo,
-        ParsedBlock, ParsedGenerator,
-    },
+    types::{BlockHeightInfo, CoinInfo, CoinSpendInfo, GeneratorBlockInfo, ParsedBlock},
 };
 use chia_bls::Signature;
 use chia_consensus::{
@@ -14,7 +11,7 @@ use chia_consensus::{
     run_block_generator::{run_block_generator2, setup_generator_args},
     validation_error::{atom, first, next, rest, ErrorCode},
 };
-use chia_protocol::{Bytes32, FullBlock};
+use chia_protocol::FullBlock;
 use chia_traits::streamable::Streamable;
 use clvm_utils::tree_hash;
 use clvmr::{
@@ -63,7 +60,7 @@ impl BlockParser {
             .map(|g| g.len() as u32);
 
         // Extract generator info
-        let generator_info = block
+        let _generator_info = block
             .transactions_generator
             .as_ref()
             .map(|gen| GeneratorBlockInfo {
@@ -101,7 +98,6 @@ impl BlockParser {
             coin_creations,
             has_transactions_generator,
             generator_size,
-            generator_info,
         })
     }
 
@@ -306,9 +302,23 @@ impl BlockParser {
     ) -> Option<CoinSpendInfo> {
         // Extract parent coin info
         let parent_bytes = self.extract_parent_coin_info(allocator, coin_spend)?;
-        let mut parent_arr = [0u8; 32];
-        parent_arr.copy_from_slice(&parent_bytes);
-        let parent_coin_info = Bytes32::new(parent_arr);
+        info!("🔍 DEBUG: parent_bytes length = {}", parent_bytes.len());
+
+        if parent_bytes.len() != 32 {
+            info!(
+                "❌ ERROR: parent_bytes wrong length: {} bytes (expected 32)",
+                parent_bytes.len()
+            );
+            return None;
+        }
+
+        // parent_bytes is already Vec<u8> with 32 bytes, just hex encode it directly
+        let parent_hex = hex::encode(&parent_bytes);
+        info!(
+            "🔍 DEBUG: parent_coin_info hex = {} (length: {})",
+            parent_hex,
+            parent_hex.len()
+        );
 
         // Extract puzzle, amount, and solution
         let rest1 = rest(allocator, coin_spend).ok()?;
@@ -324,14 +334,31 @@ impl BlockParser {
 
         // Calculate puzzle hash
         let puzzle_hash_vec = tree_hash(allocator, puzzle);
-        let mut puzzle_hash_arr = [0u8; 32];
-        puzzle_hash_arr.copy_from_slice(&puzzle_hash_vec);
-        let puzzle_hash = Bytes32::new(puzzle_hash_arr);
+        info!(
+            "🔍 DEBUG: tree_hash returned {} bytes",
+            puzzle_hash_vec.len()
+        );
+
+        if puzzle_hash_vec.len() != 32 {
+            info!(
+                "❌ ERROR: tree_hash returned wrong length: {} bytes (expected 32)",
+                puzzle_hash_vec.len()
+            );
+            return None;
+        }
+
+        // tree_hash returns Vec<u8> with 32 bytes, just hex encode it directly
+        let puzzle_hash_hex = hex::encode(&puzzle_hash_vec);
+        info!(
+            "🔍 DEBUG: puzzle_hash hex = {} (length: {})",
+            puzzle_hash_hex,
+            puzzle_hash_hex.len()
+        );
 
         // Create coin info
         let coin_info = CoinInfo {
-            parent_coin_info: hex::encode(&parent_coin_info),
-            puzzle_hash: hex::encode(&puzzle_hash),
+            parent_coin_info: parent_hex,
+            puzzle_hash: puzzle_hash_hex,
             amount,
         };
 
@@ -342,15 +369,15 @@ impl BlockParser {
         // Get created coins from conditions
         let created_coins = self.extract_created_coins(spend_index, spend_bundle_conditions);
 
-        Some(CoinSpendInfo {
-            coin: coin_info,
-            puzzle_reveal,
-            solution: solution_bytes,
-            real_data: true,
-            parsing_method: "clvm_execution".to_string(),
-            offset: 0,
+        Some(CoinSpendInfo::new(
+            coin_info,
+            hex::encode(puzzle_reveal),
+            hex::encode(solution_bytes),
+            true,
+            "From transaction generator".to_string(),
+            0,
             created_coins,
-        })
+        ))
     }
 
     /// Extract parent coin info from a coin spend node
@@ -433,42 +460,62 @@ impl BlockParser {
         })
     }
 
+    /*
     /// Parse generator from hex string
     pub fn parse_generator_from_hex(&self, generator_hex: &str) -> Result<ParsedGenerator> {
         let generator_bytes =
-            hex::decode(generator_hex).map_err(|e| GeneratorParserError::HexDecodingError(e))?;
+            hex::decode(generator_hex).map_err(|e| ParseError::HexDecodingError(e))?;
         self.parse_generator_from_bytes(&generator_bytes)
     }
 
     /// Parse generator from bytes
     pub fn parse_generator_from_bytes(&self, generator_bytes: &[u8]) -> Result<ParsedGenerator> {
-        let analysis = self.analyze_generator(generator_bytes)?;
-
+        // Create a dummy GeneratorBlockInfo for now
         Ok(ParsedGenerator {
-            block_info: GeneratorBlockInfo {
-                prev_header_hash: Bytes32::default(),
-                transactions_generator: Some(generator_bytes.to_vec()),
-                transactions_generator_ref_list: Vec::new(),
-            },
+            block_info: GeneratorBlockInfo::new(
+                [0u8; 32].into(),
+                Some(generator_bytes.to_vec()),
+                vec![],
+            ),
             generator_hex: Some(hex::encode(generator_bytes)),
-            analysis,
+            analysis: self.analyze_generator(generator_bytes)?,
         })
     }
 
     /// Analyze generator bytecode
     pub fn analyze_generator(&self, generator_bytes: &[u8]) -> Result<GeneratorAnalysis> {
         let size_bytes = generator_bytes.len();
-        let is_empty = size_bytes == 0;
-
-        // Check for CLVM patterns
-        let contains_clvm_patterns = generator_bytes
-            .windows(2)
-            .any(|w| matches!(w, [0xff, _] | [_, 0xff]));
-
-        // Check for coin patterns (CREATE_COIN opcode)
-        let contains_coin_patterns = generator_bytes.windows(1).any(|w| w[0] == 0x33);
+        let is_empty = generator_bytes.is_empty();
+
+        // Check for common CLVM patterns
+        let contains_clvm_patterns = generator_bytes.windows(2).any(|w| {
+            w == [0x01, 0x00] || // pair
+            w == [0x02, 0x00] || // cons
+            w == [0x03, 0x00] || // first
+            w == [0x04, 0x00]    // rest
+        });
+
+        // Check for coin patterns (32-byte sequences)
+        let contains_coin_patterns = generator_bytes.len() >= 32;
+
+        // Calculate simple entropy
+        let mut byte_counts = [0u64; 256];
+        for &byte in generator_bytes {
+            byte_counts[byte as usize] += 1;
+        }
 
-        let entropy = self.calculate_entropy(generator_bytes);
+        let total = generator_bytes.len() as f64;
+        let entropy = if total > 0.0 {
+            byte_counts.iter()
+                .filter(|&&count| count > 0)
+                .map(|&count| {
+                    let p = count as f64 / total;
+                    -p * p.log2()
+                })
+                .sum()
+        } else {
+            0.0
+        };
 
         Ok(GeneratorAnalysis {
             size_bytes,
@@ -478,8 +525,10 @@ impl BlockParser {
             entropy,
         })
     }
+    */
 
     /// Calculate Shannon entropy of data
+    #[allow(dead_code)]
     fn calculate_entropy(&self, data: &[u8]) -> f64 {
         if data.is_empty() {
             return 0.0;