univo 0.2.4 → 0.2.6

package/dist/cli.mjs

@@ -5,7 +5,7 @@ import { config } from 'dotenv';
 import { WebSocket } from 'partysocket';
 import { defineCommand, runMain } from 'citty';
 import { http } from './transport.mjs';
-import { c as createLogger, v as version, f as name } from './shared/univo.6U84KZUp.mjs';
+import { c as createLogger, v as version, g as name } from './shared/univo.CTWk2lBv.mjs';
 import './shared/univo.C0flyVee.mjs';
 
 const log = createLogger({ quiet: false });

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { c as createLogger, d as decompress, a as decoder, h as hexToNumber, i as isHexEqual, r as retry, v as version, n as nonNullable } from './shared/univo.6U84KZUp.mjs';
+import { c as createLogger, d as decompress, a as decoder, h as hexToNumber, i as isHexEqual, r as retry, v as version, n as nonNullable, b as normalizeHex } from './shared/univo.CTWk2lBv.mjs';
 import { c as createException, g as getException, a as catchException } from './shared/univo.C0flyVee.mjs';
 
 function matchFilter(block, filter) {
@@ -41,15 +41,26 @@ const includesLogEvent = (block, filter) => {
   return false;
 };
 function indexer(opts) {
-  const log = createLogger({ quiet: opts.quiet ?? false });
+  const log = createLogger({ quiet: opts.quiet ?? false, prefix: "[indexer]" });
   const all_events = [];
   const events_grouped_by_storage_map = /* @__PURE__ */ new Map();
   const metadata = {
     blocks: {
+      async list(head) {
+        let prefix = `/blocks/v1/${normalizeHex(head.chain)}`;
+        if (typeof head.number === "string") {
+          prefix += `/${normalizeHex(head.number, 16)}`;
+        }
+        const keys = await opts.metadataStorage.getKeys(prefix);
+        return keys.map((key) => {
+          const [__, ___, chain, number, hash] = key.split(":");
+          return { chain, number, hash };
+        });
+      },
       async get(head) {
         let prefix = `/blocks/v1/${head.chain.toLowerCase()}`;
         if (typeof head.number === "string") {
-          prefix += `/${head.number.toLowerCase()}`;
+          prefix += `/${normalizeHex(head.number, 16)}`;
         }
         if (typeof head.hash === "string") {
           if (head.number === void 0) {
@@ -72,9 +83,9 @@ function indexer(opts) {
         }
         await opts.metadataStorage.setItems(
           blocks.map((block) => {
-            const chain = block.eth_chainId.toLowerCase();
-            const hash = block.eth_getBlockByNumber.hash.toLowerCase();
-            const number = block.eth_getBlockByNumber.number.toLowerCase();
+            const chain = normalizeHex(block.eth_chainId);
+            const hash = normalizeHex(block.eth_getBlockByNumber.hash);
+            const number = normalizeHex(block.eth_getBlockByNumber.number, 16);
             const key = `/blocks/v1/${chain}/${number}/${hash}`;
             return { key, value: block };
           })
@@ -86,9 +97,9 @@ function indexer(opts) {
         }
         await Promise.all(
           blocks.map(async (block) => {
-            const chain = block.eth_chainId.toLowerCase();
-            const hash = block.eth_getBlockByNumber.hash.toLowerCase();
-            const number = block.eth_getBlockByNumber.number.toLowerCase();
+            const chain = normalizeHex(block.eth_chainId);
+            const hash = normalizeHex(block.eth_getBlockByNumber.hash);
+            const number = normalizeHex(block.eth_getBlockByNumber.number, 16);
             await opts.metadataStorage.del(`/blocks/v1/${chain}/${number}/${hash}`);
           })
         );
@@ -119,20 +130,11 @@ function indexer(opts) {
     return block;
   }
   const public_getFinalizedHeight = async (chain) => {
-    const [finalized, [stored]] = await Promise.all([
-      getBlock({ chain, number: "finalized" }),
-      //
-      metadata.blocks.get({ chain })
-    ]);
-    if (finalized === null) {
-      throw new Error("Failed to determine unfinalized height");
-    }
-    const finalizedHeight = hexToNumber(finalized.eth_getBlockByNumber.number);
+    const [stored] = await metadata.blocks.list({ chain });
     if (stored === void 0) {
-      return finalizedHeight;
+      return null;
     }
-    const storedHeight = hexToNumber(stored.eth_getBlockByNumber.number) - 1;
-    return Math.min(finalizedHeight, storedHeight);
+    return hexToNumber(stored.number) - 1;
   };
   const public_writeUnfinalizedHeads = async (heads) => {
     let chain = void 0;
@@ -247,76 +249,72 @@ function indexer(opts) {
       }
     }
     if (chain === void 0) {
-      throw new Error("Received invalid chain");
+      throw new Error(InvalidHeadsError);
     }
     log.debug(`Received ${heads.length} finalized heads...`);
-    const [unfinalizedBlocks, finalizedBlock] = await Promise.all([
-      metadata.blocks.get({ chain }),
+    const [indexerHeight, finalizedBlock] = await Promise.all([
+      public_getFinalizedHeight(chain),
       //
       getBlock({ chain, number: "finalized" })
     ]);
-    const [nextUnfinalizedBlock] = unfinalizedBlocks;
-    if (nextUnfinalizedBlock === void 0) {
-      return log.debug(`No unfinalised blocks processed for chain ${hexToNumber(chain)}, ignoring...`);
+    if (indexerHeight === null) {
+      return log.debug(`No unfinalized blocks processed for chain ${hexToNumber(chain)}, aborting...`);
     }
     if (finalizedBlock === null) {
+      log.debug("Failed to load finalized block, aborting...");
       throw new Error(GetBlockError);
     }
-    const nextUnfinalizedHeight = hexToNumber(nextUnfinalizedBlock.eth_getBlockByNumber.number);
-    const canonicalFinalizedHeight = hexToNumber(finalizedBlock.eth_getBlockByNumber.number);
-    if (canonicalFinalizedHeight < nextUnfinalizedHeight) {
-      throw new Error("Expected finalized chain to trail canonical chain");
-    }
-    const finalizedHeads = heads.filter((head) => {
-      return hexToNumber(head.number) >= nextUnfinalizedHeight && hexToNumber(head.number) <= canonicalFinalizedHeight;
+    const finalizedHeight = hexToNumber(finalizedBlock.eth_getBlockByNumber.number);
+    log.debug(`Indexer height ${indexerHeight}, finalized height ${finalizedHeight}`);
+    const newHeads = heads.filter((head) => {
+      if (hexToNumber(head.number) > finalizedHeight) {
+        return false;
+      }
+      if (hexToNumber(head.number) > indexerHeight) {
+        return true;
+      }
+      return false;
     });
-    const [firstFinalizedHead, ...remainingFinalizedHeads] = finalizedHeads;
-    if (firstFinalizedHead === void 0) {
+    const [firstHead, ...remainingHeads] = newHeads;
+    if (firstHead === void 0) {
+      log.debug("Received no new finalized heads, aborting...");
       throw new Error(InvalidHeadsError);
     }
-    if (hexToNumber(firstFinalizedHead.number) !== nextUnfinalizedHeight) {
+    if (hexToNumber(firstHead.number) !== indexerHeight + 1) {
+      log.debug("First unfinalized head received didn't match metadata, aborting...");
       throw new Error(InvalidHeadsError);
     }
-    let previousHead = firstFinalizedHead;
-    for (const head of remainingFinalizedHeads) {
+    let previousHead = firstHead;
+    for (const head of remainingHeads) {
       if (hexToNumber(head.number) !== hexToNumber(previousHead.number) + 1) {
+        log.debug("Found invalid block number in received heads, aborting...");
         throw new Error(InvalidHeadsError);
       }
       if (!isHexEqual(head.parentHash, previousHead.hash)) {
+        log.debug("Found invalid block hash in received heads, aborting...");
         throw new Error(InvalidHeadsError);
       }
       previousHead = head;
     }
-    for (const finalizedHead of finalizedHeads) {
-      let processedBlocks = void 0;
-      processedBlocks = unfinalizedBlocks.filter((block) => {
-        return isHexEqual(finalizedHead.number, block.eth_getBlockByNumber.number);
+    for (const head of newHeads) {
+      const processed = await metadata.blocks.get({ chain: head.chain, number: head.number });
+      if (processed.length === 0) {
+        await writeFinalizedHead(head, null);
+        continue;
+      }
+      const reorganised = processed.filter((block2) => {
+        return !isHexEqual(head.hash, block2.eth_getBlockByNumber.hash);
       });
-      if (processedBlocks.length === 0) {
-        processedBlocks = await metadata.blocks.get({ chain: finalizedHead.chain, number: finalizedHead.number });
+      if (reorganised.length > 0) {
+        await deleteReorganisedBlocks(reorganised);
       }
-      await reprocessFinalizedHead(finalizedHead, processedBlocks);
-      await metadata.blocks.delete(processedBlocks);
+      const block = processed.find((block2) => {
+        return isHexEqual(head.hash, block2.eth_getBlockByNumber.hash);
+      });
+      await writeFinalizedHead(head, block ?? null);
+      await metadata.blocks.delete(processed);
     }
   };
-  async function reprocessFinalizedHead(canonical, processed) {
-    if (processed.length === 0) {
-      return await writeFinalizedHead(canonical, null);
-    }
-    const reorganised = processed.filter((block2) => {
-      return !isHexEqual(canonical.hash, block2.eth_getBlockByNumber.hash);
-    });
-    if (reorganised.length > 0) {
-      await deleteReorganisedBlocks(reorganised);
-    }
-    const block = processed.find((block2) => {
-      return isHexEqual(canonical.hash, block2.eth_getBlockByNumber.hash);
-    });
-    if (block === void 0) {
-      return await writeFinalizedHead(canonical, null);
-    }
-    return await writeFinalizedHead(canonical, block);
-  }
   async function writeFinalizedHead(head, block_nullable) {
     let block = block_nullable;
     if (block === null) {

package/dist/realtime.mjs

@@ -1,4 +1,4 @@
-import { c as createLogger, b as iife, h as hexToNumber, e as numberToHex, m as mutex, r as retry, i as isHexEqual } from './shared/univo.6U84KZUp.mjs';
+import { c as createLogger, e as iife, h as hexToNumber, f as numberToHex, m as mutex, r as retry, i as isHexEqual } from './shared/univo.CTWk2lBv.mjs';
 
 const MAX_LENGTH = 1e4;
 function defineBlockchain(opts) {
@@ -79,29 +79,18 @@ function defineBlockchain(opts) {
 }
 const POLLING_INTERVAL_MS = 12 * 1e3;
 function realtime(opts) {
-  const log = createLogger({ quiet: opts.quiet ?? false });
+  const log = createLogger({ quiet: opts.quiet ?? false, prefix: "[realtime]" });
   const getBlockByHash = async (hash) => {
-    return await opts.node.request({ method: "eth_getBlockByHash", params: [hash, false] });
-  };
-  const getLatestBlock = async () => {
-    return await opts.node.request({ method: "eth_getBlockByNumber", params: ["latest", false] });
-  };
-  const getChainFinalizedBlock = async () => {
-    return await opts.node.request({ method: "eth_getBlockByNumber", params: ["finalized", false] });
-  };
-  const getIndexerFinalizedBlock = async (chain) => {
-    const height = await opts.indexer.request({ method: "public_getFinalizedHeight", params: [chain] });
-    return await opts.node.request({ method: "eth_getBlockByNumber", params: [numberToHex(height), false] });
+    const block = await opts.node.request({ method: "eth_getBlockByHash", params: [hash, false] });
+    return { number: block.number, hash: block.hash, parentHash: block.parentHash };
   };
   const promise = iife(async () => {
     log.debug("Initialising realtime client for indexer");
     const chain = await opts.node.request({ method: "eth_chainId", params: [] });
     log.debug(`Determined chain identifier for connected node: ${hexToNumber(chain)}`);
-    const [latestBlock, chainFinalizedBlock, indexerFinalizedBlock] = await Promise.all([
-      getLatestBlock(),
-      getChainFinalizedBlock(),
-      //
-      getIndexerFinalizedBlock(chain)
+    const [latestBlock, initialIndexerHeight] = await Promise.all([
+      opts.node.request({ method: "eth_getBlockByNumber", params: ["latest", false] }),
+      opts.indexer.request({ method: "public_getFinalizedHeight", params: [chain] })
     ]);
     let pending = [];
     const latest = defineBlockchain({
@@ -109,6 +98,7 @@ function realtime(opts) {
       quiet: opts.quiet ?? false,
       onBlockAdded: async (head) => {
         try {
+          log.debug("Received unfinalized head");
           pending.push(head);
           const heads = pending.map((head2) => ({ chain, ...head2 }));
           await opts.indexer.request({ method: "public_writeUnfinalizedHeads", params: [heads] });
@@ -118,72 +108,102 @@ function realtime(opts) {
               return isHexEqual(head2.hash, _head.hash);
             });
           });
-        } catch {
-          log.warn("Failed to write heads");
+        } catch (error) {
+          if (error instanceof Error) {
+            log.warn(`Failed to write heads: ${error.message}`);
+          }
         }
       },
       onBlockReorganised: async (head) => {
         try {
           await retry(() => opts.indexer.request({ method: "public_deleteReorganisedHead", params: [{ chain, ...head }] }), 2);
-        } catch {
-          log.warn("Failed to write reorganised head");
+        } catch (error) {
+          if (error instanceof Error) {
+            log.warn(`Failed to write reorganised head: ${error.message}`);
+          }
         }
       }
     });
     await latest.reconcile(latestBlock);
-    log.debug("Reconciled latest block...");
     await opts.node.subscribe("newHeads", async (head) => {
       try {
         await latest.reconcile(head);
-      } catch {
-        log.error("Failed to reconcile latest head");
+      } catch (error) {
+        if (error instanceof Error) {
+          log.error(`Failed to reconcile latest head: ${error.message}`);
+        }
       }
     });
-    log.debug("Subscribed to latest blocks");
-    let lastFinalizedHeight = hexToNumber(indexerFinalizedBlock.number);
-    log.debug(`Indexer last finalized at ${lastFinalizedHeight}, chain at ${hexToNumber(chainFinalizedBlock.number)}`);
-    const finalized = defineBlockchain({
+    log.debug("Subscribed latest chain to new heads");
+    const indexer = defineBlockchain({
       getBlockByHash,
       quiet: opts.quiet ?? false
     });
-    await finalized.reconcile(indexerFinalizedBlock);
-    await finalized.reconcile(chainFinalizedBlock);
-    log.debug("Reconciled finalized chain...");
+    if (initialIndexerHeight === null) {
+      await indexer.reconcile(latestBlock);
+    } else {
+      log.debug(`Indexer last finalized at ${initialIndexerHeight}, reconciling local chain...`);
+      const indexerBlock = await opts.node.request({
+        method: "eth_getBlockByNumber",
+        params: [numberToHex(initialIndexerHeight), false]
+      });
+      await indexer.reconcile(indexerBlock);
+      await indexer.reconcile(latestBlock);
+      log.debug("Reconciled local indexer chain");
+    }
+    await opts.node.subscribe("newHeads", async (head) => {
+      try {
+        await indexer.reconcile(head);
+      } catch (error) {
+        if (error instanceof Error) {
+          log.debug(`Failed to reconcile latest indexer head: ${error.message}`);
+        }
+      }
+    });
+    log.debug("Subscribed indexer chain to new heads");
+    let indexerHeight = initialIndexerHeight || hexToNumber(latestBlock.number);
     const poll = async () => {
       try {
         const finalizedBlock = await opts.node.request({
           method: "eth_getBlockByNumber",
           params: ["finalized", false]
-          //
         });
         const finalizedHeight = hexToNumber(finalizedBlock.number);
-        if (finalizedHeight === lastFinalizedHeight) {
-          return log.debug("Chain finalized height equal to indexer finalised height, ignoring...");
-        }
-        log.debug(`Received new chain height ${finalizedHeight} with last indexer height ${lastFinalizedHeight}`);
-        const heads = finalized.chain.filter((head) => {
-          if (hexToNumber(head.number) > finalizedHeight) return false;
-          if (hexToNumber(head.number) < lastFinalizedHeight) return false;
-          return true;
+        log.debug(`Finalized chain height ${finalizedHeight} and indexer height ${indexerHeight}`);
+        const newHeads = indexer.chain.filter((head) => {
+          if (hexToNumber(head.number) > finalizedHeight) {
+            return false;
+          }
+          if (hexToNumber(head.number) > indexerHeight) {
+            return true;
+          }
+          return false;
         }).map((head) => {
           return { chain, ...head };
         });
-        if (heads.length === 0) {
+        if (newHeads.length === 0) {
           return log.debug("No new finalized heads to deliver, ignoring...");
         }
-        await opts.indexer.request({ method: "public_writeFinalizedHeads", params: [heads] });
-        log.debug(`Delivered ${heads.length} finalized head(s)`);
-        lastFinalizedHeight = hexToNumber(finalizedBlock.number);
-      } catch {
-        log.error("Failed to reconcile finalized head");
+        log.debug(`Delivering ${newHeads.length} finalized head(s)...`);
+        await opts.indexer.request({ method: "public_writeFinalizedHeads", params: [newHeads] });
+        log.debug(`Delivered ${newHeads.length} finalized head(s)`);
+        indexerHeight = hexToNumber(finalizedBlock.number);
+        log.debug(`Updated indexer height to ${indexerHeight}`);
+      } catch (error) {
+        if (error instanceof Error) {
+          log.error(`Failed to reconcile finalized head: ${error.message}`);
+        }
+      } finally {
+        setTimeout(poll, POLLING_INTERVAL_MS);
       }
     };
     await poll();
-    setInterval(poll, POLLING_INTERVAL_MS);
-    log.debug("Start polling finalized height");
+    log.debug("Started polling finalized height");
   });
-  promise.catch(() => {
-    log.error("Failed to initialise realtime client");
+  promise.catch((error) => {
+    if (error instanceof Error) {
+      log.error(`Failed to initialise realtime client: ${error.message}`);
+    }
   });
 }
 

package/dist/rpc.d.mts

@@ -29,12 +29,20 @@ type NodeRpc = {
          * Accepts a block tag and boolean for including receipts
          * @returns A block with optional receipts
          */
-        eth_getBlockByNumber: (number: string, receipts: boolean) => Promise<Head>;
+        eth_getBlockByNumber: (number: string, receipts: boolean) => Promise<{
+            hash: `0x${string}`;
+            number: `0x${string}`;
+            parentHash: `0x${string}`;
+        }>;
         /**
          * Accepts a block hash and boolean for including receipts
          * @returns A block with optional receipts
          */
-        eth_getBlockByHash: (hash: `0x${string}`, receipts: boolean) => Promise<Head>;
+        eth_getBlockByHash: (hash: `0x${string}`, receipts: boolean) => Promise<{
+            hash: `0x${string}`;
+            number: `0x${string}`;
+            parentHash: `0x${string}`;
+        }>;
     };
     subscribe: {
         newHeads: Head;
@@ -49,7 +57,7 @@ type IndexerRpc = {
          * Accepts a chain identifier
          * @returns Height of the last finalized block indexed
          */
-        public_getFinalizedHeight: (chain: `0x${string}`) => Promise<number>;
+        public_getFinalizedHeight: (chain: `0x${string}`) => Promise<number | null>;
         /**
          * Accepts a reorganised block and deletes all related events from storage
          */

package/dist/rpc.d.ts

@@ -29,12 +29,20 @@ type NodeRpc = {
          * Accepts a block tag and boolean for including receipts
          * @returns A block with optional receipts
          */
-        eth_getBlockByNumber: (number: string, receipts: boolean) => Promise<Head>;
+        eth_getBlockByNumber: (number: string, receipts: boolean) => Promise<{
+            hash: `0x${string}`;
+            number: `0x${string}`;
+            parentHash: `0x${string}`;
+        }>;
         /**
          * Accepts a block hash and boolean for including receipts
          * @returns A block with optional receipts
          */
-        eth_getBlockByHash: (hash: `0x${string}`, receipts: boolean) => Promise<Head>;
+        eth_getBlockByHash: (hash: `0x${string}`, receipts: boolean) => Promise<{
+            hash: `0x${string}`;
+            number: `0x${string}`;
+            parentHash: `0x${string}`;
+        }>;
     };
     subscribe: {
         newHeads: Head;
@@ -49,7 +57,7 @@ type IndexerRpc = {
          * Accepts a chain identifier
          * @returns Height of the last finalized block indexed
          */
-        public_getFinalizedHeight: (chain: `0x${string}`) => Promise<number>;
+        public_getFinalizedHeight: (chain: `0x${string}`) => Promise<number | null>;
         /**
          * Accepts a reorganised block and deletes all related events from storage
          */

package/dist/shared/{univo.6U84KZUp.mjs → univo.CTWk2lBv.mjs}

@@ -1,14 +1,18 @@
 const name = "univo";
-const version = "0.2.4";
+const version = "0.2.6";
 
 function createLogger(opts) {
+  let prefix = `[${name}@${version}]`;
+  if (opts.prefix !== void 0) {
+    prefix += ` ${opts.prefix}`;
+  }
   return {
     debug(...any) {
       if (opts.quiet) {
         return;
       }
       if (process.env.LOG_LEVEL === "DEBUG") {
-        console.log(`[${name}@${version}] DEBUG`, ...any);
+        console.log(`${opts.prefix} DEBUG`, ...any);
       }
     },
     info(...any) {
@@ -16,7 +20,7 @@ function createLogger(opts) {
         return;
       }
       if (process.env.LOG_LEVEL === "DEBUG" || process.env.LOG_LEVEL === "INFO") {
-        console.log(`[${name}@${version}] INFO`, ...any);
+        console.log(`${opts.prefix} INFO`, ...any);
       }
     },
     warn(...any) {
@@ -24,7 +28,7 @@ function createLogger(opts) {
         return;
       }
       if (process.env.LOG_LEVEL === "DEBUG" || process.env.LOG_LEVEL === "INFO" || process.env.LOG_LEVEL === "WARN") {
-        console.log(`[${name}@${version}] WARN`, ...any);
+        console.log(`${opts.prefix} WARN`, ...any);
       }
     },
     error(...any) {
@@ -32,7 +36,7 @@ function createLogger(opts) {
         return;
       }
       if (process.env.LOG_LEVEL === "DEBUG" || process.env.LOG_LEVEL === "INFO" || process.env.LOG_LEVEL === "WARN" || process.env.LOG_LEVEL === "ERROR") {
-        console.log(`[${name}@${version}] ERROR`, ...any);
+        console.log(`${opts.prefix} ERROR`, ...any);
       }
     }
   };
@@ -81,5 +85,11 @@ async function decompress(input) {
   return new Response(decompressed).text();
 }
 const decoder = new TextDecoder();
+const normalizeHex = (hex, length) => {
+  if (length === void 0) {
+    return hex.toLowerCase();
+  }
+  return `0x${hex.slice(2).toLowerCase().padStart(length, "0")}`;
+};
 
-export { decoder as a, iife as b, createLogger as c, decompress as d, numberToHex as e, name as f, compress as g, hexToNumber as h, isHexEqual as i, raise as j, mutex as m, nonNullable as n, retry as r, version as v };
+export { decoder as a, normalizeHex as b, createLogger as c, decompress as d, iife as e, numberToHex as f, name as g, hexToNumber as h, isHexEqual as i, compress as j, raise as k, mutex as m, nonNullable as n, retry as r, version as v };

package/dist/transport.mjs

@@ -1,7 +1,7 @@
 import ws from 'ws';
 import { WebSocket } from 'partysocket';
 import { c as createException } from './shared/univo.C0flyVee.mjs';
-import { g as compress, j as raise, c as createLogger } from './shared/univo.6U84KZUp.mjs';
+import { j as compress, k as raise, c as createLogger } from './shared/univo.CTWk2lBv.mjs';
 
 function createSocket(url, opts) {
   const socket = new WebSocket(url, [], { WebSocket: ws });

package/package.json

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