@dignetwork/chia-block-listener 0.1.17 → 0.1.18

package/Cargo.toml

@@ -26,6 +26,7 @@ native-tls = { version = "0.2", features = ["vendored"] }
 
 # Serialization
 serde = { version = "1", features = ["derive"] }
+hex = "0.4"
 
 # Utilities
 thiserror = "1"

package/README.md

@@ -757,12 +757,358 @@ try {
 - **IPv6 URL Formatting**: Automatic bracket formatting for IPv6 addresses
 - **Type Safety**: Full TypeScript support with detailed type definitions
 
+## ChiaBlockParser Usage
+
+The `ChiaBlockParser` provides direct access to the Rust-based block parsing engine, enabling efficient parsing of Chia FullBlock data with complete control over the parsing process. This is ideal for applications that need to process block data from external sources or implement custom block analysis.
+
+### Basic Block Parsing
+
+```javascript
+const { ChiaBlockParser, initTracing } = require('@dignetwork/chia-block-listener')
+
+async function parseBlockData() {
+  // Initialize tracing
+  initTracing()
+  
+  // Create a block parser instance
+  const parser = new ChiaBlockParser()
+  
+  // Parse a block from hex string
+  const blockHex = "your_full_block_hex_data_here"
+  const parsedBlock = parser.parseFullBlockFromHex(blockHex)
+  
+  console.log(`Parsed block ${parsedBlock.height}:`)
+  console.log(`  Header hash: ${parsedBlock.headerHash}`)
+  console.log(`  Weight: ${parsedBlock.weight}`)
+  console.log(`  Timestamp: ${new Date(parsedBlock.timestamp * 1000)}`)
+  console.log(`  Coin additions: ${parsedBlock.coinAdditions.length}`)
+  console.log(`  Coin removals: ${parsedBlock.coinRemovals.length}`)
+  console.log(`  Coin spends: ${parsedBlock.coinSpends.length}`)
+  console.log(`  Has generator: ${parsedBlock.hasTransactionsGenerator}`)
+  
+  // Access detailed coin spend information
+  parsedBlock.coinSpends.forEach((spend, index) => {
+    console.log(`  Spend ${index + 1}:`)
+    console.log(`    Coin: ${spend.coin.amount} mojos`)
+    console.log(`    Puzzle hash: ${spend.coin.puzzleHash}`)
+    console.log(`    Puzzle reveal: ${spend.puzzleReveal.substring(0, 100)}...`)
+    console.log(`    Solution: ${spend.solution.substring(0, 100)}...`)
+    console.log(`    Created coins: ${spend.createdCoins.length}`)
+  })
+}
+
+parseBlockData().catch(console.error)
+```
+
+### ChiaBlockParser Class
+
+#### Constructor
+
+```javascript
+const parser = new ChiaBlockParser()
+```
+
+Creates a new block parser instance with access to the full Rust parsing engine.
+
+#### Methods
+
+##### `parseFullBlockFromBytes(blockBytes): ParsedBlockJs`
+
+Parses a FullBlock from raw bytes.
+
+**Parameters:**
+- `blockBytes` (Buffer): The serialized FullBlock data
+
+**Returns:** A `ParsedBlockJs` object containing all parsed block information
+
+```javascript
+const fs = require('fs')
+const blockData = fs.readFileSync('block.bin')
+const parsedBlock = parser.parseFullBlockFromBytes(blockData)
+```
+
+##### `parseFullBlockFromHex(blockHex): ParsedBlockJs`
+
+Parses a FullBlock from a hex-encoded string.
+
+**Parameters:**
+- `blockHex` (string): The hex-encoded FullBlock data
+
+**Returns:** A `ParsedBlockJs` object containing all parsed block information
+
+```javascript
+const blockHex = "deadbeef..." // Your hex-encoded block data
+const parsedBlock = parser.parseFullBlockFromHex(blockHex)
+```
+
+##### `extractGeneratorFromBlockBytes(blockBytes): string | null`
+
+Extracts only the transactions generator from a block without full parsing.
+
+**Parameters:**
+- `blockBytes` (Buffer): The serialized FullBlock data
+
+**Returns:** Hex-encoded generator bytecode or `null` if no generator exists
+
+```javascript
+const blockData = fs.readFileSync('block.bin')
+const generator = parser.extractGeneratorFromBlockBytes(blockData)
+if (generator) {
+  console.log(`Generator size: ${generator.length / 2} bytes`)
+}
+```
+
+##### `getHeightAndTxStatusFromBlockBytes(blockBytes): BlockHeightInfoJs`
+
+Quickly extracts basic block information without full parsing.
+
+**Parameters:**
+- `blockBytes` (Buffer): The serialized FullBlock data
+
+**Returns:** A `BlockHeightInfoJs` object with height and transaction status
+
+```javascript
+const blockData = fs.readFileSync('block.bin')
+const info = parser.getHeightAndTxStatusFromBlockBytes(blockData)
+console.log(`Block ${info.height}, has transactions: ${info.isTransactionBlock}`)
+```
+
+##### `parseBlockInfoFromBytes(blockBytes): GeneratorBlockInfoJs`
+
+Extracts generator-related block metadata.
+
+**Parameters:**
+- `blockBytes` (Buffer): The serialized FullBlock data
+
+**Returns:** A `GeneratorBlockInfoJs` object with generator metadata
+
+```javascript
+const blockData = fs.readFileSync('block.bin')
+const blockInfo = parser.parseBlockInfoFromBytes(blockData)
+console.log(`Previous hash: ${blockInfo.prevHeaderHash}`)
+console.log(`Generator refs: ${blockInfo.transactionsGeneratorRefList.length}`)
+```
+
+### Advanced Parsing Features
+
+#### Batch Block Processing
+
+```javascript
+const parser = new ChiaBlockParser()
+const fs = require('fs')
+const path = require('path')
+
+// Process multiple block files
+const blockFiles = fs.readdirSync('./blocks/').filter(f => f.endsWith('.bin'))
+
+const stats = {
+  totalBlocks: 0,
+  totalSpends: 0,
+  totalCoins: 0,
+  generatorBlocks: 0
+}
+
+for (const filename of blockFiles) {
+  const blockData = fs.readFileSync(path.join('./blocks/', filename))
+  
+  try {
+    const parsed = parser.parseFullBlockFromBytes(blockData)
+    
+    stats.totalBlocks++
+    stats.totalSpends += parsed.coinSpends.length
+    stats.totalCoins += parsed.coinAdditions.length
+    
+    if (parsed.hasTransactionsGenerator) {
+      stats.generatorBlocks++
+    }
+    
+    console.log(`Processed block ${parsed.height} with ${parsed.coinSpends.length} spends`)
+    
+  } catch (error) {
+    console.error(`Failed to parse ${filename}:`, error.message)
+  }
+}
+
+console.log('\nBatch processing complete:')
+console.log(`  Blocks processed: ${stats.totalBlocks}`)
+console.log(`  Total spends: ${stats.totalSpends}`)
+console.log(`  Total coins: ${stats.totalCoins}`)
+console.log(`  Generator blocks: ${stats.generatorBlocks}`)
+```
+
+#### Generator Analysis
+
+```javascript
+const parser = new ChiaBlockParser()
+
+function analyzeBlockGenerator(blockHex) {
+  // Parse the full block
+  const parsed = parser.parseFullBlockFromHex(blockHex)
+  
+  if (!parsed.hasTransactionsGenerator) {
+    console.log('Block has no generator')
+    return
+  }
+  
+  // Extract just the generator for analysis
+  const blockBytes = Buffer.from(blockHex, 'hex')
+  const generator = parser.extractGeneratorFromBlockBytes(blockBytes)
+  
+  console.log(`Generator Analysis for Block ${parsed.height}:`)
+  console.log(`  Generator size: ${parsed.generatorSize} bytes`)
+  console.log(`  Hex length: ${generator.length} characters`)
+  console.log(`  Coin spends extracted: ${parsed.coinSpends.length}`)
+  console.log(`  Coins created: ${parsed.coinCreations.length}`)
+  
+  // Analyze coin spends
+  parsed.coinSpends.forEach((spend, i) => {
+    console.log(`  Spend ${i + 1}:`)
+    console.log(`    Amount: ${spend.coin.amount} mojos`)
+    console.log(`    Puzzle size: ${spend.puzzleReveal.length / 2} bytes`)
+    console.log(`    Solution size: ${spend.solution.length / 2} bytes`)
+    console.log(`    Creates ${spend.createdCoins.length} new coins`)
+  })
+}
+
+// Example usage
+const blockHex = "your_generator_block_hex"
+analyzeBlockGenerator(blockHex)
+```
+
+#### Integration with Other Components
+
+```javascript
+const { ChiaBlockParser, ChiaPeerPool, DnsDiscoveryClient } = require('@dignetwork/chia-block-listener')
+
+async function integratedBlockAnalysis() {
+  // Set up components
+  const parser = new ChiaBlockParser()
+  const pool = new ChiaPeerPool()
+  const discovery = new DnsDiscoveryClient()
+  
+  // Discover and connect to peers
+  const peers = await discovery.discoverMainnetPeers()
+  for (const peer of peers.ipv4Peers.slice(0, 3)) {
+    await pool.addPeer(peer.host, peer.port, 'mainnet')
+  }
+  
+  // Fetch blocks and parse with enhanced detail
+  const heights = [5000000, 5000001, 5000002]
+  
+  for (const height of heights) {
+    // Get block using peer pool
+    const blockEvent = await pool.getBlockByHeight(height)
+    
+    // For more detailed analysis, you can also parse with ChiaBlockParser
+    // if you have access to the raw block bytes
+    console.log(`Block ${height}:`)
+    console.log(`  From peer: ${blockEvent.peerId}`)
+    console.log(`  Coin spends: ${blockEvent.coinSpends.length}`)
+    console.log(`  Has generator: ${blockEvent.hasTransactionsGenerator}`)
+    
+    // Analyze puzzle patterns
+    const puzzleHashes = new Set()
+    blockEvent.coinSpends.forEach(spend => {
+      puzzleHashes.add(spend.coin.puzzleHash)
+    })
+    console.log(`  Unique puzzle hashes: ${puzzleHashes.size}`)
+  }
+  
+  await pool.shutdown()
+}
+
+integratedBlockAnalysis().catch(console.error)
+```
+
+### Data Types
+
+#### `ParsedBlockJs`
+
+```typescript
+interface ParsedBlockJs {
+  height: number                     // Block height
+  weight: string                     // Block weight as string
+  headerHash: string                 // Block header hash (hex)
+  timestamp?: number                 // Block timestamp (Unix time)
+  coinAdditions: CoinInfoJs[]        // New coins created
+  coinRemovals: CoinInfoJs[]         // Coins spent
+  coinSpends: CoinSpendInfoJs[]      // Detailed spend information
+  coinCreations: CoinInfoJs[]        // Coins created by spends
+  hasTransactionsGenerator: boolean  // Whether block has generator
+  generatorSize?: number             // Generator size in bytes
+}
+```
+
+#### `CoinInfoJs`
+
+```typescript
+interface CoinInfoJs {
+  parentCoinInfo: string  // Parent coin ID (hex)
+  puzzleHash: string      // Puzzle hash (hex)
+  amount: string          // Amount as string (to avoid JS precision issues)
+}
+```
+
+#### `CoinSpendInfoJs`
+
+```typescript
+interface CoinSpendInfoJs {
+  coin: CoinInfoJs                // The coin being spent
+  puzzleReveal: string            // CLVM puzzle bytecode (hex)
+  solution: string                // CLVM solution bytecode (hex)
+  realData: boolean               // Whether this is real transaction data
+  parsingMethod: string           // Method used for parsing
+  offset: number                  // Offset in generator bytecode
+  createdCoins: CoinInfoJs[]      // Coins created by this spend
+}
+```
+
+#### `GeneratorBlockInfoJs`
+
+```typescript
+interface GeneratorBlockInfoJs {
+  prevHeaderHash: string                    // Previous block hash (hex)
+  transactionsGenerator?: string            // Generator bytecode (hex)
+  transactionsGeneratorRefList: number[]    // Referenced block heights
+}
+```
+
+#### `BlockHeightInfoJs`
+
+```typescript
+interface BlockHeightInfoJs {
+  height: number              // Block height
+  isTransactionBlock: boolean // Whether block contains transactions
+}
+```
+
+### When to Use ChiaBlockParser
+
+- **Use ChiaBlockParser when:**
+  - You have raw block data from external sources
+  - You need detailed CLVM puzzle and solution analysis
+  - You're implementing custom block processing logic
+  - You need to extract generators for analysis
+  - You want fine-grained control over parsing
+
+- **Use with ChiaPeerPool when:**
+  - You need both block retrieval and detailed parsing
+  - You're analyzing historical blocks in detail
+  - You want to combine network access with parsing
+
+- **Use with ChiaBlockListener when:**
+  - You're processing real-time blocks with custom logic
+  - You need both live monitoring and detailed parsing
+
+The `ChiaBlockParser` complements the other classes by providing the lowest-level access to the Chia block parsing engine, enabling sophisticated analysis and processing workflows.
+
 ## TypeScript Usage
 
 ```typescript
 import { 
   ChiaBlockListener, 
   ChiaPeerPool,
+  ChiaBlockParser,
   DnsDiscoveryClient,
   BlockReceivedEvent, 
   PeerConnectedEvent, 
@@ -773,6 +1119,11 @@ import {
   AddressResult,
   CoinRecord,
   CoinSpend,
+  ParsedBlockJs,
+  CoinInfoJs,
+  CoinSpendInfoJs,
+  GeneratorBlockInfoJs,
+  BlockHeightInfoJs,
   initTracing,
   getEventTypes
 } from '@dignetwork/chia-block-listener'
@@ -877,6 +1228,52 @@ async function typedDnsDiscovery(): Promise<void> {
   
   console.log(`IPv4 count: ${ipv4Result.count}, IPv6 count: ${ipv6Result.count}`)
 }
+
+// TypeScript ChiaBlockParser
+async function typedBlockParsing(): Promise<void> {
+  const parser = new ChiaBlockParser()
+  
+  // Type-safe block parsing from hex
+  const blockHex = "your_block_hex_data"
+  const parsedBlock: ParsedBlockJs = parser.parseFullBlockFromHex(blockHex)
+  
+  console.log(`Parsed block ${parsedBlock.height}:`)
+  console.log(`  Header hash: ${parsedBlock.headerHash}`)
+  console.log(`  Weight: ${parsedBlock.weight}`)
+  console.log(`  Coin additions: ${parsedBlock.coinAdditions.length}`)
+  console.log(`  Coin spends: ${parsedBlock.coinSpends.length}`)
+  console.log(`  Has generator: ${parsedBlock.hasTransactionsGenerator}`)
+  
+  // Type-safe access to coin spend details
+  parsedBlock.coinSpends.forEach((spend: CoinSpendInfoJs) => {
+    const coin: CoinInfoJs = spend.coin
+    console.log(`Spend: ${coin.amount} mojos from ${coin.puzzleHash}`)
+    console.log(`  Puzzle reveal size: ${spend.puzzleReveal.length / 2} bytes`)
+    console.log(`  Solution size: ${spend.solution.length / 2} bytes`)
+    console.log(`  Creates ${spend.createdCoins.length} new coins`)
+    console.log(`  Real data: ${spend.realData}`)
+    console.log(`  Parsing method: ${spend.parsingMethod}`)
+  })
+  
+  // Type-safe generator extraction
+  const blockBytes = Buffer.from(blockHex, 'hex')
+  const generator: string | null = parser.extractGeneratorFromBlockBytes(blockBytes)
+  if (generator) {
+    console.log(`Generator found: ${generator.length / 2} bytes`)
+  }
+  
+  // Type-safe height and tx status
+  const heightInfo: BlockHeightInfoJs = parser.getHeightAndTxStatusFromBlockBytes(blockBytes)
+  console.log(`Block ${heightInfo.height}, is transaction block: ${heightInfo.isTransactionBlock}`)
+  
+  // Type-safe block info extraction
+  const blockInfo: GeneratorBlockInfoJs = parser.parseBlockInfoFromBytes(blockBytes)
+  console.log(`Previous hash: ${blockInfo.prevHeaderHash}`)
+  console.log(`Generator refs: ${blockInfo.transactionsGeneratorRefList.length}`)
+  if (blockInfo.transactionsGenerator) {
+    console.log(`Generator size: ${blockInfo.transactionsGenerator.length / 2} bytes`)
+  }
+}
 ```
 
 ## Advanced Usage

package/examples/block-parser-example.mjs

@@ -0,0 +1,55 @@
+import { ChiaBlockParser } from '../index.js';
+
+async function demonstrateBlockParser() {
+    console.log('🔧 ChiaBlockParser Demo');
+    console.log('=======================\n');
+
+    // Create a new block parser instance
+    const parser = new ChiaBlockParser();
+    console.log('✅ Created ChiaBlockParser instance\n');
+
+    // Example: Parse a block from hex (you would replace this with actual block data)
+    try {
+        console.log('📄 Available methods:');
+        console.log('• parseFullBlockFromBytes(blockBytes: Buffer): ParsedBlockJs');
+        console.log('• parseFullBlockFromHex(blockHex: string): ParsedBlockJs');
+        console.log('• extractGeneratorFromBlockBytes(blockBytes: Buffer): string | null');
+        console.log('• getHeightAndTxStatusFromBlockBytes(blockBytes: Buffer): BlockHeightInfoJs');
+        console.log('• parseBlockInfoFromBytes(blockBytes: Buffer): GeneratorBlockInfoJs\n');
+
+        console.log('💡 Example usage:');
+        console.log(`
+// Parse a block from hex string
+const blockHex = "your_block_hex_here";
+const parsedBlock = parser.parseFullBlockFromHex(blockHex);
+console.log('Block height:', parsedBlock.height);
+console.log('Coin additions:', parsedBlock.coinAdditions.length);
+console.log('Coin spends:', parsedBlock.coinSpends.length);
+
+// Parse from buffer
+const blockBuffer = Buffer.from(blockHex, 'hex');
+const parsedFromBuffer = parser.parseFullBlockFromBytes(blockBuffer);
+
+// Extract just the generator
+const generator = parser.extractGeneratorFromBlockBytes(blockBuffer);
+if (generator) {
+    console.log('Generator found:', generator.substring(0, 100) + '...');
+} else {
+    console.log('No generator in this block');
+}
+
+// Get height and transaction status
+const heightInfo = parser.getHeightAndTxStatusFromBlockBytes(blockBuffer);
+console.log('Height:', heightInfo.height, 'Is transaction block:', heightInfo.isTransactionBlock);
+        `);
+
+        console.log('\n🎯 The ChiaBlockParser provides direct access to the Rust parser');
+        console.log('   with full type safety and all parsing methods available.');
+
+    } catch (error) {
+        console.error('❌ Error demonstrating parser:', error.message);
+    }
+}
+
+// Run the demo
+demonstrateBlockParser().catch(console.error); 

package/index.d.ts

@@ -22,6 +22,41 @@ export interface AddressResult {
   addresses: Array<string>
   count: number
 }
+export interface CoinInfoJs {
+  parentCoinInfo: string
+  puzzleHash: string
+  amount: string
+}
+export interface CoinSpendInfoJs {
+  coin: CoinInfoJs
+  puzzleReveal: string
+  solution: string
+  realData: boolean
+  parsingMethod: string
+  offset: number
+  createdCoins: Array<CoinInfoJs>
+}
+export interface ParsedBlockJs {
+  height: number
+  weight: string
+  headerHash: string
+  timestamp?: number
+  coinAdditions: Array<CoinInfoJs>
+  coinRemovals: Array<CoinInfoJs>
+  coinSpends: Array<CoinSpendInfoJs>
+  coinCreations: Array<CoinInfoJs>
+  hasTransactionsGenerator: boolean
+  generatorSize?: number
+}
+export interface GeneratorBlockInfoJs {
+  prevHeaderHash: string
+  transactionsGenerator?: string
+  transactionsGeneratorRefList: Array<number>
+}
+export interface BlockHeightInfoJs {
+  height: number
+  isTransactionBlock: boolean
+}
 export interface EventTypes {
   blockReceived: string
   peerConnected: string
@@ -69,6 +104,20 @@ export interface NewPeakHeightEvent {
   peerId: string
 }
 export declare function initTracing(): void
+export declare class ChiaBlockParser {
+  /** Create a new block parser */
+  constructor()
+  /** Parse a FullBlock from bytes */
+  parseFullBlockFromBytes(blockBytes: Buffer): ParsedBlockJs
+  /** Parse a FullBlock from hex string */
+  parseFullBlockFromHex(blockHex: string): ParsedBlockJs
+  /** Extract generator from block bytes */
+  extractGeneratorFromBlockBytes(blockBytes: Buffer): string | null
+  /** Get block height and transaction status from block bytes */
+  getHeightAndTxStatusFromBlockBytes(blockBytes: Buffer): BlockHeightInfoJs
+  /** Parse block info from block bytes */
+  parseBlockInfoFromBytes(blockBytes: Buffer): GeneratorBlockInfoJs
+}
 export declare class DnsDiscoveryClient {
   /** Create a new DNS discovery client */
   constructor()

package/npm/darwin-arm64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dignetwork/chia-block-listener-darwin-arm64",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "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.17",
+  "version": "0.1.18",
   "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.17",
+  "version": "0.1.18",
   "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.17",
+  "version": "0.1.18",
   "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.17",
+  "version": "0.1.18",
   "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.17",
+  "version": "0.1.18",
   "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.17",
-    "@dignetwork/chia-block-listener-darwin-x64": "0.1.17",
-    "@dignetwork/chia-block-listener-linux-x64-gnu": "0.1.17",
-    "@dignetwork/chia-block-listener-darwin-arm64": "0.1.17",
-    "@dignetwork/chia-block-listener-linux-arm64-gnu": "0.1.17"
+    "@dignetwork/chia-block-listener-win32-x64-msvc": "0.1.18",
+    "@dignetwork/chia-block-listener-darwin-x64": "0.1.18",
+    "@dignetwork/chia-block-listener-linux-x64-gnu": "0.1.18",
+    "@dignetwork/chia-block-listener-darwin-arm64": "0.1.18",
+    "@dignetwork/chia-block-listener-linux-arm64-gnu": "0.1.18"
   }
 }

package/src/block_parser_napi.rs

@@ -0,0 +1,265 @@
+use chia_generator_parser::{
+    parser::BlockParser as RustBlockParser,
+    types::{BlockHeightInfo, CoinInfo, CoinSpendInfo, GeneratorBlockInfo, ParsedBlock},
+};
+use chia_protocol::FullBlock;
+use chia_traits::streamable::Streamable;
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+use tracing::{debug, info};
+
+// Export CoinInfo for TypeScript
+#[napi(object)]
+#[derive(Clone)]
+pub struct CoinInfoJS {
+    #[napi(js_name = "parentCoinInfo")]
+    pub parent_coin_info: String,
+    #[napi(js_name = "puzzleHash")]
+    pub puzzle_hash: String,
+    pub amount: String, // Use string for u64 to avoid JS precision issues
+}
+
+impl From<&CoinInfo> for CoinInfoJS {
+    fn from(coin: &CoinInfo) -> Self {
+        Self {
+            parent_coin_info: coin.parent_coin_info.clone(),
+            puzzle_hash: coin.puzzle_hash.clone(),
+            amount: coin.amount.to_string(),
+        }
+    }
+}
+
+// Export CoinSpendInfo for TypeScript
+#[napi(object)]
+#[derive(Clone)]
+pub struct CoinSpendInfoJS {
+    pub coin: CoinInfoJS,
+    #[napi(js_name = "puzzleReveal")]
+    pub puzzle_reveal: String,
+    pub solution: String,
+    #[napi(js_name = "realData")]
+    pub real_data: bool,
+    #[napi(js_name = "parsingMethod")]
+    pub parsing_method: String,
+    pub offset: u32,
+    #[napi(js_name = "createdCoins")]
+    pub created_coins: Vec<CoinInfoJS>,
+}
+
+impl From<&CoinSpendInfo> for CoinSpendInfoJS {
+    fn from(spend: &CoinSpendInfo) -> Self {
+        Self {
+            coin: (&spend.coin).into(),
+            puzzle_reveal: spend.puzzle_reveal.clone(),
+            solution: spend.solution.clone(),
+            real_data: spend.real_data,
+            parsing_method: spend.parsing_method.clone(),
+            offset: spend.offset,
+            created_coins: spend.created_coins.iter().map(|c| c.into()).collect(),
+        }
+    }
+}
+
+// Export ParsedBlock for TypeScript
+#[napi(object)]
+#[derive(Clone)]
+pub struct ParsedBlockJS {
+    pub height: u32,
+    pub weight: String,
+    #[napi(js_name = "headerHash")]
+    pub header_hash: String,
+    pub timestamp: Option<u32>,
+    #[napi(js_name = "coinAdditions")]
+    pub coin_additions: Vec<CoinInfoJS>,
+    #[napi(js_name = "coinRemovals")]
+    pub coin_removals: Vec<CoinInfoJS>,
+    #[napi(js_name = "coinSpends")]
+    pub coin_spends: Vec<CoinSpendInfoJS>,
+    #[napi(js_name = "coinCreations")]
+    pub coin_creations: Vec<CoinInfoJS>,
+    #[napi(js_name = "hasTransactionsGenerator")]
+    pub has_transactions_generator: bool,
+    #[napi(js_name = "generatorSize")]
+    pub generator_size: Option<u32>,
+}
+
+impl From<&ParsedBlock> for ParsedBlockJS {
+    fn from(block: &ParsedBlock) -> Self {
+        Self {
+            height: block.height,
+            weight: block.weight.clone(),
+            header_hash: block.header_hash.clone(),
+            timestamp: block.timestamp,
+            coin_additions: block.coin_additions.iter().map(|c| c.into()).collect(),
+            coin_removals: block.coin_removals.iter().map(|c| c.into()).collect(),
+            coin_spends: block.coin_spends.iter().map(|s| s.into()).collect(),
+            coin_creations: block.coin_creations.iter().map(|c| c.into()).collect(),
+            has_transactions_generator: block.has_transactions_generator,
+            generator_size: block.generator_size,
+        }
+    }
+}
+
+// Export GeneratorBlockInfo for TypeScript
+#[napi(object)]
+#[derive(Clone)]
+pub struct GeneratorBlockInfoJS {
+    #[napi(js_name = "prevHeaderHash")]
+    pub prev_header_hash: String,
+    #[napi(js_name = "transactionsGenerator")]
+    pub transactions_generator: Option<String>, // Hex-encoded bytes
+    #[napi(js_name = "transactionsGeneratorRefList")]
+    pub transactions_generator_ref_list: Vec<u32>,
+}
+
+impl From<&GeneratorBlockInfo> for GeneratorBlockInfoJS {
+    fn from(info: &GeneratorBlockInfo) -> Self {
+        Self {
+            prev_header_hash: hex::encode(info.prev_header_hash),
+            transactions_generator: info.transactions_generator.as_ref().map(hex::encode),
+            transactions_generator_ref_list: info.transactions_generator_ref_list.clone(),
+        }
+    }
+}
+
+// Export BlockHeightInfo for TypeScript
+#[napi(object)]
+#[derive(Clone)]
+pub struct BlockHeightInfoJS {
+    pub height: u32,
+    #[napi(js_name = "isTransactionBlock")]
+    pub is_transaction_block: bool,
+}
+
+impl From<&BlockHeightInfo> for BlockHeightInfoJS {
+    fn from(info: &BlockHeightInfo) -> Self {
+        Self {
+            height: info.height,
+            is_transaction_block: info.is_transaction_block,
+        }
+    }
+}
+
+#[napi]
+pub struct ChiaBlockParser {
+    parser: RustBlockParser,
+}
+
+impl Default for ChiaBlockParser {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[napi]
+impl ChiaBlockParser {
+    /// Create a new block parser
+    #[napi(constructor)]
+    pub fn new() -> Self {
+        info!("Creating new ChiaBlockParser");
+        Self {
+            parser: RustBlockParser::new(),
+        }
+    }
+
+    /// Parse a FullBlock from bytes
+    #[napi]
+    pub fn parse_full_block_from_bytes(&self, block_bytes: Buffer) -> Result<ParsedBlockJS> {
+        debug!("Parsing FullBlock from {} bytes", block_bytes.len());
+
+        let parsed_block = self
+            .parser
+            .parse_full_block_from_bytes(&block_bytes)
+            .map_err(|e| Error::new(Status::GenericFailure, format!("Parse error: {e}")))?;
+
+        Ok((&parsed_block).into())
+    }
+
+    /// Parse a FullBlock from hex string
+    #[napi]
+    pub fn parse_full_block_from_hex(&self, block_hex: String) -> Result<ParsedBlockJS> {
+        debug!(
+            "Parsing FullBlock from hex string of length {}",
+            block_hex.len()
+        );
+
+        let block_bytes = hex::decode(&block_hex)
+            .map_err(|e| Error::new(Status::InvalidArg, format!("Hex decode error: {e}")))?;
+
+        let parsed_block = self
+            .parser
+            .parse_full_block_from_bytes(&block_bytes)
+            .map_err(|e| Error::new(Status::GenericFailure, format!("Parse error: {e}")))?;
+
+        Ok((&parsed_block).into())
+    }
+
+    /// Extract generator from block bytes
+    #[napi]
+    pub fn extract_generator_from_block_bytes(
+        &self,
+        block_bytes: Buffer,
+    ) -> Result<Option<String>> {
+        debug!("Extracting generator from {} bytes", block_bytes.len());
+
+        let block = FullBlock::from_bytes(&block_bytes).map_err(|e| {
+            Error::new(
+                Status::InvalidArg,
+                format!("Failed to deserialize FullBlock: {e}"),
+            )
+        })?;
+
+        let generator = self
+            .parser
+            .extract_generator_from_block(&block)
+            .map_err(|e| Error::new(Status::GenericFailure, format!("Extract error: {e}")))?;
+
+        Ok(generator.map(hex::encode))
+    }
+
+    /// Get block height and transaction status from block bytes
+    #[napi]
+    pub fn get_height_and_tx_status_from_block_bytes(
+        &self,
+        block_bytes: Buffer,
+    ) -> Result<BlockHeightInfoJS> {
+        debug!(
+            "Getting height and tx status from {} bytes",
+            block_bytes.len()
+        );
+
+        let block = FullBlock::from_bytes(&block_bytes).map_err(|e| {
+            Error::new(
+                Status::InvalidArg,
+                format!("Failed to deserialize FullBlock: {e}"),
+            )
+        })?;
+
+        let height_info = self
+            .parser
+            .get_height_and_tx_status_from_block(&block)
+            .map_err(|e| Error::new(Status::GenericFailure, format!("Parse error: {e}")))?;
+
+        Ok((&height_info).into())
+    }
+
+    /// Parse block info from block bytes
+    #[napi]
+    pub fn parse_block_info_from_bytes(&self, block_bytes: Buffer) -> Result<GeneratorBlockInfoJS> {
+        debug!("Parsing block info from {} bytes", block_bytes.len());
+
+        let block = FullBlock::from_bytes(&block_bytes).map_err(|e| {
+            Error::new(
+                Status::InvalidArg,
+                format!("Failed to deserialize FullBlock: {e}"),
+            )
+        })?;
+
+        let block_info = self
+            .parser
+            .parse_block_info(&block)
+            .map_err(|e| Error::new(Status::GenericFailure, format!("Parse error: {e}")))?;
+
+        Ok((&block_info).into())
+    }
+}

package/src/lib.rs

@@ -2,6 +2,7 @@
 
 use napi_derive::napi;
 
+mod block_parser_napi;
 mod dns_discovery_napi;
 mod error;
 mod event_emitter;
@@ -11,6 +12,7 @@ mod peer_pool_napi;
 mod protocol;
 mod tls;
 
+pub use block_parser_napi::ChiaBlockParser;
 pub use dns_discovery_napi::DnsDiscoveryClient;
 pub use event_emitter::ChiaBlockListener;
 pub use peer_pool_napi::ChiaPeerPool;