@dignetwork/chia-block-listener 0.1.6 → 0.1.8

package/.github/workflows/CI.yml

@@ -53,19 +53,20 @@ jobs:
         settings:
           - host: macos-latest
             target: x86_64-apple-darwin
-            build: npm run build -- --target x86_64-apple-darwin
+            build: npm run build -- --target x86_64-apple-darwin && node scripts/post-build.js
           - host: windows-latest
-            build: npm run build -- --target x86_64-pc-windows-msvc
+            build: npm run build -- --target x86_64-pc-windows-msvc && node scripts/post-build.js
             target: x86_64-pc-windows-msvc
           - host: ubuntu-latest
             target: x86_64-unknown-linux-gnu
             build: |
               set -e && 
               npm run build -- --target x86_64-unknown-linux-gnu &&
+              node scripts/post-build.js &&
               strip *.node
           - host: macos-latest
             target: aarch64-apple-darwin
-            build: npm run build -- --target aarch64-apple-darwin
+            build: npm run build -- --target aarch64-apple-darwin && node scripts/post-build.js     
           - host: ubuntu-latest
             target: aarch64-unknown-linux-gnu
             setup: |
@@ -74,7 +75,8 @@ jobs:
             build: |
               set -e &&
               export CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc &&
-              npm run build -- --target aarch64-unknown-linux-gnu
+              npm run build -- --target aarch64-unknown-linux-gnu &&
+              node scripts/post-build.js
     name: stable - ${{ matrix.settings.target }} - node@22
     runs-on: ${{ matrix.settings.host }}
     steps:
@@ -191,7 +193,7 @@ jobs:
         node:
           - '20'
           - '22'
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
       - name: Setup node
@@ -250,18 +252,48 @@ jobs:
         uses: addnab/docker-run-action@v3
         with:
           image: ubuntu:24.04
-          options: '--platform linux/arm64 -v ${{ github.workspace }}:/build -w /build'
+          options: '--platform linux/arm64 -v ${{ github.workspace }}:/workspace -w /workspace'
           run: |
             set -e
+            export DEBIAN_FRONTEND=noninteractive
             apt-get update
-            apt-get install -y curl
-            curl -fsSL https://deb.nodesource.com/setup_${{ matrix.node }}.x | bash -
-            apt-get install -y nodejs
+            apt-get install -y curl ca-certificates xz-utils
+            
+            # Install Node.js using a different approach - download pre-built binary directly
+            NODE_VERSION="${{ matrix.node }}"
+            case "$NODE_VERSION" in
+              "20")
+                FULL_VERSION="20.18.0"
+                ;;
+              "22") 
+                FULL_VERSION="22.11.0"  # Use slightly older version of 22 for stability
+                ;;
+              *)
+                echo "Unsupported Node version: $NODE_VERSION"
+                exit 1
+                ;;
+            esac
+            
+            # Download and install Node.js binary
+            cd /tmp
+            curl -fsSL "https://nodejs.org/dist/v${FULL_VERSION}/node-v${FULL_VERSION}-linux-arm64.tar.xz" -o node.tar.xz
+            tar -xf node.tar.xz
+            cp -r "node-v${FULL_VERSION}-linux-arm64"/* /usr/local/
+            rm -rf node.tar.xz "node-v${FULL_VERSION}-linux-arm64"
+            
+            # Return to workspace
+            cd /workspace
+            
+            # Verify we're in the right directory and have the required files
+            pwd
+            ls -la
+            echo "Looking for package-lock.json:"
+            ls -la package-lock.json || echo "package-lock.json not found"
+            
             node --version
             npm --version
             npm ci
             npm test
-            ls -la
 
   publish:
     name: Publish

package/README.md

@@ -1,22 +1,17 @@
-# Proof of Work
+# Chia Block Listener
 
-A high-performance Bitcoin-compatible proof of work library for Node.js, built with Rust and NAPI bindings. This library provides efficient mining capabilities using Bitcoin's target-based difficulty system with double SHA-256 hashing.
+A high-performance Chia blockchain listener for Node.js, built with Rust and NAPI bindings. This library provides real-time monitoring of the Chia blockchain with efficient peer connections and block parsing capabilities.
 
 ## Features
 
-- **Bitcoin-Compatible**: Uses Bitcoin's target-based difficulty system with double SHA-256 hashing
-- **High Performance**: Written in Rust for maximum mining efficiency
-- **Asynchronous Mining**: Non-blocking proof of work computation that won't freeze your application
-- **Cancellable Operations**: Start mining with ability to cancel anytime using handles
-- **Progress Tracking**: Real-time progress monitoring with attempt counts and timing
-- **Unlimited Attempts**: Mine until solution is found (unless explicitly limited)
-- **Nonce Verification**: Verify that a nonce meets difficulty requirements
-- **Standardized Verification**: Consensus-critical verification with algorithm version validation
-- **Difficulty Analysis**: Calculate difficulty levels from hash values
-- **Security Features**: Tamper-resistant verification with algorithm immutability
-- **Cross-platform Support**: Builds for Windows, macOS, and Linux
-- **Multiple Architectures**: Supports x64 and ARM64 architectures
-- **TypeScript Support**: Full TypeScript definitions included
+- **Real-time Block Monitoring**: Listen for new blocks as they're produced on the Chia network
+- **Peer Management**: Connect to multiple Chia full nodes simultaneously
+- **Efficient Parsing**: Fast extraction of coin spends, additions, and removals from blocks
+- **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
+- **Cross-platform Support**: Works on Windows, macOS, and Linux (x64 and ARM64)
+- **TypeScript Support**: Complete TypeScript definitions with IntelliSense
 
 ## Installation
 
@@ -27,311 +22,348 @@ npm install @dignetwork/chia-block-listener
 ## Quick Start
 
 ```javascript
-const { computeProofOfWorkAsync } = require('@dignetwork/chia-block-listener')
-
-async function mine() {
-  const entropySeed = Buffer.from('my_plot_entropy_seed', 'utf-8')
-  const difficulty = 1.0 // Bitcoin difficulty (1.0 = easiest)
-  
-  // Start mining (returns immediately with a handle)
-  const handle = computeProofOfWorkAsync(entropySeed, difficulty)
-  
-  // Set up Ctrl+C handling for cancellation
-  process.on('SIGINT', () => {
-    console.log('\nCancelling mining...')
-    handle.cancel()
-    process.exit(0)
-  })
-  
-  // Wait for completion
-  while (!handle.isCompleted() && !handle.hasError()) {
-    console.log(`Mining... attempts: ${handle.getAttempts()}`)
-    await new Promise(resolve => setTimeout(resolve, 1000))
+const { ChiaBlockListener, initTracing } = require('@dignetwork/chia-block-listener')
+
+// Initialize tracing for debugging (optional)
+initTracing()
+
+// Create a new listener instance
+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(`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}`)
+})
+
+// Listen for peer connection events
+listener.on('peerConnected', (peer) => {
+  console.log(`Connected to peer: ${peer.peerId} (${peer.host}:${peer.port})`)
+})
+
+listener.on('peerDisconnected', (peer) => {
+  console.log(`Disconnected from peer: ${peer.peerId}`)
+  if (peer.message) {
+    console.log(`Reason: ${peer.message}`)
   }
-  
-  if (handle.hasError()) {
-    console.log('Mining failed:', handle.getError())
-  } else {
-    const result = handle.getResult()
-    console.log('Solution found!')
-    console.log('Nonce:', result.nonce)
-    console.log('Hash:', result.hash)
-    console.log('Attempts:', result.attempts)
-    console.log('Time:', result.time_ms, 'ms')
-  }
-}
-
-mine().catch(console.error)
+})
+
+// Connect to a Chia full node
+const peerId = listener.addPeer('localhost', 8444, 'mainnet')
+console.log(`Added peer: ${peerId}`)
+
+// Keep the process running
+process.on('SIGINT', () => {
+  console.log('Shutting down...')
+  listener.disconnectAllPeers()
+  process.exit(0)
+})
 ```
 
 ## API Reference
 
-### Main Functions
+### ChiaBlockListener Class
 
-#### `computeProofOfWorkAsync(entropySeed, difficulty, maxAttempts?, logAttempts?, doubleSha?): ProofOfWorkHandle`
+#### Constructor
 
-Computes proof of work asynchronously using Bitcoin's target-based difficulty system. Returns immediately with a handle for cancellation and progress tracking.
+```javascript
+const listener = new ChiaBlockListener()
+```
 
-**Parameters:**
-- `entropySeed` (Buffer): The entropy seed (plotId) to bind the work to
-- `difficulty` (number): Bitcoin-style difficulty level (1.0 = easiest, higher = harder)
-- `maxAttempts` (number, optional): Maximum attempts before giving up (default: unlimited)
-- `logAttempts` (boolean, optional): Whether to log each hash attempt (default: false)
-- `doubleSha` (boolean, optional): Whether to use double SHA-256 like Bitcoin (default: true)
+Creates a new Chia block listener instance.
 
-**Returns:** `ProofOfWorkHandle` for cancellation and progress tracking
+#### Methods
 
-#### `verifyProofOfWork(entropySeed, nonce, difficulty, doubleSha?): boolean`
+##### `addPeer(host, port, networkId): string`
 
-Verifies that a nonce produces a hash that meets the Bitcoin difficulty target.
+Connects to a Chia full node and starts listening for blocks.
 
 **Parameters:**
-- `entropySeed` (Buffer): The entropy seed that was used
-- `nonce` (number): The nonce to verify
-- `difficulty` (number): The required difficulty level
-- `doubleSha` (boolean, optional): Whether to use double SHA-256 (default: true)
+- `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:** `true` if the nonce is valid for the given difficulty
+**Returns:** A unique peer ID string for this connection
 
-#### `verifyProofOfWorkStandardized(entropySeed, nonce, difficulty, expectedVersion?, doubleSha?): boolean`
+##### `disconnectPeer(peerId): boolean`
 
-**CONSENSUS CRITICAL:** Standardized verification with algorithm validation. This function verifies both the proof of work AND the algorithm compatibility.
+Disconnects from a specific peer.
 
 **Parameters:**
-- `entropySeed` (Buffer): The entropy seed that was used
-- `nonce` (number): The nonce to verify
-- `difficulty` (number): The required difficulty level
-- `expectedVersion` (number, optional): Expected algorithm version (default: current)
-- `doubleSha` (boolean, optional): Whether to use double SHA-256 (default: true)
+- `peerId` (string): The peer ID returned by `addPeer()`
 
-**Returns:** `true` if the nonce is valid AND algorithm is correct
+**Returns:** `true` if the peer was successfully disconnected, `false` otherwise
 
-**Security Note:** Use this function for network consensus validation. It validates algorithm version compatibility and prevents tampering.
+##### `disconnectAllPeers(): void`
 
-### Utility Functions
+Disconnects from all connected peers.
 
-#### `difficultyToTargetHex(difficulty): string`
+##### `getConnectedPeers(): string[]`
 
-Convert a Bitcoin-style difficulty to the corresponding target value as hex.
+Returns an array of currently connected peer IDs.
 
-**Parameters:**
-- `difficulty` (number): The difficulty level
+##### `getBlockByHeight(peerId, height): BlockReceivedEvent`
 
-**Returns:** The target as a hex string
+Retrieves a specific block by its height from a connected peer.
 
-#### `hashToDifficulty(hash): number`
+**Parameters:**
+- `peerId` (string): The peer ID to query
+- `height` (number): The block height to retrieve
 
-Calculate the difficulty that a given hash would satisfy.
+**Returns:** A `BlockReceivedEvent` object containing the block data
 
-**Parameters:**
-- `hash` (Buffer): The hash to analyze (32 bytes)
+##### `getBlocksRange(peerId, startHeight, endHeight): BlockReceivedEvent[]`
 
-**Returns:** The difficulty level this hash would satisfy
+Retrieves a range of blocks from a connected peer.
 
-### Consensus & Security Functions
+**Parameters:**
+- `peerId` (string): The peer ID to query
+- `startHeight` (number): The starting block height (inclusive)
+- `endHeight` (number): The ending block height (inclusive)
 
-#### `getAlgorithmVersion(): number`
+**Returns:** An array of `BlockReceivedEvent` objects
 
-Get the current difficulty algorithm version. This version number is part of the network consensus.
+### Events
 
-**Returns:** The algorithm version number
+The `ChiaBlockListener` emits the following events:
 
-#### `getAlgorithmSpec(): string`
+#### `blockReceived`
 
-Get the algorithm specification hash. This hash identifies the exact algorithm implementation.
+Fired when a new block is received from any connected peer.
 
-**Returns:** The algorithm specification identifier
+**Callback:** `(event: BlockReceivedEvent) => void`
 
-#### `getAlgorithmParameters(): AlgorithmParameters`
+#### `peerConnected`
 
-Get the standardized difficulty algorithm parameters. These parameters are part of the network consensus.
+Fired when a connection to a peer is established.
 
-**Returns:** Algorithm parameters object containing:
-- `version` (number): Algorithm version number
-- `specHash` (string): Algorithm specification hash
-- `baseZeroBits` (number): Base number of zero bits for difficulty 1.0
-- `logMultiplier` (number): Logarithmic multiplier for difficulty scaling
-- `maxZeroBits` (number): Maximum allowed zero bits
+**Callback:** `(event: PeerConnectedEvent) => void`
 
-### ProofOfWorkHandle Methods
+#### `peerDisconnected`
 
-The handle returned by `computeProofOfWorkAsync` provides these methods:
+Fired when a peer connection is lost.
 
-#### `cancel(): void`
-Cancels the running proof of work computation.
+**Callback:** `(event: PeerDisconnectedEvent) => void`
 
-#### `isCancelled(): boolean`
-Returns `true` if the computation has been cancelled.
+### Event Data Types
 
-#### `isCompleted(): boolean`
-Returns `true` if the computation has found a valid solution.
+#### `BlockReceivedEvent`
 
-#### `hasError(): boolean`
-Returns `true` if there was an error (cancelled or max attempts reached).
+```typescript
+interface BlockReceivedEvent {
+  peerId: string                    // IP address of the peer that sent this block
+  height: number                     // Block height
+  weight: string                     // Block weight as string
+  headerHash: string               // Block header hash (hex)
+  timestamp: number                 // Block timestamp (Unix time)
+  coinAdditions: CoinRecord[]      // New coins created in this block
+  coinRemovals: CoinRecord[]       // Coins spent in this block
+  coinSpends: CoinSpend[]         // Detailed spend information
+  coinCreations: CoinRecord[]      // Coins created by puzzles
+  hasTransactionsGenerator: boolean // Whether block has a generator
+  generatorSize: number            // Size of the generator bytecode
+}
+```
 
-#### `getError(): string | null`
-Returns the error message if there was an error, or `null` if no error.
+#### `PeerConnectedEvent`
 
-#### `getResult(): ProofOfWorkResult | null`
-Returns the result if computation completed successfully, or `null` if not completed.
+```typescript
+interface PeerConnectedEvent {
+  peerId: string  // Peer IP address
+  host: string     // Peer hostname/IP
+  port: number     // Peer port number
+}
+```
 
-#### `getAttempts(): bigint`
-Returns the current number of attempts made (approximate).
+#### `PeerDisconnectedEvent`
 
-#### `getProgress(): ProofOfWorkProgress`
-Returns detailed progress information (attempts, elapsed time, etc.).
+```typescript
+interface PeerDisconnectedEvent {
+  peerId: string   // Peer IP address
+  host: string      // Peer hostname/IP
+  port: number      // Peer port number
+  message?: string  // Optional disconnection reason
+}
+```
 
-#### `getDifficulty(): number`
-Returns the difficulty level for this computation.
+#### `CoinRecord`
 
-### Result Types
+```typescript
+interface CoinRecord {
+  parentCoinInfo: string  // Parent coin ID (hex)
+  puzzleHash: string       // Puzzle hash (hex)
+  amount: string            // Coin amount as string
+}
+```
 
-#### `ProofOfWorkResult`
-- `nonce` (bigint): The nonce that was found
-- `hash` (string): The resulting hash as hex string
-- `attempts` (bigint): Number of attempts made
-- `time_ms` (number): Time taken in milliseconds
-- `difficulty` (number): The difficulty that was satisfied
-- `target` (string): The target that was used (as hex string)
+#### `CoinSpend`
 
-#### `ProofOfWorkProgress`
-- `attempts` (bigint): Current number of attempts
-- `nonce` (bigint): Current nonce being tested
-- `elapsed_ms` (number): Time elapsed in milliseconds
-- `attempts_per_second` (number): Estimated attempts per second
+```typescript
+interface CoinSpend {
+  coin: CoinRecord         // The coin being spent
+  puzzleReveal: string    // CLVM puzzle bytecode (hex)
+  solution: string         // CLVM solution bytecode (hex)
+  offset: number           // Offset in the generator bytecode
+}
+```
 
 ## TypeScript Usage
 
 ```typescript
 import { 
-  computeProofOfWorkAsync, 
-  verifyProofOfWork,
-  verifyProofOfWorkStandardized,
-  getAlgorithmVersion,
-  getAlgorithmParameters,
-  hashToDifficulty,
-  ProofOfWorkResult,
-  ProofOfWorkHandle,
-  AlgorithmParameters
+  ChiaBlockListener, 
+  BlockReceivedEvent, 
+  PeerConnectedEvent, 
+  PeerDisconnectedEvent,
+  CoinRecord,
+  CoinSpend,
+  initTracing,
+  getEventTypes
 } from '@dignetwork/chia-block-listener'
 
-async function mineWithTypes(): Promise<void> {
-  const entropySeed = Buffer.from('my_plot_entropy_seed', 'utf-8')
-  const difficulty = 2.0
+// Initialize tracing for debugging
+initTracing()
+
+// Create listener with proper typing
+const listener = new ChiaBlockListener()
+
+// Type-safe event handlers
+listener.on('blockReceived', (block: BlockReceivedEvent) => {
+  console.log(`Block ${block.height} from peer ${block.peerId}`)
   
-  const handle: ProofOfWorkHandle = computeProofOfWorkAsync(entropySeed, difficulty)
+  // Process coin additions
+  block.coin_additions.forEach((coin: CoinRecord) => {
+    console.log(`New coin: ${coin.amount} mojos`)
+  })
   
-  // Wait for completion with proper typing
-  const waitForCompletion = async (handle: ProofOfWorkHandle): Promise<ProofOfWorkResult> => {
-    while (!handle.isCompleted() && !handle.hasError()) {
-      await new Promise(resolve => setTimeout(resolve, 100))
-    }
-    
-    if (handle.hasError()) {
-      throw new Error(handle.getError() || 'Unknown error')
-    }
-    
-    const result = handle.getResult()
-    if (!result) {
-      throw new Error('No result available')
-    }
+  // Process coin spends
+  block.coin_spends.forEach((spend: CoinSpend) => {
+    console.log(`Spend: ${spend.coin.amount} mojos`)
+    console.log(`Puzzle: ${spend.puzzle_reveal}`)
+    console.log(`Solution: ${spend.solution}`)
+  })
+})
+
+listener.on('peerConnected', (peer: PeerConnectedEvent) => {
+  console.log(`Connected: ${peer.peerId} at ${peer.host}:${peer.port}`)
+})
+
+listener.on('peerDisconnected', (peer: PeerDisconnectedEvent) => {
+  console.log(`Disconnected: ${peer.peerId}`)
+  if (peer.message) {
+    console.log(`Reason: ${peer.message}`)
+  }
+})
+
+// Connect to peers
+const mainnetPeer = listener.addPeer('localhost', 8444, 'mainnet')
+const testnetPeer = listener.addPeer('testnet-node.chia.net', 58444, 'testnet')
+
+// Get historical blocks
+async function getHistoricalBlocks() {
+  try {
+    const block = listener.getBlockByHeight(mainnetPeer, 1000000)
+    console.log(`Block 1000000 hash: ${block.header_hash}`)
     
-    return result
+    const blocks = listener.getBlocksRange(mainnetPeer, 1000000, 1000010)
+    console.log(`Retrieved ${blocks.length} blocks`)
+  } catch (error) {
+    console.error('Error getting blocks:', error)
   }
-  
-  const result: ProofOfWorkResult = await waitForCompletion(handle)
-  
-  // Standard verification
-  const isValid: boolean = verifyProofOfWork(
-    entropySeed, 
-    Number(result.nonce), 
-    difficulty
-  )
-  
-  // Standardized verification (recommended for networks)
-  const isStandardValid: boolean = verifyProofOfWorkStandardized(
-    entropySeed,
-    Number(result.nonce),
-    difficulty
-  )
-  
-  // Check algorithm parameters
-  const params: AlgorithmParameters = getAlgorithmParameters()
-  console.log(`Algorithm version: ${params.version}`)
-  console.log(`Algorithm spec: ${params.specHash}`)
-  
-  console.log('Mining completed, valid:', isValid)
-  console.log('Consensus valid:', isStandardValid)
 }
-```
 
-## Difficulty System
+// Get event type constants
+const eventTypes = getEventTypes()
+console.log('Available events:', eventTypes)
+```
 
-This library uses Bitcoin's target-based difficulty system:
+## Advanced Usage
 
-- **Difficulty 1.0**: Easiest level, requires 8 leading zero bits in hash
-- **Difficulty 2.0**: Requires 12 leading zero bits
-- **Difficulty 4.0**: Requires 16 leading zero bits (2 zero bytes)
-- **Higher difficulties**: Exponentially more difficult
+### Monitoring Specific Transactions
 
-The difficulty directly corresponds to how computationally expensive it is to find a valid nonce.
+```javascript
+// Monitor all coin spends for a specific puzzle hash
+listener.on('blockReceived', (block) => {
+  const targetPuzzleHash = '0x1234...' // Your puzzle hash
+  
+  block.coin_spends.forEach((spend) => {
+    if (spend.coin.puzzle_hash === targetPuzzleHash) {
+      console.log('Found spend for our puzzle!')
+      console.log('Amount:', spend.coin.amount)
+      console.log('Solution:', spend.solution)
+    }
+  })
+})
+```
 
-## Security & Consensus
+### Multiple Network Monitoring
 
-This library implements a **consensus-critical verification system** to prevent tampering and ensure network compatibility.
+```javascript
+// Monitor both mainnet and testnet
+const mainnetPeer = listener.addPeer('localhost', 8444, 'mainnet')
+const testnetPeer = listener.addPeer('localhost', 58444, 'testnet')
+
+listener.on('blockReceived', (block) => {
+  if (block.peerId === mainnetPeer) {
+    console.log(`Mainnet block ${block.height}`)
+  } else if (block.peerId === testnetPeer) {
+    console.log(`Testnet block ${block.height}`)
+  }
+})
+```
 
-### Algorithm Standardization
+### Connection Management
 
-- **Version 1 Specification**: `DIG_POW_V1_SMOOTH_LOG_DIFFICULTY_2024`
-- **Formula**: `zero_bits = 8 + log2(difficulty) * 2`
-- **Immutable Parameters**: All difficulty calculation parameters are locked constants
-- **Version Validation**: Algorithm version must match across all network participants
+```javascript
+// Automatic reconnection
+listener.on('peerDisconnected', (peer) => {
+  console.log(`Lost connection to ${peer.peerId}, reconnecting...`)
+  
+  // Reconnect after 5 seconds
+  setTimeout(() => {
+    try {
+      listener.addPeer(peer.host, peer.port, 'mainnet')
+      console.log('Reconnected successfully')
+    } catch (error) {
+      console.error('Reconnection failed:', error)
+    }
+  }, 5000)
+})
+```
 
-### Security Guarantees
+## Utility Functions
 
-1. **Tamper Detection**: Algorithm spec hash prevents silent modifications
-2. **Version Enforcement**: Mismatched versions are rejected automatically
-3. **Consensus Compliance**: All parameters are immutable constants
-4. **Network Compatibility**: Ensures identical verification across nodes
-5. **Upgrade Safety**: Algorithm changes require coordinated hard forks
+### `initTracing(): void`
 
-### Usage for Network Consensus
+Initializes the Rust tracing system for debugging purposes. Call this before creating any `ChiaBlockListener` instances if you want to see debug output.
 
-```javascript
-// For production networks: Always use standardized verification
-const isValid = verifyProofOfWorkStandardized(entropySeed, nonce, difficulty)
+### `getEventTypes(): EventTypes`
 
-// Check algorithm compatibility
-const version = getAlgorithmVersion()  // Returns: 1
-const spec = getAlgorithmSpec()        // Returns: "DIG_POW_V1_SMOOTH_LOG_DIFFICULTY_2024"
+Returns an object containing the event type constants:
 
-// Validate all proofs with version checking
-function validateNetworkProof(entropySeed, nonce, difficulty) {
-  return verifyProofOfWorkStandardized(entropySeed, nonce, difficulty, 1)
-}
+```javascript
+const eventTypes = getEventTypes()
+console.log(eventTypes)
+// Output: { blockReceived: "blockReceived", peerConnected: "peerConnected", peerDisconnected: "peerDisconnected" }
 ```
 
-### Network Upgrade Process
-
-To change the difficulty algorithm:
-1. Define new algorithm version (e.g., version 2)
-2. Update consensus parameters and spec hash
-3. Coordinate hard fork across all network participants
-4. Validate version compatibility on peer connections
-
 ## Performance Tips
 
-1. **Use appropriate difficulty levels**: Start with 1.0-4.0 for testing
-2. **Monitor progress**: Use the handle to track mining progress
-3. **Set reasonable limits**: Use `maxAttempts` for time-critical applications
-4. **Handle cancellation**: Always provide a way to cancel long-running operations
+1. **Use specific event handlers**: Only listen for the events you need
+2. **Process blocks efficiently**: Avoid heavy computation in event handlers
+3. **Manage connections**: Don't create too many peer connections simultaneously
+4. **Handle errors gracefully**: Always wrap peer operations in try-catch blocks
 
 ## Development
 
 ### Prerequisites
 
 - [Rust](https://rustup.rs/) (latest stable)
-- [Node.js](https://nodejs.org/) (16 or later)
+- [Node.js](https://nodejs.org/) (20 or later)
 - [npm](https://www.npmjs.com/)
 
 ### Setup
@@ -353,15 +385,20 @@ npm test
 
 ```
 chia-block-listener/
-├── src/
-│   └── lib.rs          # Rust implementation with NAPI bindings
-├── __test__/
-│   └── index.spec.mjs  # Test suite
-├── npm/                # Platform-specific native binaries
-├── .github/workflows/  # CI/CD pipeline
-├── Cargo.toml          # Rust configuration
-├── package.json        # Node.js configuration
-└── index.d.ts          # TypeScript definitions
+├── src/                     # Rust source code
+│   ├── lib.rs              # Main NAPI bindings
+│   ├── peer.rs             # Peer connection management
+│   ├── protocol.rs         # Chia protocol implementation
+│   ├── event_emitter.rs    # Event system
+│   └── tls.rs              # TLS connection handling
+├── crate/                  # Additional Rust crates
+│   └── chia-generator-parser/ # CLVM parser
+├── __test__/               # Test suite
+├── npm/                    # Platform-specific binaries
+├── .github/workflows/      # CI/CD pipeline
+├── Cargo.toml              # Rust configuration
+├── package.json            # Node.js configuration
+└── index.d.ts              # TypeScript definitions
 ```
 
 ## CI/CD & Publishing
@@ -369,8 +406,8 @@ chia-block-listener/
 This project uses GitHub Actions for:
 - Cross-platform builds (Windows, macOS, Linux)
 - Multiple architectures (x64, ARM64)
-- Automated testing
-- npm publishing based on commit messages
+- Automated testing on all platforms
+- npm publishing based on git tags
 
 ## License
 
@@ -385,3 +422,10 @@ MIT
 5. Commit your changes (`git commit -m 'Add some amazing feature'`)
 6. Push to the branch (`git push origin feature/amazing-feature`)
 7. Open a Pull Request
+
+## Support
+
+For issues and questions:
+- GitHub Issues: [Report bugs or request features](https://github.com/DIG-Network/chia-block-listener/issues)
+- Documentation: Check the TypeScript definitions in `index.d.ts`
+- Examples: See the `examples/` directory for more usage examples 

package/index.d.ts

@@ -42,8 +42,6 @@ export interface CoinSpend {
   coin: CoinRecord
   puzzleReveal: string
   solution: string
-  realData: boolean
-  parsingMethod: string
   offset: number
 }
 export declare function initTracing(): void
@@ -53,21 +51,7 @@ 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>

package/npm/darwin-arm64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dignetwork/chia-block-listener-darwin-arm64",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "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.6",
+  "version": "0.1.8",
   "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.6",
+  "version": "0.1.8",
   "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.6",
+  "version": "0.1.8",
   "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.6",
+  "version": "0.1.8",
   "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.6",
+  "version": "0.1.8",
   "main": "index.js",
   "types": "index.d.ts",
   "repository": {
@@ -58,10 +58,10 @@
   },
   "packageManager": "yarn@1.22.22",
   "optionalDependencies": {
-    "@dignetwork/chia-block-listener-win32-x64-msvc": "0.1.6",
-    "@dignetwork/chia-block-listener-darwin-x64": "0.1.6",
-    "@dignetwork/chia-block-listener-linux-x64-gnu": "0.1.6",
-    "@dignetwork/chia-block-listener-darwin-arm64": "0.1.6",
-    "@dignetwork/chia-block-listener-linux-arm64-gnu": "0.1.6"
+    "@dignetwork/chia-block-listener-win32-x64-msvc": "0.1.8",
+    "@dignetwork/chia-block-listener-darwin-x64": "0.1.8",
+    "@dignetwork/chia-block-listener-linux-x64-gnu": "0.1.8",
+    "@dignetwork/chia-block-listener-darwin-arm64": "0.1.8",
+    "@dignetwork/chia-block-listener-linux-arm64-gnu": "0.1.8"
   }
 }

package/scripts/post-build.js

@@ -3,11 +3,25 @@ const path = require('path');
 
 const indexDtsPath = path.join(__dirname, '..', 'index.d.ts');
 
-function addTypedOverloads() {
+function fixFieldNames() {
   try {
     // Read the auto-generated index.d.ts file
     let content = fs.readFileSync(indexDtsPath, 'utf8');
     
+    console.log('✅ Field names should now be camelCase from NAPI js_name attributes');
+    return content;
+    
+  } catch (error) {
+    console.error('❌ Error fixing field names:', error.message);
+    process.exit(1);
+  }
+}
+
+function addTypedOverloads() {
+  try {
+    // Read the auto-generated index.d.ts file (or use fixed content from field name correction)
+    let content = fixFieldNames();
+    
     // Check if typed overloads are already present (avoid duplicates)
     if (content.includes('Typed event method overloads')) {
       console.log('✅ Typed event method overloads already present in index.d.ts');

package/src/event_emitter.rs

@@ -83,6 +83,7 @@ enum PeerEventType {
 #[napi(object)]
 #[derive(Clone)]
 pub struct PeerConnectedEvent {
+    #[napi(js_name = "peerId")]
     pub peer_id: String,
     pub host: String,
     pub port: u32,
@@ -92,6 +93,7 @@ pub struct PeerConnectedEvent {
 #[napi(object)]
 #[derive(Clone)]
 pub struct PeerDisconnectedEvent {
+    #[napi(js_name = "peerId")]
     pub peer_id: String,
     pub host: String,
     pub port: u32,
@@ -102,23 +104,33 @@ pub struct PeerDisconnectedEvent {
 #[napi(object)]
 #[derive(Clone)]
 pub struct BlockReceivedEvent {
+    #[napi(js_name = "peerId")]
     pub peer_id: String,
     pub height: u32,
     pub weight: String,
+    #[napi(js_name = "headerHash")]
     pub header_hash: String,
     pub timestamp: u32,
+    #[napi(js_name = "coinAdditions")]
     pub coin_additions: Vec<CoinRecord>,
+    #[napi(js_name = "coinRemovals")]
     pub coin_removals: Vec<CoinRecord>,
+    #[napi(js_name = "coinSpends")]
     pub coin_spends: Vec<CoinSpend>,
+    #[napi(js_name = "coinCreations")]
     pub coin_creations: Vec<CoinRecord>,
+    #[napi(js_name = "hasTransactionsGenerator")]
     pub has_transactions_generator: bool,
+    #[napi(js_name = "generatorSize")]
     pub generator_size: u32,
 }
 
 #[napi(object)]
 #[derive(Clone)]
 pub struct CoinRecord {
+    #[napi(js_name = "parentCoinInfo")]
     pub parent_coin_info: String,
+    #[napi(js_name = "puzzleHash")]
     pub puzzle_hash: String,
     pub amount: String,
 }
@@ -127,10 +139,9 @@ pub struct CoinRecord {
 #[derive(Clone)]
 pub struct CoinSpend {
     pub coin: CoinRecord,
+    #[napi(js_name = "puzzleReveal")]
     pub puzzle_reveal: String,
     pub solution: String,
-    pub real_data: bool,
-    pub parsing_method: String,
     pub offset: u32,
 }
 
@@ -241,7 +252,7 @@ impl ChiaBlockListener {
 
         let peer_id = rt.block_on(async {
             let mut guard = inner.write().await;
-            let peer_id = format!("{}:{}", host, port);
+            let peer_id = host.clone();
 
             guard.peers.insert(
                 peer_id.clone(),
@@ -331,7 +342,7 @@ impl ChiaBlockListener {
                     obj.set_named_property("height", ctx.env.create_uint32(event.height)?)?;
                     obj.set_named_property("weight", ctx.env.create_string(&event.weight)?)?;
                     obj.set_named_property(
-                        "header_hash",
+                        "headerHash",
                         ctx.env.create_string(&event.header_hash)?,
                     )?;
                     obj.set_named_property("timestamp", ctx.env.create_uint32(event.timestamp)?)?;
@@ -343,11 +354,11 @@ impl ChiaBlockListener {
                     for (i, coin) in event.coin_additions.iter().enumerate() {
                         let mut coin_obj = ctx.env.create_object()?;
                         coin_obj.set_named_property(
-                            "parent_coin_info",
+                            "parentCoinInfo",
                             ctx.env.create_string(&coin.parent_coin_info)?,
                         )?;
                         coin_obj.set_named_property(
-                            "puzzle_hash",
+                            "puzzleHash",
                             ctx.env.create_string(&coin.puzzle_hash)?,
                         )?;
                         coin_obj.set_named_property(
@@ -356,7 +367,7 @@ impl ChiaBlockListener {
                         )?;
                         additions_array.set_element(i as u32, coin_obj)?;
                     }
-                    obj.set_named_property("coin_additions", additions_array)?;
+                    obj.set_named_property("coinAdditions", additions_array)?;
 
                     // Coin removals array
                     let mut removals_array = ctx
@@ -365,11 +376,11 @@ impl ChiaBlockListener {
                     for (i, coin) in event.coin_removals.iter().enumerate() {
                         let mut coin_obj = ctx.env.create_object()?;
                         coin_obj.set_named_property(
-                            "parent_coin_info",
+                            "parentCoinInfo",
                             ctx.env.create_string(&coin.parent_coin_info)?,
                         )?;
                         coin_obj.set_named_property(
-                            "puzzle_hash",
+                            "puzzleHash",
                             ctx.env.create_string(&coin.puzzle_hash)?,
                         )?;
                         coin_obj.set_named_property(
@@ -378,7 +389,7 @@ impl ChiaBlockListener {
                         )?;
                         removals_array.set_element(i as u32, coin_obj)?;
                     }
-                    obj.set_named_property("coin_removals", removals_array)?;
+                    obj.set_named_property("coinRemovals", removals_array)?;
 
                     // Coin spends array
                     let mut spends_array =
@@ -389,11 +400,11 @@ impl ChiaBlockListener {
                         // Create coin object
                         let mut coin_obj = ctx.env.create_object()?;
                         coin_obj.set_named_property(
-                            "parent_coin_info",
+                            "parentCoinInfo",
                             ctx.env.create_string(&spend.coin.parent_coin_info)?,
                         )?;
                         coin_obj.set_named_property(
-                            "puzzle_hash",
+                            "puzzleHash",
                             ctx.env.create_string(&spend.coin.puzzle_hash)?,
                         )?;
                         coin_obj.set_named_property(
@@ -403,27 +414,20 @@ impl ChiaBlockListener {
                         spend_obj.set_named_property("coin", coin_obj)?;
 
                         spend_obj.set_named_property(
-                            "puzzle_reveal",
+                            "puzzleReveal",
                             ctx.env.create_string(&spend.puzzle_reveal)?,
                         )?;
                         spend_obj.set_named_property(
                             "solution",
                             ctx.env.create_string(&spend.solution)?,
                         )?;
-                        spend_obj.set_named_property(
-                            "real_data",
-                            ctx.env.get_boolean(spend.real_data)?,
-                        )?;
-                        spend_obj.set_named_property(
-                            "parsing_method",
-                            ctx.env.create_string(&spend.parsing_method)?,
-                        )?;
+
                         spend_obj
                             .set_named_property("offset", ctx.env.create_uint32(spend.offset)?)?;
 
                         spends_array.set_element(i as u32, spend_obj)?;
                     }
-                    obj.set_named_property("coin_spends", spends_array)?;
+                    obj.set_named_property("coinSpends", spends_array)?;
 
                     // Coin creations array
                     let mut creations_array = ctx
@@ -432,25 +436,25 @@ impl ChiaBlockListener {
                     for (i, coin) in event.coin_creations.iter().enumerate() {
                         let mut coin_obj = ctx.env.create_object()?;
                         coin_obj.set_named_property(
-                            "parent_coin_info",
+                            "parentCoinInfo",
                             ctx.env.create_string(&coin.parent_coin_info)?,
                         )?;
                         coin_obj.set_named_property(
-                            "puzzle_hash",
+                            "puzzleHash",
                             ctx.env.create_string(&coin.puzzle_hash)?,
                         )?;
                         coin_obj
                             .set_named_property("amount", ctx.env.create_string(&coin.amount)?)?;
                         creations_array.set_element(i as u32, coin_obj)?;
                     }
-                    obj.set_named_property("coin_creations", creations_array)?;
+                    obj.set_named_property("coinCreations", creations_array)?;
 
                     obj.set_named_property(
-                        "has_transactions_generator",
+                        "hasTransactionsGenerator",
                         ctx.env.get_boolean(event.has_transactions_generator)?,
                     )?;
                     obj.set_named_property(
-                        "generator_size",
+                        "generatorSize",
                         ctx.env.create_uint32(event.generator_size)?,
                     )?;
 
@@ -734,8 +738,6 @@ impl ChiaBlockListener {
                     },
                     puzzle_reveal: hex::encode(&spend.puzzle_reveal),
                     solution: hex::encode(&spend.solution),
-                    real_data: spend.real_data,
-                    parsing_method: spend.parsing_method.clone(),
                     offset: spend.offset,
                 })
                 .collect(),