0.1.10

Author: MichaelTaylor3D

README.md

@@ -177,7 +177,15 @@ Shuts down the pool and disconnects all peers.
 
 ##### `getConnectedPeers(): Promise<string[]>`
 
-Returns a list of connected peer IDs.
+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`
 
@@ -232,6 +240,12 @@ 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`
@@ -273,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
@@ -319,6 +343,13 @@ async function main() {
     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')
@@ -396,6 +427,46 @@ try {
 }
 ```
 
+#### 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:**
@@ -421,6 +492,7 @@ import {
   BlockReceivedEvent, 
   PeerConnectedEvent, 
   PeerDisconnectedEvent,
+  NewPeakHeightEvent,
   CoinRecord,
   CoinSpend,
   initTracing,
@@ -490,13 +562,19 @@ 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'}`)
 }
 ```
 

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,
         })
     }
 
@@ -373,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
@@ -464,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,
@@ -509,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;