@dignetwork/chia-block-listener 0.1.7 → 0.1.9

package/.github/workflows/CI.yml

@@ -193,7 +193,7 @@ jobs:
         node:
           - '20'
           - '22'
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
       - name: Setup node
@@ -252,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/.yarnrc.yml

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

package/README.md

@@ -33,11 +33,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.headerHash}`)
+  console.log(`Header hash: ${block.header_hash}`)
   console.log(`Timestamp: ${new Date(block.timestamp * 1000)}`)
-  console.log(`Coin additions: ${block.coinAdditions.length}`)
-  console.log(`Coin removals: ${block.coinRemovals.length}`)
-  console.log(`Coin spends: ${block.coinSpends.length}`)
+  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
@@ -155,11 +155,11 @@ Fired when a peer connection is lost.
 
 ```typescript
 interface BlockReceivedEvent {
-  peerId: string                    // ID of the peer that sent this block
-  height: number                    // Block height
-  weight: string                    // Block weight as string
+  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)
+  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
@@ -173,9 +173,9 @@ interface BlockReceivedEvent {
 
 ```typescript
 interface PeerConnectedEvent {
-  peerId: string  // Unique peer identifier
-  host: string    // Peer hostname/IP
-  port: number    // Peer port number
+  peerId: string  // Peer IP address
+  host: string     // Peer hostname/IP
+  port: number     // Peer port number
 }
 ```
 
@@ -183,7 +183,7 @@ interface PeerConnectedEvent {
 
 ```typescript
 interface PeerDisconnectedEvent {
-  peerId: string    // Unique peer identifier
+  peerId: string   // Peer IP address
   host: string      // Peer hostname/IP
   port: number      // Peer port number
   message?: string  // Optional disconnection reason
@@ -195,8 +195,8 @@ interface PeerDisconnectedEvent {
 ```typescript
 interface CoinRecord {
   parentCoinInfo: string  // Parent coin ID (hex)
-  puzzleHash: string      // Puzzle hash (hex)
-  amount: string          // Coin amount as string
+  puzzleHash: string       // Puzzle hash (hex)
+  amount: string            // Coin amount as string
 }
 ```
 
@@ -204,12 +204,10 @@ interface CoinRecord {
 
 ```typescript
 interface CoinSpend {
-  coin: CoinRecord        // The coin being spent
+  coin: CoinRecord         // The coin being spent
   puzzleReveal: string    // CLVM puzzle bytecode (hex)
-  solution: string        // CLVM solution bytecode (hex)
-  realData: boolean       // Whether this is real spend data
-  parsingMethod: string   // Method used to parse the spend
-  offset: number          // Offset in the generator bytecode
+  solution: string         // CLVM solution bytecode (hex)
+  offset: number           // Offset in the generator bytecode
 }
 ```
 
@@ -238,14 +236,14 @@ listener.on('blockReceived', (block: BlockReceivedEvent) => {
   console.log(`Block ${block.height} from peer ${block.peerId}`)
   
   // Process coin additions
-  block.coinAdditions.forEach((coin: CoinRecord) => {
+  block.coin_additions.forEach((coin: CoinRecord) => {
     console.log(`New coin: ${coin.amount} mojos`)
   })
   
   // Process coin spends
-  block.coinSpends.forEach((spend: CoinSpend) => {
+  block.coin_spends.forEach((spend: CoinSpend) => {
     console.log(`Spend: ${spend.coin.amount} mojos`)
-    console.log(`Puzzle: ${spend.puzzleReveal}`)
+    console.log(`Puzzle: ${spend.puzzle_reveal}`)
     console.log(`Solution: ${spend.solution}`)
   })
 })
@@ -269,7 +267,7 @@ const testnetPeer = listener.addPeer('testnet-node.chia.net', 58444, 'testnet')
 async function getHistoricalBlocks() {
   try {
     const block = listener.getBlockByHeight(mainnetPeer, 1000000)
-    console.log(`Block 1000000 hash: ${block.headerHash}`)
+    console.log(`Block 1000000 hash: ${block.header_hash}`)
     
     const blocks = listener.getBlocksRange(mainnetPeer, 1000000, 1000010)
     console.log(`Retrieved ${blocks.length} blocks`)
@@ -292,8 +290,8 @@ console.log('Available events:', eventTypes)
 listener.on('blockReceived', (block) => {
   const targetPuzzleHash = '0x1234...' // Your puzzle hash
   
-  block.coinSpends.forEach((spend) => {
-    if (spend.coin.puzzleHash === targetPuzzleHash) {
+  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)

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

@@ -306,9 +306,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 +338,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,
         };
 

package/examples/coin-monitor.js

@@ -2,6 +2,8 @@ const { ChiaBlockListener, initTracing } = require('../index.js');
 const dns = require('dns').promises;
 const fs = require('fs');
 const path = require('path');
+const dig = require('@dignetwork/datalayer-driver');
+
 
 // Create log file with timestamp
 const logFileName = `coin-monitor-${new Date().toISOString().replace(/:/g, '-').split('.')[0]}.log`;
@@ -110,7 +112,7 @@ function formatAddress(host, port, family) {
 }
 
 // Try to connect to peers until one succeeds
-async function connectToAnyPeer(listener, networkId = 'mainnet', maxAttempts = 10) {
+async function connectToAnyPeer(listener, networkId = 'mainnet', maxAttempts = 20) {
   const peers = await discoverPeers(networkId);
   
   console.log(`🔌 Attempting to connect to peers (max ${maxAttempts} attempts)...`);
@@ -154,6 +156,57 @@ async function main() {
     // Log every block as it's received
     listener.on('blockReceived', (event) => {
       console.log('\n📦 Real-time Block Event:');
+      console.log(`Block Height: ${event.height}, Timestamp: ${event.timestamp}`);
+      console.log(`Coin Additions: ${event.coinAdditions.length}, Coin Removals: ${event.coinRemovals.length}`);
+      console.log(`Coin Spends: ${event.coinSpends.length}, Coin Creations: ${event.coinCreations.length}`);
+      
+      // Extract and log puzzle hashes from coin spends
+      if (event.coinSpends && event.coinSpends.length > 0) {
+        const puzzleHashes = event.coinSpends.map(spend => spend.coin.puzzleHash);
+        console.log('\n🧩 Puzzle Hashes from Coin Spends:');
+        console.log(`Found ${puzzleHashes.length} puzzle hashes:`);
+        puzzleHashes.forEach((hash, index) => {
+          console.log(`  ${index + 1}. ${hash} (length: ${hash.length} chars, expected: 64)`);
+          
+          // Only try to convert to address if it's the right length
+          if (hash.length === 64) {
+            try {
+              const address = dig.puzzleHashToAddress(Buffer.from(hash, 'hex'), 'xch');
+              console.log(`    Address: ${address}`);
+            } catch (e) {
+              console.log(`    Address conversion failed: ${e.message}`);
+            }
+          } else {
+            console.log(`    ❌ Invalid puzzle hash length (should be 64 hex chars for 32 bytes)`);
+          }
+        });
+        
+        // Also log unique puzzle hashes
+        const uniquePuzzleHashes = [...new Set(puzzleHashes)];
+        if (uniquePuzzleHashes.length !== puzzleHashes.length) {
+          console.log(`\n🔍 Unique Puzzle Hashes (${uniquePuzzleHashes.length} unique):`);
+          uniquePuzzleHashes.forEach((hash, index) => {
+            console.log(`  ${index + 1}. ${hash} (length: ${hash.length} chars)`);
+            
+            // Only try to convert to address if it's the right length
+            if (hash.length === 64) {
+              try {
+                const address = dig.puzzleHashToAddress(Buffer.from(hash, 'hex'), 'xch');
+                console.log(`    Address: ${address}`);
+              } catch (e) {
+                console.log(`    Address conversion failed: ${e.message}`);
+              }
+            } else {
+              console.log(`    ❌ Invalid puzzle hash length`);
+            }
+          });
+        }
+      } else {
+        console.log('\n🧩 No coin spends found in this block');
+      }
+      
+      // Full block details for debugging (can be commented out if too verbose)
+      console.log('\n📋 Full Block Details:');
       console.log(JSON.stringify(event, null, 2));
       console.log('\n' + '='.repeat(80) + '\n');
     });

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.7",
+  "version": "0.1.9",
   "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.7",
+  "version": "0.1.9",
   "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.7",
+  "version": "0.1.9",
   "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.7",
+  "version": "0.1.9",
   "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.7",
+  "version": "0.1.9",
   "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.7",
+  "version": "0.1.9",
   "main": "index.js",
   "types": "index.d.ts",
   "repository": {
@@ -57,11 +57,14 @@
     "update:images": "echo '💡 Tip: Update your CI images to use newer Rust versions that support edition2024'"
   },
   "packageManager": "yarn@1.22.22",
+  "dependencies": {
+    "@dignetwork/datalayer-driver": "^0.1.35"
+  },
   "optionalDependencies": {
-    "@dignetwork/chia-block-listener-win32-x64-msvc": "0.1.7",
-    "@dignetwork/chia-block-listener-darwin-x64": "0.1.7",
-    "@dignetwork/chia-block-listener-linux-x64-gnu": "0.1.7",
-    "@dignetwork/chia-block-listener-darwin-arm64": "0.1.7",
-    "@dignetwork/chia-block-listener-linux-arm64-gnu": "0.1.7"
+    "@dignetwork/chia-block-listener-win32-x64-msvc": "0.1.9",
+    "@dignetwork/chia-block-listener-darwin-x64": "0.1.9",
+    "@dignetwork/chia-block-listener-linux-x64-gnu": "0.1.9",
+    "@dignetwork/chia-block-listener-darwin-arm64": "0.1.9",
+    "@dignetwork/chia-block-listener-linux-arm64-gnu": "0.1.9"
   }
 }

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)?,
                     )?;
 
@@ -703,14 +707,14 @@ impl ChiaBlockListener {
             peer_id,
             height: parsed_block.height,
             weight: parsed_block.weight.clone(),
-            header_hash: hex::encode(&parsed_block.header_hash),
+            header_hash: parsed_block.header_hash.clone(),
             timestamp: parsed_block.timestamp.unwrap_or(0),
             coin_additions: parsed_block
                 .coin_additions
                 .iter()
                 .map(|coin| CoinRecord {
-                    parent_coin_info: hex::encode(&coin.parent_coin_info),
-                    puzzle_hash: hex::encode(&coin.puzzle_hash),
+                    parent_coin_info: coin.parent_coin_info.clone(),
+                    puzzle_hash: coin.puzzle_hash.clone(),
                     amount: coin.amount.to_string(),
                 })
                 .collect(),
@@ -718,8 +722,8 @@ impl ChiaBlockListener {
                 .coin_removals
                 .iter()
                 .map(|coin| CoinRecord {
-                    parent_coin_info: hex::encode(&coin.parent_coin_info),
-                    puzzle_hash: hex::encode(&coin.puzzle_hash),
+                    parent_coin_info: coin.parent_coin_info.clone(),
+                    puzzle_hash: coin.puzzle_hash.clone(),
                     amount: coin.amount.to_string(),
                 })
                 .collect(),
@@ -728,14 +732,12 @@ impl ChiaBlockListener {
                 .iter()
                 .map(|spend| CoinSpend {
                     coin: CoinRecord {
-                        parent_coin_info: hex::encode(&spend.coin.parent_coin_info),
-                        puzzle_hash: hex::encode(&spend.coin.puzzle_hash),
+                        parent_coin_info: spend.coin.parent_coin_info.clone(),
+                        puzzle_hash: spend.coin.puzzle_hash.clone(),
                         amount: spend.coin.amount.to_string(),
                     },
                     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(),
@@ -743,8 +745,8 @@ impl ChiaBlockListener {
                 .coin_creations
                 .iter()
                 .map(|coin| CoinRecord {
-                    parent_coin_info: hex::encode(&coin.parent_coin_info),
-                    puzzle_hash: hex::encode(&coin.puzzle_hash),
+                    parent_coin_info: coin.parent_coin_info.clone(),
+                    puzzle_hash: coin.puzzle_hash.clone(),
                     amount: coin.amount.to_string(),
                 })
                 .collect(),