univo 0.3.1 → 0.3.3

package/dist/cli.mjs

@@ -4,8 +4,8 @@ import open from 'open';
 import { config } from 'dotenv';
 import { WebSocket } from 'partysocket';
 import { defineCommand, runMain } from 'citty';
-import { h as http } from './shared/univo.BlbeUAWT.mjs';
-import { c as createLogger, v as version, n as name } from './shared/univo.Dxj7VaSK.mjs';
+import { h as http } from './shared/univo.DObJAnN6.mjs';
+import { c as createLogger, v as version, n as name } from './shared/univo.BCKcG-WP.mjs';
 
 const log = createLogger({ quiet: false });
 const dev = defineCommand({

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import * as viem from 'viem';
-import { g as getException, c as createException, a as catchException, l as local } from './shared/univo.BlbeUAWT.mjs';
-import { c as createLogger, d as decompress, b as decoder, r as retry, v as version, e as normalizeHex, a as isHexEqual, f as compress } from './shared/univo.Dxj7VaSK.mjs';
+import { g as getException, c as createException, a as catchException, l as local } from './shared/univo.DObJAnN6.mjs';
+import { c as createLogger, d as decompress, b as decoder, r as retry, v as version, e as normalizeHex, a as isHexEqual, f as compress } from './shared/univo.BCKcG-WP.mjs';
 import { AdapterError } from './metadata/adapters.mjs';
 import 'ws';
 import 'partysocket';
@@ -94,6 +94,7 @@ function createServer(opts) {
   };
 }
 
+const SUPPORTED_TRANSACTION_TYPES = /* @__PURE__ */ new Set([0n, 1n, 2n, 3n, 4n]);
 function matchFilter(block, filter) {
   if (!chainValid(block, filter)) return false;
   if (!toBlockValid(block, filter)) return false;
@@ -139,58 +140,54 @@ function defineIndexer(opts) {
   const eventsGroupedByStorageMap = /* @__PURE__ */ new Map();
   const allActions = [];
   async function getBlockFromChain(head) {
-    try {
-      const block = await opts.getBlock({ chain: head.chain, number: head.number });
-      if (block === null) {
-        throw new Error("Provided `getBlock` function returned null");
-      }
-      if (typeof head.hash === "string") {
-        if (!isHexEqual(head.hash, block.eth_getBlockByNumber.hash)) {
-          throw new Error("Method `eth_getBlockByNumber` returned unexpected block hash");
-        }
-      }
-      if (typeof head.parent_hash === "string") {
-        if (!isHexEqual(head.parent_hash, block.eth_getBlockByNumber.parentHash)) {
-          throw new Error("Method `eth_getBlockByNumber` returned unexpected parent hash");
-        }
+    return await retry(() => retry_getBlockFromChain(head), 2);
+  }
+  async function retry_getBlockFromChain(head) {
+    const block = await opts.getBlock({ chain: head.chain, number: head.number });
+    if (block === null) {
+      throw new Error("Provided `getBlock` function returned null");
+    }
+    if (typeof head.hash === "string") {
+      if (!isHexEqual(head.hash, block.eth_getBlockByNumber.hash)) {
+        throw new Error("Block returned unexpected block hash");
       }
-      verifyBlockHashes(block);
-      verifyLogIndicies(block);
-      verifyReceiptsRoot(block);
-      verifyTransactionsRoot(block);
-      verifyTransactionIndicies(block);
-      verifyTransactionGasUsage(block);
-      return block;
-    } catch (error) {
-      if (error instanceof Error) {
-        log.error(`Failed to load block: ${error.message}`);
+    }
+    if (typeof head.parent_hash === "string") {
+      if (!isHexEqual(head.parent_hash, block.eth_getBlockByNumber.parentHash)) {
+        throw new Error("Block returned unexpected parent hash");
       }
-      throw error;
     }
+    verifyBlockHashes(block);
+    verifyLogIndicies(block);
+    verifyReceiptsRoot(block);
+    verifyTransactionsRoot(block);
+    verifyTransactionIndicies(block);
+    verifyTransactionGasUsage(block);
+    return block;
   }
   function verifyBlockHashes(block) {
     const blockHash = block.eth_getBlockByNumber.hash;
     const transactions = block.eth_getBlockByNumber.transactions;
     for (const transaction of transactions) {
       if (!isHexEqual(blockHash, transaction.blockHash)) {
-        throw new Error("Method `eth_getBlockByNumber` returned transaction with unexpected block hash");
+        throw new Error("Block returned transaction with unexpected block hash");
       }
     }
     for (const receipt of block.eth_getBlockReceipts) {
       if (!isHexEqual(block.eth_getBlockByNumber.hash, receipt.blockHash)) {
-        throw new Error("Method `eth_getBlockReceipts` returned receipt with unexpected block hash");
+        throw new Error("Block returned receipt with unexpected block hash");
       }
       const transactionIndex = viem.hexToNumber(receipt.transactionIndex);
       const transaction = transactions[transactionIndex];
       if (transaction === void 0 || !isHexEqual(transaction.hash, receipt.transactionHash)) {
-        throw new Error("Method `eth_getBlockReceipts` returned receipt with unexpected transaction hash");
+        throw new Error("Block returned receipt with unexpected transaction hash");
       }
       for (const entry of receipt.logs) {
         if (!isHexEqual(blockHash, entry.blockHash)) {
-          throw new Error("Method `eth_getBlockReceipts` returned log with unexpected block hash");
+          throw new Error("Block returned log with unexpected block hash");
         }
         if (!isHexEqual(receipt.transactionHash, entry.transactionHash)) {
-          throw new Error("Method `eth_getBlockReceipts` returned log with unexpected transaction hash");
+          throw new Error("Block returned log with unexpected transaction hash");
         }
       }
     }
@@ -200,7 +197,7 @@ function defineIndexer(opts) {
     for (const receipt of block.eth_getBlockReceipts) {
       for (const entry of receipt.logs) {
         if (viem.hexToBigInt(entry.logIndex) !== expectedLogIndex) {
-          throw new Error("Method `eth_getBlockReceipts` returned non-contiguous log indices");
+          throw new Error("Block returned non-contiguous log indices");
         }
         expectedLogIndex++;
       }
@@ -209,7 +206,7 @@ function defineIndexer(opts) {
   function verifyReceiptsRoot(block) {
     const receiptsRoot = calculateTrieRoot(block.eth_getBlockReceipts.map(serializeReceipt));
     if (!isHexEqual(block.eth_getBlockByNumber.receiptsRoot, receiptsRoot)) {
-      throw new Error("Method `eth_getBlockReceipts` returned receipts that do not match the block receipts root");
+      throw new Error("Block returned receipts that do not match the block receipts root");
     }
   }
   function calculateTrieRoot(values) {
@@ -284,41 +281,53 @@ function defineIndexer(opts) {
     return type === 0n ? encoded : viem.concatBytes([Uint8Array.of(Number(type)), encoded]);
   }
   function verifyTransactionsRoot(block) {
-    const transactions = block.eth_getBlockByNumber.transactions.map((transaction) => {
-      const { input, ...formatted } = viem.formatTransaction(transaction);
+    const unsupportedTxs = block.eth_getBlockByNumber.transactions.filter((tx) => {
+      return !SUPPORTED_TRANSACTION_TYPES.has(viem.hexToBigInt(tx.type));
+    });
+    for (const tx of unsupportedTxs) {
+      log.warn(`Encountered unsupported tx type for ${tx.hash} on ${block.eth_chainId}`);
+    }
+    if (unsupportedTxs.length > 0) {
+      return log.warn("Unable to verify block `transactionsRoot` because of unsupported tx type");
+    }
+    const transactions = block.eth_getBlockByNumber.transactions.map((tx) => {
+      const { input, ...formatted } = viem.formatTransaction(tx);
+      if (formatted.type === "legacy" && (formatted.v === 27n || formatted.v === 28n)) {
+        formatted.chainId = void 0;
+      }
       const signature = formatted.type === "legacy" ? { r: formatted.r, s: formatted.s, v: formatted.v } : { r: formatted.r, s: formatted.s, yParity: formatted.yParity };
       const serialized = viem.serializeTransaction(
         { ...formatted, data: input },
         //
         signature
       );
-      if (!isHexEqual(transaction.hash, viem.keccak256(serialized))) {
-        throw new Error("Method `eth_getBlockByNumber` returned transaction with unexpected transaction hash");
+      if (!isHexEqual(tx.hash, viem.keccak256(serialized))) {
+        throw new Error(`Transaction ${tx.hash} failed serialization check`);
       }
       return viem.hexToBytes(serialized);
     });
     const transactionsRoot = calculateTrieRoot(transactions);
     if (!isHexEqual(block.eth_getBlockByNumber.transactionsRoot, transactionsRoot)) {
-      throw new Error("Method `eth_getBlockByNumber` returned transactions that do not match the block transactions root");
+      throw new Error("Block returned transactions that do not match the block transactions root");
     }
   }
   function verifyTransactionIndicies(block) {
     const receipts = block.eth_getBlockReceipts;
     const transactions = block.eth_getBlockByNumber.transactions;
     if (transactions.length !== receipts.length) {
-      throw new Error("Methods `eth_getBlockByNumber` and `eth_getBlockReceipts` returned different transaction counts");
+      throw new Error("Block returned different transaction counts");
     }
     for (let index = 0; index < transactions.length; index++) {
       const expectedIndex = BigInt(index);
       if (viem.hexToBigInt(transactions[index].transactionIndex) !== expectedIndex) {
-        throw new Error("Method `eth_getBlockByNumber` returned non-contiguous transaction indices");
+        throw new Error("Block returned non-contiguous transaction indices");
       }
       if (viem.hexToBigInt(receipts[index].transactionIndex) !== expectedIndex) {
-        throw new Error("Method `eth_getBlockReceipts` returned non-contiguous transaction indices");
+        throw new Error("Block returned non-contiguous transaction indices");
       }
       for (const entry of receipts[index].logs) {
         if (viem.hexToBigInt(entry.transactionIndex) !== expectedIndex) {
-          throw new Error("Method `eth_getBlockReceipts` returned log with unexpected transaction index");
+          throw new Error("Block returned log with unexpected transaction index");
         }
       }
     }
@@ -327,20 +336,20 @@ function defineIndexer(opts) {
     const gasLimit = viem.hexToBigInt(block.eth_getBlockByNumber.gasLimit);
     const blockGasUsed = viem.hexToBigInt(block.eth_getBlockByNumber.gasUsed);
     if (blockGasUsed > gasLimit) {
-      throw new Error("Method `eth_getBlockByNumber` returned gas used greater than the block gas limit");
+      throw new Error("Block returned gas used greater than the block gas limit");
     }
     let cumulativeGasUsed = 0n;
     for (const receipt of block.eth_getBlockReceipts) {
       cumulativeGasUsed += viem.hexToBigInt(receipt.gasUsed);
       if (viem.hexToBigInt(receipt.cumulativeGasUsed) !== cumulativeGasUsed) {
-        throw new Error("Method `eth_getBlockReceipts` returned inconsistent cumulative gas used");
+        throw new Error("Block returned inconsistent cumulative gas used");
       }
       if (cumulativeGasUsed > gasLimit) {
-        throw new Error("Method `eth_getBlockReceipts` returned cumulative gas used greater than the block gas limit");
+        throw new Error("Block returned cumulative gas used greater than the block gas limit");
       }
     }
     if (cumulativeGasUsed !== blockGasUsed) {
-      throw new Error("Methods `eth_getBlockByNumber` and `eth_getBlockReceipts` returned inconsistent gas used");
+      throw new Error("Block returned inconsistent gas used");
     }
   }
   async function getOrInitManifest(chain) {

package/dist/realtime.mjs

@@ -1,5 +1,5 @@
 import { hexToNumber } from 'viem';
-import { c as createLogger, i as iife, m as mutex, r as retry, a as isHexEqual } from './shared/univo.Dxj7VaSK.mjs';
+import { c as createLogger, i as iife, m as mutex, r as retry, a as isHexEqual } from './shared/univo.BCKcG-WP.mjs';
 
 function defineBlockchain(opts) {
   const log = createLogger({ quiet: opts.quiet });
@@ -122,7 +122,7 @@ function realtime(opts) {
           await retry(
             () => opts.indexer.request({ method: "public_deleteReorganisedHead", params: [{ chain, ...head }] }),
             //
-            4
+            2
           );
           log.debug("Delivered reorganised head");
         } catch (error) {
@@ -152,7 +152,7 @@ function realtime(opts) {
         log.debug("Indexer finalized");
       } catch (error) {
         if (error instanceof Error) {
-          log.warn(`Failed to finalize ${error.message}`);
+          log.warn(`Failed to finalize: ${error.message}`);
         }
       }
     }

package/dist/shared/{univo.Dxj7VaSK.mjs → univo.BCKcG-WP.mjs}

@@ -1,5 +1,5 @@
 const name = "univo";
-const version = "0.3.1";
+const version = "0.3.3";
 
 function createLogger(opts) {
   let prefix = `[${name}@${version}]`;

package/dist/shared/{univo.BlbeUAWT.mjs → univo.DObJAnN6.mjs}

@@ -1,6 +1,6 @@
 import ws from 'ws';
 import { WebSocket } from 'partysocket';
-import { f as compress, g as raise, c as createLogger, m as mutex } from './univo.Dxj7VaSK.mjs';
+import { f as compress, g as raise, c as createLogger, m as mutex } from './univo.BCKcG-WP.mjs';
 
 function createException(message) {
   return `univo:${message}`;

package/dist/transport.mjs

@@ -1,4 +1,4 @@
 import 'ws';
 import 'partysocket';
-export { h as http, l as local, w as wss } from './shared/univo.BlbeUAWT.mjs';
-import './shared/univo.Dxj7VaSK.mjs';
+export { h as http, l as local, w as wss } from './shared/univo.DObJAnN6.mjs';
+import './shared/univo.BCKcG-WP.mjs';

package/package.json

@@ -2,7 +2,7 @@
 	"name": "univo",
 	"license": "MIT",
 	"type": "module",
-	"version": "0.3.1",
+	"version": "0.3.3",
 	"sideEffects": false,
 	"module": "./dist/index.mjs",
 	"types": "./dist/index.d.ts",