univo 0.3.2 → 0.4.0

package/dist/index.mjs

@@ -1,99 +1,11 @@
-import * as viem from 'viem';
-import { g as getException, c as createException, a as catchException, l as local } from './shared/univo.j1HWrILH.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.vwk4Xrn3.mjs';
+import { hexToNumber, numberToHex, hexToBytes, keccak256, toRlp, hexToBigInt, formatTransaction, serializeTransaction, numberToBytes, isHex, concatBytes } from 'viem';
+import { local } from './transport.mjs';
+import { c as createLogger, r as retry, v as version, n as normalizeHex, d as decompress, i as isHexEqual, a as compress, b as iife, e as decoder } from './shared/univo.mlthZw0m.mjs';
 import { AdapterError } from './metadata/adapters.mjs';
+import { c as createException, a as catchException } from './shared/univo.C0flyVee.mjs';
 import 'ws';
 import 'partysocket';
 
-function createServer(opts) {
-  const log = createLogger({ quiet: opts.quiet, prefix: "[server]" });
-  const http = async (req) => {
-    let body_buffer;
-    try {
-      body_buffer = await req.arrayBuffer();
-    } catch {
-      return Response.json(
-        { jsonrpc: "2.0", id: null, error: { code: 0, message: "Invalid request body" } },
-        //
-        { status: 400 }
-      );
-    }
-    const authorization = req.headers.get("Authorization");
-    const authenticated = authorization === `Bearer ${opts.signingKey}`;
-    let body_string;
-    if (req.headers.get("Content-Encoding") === "gzip") {
-      if (!authorization) {
-        return Response.json(
-          { jsonrpc: "2.0", id: null, error: { code: 0, message: "No bearer token provided" } },
-          //
-          { status: 400 }
-        );
-      }
-      if (!authenticated) {
-        return Response.json(
-          { jsonrpc: "2.0", id: null, error: { code: 0, message: "Invalid bearer token" } },
-          //
-          { status: 400 }
-        );
-      }
-      body_string = await decompress(body_buffer);
-    } else {
-      body_string = decoder.decode(body_buffer);
-    }
-    let json;
-    try {
-      json = JSON.parse(body_string);
-    } catch {
-      return Response.json(
-        { jsonrpc: "2.0", id: null, error: { code: 0, message: "Malformed JSON request body" } },
-        //
-        { status: 400 }
-      );
-    }
-    if (json.method.startsWith("private_")) {
-      if (!authorization) {
-        return Response.json(
-          { jsonrpc: "2.0", id: json.id, error: { code: 0, message: "No bearer token provided" } },
-          //
-          { status: 400 }
-        );
-      }
-      if (authorization !== `Bearer ${opts.signingKey}`) {
-        return Response.json(
-          { jsonrpc: "2.0", id: json.id, error: { code: 0, message: "Invalid bearer token" } },
-          //
-          { status: 400 }
-        );
-      }
-    }
-    try {
-      const result = await opts.transport.request({ method: json.method, params: json.params });
-      return Response.json({ jsonrpc: "2.0", id: json.id, result });
-    } catch (error) {
-      const message = getException(error);
-      if (message) {
-        log.error(message);
-        return Response.json(
-          { jsonrpc: "2.0", id: json.id, error: { code: 0, message } },
-          //
-          { status: 400 }
-        );
-      }
-      if (error instanceof Error) {
-        log.error(error.message);
-      }
-      return Response.json(
-        { jsonrpc: "2.0", id: json.id, error: { code: 0, message: "Internal server error" } },
-        //
-        { status: 500 }
-      );
-    }
-  };
-  return {
-    http
-  };
-}
-
 function matchFilter(block, filter) {
   if (!chainValid(block, filter)) return false;
   if (!toBlockValid(block, filter)) return false;
@@ -103,16 +15,16 @@ function matchFilter(block, filter) {
   return true;
 }
 const chainValid = (block, filter) => {
-  if (viem.hexToNumber(block.eth_chainId) === filter.chain) return true;
+  if (hexToNumber(block.eth_chainId) === filter.chain) return true;
   return false;
 };
 const fromBlockValid = (block, filter) => {
-  if (viem.hexToNumber(block.eth_getBlockByNumber.number) >= filter.fromBlock) return true;
+  if (hexToNumber(block.eth_getBlockByNumber.number) >= filter.fromBlock) return true;
   return false;
 };
 const toBlockValid = (block, filter) => {
   if (filter.toBlock === void 0) return true;
-  if (viem.hexToNumber(block.eth_getBlockByNumber.number) <= filter.toBlock) return true;
+  if (hexToNumber(block.eth_getBlockByNumber.number) <= filter.toBlock) return true;
   return false;
 };
 const includesLogAddress = (block, filter) => {
@@ -133,18 +45,45 @@ const includesLogEvent = (block, filter) => {
   }
   return false;
 };
+function defineEvent(event) {
+  return event;
+}
+function defineAction(action) {
+  return action;
+}
 function defineIndexer(opts) {
   const log = createLogger({ quiet: opts.quiet ?? false, prefix: "[indexer]" });
-  const allEvents = [];
+  const allEvents = [...opts.events];
   const eventsGroupedByStorageMap = /* @__PURE__ */ new Map();
-  const allActions = [];
+  for (const event of allEvents) {
+    if (!/^[A-Za-z0-9_-]+$/.test(event.id)) {
+      throw new Error(`Invalid event id \`${event.id}\`. Only characters A-Z, a-z, 0-9, underscores, and hyphens are permitted.`);
+    }
+    const group = eventsGroupedByStorageMap.get(event.storage) ?? [];
+    group.push(event);
+    eventsGroupedByStorageMap.set(event.storage, group);
+  }
+  const allActions = [...opts.actions];
+  const actionIds = /* @__PURE__ */ new Set();
+  for (const action of allActions) {
+    if (!/^[A-Za-z0-9_-]+$/.test(action.id)) {
+      throw new Error(`Invalid action id \`${action.id}\`. Only characters A-Z, a-z, 0-9, underscores, and hyphens are permitted.`);
+    }
+    if (actionIds.has(action.id)) {
+      throw new Error(`Duplicate action id \`${action.id}\`.`);
+    }
+    actionIds.add(action.id);
+  }
   async function getBlockFromChain(head) {
     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 (block.eth_getBlockByNumber === null) {
+      throw new Error("eth_getBlockByNumber returned null response");
+    }
+    if (block.eth_getBlockReceipts === null) {
+      throw new Error("eth_getBlockReceipts returned null response");
     }
     if (typeof head.hash === "string") {
       if (!isHexEqual(head.hash, block.eth_getBlockByNumber.hash)) {
@@ -156,6 +95,7 @@ function defineIndexer(opts) {
         throw new Error("Block returned unexpected parent hash");
       }
     }
+    verifyBlockHash(block);
     verifyBlockHashes(block);
     verifyLogIndicies(block);
     verifyReceiptsRoot(block);
@@ -164,6 +104,48 @@ function defineIndexer(opts) {
     verifyTransactionGasUsage(block);
     return block;
   }
+  function verifyBlockHash(block) {
+    const header = block.eth_getBlockByNumber;
+    const fields = [
+      hexToBytes(header.parentHash),
+      hexToBytes(header.sha3Uncles),
+      hexToBytes(header.miner),
+      hexToBytes(header.stateRoot),
+      hexToBytes(header.transactionsRoot),
+      hexToBytes(header.receiptsRoot),
+      hexToBytes(header.logsBloom),
+      quantityToBytes(header.difficulty),
+      quantityToBytes(header.number),
+      quantityToBytes(header.gasLimit),
+      quantityToBytes(header.gasUsed),
+      quantityToBytes(header.timestamp),
+      hexToBytes(header.extraData),
+      hexToBytes(header.mixHash),
+      hexToBytes(header.nonce)
+    ];
+    const extensions = [
+      [header.baseFeePerGas, quantityToBytes],
+      [header.withdrawalsRoot, hexToBytes],
+      [header.blobGasUsed, quantityToBytes],
+      [header.excessBlobGas, quantityToBytes],
+      [header.parentBeaconBlockRoot, hexToBytes],
+      [header.requestsHash, hexToBytes]
+    ];
+    let missingField = false;
+    for (const [value, encode] of extensions) {
+      if (value == null) {
+        missingField = true;
+        continue;
+      }
+      if (missingField) {
+        throw new Error("Block returned incomplete block header");
+      }
+      fields.push(encode(value));
+    }
+    if (!isHexEqual(header.hash, keccak256(toRlp(fields, "bytes")))) {
+      throw new Error("Block returned header that does not match the block hash");
+    }
+  }
   function verifyBlockHashes(block) {
     const blockHash = block.eth_getBlockByNumber.hash;
     const transactions = block.eth_getBlockByNumber.transactions;
@@ -176,7 +158,7 @@ function defineIndexer(opts) {
       if (!isHexEqual(block.eth_getBlockByNumber.hash, receipt.blockHash)) {
         throw new Error("Block returned receipt with unexpected block hash");
       }
-      const transactionIndex = viem.hexToNumber(receipt.transactionIndex);
+      const transactionIndex = hexToNumber(receipt.transactionIndex);
       const transaction = transactions[transactionIndex];
       if (transaction === void 0 || !isHexEqual(transaction.hash, receipt.transactionHash)) {
         throw new Error("Block returned receipt with unexpected transaction hash");
@@ -195,7 +177,7 @@ function defineIndexer(opts) {
     let expectedLogIndex = 0n;
     for (const receipt of block.eth_getBlockReceipts) {
       for (const entry of receipt.logs) {
-        if (viem.hexToBigInt(entry.logIndex) !== expectedLogIndex) {
+        if (hexToBigInt(entry.logIndex) !== expectedLogIndex) {
           throw new Error("Block returned non-contiguous log indices");
         }
         expectedLogIndex++;
@@ -210,17 +192,17 @@ function defineIndexer(opts) {
   }
   function calculateTrieRoot(values) {
     if (values.length === 0) {
-      return viem.keccak256(viem.toRlp(new Uint8Array(), "bytes"));
+      return keccak256(toRlp(new Uint8Array(), "bytes"));
     }
     const entries = values.map((value, index) => ({
-      key: bytesToNibbles(viem.toRlp(quantityToBytes(BigInt(index)), "bytes")),
+      key: bytesToNibbles(toRlp(quantityToBytes(BigInt(index)), "bytes")),
       value
     }));
-    return viem.keccak256(viem.toRlp(encodeTrieNode(entries), "bytes"));
+    return keccak256(toRlp(encodeTrieNode(entries), "bytes"));
   }
   function trieNodeReference(node) {
-    const encoded = viem.toRlp(node, "bytes");
-    return encoded.length < 32 ? node : viem.hexToBytes(viem.keccak256(encoded));
+    const encoded = toRlp(node, "bytes");
+    return encoded.length < 32 ? node : hexToBytes(keccak256(encoded));
   }
   function encodeTrieNode(entries, depth = 0) {
     if (entries.length === 1) {
@@ -258,43 +240,53 @@ function defineIndexer(opts) {
     return bytes;
   }
   function quantityToBytes(value) {
-    const number = typeof value === "bigint" ? value : viem.hexToBigInt(value);
-    return number === 0n ? new Uint8Array() : viem.numberToBytes(number);
+    const number = typeof value === "bigint" ? value : hexToBigInt(value);
+    return number === 0n ? new Uint8Array() : numberToBytes(number);
   }
   function bytesToNibbles(value) {
     return Array.from(value).flatMap((byte) => [byte >> 4, byte & 15]);
   }
   function serializeReceipt(receipt) {
-    const outcome = receipt.status === void 0 ? viem.hexToBytes(receipt.root) : quantityToBytes(receipt.status);
+    const outcome = receipt.status === void 0 ? hexToBytes(receipt.root) : quantityToBytes(receipt.status);
     const fields = [
       outcome,
       quantityToBytes(receipt.cumulativeGasUsed),
-      viem.hexToBytes(receipt.logsBloom),
-      receipt.logs.map((log2) => [viem.hexToBytes(log2.address), log2.topics.map(viem.hexToBytes), viem.hexToBytes(log2.data)])
+      hexToBytes(receipt.logsBloom),
+      receipt.logs.map((log2) => [hexToBytes(log2.address), log2.topics.map(hexToBytes), hexToBytes(log2.data)])
     ];
-    const encoded = viem.toRlp(fields, "bytes");
-    if (!viem.isHex(receipt.type)) {
+    const encoded = toRlp(fields, "bytes");
+    if (!isHex(receipt.type)) {
       throw new Error(`Unsupported receipt type ${receipt.type}`);
     }
-    const type = viem.hexToBigInt(receipt.type);
-    return type === 0n ? encoded : viem.concatBytes([Uint8Array.of(Number(type)), encoded]);
+    const type = hexToBigInt(receipt.type);
+    return type === 0n ? encoded : concatBytes([Uint8Array.of(Number(type)), encoded]);
   }
+  const SUPPORTED_TRANSACTION_TYPES = /* @__PURE__ */ new Set([0n, 1n, 2n, 3n, 4n]);
   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(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 } = 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(
+      const serialized = serializeTransaction(
         { ...formatted, data: input },
         //
         signature
       );
-      if (!isHexEqual(transaction.hash, viem.keccak256(serialized))) {
-        throw new Error(`Transaction ${transaction.hash} failed serialization check`);
+      if (!isHexEqual(tx.hash, keccak256(serialized))) {
+        throw new Error(`Transaction ${tx.hash} failed serialization check`);
       }
-      return viem.hexToBytes(serialized);
+      return hexToBytes(serialized);
     });
     const transactionsRoot = calculateTrieRoot(transactions);
     if (!isHexEqual(block.eth_getBlockByNumber.transactionsRoot, transactionsRoot)) {
@@ -309,29 +301,29 @@ function defineIndexer(opts) {
     }
     for (let index = 0; index < transactions.length; index++) {
       const expectedIndex = BigInt(index);
-      if (viem.hexToBigInt(transactions[index].transactionIndex) !== expectedIndex) {
+      if (hexToBigInt(transactions[index].transactionIndex) !== expectedIndex) {
         throw new Error("Block returned non-contiguous transaction indices");
       }
-      if (viem.hexToBigInt(receipts[index].transactionIndex) !== expectedIndex) {
+      if (hexToBigInt(receipts[index].transactionIndex) !== expectedIndex) {
         throw new Error("Block returned non-contiguous transaction indices");
       }
       for (const entry of receipts[index].logs) {
-        if (viem.hexToBigInt(entry.transactionIndex) !== expectedIndex) {
+        if (hexToBigInt(entry.transactionIndex) !== expectedIndex) {
           throw new Error("Block returned log with unexpected transaction index");
         }
       }
     }
   }
   function verifyTransactionGasUsage(block) {
-    const gasLimit = viem.hexToBigInt(block.eth_getBlockByNumber.gasLimit);
-    const blockGasUsed = viem.hexToBigInt(block.eth_getBlockByNumber.gasUsed);
+    const gasLimit = hexToBigInt(block.eth_getBlockByNumber.gasLimit);
+    const blockGasUsed = hexToBigInt(block.eth_getBlockByNumber.gasUsed);
     if (blockGasUsed > gasLimit) {
       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) {
+      cumulativeGasUsed += hexToBigInt(receipt.gasUsed);
+      if (hexToBigInt(receipt.cumulativeGasUsed) !== cumulativeGasUsed) {
         throw new Error("Block returned inconsistent cumulative gas used");
       }
       if (cumulativeGasUsed > gasLimit) {
@@ -342,13 +334,17 @@ function defineIndexer(opts) {
       throw new Error("Block returned inconsistent gas used");
     }
   }
+  const public_getFinalizedHeight = async (chain) => {
+    const manifest = await getOrInitManifest(chain);
+    return manifest.finalized_block_height;
+  };
   async function getOrInitManifest(chain) {
     const path = `manifest/v1/${normalizeHex(chain)}`;
     const manifestRes = await opts.metadataStorage.adapter.get(path);
     let manifest;
     if (manifestRes === null) {
       const block = await getBlockFromChain({ chain, number: "finalized" });
-      const chainFinalizedHeight = viem.hexToNumber(block.eth_getBlockByNumber.number);
+      const chainFinalizedHeight = hexToNumber(block.eth_getBlockByNumber.number);
       const newManifest = {
         finalized_block_height: chainFinalizedHeight,
         finalized_block_hash: block.eth_getBlockByNumber.hash,
@@ -362,39 +358,70 @@ function defineIndexer(opts) {
     }
     return manifest;
   }
-  const public_getFinalizedHeight = async (chain) => {
-    const manifest = await getOrInitManifest(chain);
-    return manifest.finalized_block_height;
+  const public_writeUnfinalizedHead = async (head) => {
+    log.debug("Received unfinalized head...");
+    const blocksStart = Date.now();
+    const [block, manifest] = await Promise.all([
+      getBlockFromChain(head),
+      //
+      getOrInitManifest(head.chain)
+    ]);
+    log.debug(`Loaded block in ${Date.now() - blocksStart}ms`);
+    const indexerFinalizedHeight = manifest.finalized_block_height;
+    if (hexToNumber(head.number) <= indexerFinalizedHeight) {
+      return log.debug("Receiving finalized head, ignoring...");
+    }
+    const metadata_start = Date.now();
+    const chain = normalizeHex(block.eth_chainId);
+    const hash = normalizeHex(block.eth_getBlockByNumber.hash);
+    const number = normalizeHex(block.eth_getBlockByNumber.number, 16);
+    const parentHash = normalizeHex(block.eth_getBlockByNumber.parentHash);
+    const blocksKey = `blocks/v1/${chain}/${number}/${hash}/${parentHash}`;
+    const blocksValue = await compress(JSON.stringify(block));
+    const conditional = { ifNoneMatch: "*" };
+    const result = await opts.metadataStorage.adapter.put(blocksKey, blocksValue, conditional).catch((error) => {
+      if (error instanceof AdapterError) {
+        if (error.tag === "PreconditionFailed") {
+          return null;
+        }
+      }
+      throw error;
+    });
+    if (result === null) {
+      return log.debug("Block already persisted to wal, ignoring...");
+    }
+    log.debug(`Persisted block to wal in ${Date.now() - metadata_start}ms`);
+    await writeUnfinalizedBlock(block);
   };
   async function writeUnfinalizedBlock(block) {
     const events_start = Date.now();
     const events = eventsGroupedByStorageMap.entries().map(async ([storage, grouped_events]) => {
       const batch = [];
-      for (const event2 of grouped_events) {
+      for (const event of grouped_events) {
         try {
-          if (!event2.filters.some((filter) => matchFilter(block, filter))) {
-            log.debug(`Block matches no filters for event ${event2.id}`);
+          if (!event.filters.some((filter) => matchFilter(block, filter))) {
+            log.debug(`Block matches no filters for event ${event.id}`);
             continue;
           }
-          const events2 = event2.handler(block);
-          for (const event3 of events2) {
-            batch.push(event3);
+          const events2 = event.handler(block);
+          for (const event2 of events2) {
+            batch.push(event2);
           }
         } catch (error) {
-          log.error(`Failed to run your 'handler' for event ${event2.id}`);
+          log.error(`Failed to run your 'handler' for event ${event.id}`);
           throw error;
         }
       }
       if (batch.length > 0) {
         const start = Date.now();
         await retry(() => storage.upsert(batch), 2).catch((error) => {
-          for (const event2 of grouped_events) {
-            log.error(`Failed to run your 'upsert' handler for event ${event2.id}`);
+          for (const event of grouped_events) {
+            log.error(`Failed to run your 'upsert' handler for event ${event.id}`);
           }
           throw error;
         });
-        for (const event2 of grouped_events) {
-          log.debug(`Recorded ${batch.length} ${event2.id} in ${Date.now() - start}ms`);
+        for (const event of grouped_events) {
+          log.debug(`Recorded ${batch.length} ${event.id} in ${Date.now() - start}ms`);
         }
       }
     });
@@ -408,84 +435,71 @@ function defineIndexer(opts) {
     const commitsValue = JSON.stringify({ hello: "world" });
     await opts.metadataStorage.adapter.put(commitsKey, commitsValue);
   }
-  const public_writeUnfinalizedHead = async (head) => {
-    log.debug("Received unfinalized head...");
-    const blocksStart = Date.now();
-    const [block, manifest] = await Promise.all([
-      getBlockFromChain(head),
+  const public_deleteReorganisedHead = async (head) => {
+    log.debug(`Received reorganised head ${hexToNumber(head.number)}`);
+    const chain = normalizeHex(head.chain);
+    const number = normalizeHex(head.number, 16);
+    const hash = normalizeHex(head.hash);
+    const parentHash = normalizeHex(head.parent_hash);
+    const blocksKey = `blocks/v1/${chain}/${number}/${hash}/${parentHash}`;
+    const [blocksRes, canonicalBlock] = await Promise.all([
+      opts.metadataStorage.adapter.get(blocksKey),
       //
-      getOrInitManifest(head.chain)
+      getBlockFromChain({ chain: head.chain, number: head.number })
     ]);
-    log.debug(`Loaded block in ${Date.now() - blocksStart}ms`);
-    const indexerFinalizedHeight = manifest.finalized_block_height;
-    if (viem.hexToNumber(head.number) <= indexerFinalizedHeight) {
-      return log.debug("Receiving finalized head, ignoring...");
+    if (blocksRes === null) {
+      return log.debug("Reorganised block never/already processed");
     }
-    const metadata_start = Date.now();
-    const chain = normalizeHex(block.eth_chainId);
-    const hash = normalizeHex(block.eth_getBlockByNumber.hash);
-    const number = normalizeHex(block.eth_getBlockByNumber.number, 16);
-    const parentHash = normalizeHex(block.eth_getBlockByNumber.parentHash);
-    const blocksKey = `blocks/v1/${chain}/${number}/${hash}/${parentHash}`;
-    const blocksValue = await compress(JSON.stringify(block));
-    const conditional = { ifNoneMatch: "*" };
-    const result = await opts.metadataStorage.adapter.put(blocksKey, blocksValue, conditional).catch((error) => {
-      if (error instanceof AdapterError) {
-        if (error.tag === "PreconditionFailed") {
-          return null;
-        }
-      }
-      throw error;
-    });
-    if (result === null) {
-      return log.debug("Block already persisted to wal, ignoring...");
+    const decompressedBlock = await decompress(blocksRes.body);
+    const storedBlock = JSON.parse(decompressedBlock);
+    if (isHexEqual(head.hash, canonicalBlock.eth_getBlockByNumber.hash)) {
+      throw new Error("Attempted to delete canonical block");
     }
-    log.debug(`Persisted block to wal in ${Date.now() - metadata_start}ms`);
-    await writeUnfinalizedBlock(block);
+    await deleteReorganisedBlocksAndWriteCanonicalBlock([storedBlock], canonicalBlock);
   };
   async function deleteReorganisedBlocksAndWriteCanonicalBlock(reorganised, canonical) {
-    const deletes = allEvents.map(async (event2) => {
+    const deletes = allEvents.map(async (event) => {
       const batch = [];
       try {
         for (const block of reorganised) {
-          const events = event2.handler(block);
-          for (const event3 of events) {
-            batch.push(event3);
+          const events = event.handler(block);
+          for (const event2 of events) {
+            batch.push(event2);
           }
         }
       } catch (error) {
-        log.error(`Failed to run your 'handler' for event ${event2.id}`);
+        log.error(`Failed to run your 'handler' for event ${event.id}`);
         throw error;
       }
       if (batch.length === 0) {
         return;
       }
-      await retry(() => event2.storage.delete(batch), 2).catch((error) => {
-        log.error(`Failed to run your 'delete' handler for event ${event2.id}`);
+      await retry(() => event.storage.delete(batch), 2).catch((error) => {
+        log.error(`Failed to run your 'delete' handler for event ${event.id}`);
         throw error;
       });
     });
     await Promise.all(deletes);
     const upserts = eventsGroupedByStorageMap.entries().map(async ([storage, grouped_events]) => {
       const batch = [];
-      for (const event2 of grouped_events) {
+      for (const event of grouped_events) {
         try {
-          if (!event2.filters.some((filter) => matchFilter(canonical, filter))) {
+          if (!event.filters.some((filter) => matchFilter(canonical, filter))) {
             continue;
           }
-          const events = event2.handler(canonical);
-          for (const event3 of events) {
-            batch.push(event3);
+          const events = event.handler(canonical);
+          for (const event2 of events) {
+            batch.push(event2);
           }
         } catch (error) {
-          log.error(`Failed to run your 'handler' for event ${event2.id}`);
+          log.error(`Failed to run your 'handler' for event ${event.id}`);
           throw error;
         }
       }
       if (batch.length > 0) {
         await retry(() => storage.upsert(batch), 2).catch((error) => {
-          for (const event2 of grouped_events) {
-            log.error(`Failed to run your 'upsert' handler for event ${event2.id}`);
+          for (const event of grouped_events) {
+            log.error(`Failed to run your 'upsert' handler for event ${event.id}`);
           }
           throw error;
         });
@@ -493,55 +507,38 @@ function defineIndexer(opts) {
     });
     await Promise.all(upserts);
   }
-  const public_deleteReorganisedHead = async (head) => {
-    log.debug(`Received reorganised head ${viem.hexToNumber(head.number)}`);
-    const chain = normalizeHex(head.chain);
-    const number = normalizeHex(head.number, 16);
-    const hash = normalizeHex(head.hash);
-    const parentHash = normalizeHex(head.parent_hash);
-    const blocksKey = `blocks/v1/${chain}/${number}/${hash}/${parentHash}`;
-    const [blocksRes, canonicalBlock] = await Promise.all([
-      opts.metadataStorage.adapter.get(blocksKey),
+  const public_writeFinalizedHeight = async (chain) => {
+    const path = `cache/v1/${normalizeHex(chain)}`;
+    const [cached, block] = await Promise.all([
+      getChainCache(chain),
+      getBlockFromChain({ chain, number: "finalized" })
       //
-      getBlockFromChain({ chain: head.chain, number: head.number })
     ]);
-    if (blocksRes === null) {
-      return log.debug("Reorganised block never/already processed");
-    }
-    const decompressedBlock = await decompress(blocksRes.body);
-    const storedBlock = JSON.parse(decompressedBlock);
-    if (isHexEqual(head.hash, canonicalBlock.eth_getBlockByNumber.hash)) {
-      throw new Error("Attempted to delete canonical block");
+    const cache = {
+      chain_finalized_height: hexToNumber(block.eth_getBlockByNumber.number),
+      chain_finalized_block_hash: block.eth_getBlockByNumber.hash,
+      chain_finalized_parent_hash: block.eth_getBlockByNumber.parentHash
+    };
+    if (cached.chain_finalized_height >= cache.chain_finalized_height) {
+      return;
     }
-    await deleteReorganisedBlocksAndWriteCanonicalBlock([storedBlock], canonicalBlock);
+    await opts.metadataStorage.adapter.put(path, JSON.stringify(cache));
   };
-  async function writeFinalizedBlock(block, actions) {
-    if (actions.length === 0) {
-      return;
+  async function getChainCache(chain) {
+    const path = `cache/v1/${normalizeHex(chain)}`;
+    const cacheRes = await opts.metadataStorage.adapter.get(path);
+    if (cacheRes === null) {
+      const block = await getBlockFromChain({ chain, number: "finalized" });
+      const cache2 = {
+        chain_finalized_height: hexToNumber(block.eth_getBlockByNumber.number),
+        chain_finalized_block_hash: block.eth_getBlockByNumber.hash,
+        chain_finalized_parent_hash: block.eth_getBlockByNumber.parentHash
+      };
+      await opts.metadataStorage.adapter.put(path, JSON.stringify(cache2));
+      return cache2;
     }
-    const chain = normalizeHex(block.eth_chainId);
-    const number = normalizeHex(block.eth_getBlockByNumber.number, 16);
-    const hash = normalizeHex(block.eth_getBlockByNumber.hash);
-    const parentHash = normalizeHex(block.eth_getBlockByNumber.parentHash);
-    const prefix = `commits/v1/${chain}/${number}/${hash}/${parentHash}`;
-    const promises = actions.map(async (action2) => {
-      const events = action2.event.filters.some((filter) => matchFilter(block, filter)) ? action2.event.handler(block) : [];
-      const promises2 = events.map(async (event2) => {
-        await retry(() => action2.handler(event2), 2).catch((error) => {
-          log.error(`Failed to execute action ${action2.id}`);
-          throw error;
-        });
-      });
-      const results = await Promise.allSettled(promises2);
-      const failure = results.find((result) => result.status === "rejected");
-      if (failure !== void 0) {
-        throw failure.reason;
-      }
-      const commitsKey = `${prefix}/action/${action2.id}`;
-      const commitsValue = JSON.stringify({ hello: "world" });
-      await opts.metadataStorage.adapter.put(commitsKey, commitsValue);
-    });
-    await Promise.all(promises);
+    const cache = JSON.parse(decoder.decode(cacheRes.body));
+    return cache;
   }
   const public_writeFinalizedHead = async (head) => {
     log.debug("Received finalized head...");
@@ -549,24 +546,59 @@ function defineIndexer(opts) {
       return;
     }
     const blocksStart = Date.now();
-    const [block, manifest, chainFinalizedBlock] = await Promise.all([
-      getBlockFromChain(head),
+    const [cache, blockFromMetadata, manifest, heads] = await Promise.all([
+      getChainCache(head.chain),
+      //
+      getBlockFromMetadata(head),
       getOrInitManifest(head.chain),
-      getBlockFromChain({ chain: head.chain, number: "finalized" })
+      listUnfinalizedHeads(head.chain)
     ]);
-    log.debug(`Loaded block in ${Date.now() - blocksStart}ms`);
-    const receivedHeight = viem.hexToNumber(head.number);
+    const receivedHeight = hexToNumber(head.number);
+    const chainFinalizedHeight = cache.chain_finalized_height;
     const indexerFinalizedHeight = manifest.finalized_block_height;
-    const chainFinalizedHeight = viem.hexToNumber(chainFinalizedBlock.eth_getBlockByNumber.number);
     if (receivedHeight <= indexerFinalizedHeight) {
       return log.debug(`Received finalized head (${receivedHeight}) below indexer height (${indexerFinalizedHeight})`);
     }
     if (receivedHeight > chainFinalizedHeight) {
-      return log.error(`Received finalized head (${receivedHeight}) that has not finalized (${chainFinalizedHeight})`);
+      return log.error(`Received finalized head (${receivedHeight}) that has not actually finalized (${chainFinalizedHeight})`);
     }
+    log.debug(`Loaded block in ${Date.now() - blocksStart}ms`);
+    const canonical = iife(() => {
+      let matchesHead = false;
+      let canonicalHead = {
+        chain: head.chain,
+        hash: cache.chain_finalized_block_hash,
+        parent_hash: cache.chain_finalized_parent_hash,
+        number: numberToHex(cache.chain_finalized_height)
+      };
+      const receivedHeight2 = hexToNumber(head.number);
+      for (let number2 = cache.chain_finalized_height; number2 > manifest.finalized_block_height; number2--) {
+        if (number2 === receivedHeight2) {
+          matchesHead = isHexEqual(head.hash, canonicalHead.hash) && isHexEqual(head.parent_hash, canonicalHead.parent_hash);
+          if (!matchesHead) {
+            return false;
+          }
+        }
+        if (number2 === manifest.finalized_block_height + 1) {
+          return matchesHead && isHexEqual(canonicalHead.parent_hash, manifest.finalized_block_hash);
+        }
+        const parent = heads.get(`${number2 - 1}/${normalizeHex(canonicalHead.parent_hash)}`);
+        if (parent === void 0) {
+          return false;
+        }
+        canonicalHead = parent;
+      }
+      return false;
+    });
+    const block = await iife(async () => {
+      if (canonical === false || blockFromMetadata === null) {
+        return await getBlockFromChain(head);
+      }
+      return blockFromMetadata;
+    });
     const chain = normalizeHex(block.eth_chainId);
-    const number = normalizeHex(block.eth_getBlockByNumber.number, 16);
     const hash = normalizeHex(block.eth_getBlockByNumber.hash);
+    const number = normalizeHex(block.eth_getBlockByNumber.number, 16);
     const parentHash = normalizeHex(block.eth_getBlockByNumber.parentHash);
     const finalizedKey = `finalized/v1/${chain}/${number}/${hash}/${parentHash}`;
     const finalizedValue = JSON.stringify({ hello: "world" });
@@ -582,68 +614,62 @@ function defineIndexer(opts) {
     }
     await writeFinalizedBlock(block, allActions);
   };
-  const FINALIZATION_BATCH_SIZE = 32;
-  const LEASE_DURATION_MS = 60 * 1e3;
-  async function getBlocksProcessedAndGarbageCollect(chain, finalizedHeight) {
-    while (true) {
-      const blocksKey = `blocks/v1/${normalizeHex(chain)}/`;
-      const blocks = await opts.metadataStorage.adapter.list({ prefix: blocksKey, limit: 1e3 });
-      if (blocks.keys.length === 0) {
-        return [];
-      }
-      const garbageCollectionKeys = blocks.keys.filter((key) => {
-        const [_, __, ___, number] = key.split("/");
-        return viem.hexToNumber(number) <= finalizedHeight;
-      });
-      if (garbageCollectionKeys.length === 0) {
-        return blocks.keys.map((key) => {
-          const [_, __, ___, number, hash, parent_hash] = key.split("/");
-          return { chain, number, hash, parent_hash };
-        });
-      }
-      const garbageCollectionPromises = garbageCollectionKeys.map(async (key) => {
-        await opts.metadataStorage.adapter.delete(key);
-      });
-      await Promise.all(garbageCollectionPromises);
-    }
-  }
-  async function getCommitsAndGarbageCollect(chain, finalizedHeight) {
-    while (true) {
-      const commitsKey = `commits/v1/${normalizeHex(chain)}/`;
-      const commits = await opts.metadataStorage.adapter.list({ prefix: commitsKey, limit: 1e3 });
-      if (commits.keys.length === 0) {
-        return [];
-      }
-      const garbageCollectionKeys = commits.keys.filter((key) => {
-        const [_, __, ___, number] = key.split("/");
-        return viem.hexToNumber(number) <= finalizedHeight;
-      });
-      if (garbageCollectionKeys.length === 0) {
-        return commits.keys.map((key) => {
-          const [_, __, ___, number, hash, parent_hash, type, id] = key.split("/");
-          return { chain, number, hash, parent_hash, type, id };
-        });
-      }
-      const garbageCollectionPromises = garbageCollectionKeys.map(async (key) => {
-        await opts.metadataStorage.adapter.delete(key);
-      });
-      await Promise.all(garbageCollectionPromises);
-    }
-  }
-  async function getBlockFromMetadataOrChain(head) {
+  async function getBlockFromMetadata(head) {
+    const hash = normalizeHex(head.hash);
     const chain = normalizeHex(head.chain);
     const number = normalizeHex(head.number, 16);
-    const hash = normalizeHex(head.hash);
     const parentHash = normalizeHex(head.parent_hash);
     const prefix = `blocks/v1/${chain}/${number}/${hash}/${parentHash}`;
     const object = await opts.metadataStorage.adapter.get(prefix);
-    if (object !== null) {
-      const block = await decompress(object.body);
-      const parsed = JSON.parse(block);
-      return parsed;
+    if (object === null) {
+      return null;
+    }
+    const block = await decompress(object.body);
+    const parsed = JSON.parse(block);
+    return parsed;
+  }
+  async function listUnfinalizedHeads(chain) {
+    const blocks = await opts.metadataStorage.adapter.list({
+      prefix: `blocks/v1/${normalizeHex(chain)}/`,
+      limit: 1e3
+    });
+    const heads = /* @__PURE__ */ new Map();
+    for (const key of blocks.keys) {
+      const [_, __, chain2, number, hash, parent_hash] = key.split("/");
+      heads.set(`${hexToNumber(number)}/${normalizeHex(hash)}`, { chain: chain2, number, hash, parent_hash });
     }
-    return await getBlockFromChain(head);
+    return heads;
+  }
+  async function writeFinalizedBlock(block, actions) {
+    if (actions.length === 0) {
+      return;
+    }
+    const chain = normalizeHex(block.eth_chainId);
+    const number = normalizeHex(block.eth_getBlockByNumber.number, 16);
+    const hash = normalizeHex(block.eth_getBlockByNumber.hash);
+    const parentHash = normalizeHex(block.eth_getBlockByNumber.parentHash);
+    const prefix = `commits/v1/${chain}/${number}/${hash}/${parentHash}`;
+    const promises = actions.map(async (action) => {
+      const events = action.event.filters.some((filter) => matchFilter(block, filter)) ? action.event.handler(block) : [];
+      const promises2 = events.map(async (event) => {
+        await retry(() => action.handler(event), 2).catch((error) => {
+          log.error(`Failed to execute action ${action.id}`);
+          throw error;
+        });
+      });
+      const results = await Promise.allSettled(promises2);
+      const failure = results.find((result) => result.status === "rejected");
+      if (failure !== void 0) {
+        throw failure.reason;
+      }
+      const commitsKey = `${prefix}/action/${action.id}`;
+      const commitsValue = JSON.stringify({ hello: "world" });
+      await opts.metadataStorage.adapter.put(commitsKey, commitsValue);
+    });
+    await Promise.all(promises);
   }
+  const FINALIZATION_BATCH_SIZE = 32;
+  const LEASE_DURATION_MS = 60 * 1e3;
   const public_finalize = async (chain) => {
     const manifestKey = `manifest/v1/${normalizeHex(chain)}`;
     const [chainFinalizedBlock, manifestGetRes] = await Promise.all([
@@ -651,7 +677,7 @@ function defineIndexer(opts) {
       opts.metadataStorage.adapter.get(manifestKey)
       //
     ]);
-    const chainFinalizedHeight = viem.hexToNumber(chainFinalizedBlock.eth_getBlockByNumber.number);
+    const chainFinalizedHeight = hexToNumber(chainFinalizedBlock.eth_getBlockByNumber.number);
     if (manifestGetRes === null) {
       log.debug("No manifest file found");
       const manifest2 = {
@@ -698,7 +724,7 @@ function defineIndexer(opts) {
       const nextFinalizedHeight = Math.min(chainFinalizedHeight, indexerFinalizedBlockHeight + FINALIZATION_BATCH_SIZE);
       const finalizationBatchSize = nextFinalizedHeight - indexerFinalizedBlockHeight;
       const [nextFinalizedBlock, blocksProcessed] = await Promise.all([
-        getBlockFromChain({ chain, number: viem.numberToHex(nextFinalizedHeight) }),
+        getBlockFromChain({ chain, number: numberToHex(nextFinalizedHeight) }),
         getBlocksProcessedAndGarbageCollect(chain, indexerFinalizedBlockHeight)
       ]);
       const nextFinalizedHead = {
@@ -708,7 +734,7 @@ function defineIndexer(opts) {
         parent_hash: nextFinalizedBlock.eth_getBlockByNumber.parentHash
       };
       const nextFinalizedBlockProcessed = blocksProcessed.some((block) => {
-        return isHexEqual(block.hash, nextFinalizedHead.hash) && isHexEqual(block.parent_hash, nextFinalizedHead.parent_hash) && viem.hexToNumber(block.number) === viem.hexToNumber(nextFinalizedHead.number);
+        return isHexEqual(block.hash, nextFinalizedHead.hash) && isHexEqual(block.parent_hash, nextFinalizedHead.parent_hash) && hexToNumber(block.number) === hexToNumber(nextFinalizedHead.number);
       });
       if (nextFinalizedBlockProcessed === false) {
         await Promise.all([
@@ -723,7 +749,7 @@ function defineIndexer(opts) {
       for (let index = 1; index < finalizationBatchSize; index++) {
         const number = nextFinalizedHeight - index;
         const blocksProcessedForHeight = blocksProcessed.filter((block) => {
-          return viem.hexToNumber(block.number) === number;
+          return hexToNumber(block.number) === number;
         });
         const canonicalHead = blocksProcessedForHeight.find((block) => {
           return isHexEqual(block.hash, parentHash);
@@ -734,7 +760,7 @@ function defineIndexer(opts) {
           continue;
         }
         log.debug("Canonical head never processed, loading from chain...");
-        const canonicalBlock = await getBlockFromChain({ chain, number: viem.numberToHex(number) });
+        const canonicalBlock = await getBlockFromChain({ chain, number: numberToHex(number) });
         const head = {
           chain,
           hash: canonicalBlock.eth_getBlockByNumber.hash,
@@ -761,17 +787,17 @@ function defineIndexer(opts) {
       const commits = await getCommitsAndGarbageCollect(chain, indexerFinalizedBlockHeight);
       for (const canonicalHead of canonicalHeads) {
         const blocksProcessedForHeight = blocksProcessed.filter((head) => {
-          return viem.hexToNumber(canonicalHead.number) === viem.hexToNumber(head.number);
+          return hexToNumber(canonicalHead.number) === hexToNumber(head.number);
         });
         const processedOnlyCanonicalBlock = blocksProcessedForHeight.every((head) => {
           return isHexEqual(canonicalHead.hash, head.hash) && isHexEqual(canonicalHead.parent_hash, head.parent_hash);
         });
         const eventsCommittedForHeight = commits.some((commit) => {
-          return commit.type === void 0 && isHexEqual(canonicalHead.hash, commit.hash) && isHexEqual(canonicalHead.parent_hash, commit.parent_hash) && viem.hexToNumber(canonicalHead.number) === viem.hexToNumber(commit.number);
+          return commit.type === void 0 && isHexEqual(canonicalHead.hash, commit.hash) && isHexEqual(canonicalHead.parent_hash, commit.parent_hash) && hexToNumber(canonicalHead.number) === hexToNumber(commit.number);
         });
-        const actionsWithoutCommit = allActions.filter((action2) => {
+        const actionsWithoutCommit = allActions.filter((action) => {
           const commitExists = commits.some((commit) => {
-            return commit.id === action2.id && commit.type === "action" && isHexEqual(canonicalHead.hash, commit.hash) && isHexEqual(canonicalHead.parent_hash, commit.parent_hash) && viem.hexToNumber(canonicalHead.number) === viem.hexToNumber(commit.number);
+            return commit.id === action.id && commit.type === "action" && isHexEqual(canonicalHead.hash, commit.hash) && isHexEqual(canonicalHead.parent_hash, commit.parent_hash) && hexToNumber(canonicalHead.number) === hexToNumber(commit.number);
           });
           return !commitExists;
         });
@@ -827,6 +853,59 @@ function defineIndexer(opts) {
     }
     log.debug("Indexer finalized, returning...");
   };
+  async function getBlocksProcessedAndGarbageCollect(chain, finalizedHeight) {
+    while (true) {
+      const blocksKey = `blocks/v1/${normalizeHex(chain)}/`;
+      const blocks = await opts.metadataStorage.adapter.list({ prefix: blocksKey, limit: 1e3 });
+      if (blocks.keys.length === 0) {
+        return [];
+      }
+      const garbageCollectionKeys = blocks.keys.filter((key) => {
+        const [_, __, ___, number] = key.split("/");
+        return hexToNumber(number) <= finalizedHeight;
+      });
+      if (garbageCollectionKeys.length === 0) {
+        return blocks.keys.map((key) => {
+          const [_, __, ___, number, hash, parent_hash] = key.split("/");
+          return { chain, number, hash, parent_hash };
+        });
+      }
+      const garbageCollectionPromises = garbageCollectionKeys.map(async (key) => {
+        await opts.metadataStorage.adapter.delete(key);
+      });
+      await Promise.all(garbageCollectionPromises);
+    }
+  }
+  async function getCommitsAndGarbageCollect(chain, finalizedHeight) {
+    while (true) {
+      const commitsKey = `commits/v1/${normalizeHex(chain)}/`;
+      const commits = await opts.metadataStorage.adapter.list({ prefix: commitsKey, limit: 1e3 });
+      if (commits.keys.length === 0) {
+        return [];
+      }
+      const garbageCollectionKeys = commits.keys.filter((key) => {
+        const [_, __, ___, number] = key.split("/");
+        return hexToNumber(number) <= finalizedHeight;
+      });
+      if (garbageCollectionKeys.length === 0) {
+        return commits.keys.map((key) => {
+          const [_, __, ___, number, hash, parent_hash, type, id] = key.split("/");
+          return { chain, number, hash, parent_hash, type, id };
+        });
+      }
+      const garbageCollectionPromises = garbageCollectionKeys.map(async (key) => {
+        await opts.metadataStorage.adapter.delete(key);
+      });
+      await Promise.all(garbageCollectionPromises);
+    }
+  }
+  async function getBlockFromMetadataOrChain(head) {
+    const metadata = await getBlockFromMetadata(head);
+    if (metadata === null) {
+      return await getBlockFromChain(head);
+    }
+    return metadata;
+  }
   const private_getMetadata = async () => {
     return {
       version,
@@ -834,8 +913,8 @@ function defineIndexer(opts) {
     };
   };
   const private_getEvents = async () => {
-    return allEvents.map((event2) => {
-      const filters = event2.filters.map((filter) => {
+    return allEvents.map((event) => {
+      const filters = event.filters.map((filter) => {
         return {
           chain: filter.chain,
           event: filter.event,
@@ -844,7 +923,7 @@ function defineIndexer(opts) {
           from_block: filter.fromBlock
         };
       });
-      return { id: event2.id, filters };
+      return { id: event.id, filters };
     });
   };
   const ignored = [
@@ -890,26 +969,40 @@ function defineIndexer(opts) {
   };
   const IncompleteBlockError = createException("Received block with missing required property");
   const private_writeEvents = async (params) => {
-    if (allEvents.length === 0) return { failures: [] };
-    const relevant_events = allEvents.filter((event2) => params.events.includes(event2.id));
-    if (relevant_events.length === 0) return { failures: [] };
-    if (params.events.length === 0) return { failures: [] };
+    if (allEvents.length === 0) {
+      return { failures: [] };
+    }
+    const relevantEvents = allEvents.filter((event) => params.events.includes(event.id));
+    if (relevantEvents.length === 0) {
+      return { failures: [] };
+    }
+    if (params.events.length === 0) {
+      return { failures: [] };
+    }
     const failures = {};
-    let accessed_undefined_key = false;
-    const proxied_blocks = getWriteEventsProxy(params.blocks, () => {
-      accessed_undefined_key = true;
+    let accessedUndefinedKey = false;
+    const proxiedBlocks = getWriteEventsProxy(params.blocks, () => {
+      accessedUndefinedKey = true;
       throw new Error(IncompleteBlockError);
     });
     const promises = eventsGroupedByStorageMap.entries().map(async ([storage, grouped_events]) => {
       const batch = [];
-      for (const event2 of grouped_events) {
-        if (!params.events.includes(event2.id)) continue;
-        for (const block of proxied_blocks) {
+      for (const event of grouped_events) {
+        if (!params.events.includes(event.id)) {
+          continue;
+        }
+        for (const block of proxiedBlocks) {
           try {
-            if (!event2.filters.some((filter) => matchFilter(block, filter))) continue;
-            const events = event2.handler(block);
-            if (accessed_undefined_key) throw new Error(IncompleteBlockError);
-            for (const event3 of events) batch.push(event3);
+            if (!event.filters.some((filter) => matchFilter(block, filter))) {
+              continue;
+            }
+            const events = event.handler(block);
+            if (accessedUndefinedKey) {
+              throw new Error(IncompleteBlockError);
+            }
+            for (const event2 of events) {
+              batch.push(event2);
+            }
           } catch (error) {
             const status = catchException(error, IncompleteBlockError) ? "incomplete_error" : "handler_error";
             if (status === "handler_error") {
@@ -917,9 +1010,9 @@ function defineIndexer(opts) {
                 log.error(error.message);
               }
             }
-            failures[event2.id + block.eth_getBlockByNumber.number] ??= {
+            failures[event.id + block.eth_getBlockByNumber.number] ??= {
               status,
-              event_id: event2.id,
+              event_id: event.id,
               chain: block.eth_chainId,
               hash: block.eth_getBlockByNumber.hash,
               number: block.eth_getBlockByNumber.number,
@@ -929,11 +1022,15 @@ function defineIndexer(opts) {
           }
         }
       }
-      if (batch.length === 0) return;
+      if (batch.length === 0) {
+        return;
+      }
       const start = Date.now();
       try {
         await retry(() => storage.upsert(batch), 2);
-        if (accessed_undefined_key) throw new Error(IncompleteBlockError);
+        if (accessedUndefinedKey) {
+          throw new Error(IncompleteBlockError);
+        }
       } catch (error) {
         const status = catchException(error, IncompleteBlockError) ? "incomplete_error" : "upsert_error";
         if (status === "upsert_error") {
@@ -941,12 +1038,14 @@ function defineIndexer(opts) {
             log.error(error.message);
           }
         }
-        for (const event2 of relevant_events) {
-          for (const block of proxied_blocks) {
-            if (!event2.filters.some((filter) => matchFilter(block, filter))) continue;
-            failures[event2.id + block.eth_getBlockByNumber.number] ??= {
+        for (const event of relevantEvents) {
+          for (const block of proxiedBlocks) {
+            if (!event.filters.some((filter) => matchFilter(block, filter))) {
+              continue;
+            }
+            failures[event.id + block.eth_getBlockByNumber.number] ??= {
               status,
-              event_id: event2.id,
+              event_id: event.id,
               chain: block.eth_chainId,
               hash: block.eth_getBlockByNumber.hash,
               number: block.eth_getBlockByNumber.number,
@@ -957,13 +1056,13 @@ function defineIndexer(opts) {
         }
       }
       const stop = Date.now() - start;
-      for (const event2 of relevant_events) {
-        log.debug(`Recorded ${batch.length} ${event2.id} in ${stop}ms`);
+      for (const event of relevantEvents) {
+        log.debug(`Recorded ${batch.length} ${event.id} in ${stop}ms`);
       }
     });
     await Promise.all(promises);
-    const failures_array = Object.values(failures);
-    return { failures: failures_array };
+    const failuresArray = Object.values(failures);
+    return { failures: failuresArray };
   };
   const private_writeEventsAndGetKeys = async (params) => {
     if (allEvents.length === 0) {
@@ -972,7 +1071,7 @@ function defineIndexer(opts) {
     if (params.events.length === 0) {
       return { results: [], keys: [] };
     }
-    const relevant_events = allEvents.filter((event2) => params.events.includes(event2.id));
+    const relevant_events = allEvents.filter((event) => params.events.includes(event.id));
     if (relevant_events.length === 0) {
       return { results: [], keys: [] };
     }
@@ -1002,20 +1101,20 @@ function defineIndexer(opts) {
     }
     const proxy = new Proxy(block, createProxyHandler(""));
     await Promise.all(
-      relevant_events.map(async (event2) => {
-        if (!event2.filters.some((filter) => matchFilter(proxy, filter))) {
+      relevant_events.map(async (event) => {
+        if (!event.filters.some((filter) => matchFilter(proxy, filter))) {
           return;
         }
         let events = [];
         try {
-          events = event2.handler(proxy);
+          events = event.handler(proxy);
         } catch (error) {
           if (error instanceof Error) {
             log.error(error.message);
           }
-          results[event2.id + proxy.eth_getBlockByNumber.number] = {
+          results[event.id + proxy.eth_getBlockByNumber.number] = {
             status: "handler_error",
-            event_id: event2.id,
+            event_id: event.id,
             chain: proxy.eth_chainId,
             hash: proxy.eth_getBlockByNumber.hash,
             number: proxy.eth_getBlockByNumber.number,
@@ -1025,9 +1124,9 @@ function defineIndexer(opts) {
           return;
         }
         if (events.length === 0) {
-          results[event2.id + proxy.eth_getBlockByNumber.number] = {
+          results[event.id + proxy.eth_getBlockByNumber.number] = {
             status: "ok",
-            event_id: event2.id,
+            event_id: event.id,
             chain: proxy.eth_chainId,
             hash: proxy.eth_getBlockByNumber.hash,
             number: proxy.eth_getBlockByNumber.number,
@@ -1038,15 +1137,15 @@ function defineIndexer(opts) {
         }
         try {
           const start = Date.now();
-          await event2.storage.upsert(events);
-          log.debug(`Recorded ${events.length} ${event2.id} in ${Date.now() - start}ms`);
+          await event.storage.upsert(events);
+          log.debug(`Recorded ${events.length} ${event.id} in ${Date.now() - start}ms`);
         } catch (error) {
           if (error instanceof Error) {
             log.error(error.message);
           }
-          results[event2.id + proxy.eth_getBlockByNumber.number] = {
+          results[event.id + proxy.eth_getBlockByNumber.number] = {
             status: "upsert_error",
-            event_id: event2.id,
+            event_id: event.id,
             chain: proxy.eth_chainId,
             hash: proxy.eth_getBlockByNumber.hash,
             number: proxy.eth_getBlockByNumber.number,
@@ -1055,9 +1154,9 @@ function defineIndexer(opts) {
           };
           return;
         }
-        results[event2.id + proxy.eth_getBlockByNumber.number] = {
+        results[event.id + proxy.eth_getBlockByNumber.number] = {
           status: "ok",
-          event_id: event2.id,
+          event_id: event.id,
           chain: proxy.eth_chainId,
           hash: proxy.eth_getBlockByNumber.hash,
           number: proxy.eth_getBlockByNumber.number,
@@ -1075,52 +1174,20 @@ function defineIndexer(opts) {
     });
     return { results: results_array, keys: filtered_keys };
   };
-  const event = (event2) => {
-    if (!/^[A-Za-z0-9_-]+$/.test(event2.id)) {
-      throw new Error(`Invalid event id \`${event2.id}\`. Only characters A-Z, a-z, 0-9, underscores, and hyphens are permitted.`);
-    }
-    allEvents.push(event2);
-    const group = eventsGroupedByStorageMap.get(event2.storage) ?? [];
-    group.push(event2);
-    eventsGroupedByStorageMap.set(event2.storage, group);
-    return event2;
-  };
-  const action = (action2) => {
-    if (!/^[A-Za-z0-9_-]+$/.test(action2.id)) {
-      throw new Error(`Invalid action id \`${action2.id}\`. Only characters A-Z, a-z, 0-9, underscores, and hyphens are permitted.`);
-    }
-    if (allActions.some((existing) => existing.id === action2.id)) {
-      throw new Error(`Duplicate action id \`${action2.id}\`.`);
-    }
-    allActions.push(action2);
-    return action2;
-  };
   const rpc = {
     request: {
       public_finalize,
       public_getFinalizedHeight,
       public_writeFinalizedHead,
+      public_writeFinalizedHeight,
       public_writeUnfinalizedHead,
       public_deleteReorganisedHead,
       private_getEvents,
       private_getMetadata,
       private_writeEvents,
       private_writeEventsAndGetKeys
-    },
-    subscribe: {}
-  };
-  const server = createServer({
-    transport: local(rpc),
-    quiet: opts.quiet ?? false,
-    signingKey: opts.signingKey
-  });
-  const indexer = {
-    ...rpc,
-    event,
-    action,
-    fetch: server.http
-  };
-  return indexer;
+    }};
+  return local(rpc);
 }
 
-export { defineIndexer };
+export { defineAction, defineEvent, defineIndexer };