univo 0.2.7 → 0.2.9

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, g as name } from './shared/univo.Crj0ggpm.mjs';
+import { c as createLogger, v as version, f as name } from './shared/univo.RhVE6xw6.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, b as normalizeHex } from './shared/univo.Crj0ggpm.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 normalizeHex } from './shared/univo.RhVE6xw6.mjs';
 import { c as createException, g as getException, a as catchException } from './shared/univo.C0flyVee.mjs';
 
 function matchFilter(block, filter) {
@@ -129,34 +129,62 @@ function indexer(opts) {
     }
     return block;
   }
+  const GetBlockError = createException("Failed to load block from the provided `getBlock` function");
   const public_getFinalizedHeight = async (chain) => {
-    const [stored] = await metadata.blocks.list({ chain });
+    const [[stored], finalizedBlock] = await Promise.all([
+      metadata.blocks.list({ chain }),
+      //
+      getBlock({ chain, number: "finalized" })
+    ]);
+    if (finalizedBlock === null) {
+      log.debug("Failed to fetch finalized block and unable to determine finalized height, aborting...");
+      throw new Error(GetBlockError);
+    }
+    const finalizedHeight = hexToNumber(finalizedBlock.eth_getBlockByNumber.number);
     if (stored === void 0) {
-      return null;
+      return finalizedHeight;
     }
-    return hexToNumber(stored.number) - 1;
+    const indexerHeight = hexToNumber(stored.number) - 1;
+    return Math.min(indexerHeight, finalizedHeight);
   };
   const public_writeUnfinalizedHeads = async (heads) => {
+    if (heads.length === 0) {
+      return log.debug("No heads received, returning...");
+    }
     let chain = void 0;
     for (const head of heads) {
       if (chain === void 0) {
         chain = head.chain;
       }
       if (!isHexEqual(chain, head.chain)) {
-        throw new Error(MultipleChainsError);
+        throw new Error("Received heads from separate chains");
       }
     }
     if (chain === void 0) {
-      return;
+      throw new Error("Internal error. Expected chain to be defined after checking heads length");
     }
     log.debug(`Received ${heads.length} unfinalized heads...`);
     const blocks_start = Date.now();
-    const blocks_nullable = await Promise.all(
-      heads.map(async (head) => {
+    const [finalizedBlock, ...blocks_nullable] = await Promise.all([
+      getBlock({ chain, number: "finalized" }),
+      ...heads.map(async (head) => {
         return await getBlock({ chain, number: head.number, hash: head.hash });
       })
-    );
-    const blocks = blocks_nullable.filter(nonNullable);
+    ]);
+    if (finalizedBlock === null) {
+      log.debug("Failed to determine finalized height when processing unfinalized heads");
+      throw new Error(GetBlockError);
+    }
+    const finalizedHeight = hexToNumber(finalizedBlock.eth_getBlockByNumber.number);
+    const blocks = blocks_nullable.flatMap((block) => {
+      if (block === null) {
+        return [];
+      }
+      if (hexToNumber(block.eth_getBlockByNumber.number) <= finalizedHeight) {
+        return [];
+      }
+      return block;
+    });
     if (blocks.length === 0) {
       return log.debug("All blocks failed to load, aborting early...");
     }
@@ -239,61 +267,68 @@ function indexer(opts) {
     await Promise.all(promises);
   };
   const public_writeFinalizedHeads = async (heads) => {
+    if (heads.length === 0) {
+      return log.debug("No heads received, returning...");
+    }
+    log.debug(`Received ${heads.length} finalized heads...`);
     let chain = void 0;
     for (const head of heads) {
       if (chain === void 0) {
         chain = head.chain;
       }
       if (!isHexEqual(chain, head.chain)) {
-        throw new Error(MultipleChainsError);
+        throw new Error("Received heads from separate chains");
       }
     }
     if (chain === void 0) {
-      throw new Error(InvalidHeadsError);
+      throw new Error("Internal error. Expected chain to be defined after checking heads length");
     }
-    log.debug(`Received ${heads.length} finalized heads...`);
-    const [indexerHeight, finalizedBlock] = await Promise.all([
-      public_getFinalizedHeight(chain),
+    const [firstHead, ...remainingHeads] = heads;
+    if (firstHead === void 0) {
+      throw new Error("Internal error. Expected firstHead to be defined after checking heads length");
+    }
+    let previousHead = firstHead;
+    for (const head of remainingHeads) {
+      if (hexToNumber(head.number) !== hexToNumber(previousHead.number) + 1) {
+        throw new Error("Found invalid block number in received heads, aborting...");
+      }
+      if (!isHexEqual(head.parentHash, previousHead.hash)) {
+        throw new Error("Found invalid block hash in received heads, aborting...");
+      }
+      previousHead = head;
+    }
+    const [[unfinalizedMetadataBlock], finalizedBlock] = await Promise.all([
+      metadata.blocks.list({ chain }),
       //
       getBlock({ chain, number: "finalized" })
     ]);
-    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...");
+      log.debug("Failed to load chain finalized block. Request should be retried");
       throw new Error(GetBlockError);
     }
     const finalizedHeight = hexToNumber(finalizedBlock.eth_getBlockByNumber.number);
-    log.debug(`Indexer height ${indexerHeight}, finalized height ${finalizedHeight}`);
-    const newHeads = heads.filter((head) => {
+    for (const head of heads) {
       if (hexToNumber(head.number) > finalizedHeight) {
-        return false;
+        throw new Error("Received invalid finalized heads");
       }
-      if (hexToNumber(head.number) > indexerHeight) {
-        return true;
-      }
-      return false;
-    });
-    const [firstHead, ...remainingHeads] = newHeads;
-    if (firstHead === void 0) {
-      return log.debug("Received no new finalized heads, aborting...");
     }
-    if (hexToNumber(firstHead.number) !== indexerHeight + 1) {
-      log.debug("First unfinalized head received didn't match metadata, aborting...");
-      throw new Error(InvalidHeadsError);
+    if (unfinalizedMetadataBlock === void 0) {
+      return log.debug("No heads to finalize, returning...");
     }
-    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;
+    const indexerHeight = hexToNumber(unfinalizedMetadataBlock.number) - 1;
+    log.debug(`Indexer height ${indexerHeight}, finalized height ${finalizedHeight}`);
+    if (indexerHeight === finalizedHeight) {
+      return log.debug("No heads to finalize, returning...");
+    }
+    const newHeads = heads.filter((head) => {
+      return hexToNumber(head.number) > indexerHeight;
+    });
+    const [firstNewHead] = newHeads;
+    if (firstNewHead === void 0) {
+      return log.debug("No new heads received, returning...");
+    }
+    if (hexToNumber(firstNewHead.number) !== indexerHeight + 1) {
+      throw new Error("Client advanced too far. Heads received are greater is than the indexer height");
     }
     for (const head of newHeads) {
       const processed = await metadata.blocks.get({ chain: head.chain, number: head.number });
@@ -320,7 +355,7 @@ function indexer(opts) {
       block = await getBlock({ chain: head.chain, number: head.number, hash: head.hash });
     }
     if (block === null) {
-      throw new Error(InvalidHeadsError);
+      throw new Error("Received invalid finalized heads");
     }
     const promises = events_grouped_by_storage_map.entries().map(async ([storage, grouped_events]) => {
       const batch = [];
@@ -445,6 +480,7 @@ function indexer(opts) {
     };
     return new Proxy(value, createProxyHandler());
   };
+  const IncompleteBlockError = createException("Received block with missing required property");
   const private_writeEvents = async (params) => {
     if (all_events.length === 0) return { failures: [] };
     const relevant_events = all_events.filter((event2) => params.events.includes(event2.id));
@@ -636,6 +672,7 @@ function indexer(opts) {
     events_grouped_by_storage_map.set(event2.storage, group);
     return event2;
   };
+  const UnknownMethodError = createException("The requested method does not exist");
   const handler = async (req) => {
     let body_buffer;
     try {
@@ -702,6 +739,7 @@ function indexer(opts) {
     } catch (error) {
       const message = getException(error);
       if (message) {
+        log.error(message);
         return Response.json(
           { jsonrpc: "2.0", id: json.id, error: { code: 0, message } },
           //
@@ -720,10 +758,5 @@ function indexer(opts) {
   };
   return { fetch: handler, event };
 }
-const InvalidHeadsError = createException("Received invalid finalized heads");
-const UnknownMethodError = createException("The requested method does not exist");
-const MultipleChainsError = createException("Received heads from separate chains");
-const IncompleteBlockError = createException("Received block with missing required property");
-const GetBlockError = createException("Failed to load block from the provided `getBlock` function");
 
 export { indexer, matchFilter };

package/dist/realtime.mjs

@@ -1,4 +1,4 @@
-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.Crj0ggpm.mjs';
+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.RhVE6xw6.mjs';
 
 const MAX_LENGTH = 1e4;
 function defineBlockchain(opts) {
@@ -139,18 +139,14 @@ function realtime(opts) {
       getBlockByHash,
       quiet: opts.quiet ?? false
     });
-    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");
-    }
+    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);
@@ -161,7 +157,7 @@ function realtime(opts) {
       }
     });
     log.debug("Subscribed indexer chain to new heads");
-    let indexerHeight = initialIndexerHeight || hexToNumber(latestBlock.number);
+    let indexerHeight = initialIndexerHeight;
     const poll = async () => {
       try {
         const finalizedBlock = await opts.node.request({

package/dist/rpc.d.mts

@@ -57,7 +57,7 @@ type IndexerRpc = {
          * Accepts a chain identifier
          * @returns Height of the last finalized block indexed
          */
-        public_getFinalizedHeight: (chain: `0x${string}`) => Promise<number | null>;
+        public_getFinalizedHeight: (chain: `0x${string}`) => Promise<number>;
         /**
          * Accepts a reorganised block and deletes all related events from storage
          */

package/dist/rpc.d.ts

@@ -57,7 +57,7 @@ type IndexerRpc = {
          * Accepts a chain identifier
          * @returns Height of the last finalized block indexed
          */
-        public_getFinalizedHeight: (chain: `0x${string}`) => Promise<number | null>;
+        public_getFinalizedHeight: (chain: `0x${string}`) => Promise<number>;
         /**
          * Accepts a reorganised block and deletes all related events from storage
          */

package/dist/shared/{univo.Crj0ggpm.mjs → univo.RhVE6xw6.mjs}

@@ -1,5 +1,5 @@
 const name = "univo";
-const version = "0.2.7";
+const version = "0.2.9";
 
 function createLogger(opts) {
   let prefix = `[${name}@${version}]`;
@@ -73,9 +73,6 @@ function raise(...args) {
   if (args[0] instanceof Error) throw args[0];
   throw new Error(...args);
 }
-function nonNullable(value) {
-  return value !== null && value !== void 0;
-}
 async function compress(input) {
   const compressed = new Blob([input]).stream().pipeThrough(new CompressionStream("gzip"));
   return new Response(compressed).arrayBuffer();
@@ -92,4 +89,4 @@ const normalizeHex = (hex, length) => {
   return `0x${hex.slice(2).toLowerCase().padStart(length, "0")}`;
 };
 
-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 };
+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, normalizeHex 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 { j as compress, k as raise, c as createLogger } from './shared/univo.Crj0ggpm.mjs';
+import { g as compress, j as raise, c as createLogger } from './shared/univo.RhVE6xw6.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.7",
+	"version": "0.2.9",
 	"sideEffects": false,
 	"module": "./dist/index.mjs",
 	"types": "./dist/index.d.ts",