univo 0.2.23 → 0.3.0

package/dist/index.mjs

@@ -1,6 +1,7 @@
-import { StorageError } from '@storagesdk/core';
-import { g as getException, c as createException, a as catchException, l as local } from './shared/univo.1clH0g-n.mjs';
-import { c as createLogger, d as decompress, e as decoder, r as retry, v as version, h as hexToNumber, a as isHexEqual, n as numberToHex, f as normalizeHex, g as compress } from './shared/univo.DvxWs2zB.mjs';
+import * as viem from 'viem';
+import { g as getException, c as createException, a as catchException, l as local } from './shared/univo.TsC-vBTq.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.CX4GZB_1.mjs';
+import { AdapterError } from './metadata/adapters.mjs';
 import 'ws';
 import 'partysocket';
 
@@ -102,16 +103,16 @@ function matchFilter(block, filter) {
   return true;
 }
 const chainValid = (block, filter) => {
-  if (hexToNumber(block.eth_chainId) === filter.chain) return true;
+  if (viem.hexToNumber(block.eth_chainId) === filter.chain) return true;
   return false;
 };
 const fromBlockValid = (block, filter) => {
-  if (hexToNumber(block.eth_getBlockByNumber.number) >= filter.fromBlock) return true;
+  if (viem.hexToNumber(block.eth_getBlockByNumber.number) >= filter.fromBlock) return true;
   return false;
 };
 const toBlockValid = (block, filter) => {
   if (filter.toBlock === void 0) return true;
-  if (hexToNumber(block.eth_getBlockByNumber.number) <= filter.toBlock) return true;
+  if (viem.hexToNumber(block.eth_getBlockByNumber.number) <= filter.toBlock) return true;
   return false;
 };
 const includesLogAddress = (block, filter) => {
@@ -132,213 +133,243 @@ const includesLogEvent = (block, filter) => {
   }
   return false;
 };
-function indexer(opts) {
+function defineIndexer(opts) {
   const log = createLogger({ quiet: opts.quiet ?? false, prefix: "[indexer]" });
-  const all_events = [];
-  const events_grouped_by_storage_map = /* @__PURE__ */ new Map();
-  const all_actions = [];
-  const metadata = {
-    // The blocks store essentially operates as our write-ahead-log (WAL) for unfinalized blocks. Before we
-    // commit any events to storage we first record the block input in our metadata layer. This allows our
-    // finalization handler to always have access to the input data in the case we need to remove events
-    // because of chain reorganisations
-    blocks: {
-      async list(chain, number) {
-        let prefix = `blocks/v1/${normalizeHex(chain)}`;
-        if (typeof number === "string") {
-          prefix += `/${normalizeHex(number, 16)}`;
+  const allEvents = [];
+  const eventsGroupedByStorageMap = /* @__PURE__ */ new Map();
+  const allActions = [];
+  async function getBlockFromChain(head) {
+    try {
+      const block = await opts.getBlock({ chain: head.chain, number: head.number });
+      if (block === null) {
+        throw new Error("Provided `getBlock` function returned null");
+      }
+      if (typeof head.hash === "string") {
+        if (!isHexEqual(head.hash, block.eth_getBlockByNumber.hash)) {
+          throw new Error("Method `eth_getBlockByNumber` returned unexpected block hash");
         }
-        const keys = await opts.metadataStorage.list({ prefix });
-        const mapped = keys.items.map((key) => {
-          const [_, __, ___, number2, hash, parent_hash] = key.path.split("/");
-          return { chain, number: number2, hash, parent_hash };
-        });
-        return mapped;
-      },
-      async get(head) {
-        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 blob = await opts.metadataStorage.download(prefix, { as: "blob" }).catch((error) => {
-          if (error instanceof StorageError) {
-            if (error.code === "NotFound") {
-              return null;
-            }
-          }
-          throw error;
-        });
-        if (blob === null) {
-          return null;
+      }
+      if (typeof head.parent_hash === "string") {
+        if (!isHexEqual(head.parent_hash, block.eth_getBlockByNumber.parentHash)) {
+          throw new Error("Method `eth_getBlockByNumber` returned unexpected parent hash");
         }
-        const block = await decompress(blob);
-        const parsed = JSON.parse(block);
-        return parsed;
-      },
-      async upsert(blocks) {
-        if (blocks.length === 0) {
-          return;
+      }
+      verifyBlockHashes(block);
+      verifyLogIndicies(block);
+      verifyReceiptsRoot(block);
+      verifyTransactionsRoot(block);
+      verifyTransactionIndicies(block);
+      verifyTransactionGasUsage(block);
+      return block;
+    } catch (error) {
+      if (error instanceof Error) {
+        log.error(`Failed to load block: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  function verifyBlockHashes(block) {
+    const blockHash = block.eth_getBlockByNumber.hash;
+    const transactions = block.eth_getBlockByNumber.transactions;
+    for (const transaction of transactions) {
+      if (!isHexEqual(blockHash, transaction.blockHash)) {
+        throw new Error("Method `eth_getBlockByNumber` returned transaction with unexpected block hash");
+      }
+    }
+    for (const receipt of block.eth_getBlockReceipts) {
+      if (!isHexEqual(block.eth_getBlockByNumber.hash, receipt.blockHash)) {
+        throw new Error("Method `eth_getBlockReceipts` returned receipt with unexpected block hash");
+      }
+      const transactionIndex = viem.hexToNumber(receipt.transactionIndex);
+      const transaction = transactions[transactionIndex];
+      if (transaction === void 0 || !isHexEqual(transaction.hash, receipt.transactionHash)) {
+        throw new Error("Method `eth_getBlockReceipts` returned receipt with unexpected transaction hash");
+      }
+      for (const entry of receipt.logs) {
+        if (!isHexEqual(blockHash, entry.blockHash)) {
+          throw new Error("Method `eth_getBlockReceipts` returned log with unexpected block hash");
         }
-        await Promise.all(
-          blocks.map(async (block) => {
-            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 = `blocks/v1/${chain}/${number}/${hash}/${parentHash}`;
-            const compressed = await compress(JSON.stringify(block));
-            await opts.metadataStorage.upload(prefix, compressed);
-          })
-        );
-      },
-      async delete(blocks) {
-        if (blocks.length === 0) {
-          return;
+        if (!isHexEqual(receipt.transactionHash, entry.transactionHash)) {
+          throw new Error("Method `eth_getBlockReceipts` returned log with unexpected transaction hash");
         }
-        await Promise.all(
-          blocks.map(async (block) => {
-            const chain = normalizeHex(block.chain);
-            const number = normalizeHex(block.number, 16);
-            const hash = normalizeHex(block.hash);
-            const parentHash = normalizeHex(block.parent_hash);
-            const prefix = `blocks/v1/${chain}/${number}/${hash}/${parentHash}`;
-            await opts.metadataStorage.delete(prefix);
-          })
-        );
       }
-    },
-    // When unfinalized events are upserted we commit a given block number and block hash to indicate
-    // that those events were successfully recorded. This enables an optimisation in our finalized
-    // handler that allows it to skip processing blocks that were successfully processed
-    commits: {
-      async list(chain, number) {
-        let prefix = `commits/v1/${normalizeHex(chain)}`;
-        if (typeof number === "string") {
-          prefix += `/${normalizeHex(number, 16)}`;
+    }
+  }
+  function verifyLogIndicies(block) {
+    let expectedLogIndex = 0n;
+    for (const receipt of block.eth_getBlockReceipts) {
+      for (const entry of receipt.logs) {
+        if (viem.hexToBigInt(entry.logIndex) !== expectedLogIndex) {
+          throw new Error("Method `eth_getBlockReceipts` returned non-contiguous log indices");
         }
-        const keys = await opts.metadataStorage.list({ prefix });
-        const mapped = keys.items.map((key) => {
-          const [_, __, ___, number2, hash, parent_hash] = key.path.split("/");
-          return { chain, number: number2, hash, parent_hash };
-        });
-        return mapped;
-      },
-      async upsert(head) {
-        const chain = normalizeHex(head.chain);
-        const number = normalizeHex(head.number, 16);
-        const hash = normalizeHex(head.hash);
-        const parentHash = normalizeHex(head.parent_hash);
-        const prefix = `commits/v1/${chain}/${number}/${hash}/${parentHash}`;
-        const body = JSON.stringify({ hello: "world" });
-        await opts.metadataStorage.upload(prefix, body);
-      },
-      async delete(commits) {
-        await Promise.all(
-          commits.map(async (commit) => {
-            const chain = normalizeHex(commit.chain);
-            const number = normalizeHex(commit.number, 16);
-            const hash = normalizeHex(commit.hash);
-            const parentHash = normalizeHex(commit.parent_hash);
-            const prefix = `commits/v1/${chain}/${number}/${hash}/${parentHash}`;
-            await opts.metadataStorage.delete(prefix);
-          })
-        );
+        expectedLogIndex++;
       }
-    },
-    // Our indexer always lags behind the canonical chain. The heights table is used as a durable record
-    // to track its own finalized height. As the chain finalizes, we process newly finalized blocks and
-    // then update the heights here to reflect to that outside world what height the indexer has currently
-    // finalized up to. This information is stored in a separate table so that we can `list` keys and
-    // immediately know which blocks were finalized correctly without ever having to load the entire block
-    // values themselves reducing memory usage and increasing finalizing throughput
-    heights: {
-      async list(chain) {
-        const prefix = `heights/v1/${normalizeHex(chain)}`;
-        const keys = await opts.metadataStorage.list({ prefix });
-        const mapped = keys.items.map((key) => {
-          const [_, __, ___, number] = key.path.split("/");
-          return { chain, number };
-        });
-        return mapped;
-      },
-      async upsert(chain, number) {
-        const prefix = `heights/v1/${normalizeHex(chain)}/${normalizeHex(number, 16)}`;
-        const body = JSON.stringify({ hello: "world" });
-        await opts.metadataStorage.upload(prefix, body);
-      },
-      async delete(heights) {
-        await Promise.all(
-          heights.map(async (height) => {
-            const prefix = `heights/v1/${normalizeHex(height.chain)}/${normalizeHex(height.number, 16)}`;
-            await opts.metadataStorage.delete(prefix);
-          })
-        );
+    }
+  }
+  function verifyReceiptsRoot(block) {
+    const receiptsRoot = calculateTrieRoot(block.eth_getBlockReceipts.map(serializeReceipt));
+    if (!isHexEqual(block.eth_getBlockByNumber.receiptsRoot, receiptsRoot)) {
+      throw new Error("Method `eth_getBlockReceipts` returned receipts that do not match the block receipts root");
+    }
+  }
+  function calculateTrieRoot(values) {
+    if (values.length === 0) {
+      return viem.keccak256(viem.toRlp(new Uint8Array(), "bytes"));
+    }
+    const entries = values.map((value, index) => ({
+      key: bytesToNibbles(viem.toRlp(quantityToBytes(BigInt(index)), "bytes")),
+      value
+    }));
+    return viem.keccak256(viem.toRlp(encodeTrieNode(entries), "bytes"));
+  }
+  function trieNodeReference(node) {
+    const encoded = viem.toRlp(node, "bytes");
+    return encoded.length < 32 ? node : viem.hexToBytes(viem.keccak256(encoded));
+  }
+  function encodeTrieNode(entries, depth = 0) {
+    if (entries.length === 1) {
+      const entry = entries[0];
+      return [encodePath(entry.key.slice(depth), true), entry.value];
+    }
+    let shared = 0;
+    while (entries.every((entry) => entry.key[depth + shared] === entries[0].key[depth + shared])) {
+      shared++;
+    }
+    if (shared > 0) {
+      const child = encodeTrieNode(entries, depth + shared);
+      return [encodePath(entries[0].key.slice(depth, depth + shared), false), trieNodeReference(child)];
+    }
+    const children = Array.from({ length: 17 }, () => new Uint8Array());
+    for (let nibble = 0; nibble < 16; nibble++) {
+      const matching = entries.filter((entry) => entry.key[depth] === nibble);
+      if (matching.length > 0) {
+        children[nibble] = trieNodeReference(encodeTrieNode(matching, depth + 1));
       }
     }
-  };
-  async function getBlock(head) {
-    return await retry(() => retry_getBlock(head), 2).catch(() => {
-      log.error("Failed to load block from the provided `getBlock` function after 3 attempts");
-      return null;
+    const value = entries.find((entry) => entry.key.length === depth)?.value;
+    if (value !== void 0) {
+      children[16] = value;
+    }
+    return children;
+  }
+  function encodePath(path, leaf) {
+    const odd = path.length % 2 === 1;
+    const nibbles = odd ? [leaf ? 3 : 1, ...path] : [leaf ? 2 : 0, 0, ...path];
+    const bytes = new Uint8Array(nibbles.length / 2);
+    for (let index = 0; index < nibbles.length; index += 2) {
+      bytes[index / 2] = nibbles[index] << 4 | nibbles[index + 1];
+    }
+    return bytes;
+  }
+  function quantityToBytes(value) {
+    const number = typeof value === "bigint" ? value : viem.hexToBigInt(value);
+    return number === 0n ? new Uint8Array() : viem.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 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)])
+    ];
+    const encoded = viem.toRlp(fields, "bytes");
+    if (!viem.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]);
+  }
+  function verifyTransactionsRoot(block) {
+    const transactions = block.eth_getBlockByNumber.transactions.map((transaction) => {
+      const { input, ...formatted } = viem.formatTransaction(transaction);
+      const signature = formatted.type === "legacy" ? { r: formatted.r, s: formatted.s, v: formatted.v } : { r: formatted.r, s: formatted.s, yParity: formatted.yParity };
+      const serialized = viem.serializeTransaction(
+        { ...formatted, data: input },
+        //
+        signature
+      );
+      if (!isHexEqual(transaction.hash, viem.keccak256(serialized))) {
+        throw new Error("Method `eth_getBlockByNumber` returned transaction with unexpected transaction hash");
+      }
+      return viem.hexToBytes(serialized);
     });
+    const transactionsRoot = calculateTrieRoot(transactions);
+    if (!isHexEqual(block.eth_getBlockByNumber.transactionsRoot, transactionsRoot)) {
+      throw new Error("Method `eth_getBlockByNumber` returned transactions that do not match the block transactions root");
+    }
   }
-  async function retry_getBlock(head) {
-    const block = await opts.getBlock({ chain: head.chain, number: head.number });
-    if (block === null) {
-      throw new Error("Provided `getBlock` function returned null");
-    }
-    if (typeof head.hash === "string") {
-      if (!isHexEqual(head.hash, block.eth_getBlockByNumber.hash)) {
-        throw new Error("Method `eth_getBlockByNumber` returned unexpected block hash");
-      }
-      for (const receipt of block.eth_getBlockReceipts) {
-        if (!isHexEqual(head.hash, receipt.blockHash)) {
-          throw new Error("Method `eth_getBlockReceipts` returned receipt with unexpected block hash");
+  function verifyTransactionIndicies(block) {
+    const receipts = block.eth_getBlockReceipts;
+    const transactions = block.eth_getBlockByNumber.transactions;
+    if (transactions.length !== receipts.length) {
+      throw new Error("Methods `eth_getBlockByNumber` and `eth_getBlockReceipts` returned different transaction counts");
+    }
+    for (let index = 0; index < transactions.length; index++) {
+      const expectedIndex = BigInt(index);
+      if (viem.hexToBigInt(transactions[index].transactionIndex) !== expectedIndex) {
+        throw new Error("Method `eth_getBlockByNumber` returned non-contiguous transaction indices");
+      }
+      if (viem.hexToBigInt(receipts[index].transactionIndex) !== expectedIndex) {
+        throw new Error("Method `eth_getBlockReceipts` returned non-contiguous transaction indices");
+      }
+      for (const entry of receipts[index].logs) {
+        if (viem.hexToBigInt(entry.transactionIndex) !== expectedIndex) {
+          throw new Error("Method `eth_getBlockReceipts` returned log with unexpected transaction index");
         }
       }
     }
-    return block;
   }
-  const GetBlockError = createException("Failed to load block from the provided `getBlock` function");
-  const public_getFinalizedHeight = async (chain) => {
-    const heights = await metadata.heights.list(chain);
-    if (heights.length === 0) {
-      const block = await getBlock({ chain, number: "finalized" });
-      if (block === null) {
-        log.debug("Failed to fetch finalized block and unable to determine finalized height, aborting...");
-        throw new Error(GetBlockError);
-      }
-      await metadata.heights.upsert(chain, block.eth_getBlockByNumber.number);
-      return hexToNumber(block.eth_getBlockByNumber.number);
+  function verifyTransactionGasUsage(block) {
+    const gasLimit = viem.hexToBigInt(block.eth_getBlockByNumber.gasLimit);
+    const blockGasUsed = viem.hexToBigInt(block.eth_getBlockByNumber.gasUsed);
+    if (blockGasUsed > gasLimit) {
+      throw new Error("Method `eth_getBlockByNumber` returned gas used greater than the block gas limit");
     }
-    const height = Math.max(...heights.map((height2) => hexToNumber(height2.number)));
-    return height;
-  };
-  const public_writeUnfinalizedHead = async (head) => {
-    log.debug("Received unfinalized head...");
-    const blocks_start = Date.now();
-    const [finalizedBlock, block] = await Promise.all([
-      getBlock({ chain: head.chain, number: "finalized" }),
-      getBlock({ chain: head.chain, number: head.number, hash: head.hash })
-    ]);
-    if (block === null) {
-      return;
+    let cumulativeGasUsed = 0n;
+    for (const receipt of block.eth_getBlockReceipts) {
+      cumulativeGasUsed += viem.hexToBigInt(receipt.gasUsed);
+      if (viem.hexToBigInt(receipt.cumulativeGasUsed) !== cumulativeGasUsed) {
+        throw new Error("Method `eth_getBlockReceipts` returned inconsistent cumulative gas used");
+      }
+      if (cumulativeGasUsed > gasLimit) {
+        throw new Error("Method `eth_getBlockReceipts` returned cumulative gas used greater than the block gas limit");
+      }
     }
-    if (finalizedBlock === null) {
-      log.debug("Failed to determine finalized height when processing unfinalized heads");
-      throw new Error(GetBlockError);
+    if (cumulativeGasUsed !== blockGasUsed) {
+      throw new Error("Methods `eth_getBlockByNumber` and `eth_getBlockReceipts` returned inconsistent gas used");
     }
-    const finalizedHeight = hexToNumber(finalizedBlock.eth_getBlockByNumber.number);
-    if (hexToNumber(head.number) <= finalizedHeight) {
-      return;
+  }
+  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 newManifest = {
+        finalized_block_height: chainFinalizedHeight,
+        finalized_block_hash: block.eth_getBlockByNumber.hash,
+        next_finalized_height: chainFinalizedHeight,
+        updated_at: Date.now()
+      };
+      await opts.metadataStorage.adapter.put(path, JSON.stringify(newManifest), { ifNoneMatch: "*" });
+      manifest = newManifest;
+    } else {
+      manifest = JSON.parse(decoder.decode(manifestRes.body));
     }
-    log.debug(`Loaded block in ${Date.now() - blocks_start}ms`);
-    const metadata_start = Date.now();
-    await metadata.blocks.upsert([block]);
-    log.debug(`Persisted block to metadata in ${Date.now() - metadata_start}ms`);
+    return manifest;
+  }
+  const public_getFinalizedHeight = async (chain) => {
+    const manifest = await getOrInitManifest(chain);
+    return manifest.finalized_block_height;
+  };
+  async function writeUnfinalizedBlock(block) {
     const events_start = Date.now();
-    const events = events_grouped_by_storage_map.entries().map(async ([storage, grouped_events]) => {
+    const events = eventsGroupedByStorageMap.entries().map(async ([storage, grouped_events]) => {
       const batch = [];
       for (const event2 of grouped_events) {
         try {
@@ -370,42 +401,59 @@ function indexer(opts) {
     });
     await Promise.all(events);
     log.debug(`Wrote events in ${Date.now() - events_start}ms`);
-    await metadata.commits.upsert(head);
-    const actions = all_actions.flatMap((action2) => {
-      if (typeof action2.handler.latest === "undefined") {
-        return [];
-      }
-      return action2.event.handler(block).map(async (event2) => {
-        await retry(() => action2.handler.latest(event2), 2).catch((error) => {
-          log.error(`Failed to execute 'latest' action ${action2.id}`);
-          throw error;
-        });
-      });
-    });
-    await Promise.allSettled(actions);
-  };
-  const public_deleteReorganisedHead = async (head) => {
-    log.debug(`Received reorganised head ${hexToNumber(head.number)}`);
-    const [stored_block, canonical_block] = await Promise.all([
-      metadata.blocks.get(head),
+    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 commitsKey = `commits/v1/${chain}/${number}/${hash}/${parentHash}`;
+    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),
       //
-      getBlock({ chain: head.chain, number: head.number })
+      getOrInitManifest(head.chain)
     ]);
-    if (stored_block === null) {
-      return log.debug("Reorganised block never/already processed");
-    }
-    if (canonical_block === null) {
-      throw new Error("Attempted to delete unknown block");
+    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 (isHexEqual(head.hash, canonical_block.eth_getBlockByNumber.hash)) {
-      throw new Error("Attempted to delete canonical block");
+    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 deletes = all_events.map(async (event2) => {
+    log.debug(`Persisted block to wal in ${Date.now() - metadata_start}ms`);
+    await writeUnfinalizedBlock(block);
+  };
+  async function deleteReorganisedBlocksAndWriteCanonicalBlock(reorganised, canonical) {
+    const deletes = allEvents.map(async (event2) => {
       const batch = [];
       try {
-        const events = event2.handler(stored_block);
-        for (const event3 of events) {
-          batch.push(event3);
+        for (const block of reorganised) {
+          const events = event2.handler(block);
+          for (const event3 of events) {
+            batch.push(event3);
+          }
         }
       } catch (error) {
         log.error(`Failed to run your 'handler' for event ${event2.id}`);
@@ -420,14 +468,14 @@ function indexer(opts) {
       });
     });
     await Promise.all(deletes);
-    const upserts = events_grouped_by_storage_map.entries().map(async ([storage, grouped_events]) => {
+    const upserts = eventsGroupedByStorageMap.entries().map(async ([storage, grouped_events]) => {
       const batch = [];
       for (const event2 of grouped_events) {
         try {
-          if (!event2.filters.some((filter) => matchFilter(canonical_block, filter))) {
+          if (!event2.filters.some((filter) => matchFilter(canonical, filter))) {
             continue;
           }
-          const events = event2.handler(canonical_block);
+          const events = event2.handler(canonical);
           for (const event3 of events) {
             batch.push(event3);
           }
@@ -446,209 +494,338 @@ function indexer(opts) {
       }
     });
     await Promise.all(upserts);
-  };
-  const public_writeFinalizedHeads = async (heads) => {
-    if (heads.length === 0) {
-      throw new Error("No heads received, aborting...");
-    }
-    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("Received heads from separate chains");
-      }
+  }
+  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),
+      //
+      getBlockFromChain({ chain: head.chain, number: head.number })
+    ]);
+    if (blocksRes === null) {
+      return log.debug("Reorganised block never/already processed");
     }
-    if (chain === void 0) {
-      throw new Error("Internal error. Expected chain to be defined after checking heads length");
+    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 [firstHead, ...remainingHeads] = heads;
-    if (firstHead === void 0) {
-      throw new Error("Internal error. Expected firstHead to be defined after checking heads length");
+    await deleteReorganisedBlocksAndWriteCanonicalBlock([storedBlock], canonicalBlock);
+  };
+  async function writeFinalizedBlock(block, actions) {
+    if (actions.length === 0) {
+      return;
     }
-    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.parent_hash, previousHead.hash)) {
-        throw new Error("Found invalid block hash in received heads, aborting...");
+    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;
       }
-      previousHead = head;
-    }
-    const [heights, finalizedBlock] = await Promise.all([
-      metadata.heights.list(chain),
-      //
-      getBlock({ chain, number: "finalized" })
-    ]);
-    if (finalizedBlock === null) {
-      log.debug("Failed to load chain finalized block. Request should be retried");
-      throw new Error(GetBlockError);
-    }
-    if (heights.length === 0) {
-      await metadata.heights.upsert(chain, finalizedBlock.eth_getBlockByNumber.number);
-      heights.push({ chain, number: finalizedBlock.eth_getBlockByNumber.number });
-    }
-    const indexerHeight = Math.max(...heights.map((height) => hexToNumber(height.number)));
-    const finalizedHeight = hexToNumber(finalizedBlock.eth_getBlockByNumber.number);
-    const lastHead = heads[heads.length - 1];
-    if (lastHead === void 0 || hexToNumber(lastHead.number) !== finalizedHeight) {
-      throw new Error("Client has stalled. Chain has finalized greater than the heads received");
-    }
-    log.debug(`Indexer height ${indexerHeight}, finalized height ${finalizedHeight}`);
-    const newHeads = heads.filter((head) => {
-      return hexToNumber(head.number) > indexerHeight;
+      const commitsKey = `${prefix}/action/${action2.id}`;
+      await opts.metadataStorage.adapter.put(commitsKey, "");
     });
-    const [firstNewHead] = newHeads;
-    if (firstNewHead === void 0 && indexerHeight === finalizedHeight) {
-      return log.debug("No heads to finalize, returning...");
-    }
-    if (firstNewHead === void 0) {
-      throw new Error("Internal error. Expected at least one head greater than the indexer height and less than the finalized height.");
+    await Promise.all(promises);
+  }
+  const public_writeFinalizedHead = async (head) => {
+    log.debug("Received finalized head...");
+    if (allActions.length === 0) {
+      return;
     }
-    if (hexToNumber(firstNewHead.number) !== indexerHeight + 1) {
-      throw new Error("Client advanced too far. Heads received are greater than the first new head");
+    const blocksStart = Date.now();
+    const [block, manifest, chainFinalizedBlock] = await Promise.all([
+      getBlockFromChain(head),
+      getOrInitManifest(head.chain),
+      getBlockFromChain({ chain: head.chain, number: "finalized" })
+    ]);
+    log.debug(`Loaded block in ${Date.now() - blocksStart}ms`);
+    const receivedHeight = viem.hexToNumber(head.number);
+    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 (heights.length > 1) {
-      await cleanupFinalizedHeads(chain, numberToHex(indexerHeight));
+    if (receivedHeight > chainFinalizedHeight) {
+      return log.error(`Received finalized head (${receivedHeight}) that has not finalized (${chainFinalizedHeight})`);
     }
-    for (const head of newHeads) {
-      await Promise.all([
-        processEventsForCanonicalHead(head),
-        processActionsForCanonicalHead(head)
-        //
-      ]);
-      await metadata.heights.upsert(head.chain, head.number);
+    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 finalizedKey = `finalized/v1/${chain}/${number}/${hash}/${parentHash}`;
+    const result = await opts.metadataStorage.adapter.put(finalizedKey, "", { ifNoneMatch: "*" }).catch((error) => {
+      if (error instanceof AdapterError && error.tag === "PreconditionFailed") {
+        return null;
+      }
+      throw error;
+    });
+    if (result === null) {
+      return log.debug("Finalized block already persisted to wal, ignoring...");
     }
-    await cleanupFinalizedHeads(chain, numberToHex(finalizedHeight));
+    await writeFinalizedBlock(block, allActions);
   };
-  async function processActionsForCanonicalHead(head) {
-    if (all_actions.every((action2) => typeof action2.handler.finalized === "undefined")) {
-      return;
+  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);
     }
-    const block = await getBlock({ chain: head.chain, number: head.number, hash: head.hash });
-    const promises = all_actions.flatMap((action2) => {
-      if (typeof action2.handler.finalized === "undefined") {
+  }
+  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 [];
       }
-      return action2.event.handler(block).map(async (event2) => {
-        await retry(() => action2.handler.finalized(event2), 2).catch((error) => {
-          log.error(`Failed to execute 'finalized' action ${action2.id}`);
-          throw error;
+      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(promises);
+      await Promise.all(garbageCollectionPromises);
+    }
+  }
+  async function getBlockFromMetadataOrChain(head) {
+    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;
+    }
+    return await getBlockFromChain(head);
   }
-  async function processEventsForCanonicalHead(head) {
-    const [processed, commits] = await Promise.all([
-      metadata.blocks.list(head.chain, head.number),
+  const public_finalize = async (chain) => {
+    const manifestKey = `manifest/v1/${normalizeHex(chain)}`;
+    const [chainFinalizedBlock, manifestGetRes] = await Promise.all([
+      getBlockFromChain({ chain, number: "finalized" }),
+      opts.metadataStorage.adapter.get(manifestKey)
       //
-      metadata.commits.list(head.chain, head.number)
     ]);
-    if (processed.length === 1) {
-      if (commits.some((commit) => isHexEqual(head.hash, commit.hash) && isHexEqual(head.parent_hash, commit.parent_hash))) {
-        return;
+    const chainFinalizedHeight = viem.hexToNumber(chainFinalizedBlock.eth_getBlockByNumber.number);
+    if (manifestGetRes === null) {
+      log.debug("No manifest file found");
+      const manifest2 = {
+        finalized_block_height: chainFinalizedHeight,
+        finalized_block_hash: chainFinalizedBlock.eth_getBlockByNumber.hash,
+        next_finalized_height: chainFinalizedHeight,
+        updated_at: Date.now()
+      };
+      await opts.metadataStorage.adapter.put(manifestKey, JSON.stringify(manifest2), { ifNoneMatch: "*" });
+      return log.debug("Nothing to finalize, returning...");
+    }
+    const manifest = JSON.parse(decoder.decode(manifestGetRes.body));
+    if (manifest.finalized_block_height !== manifest.next_finalized_height) {
+      if (Date.now() - manifest.updated_at < LEASE_DURATION_MS) {
+        return log.debug("Found valid lease, returning...");
       }
+      log.debug("Found expired lease");
     }
-    const reorganised = processed.filter((block) => {
-      return !isHexEqual(head.hash, block.hash);
+    let indexerFinalizedBlockHeight = manifest.finalized_block_height;
+    let indexerFinalizedBlockHash = manifest.finalized_block_hash;
+    if (indexerFinalizedBlockHeight >= chainFinalizedHeight) {
+      return log.debug("Indexer already finalized, returning...");
+    }
+    log.debug("Acquiring lease...");
+    const updatedManifest = {
+      finalized_block_height: indexerFinalizedBlockHeight,
+      finalized_block_hash: indexerFinalizedBlockHash,
+      next_finalized_height: Math.min(chainFinalizedHeight, indexerFinalizedBlockHeight + FINALIZATION_BATCH_SIZE),
+      updated_at: Date.now()
+    };
+    const conditional = { ifMatch: manifestGetRes.etag };
+    const manifestValue = JSON.stringify(updatedManifest);
+    const manifestPutRes = await opts.metadataStorage.adapter.put(manifestKey, manifestValue, conditional).catch((error) => {
+      if (error instanceof AdapterError && error.tag === "PreconditionFailed") {
+        return null;
+      }
+      throw error;
     });
-    await Promise.all(
-      reorganised.map(async (block) => {
-        await deleteReorganisedHead(block);
-      })
-    );
-    await writeFinalizedHead(head);
-  }
-  async function writeFinalizedHead(head) {
-    const block = await getBlock({ chain: head.chain, number: head.number, hash: head.hash });
-    if (block === null) {
-      throw new Error("Received unknown head that wasn't canonical");
+    if (manifestPutRes === null) {
+      return log.debug("Failed to acquire lease, returning...");
     }
-    const promises = events_grouped_by_storage_map.entries().map(async ([storage, grouped_events]) => {
-      const batch = [];
-      for (const event2 of grouped_events) {
-        try {
-          if (!event2.filters.some((filter) => matchFilter(block, filter))) {
-            log.debug(`Block matches no filters for event ${event2.id}`);
-            continue;
-          }
-          const events = event2.handler(block);
-          for (const event3 of events) {
-            batch.push(event3);
-          }
-        } catch (error) {
-          log.error(`Failed to run your 'handler' for event ${event2.id}`);
-          throw error;
-        }
+    let latestManifestEtag = manifestPutRes.etag;
+    while (indexerFinalizedBlockHeight < chainFinalizedHeight) {
+      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) }),
+        getBlocksProcessedAndGarbageCollect(chain, indexerFinalizedBlockHeight)
+      ]);
+      const nextFinalizedHead = {
+        chain,
+        hash: nextFinalizedBlock.eth_getBlockByNumber.hash,
+        number: nextFinalizedBlock.eth_getBlockByNumber.number,
+        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);
+      });
+      if (nextFinalizedBlockProcessed === false) {
+        await Promise.all([
+          writeUnfinalizedBlock(nextFinalizedBlock),
+          //
+          writeFinalizedBlock(nextFinalizedBlock, allActions)
+        ]);
+        blocksProcessed.push(nextFinalizedHead);
       }
-      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}`);
-          }
-          throw error;
+      const canonicalHeads = [nextFinalizedHead];
+      let parentHash = nextFinalizedBlock.eth_getBlockByNumber.parentHash;
+      for (let index = 1; index < finalizationBatchSize; index++) {
+        const number = nextFinalizedHeight - index;
+        const blocksProcessedForHeight = blocksProcessed.filter((block) => {
+          return viem.hexToNumber(block.number) === number;
         });
-        for (const event2 of grouped_events) {
-          log.debug(`Recorded ${batch.length} ${event2.id} in ${Date.now() - start}ms`);
+        const canonicalHead = blocksProcessedForHeight.find((block) => {
+          return isHexEqual(block.hash, parentHash);
+        });
+        if (canonicalHead) {
+          canonicalHeads.unshift(canonicalHead);
+          parentHash = canonicalHead.parent_hash;
+          continue;
         }
+        log.debug("Canonical head never processed, loading from chain...");
+        const canonicalBlock = await getBlockFromChain({ chain, number: viem.numberToHex(number) });
+        const head = {
+          chain,
+          hash: canonicalBlock.eth_getBlockByNumber.hash,
+          number: canonicalBlock.eth_getBlockByNumber.number,
+          parent_hash: canonicalBlock.eth_getBlockByNumber.parentHash
+        };
+        log.debug("Processing canonical head");
+        await Promise.all([
+          writeUnfinalizedBlock(canonicalBlock),
+          //
+          writeFinalizedBlock(canonicalBlock, allActions)
+        ]);
+        canonicalHeads.unshift(head);
+        blocksProcessed.push(head);
+        parentHash = canonicalBlock.eth_getBlockByNumber.parentHash;
       }
-    });
-    await Promise.all(promises);
-  }
-  async function deleteReorganisedHead(head) {
-    const block = await metadata.blocks.get(head);
-    if (block === null) {
-      throw new Error("Expected reorganised block to exist in metadata");
-    }
-    const promises = all_events.map(async (event2) => {
-      const batch = [];
-      try {
-        const events = event2.handler(block);
-        for (const event3 of events) {
-          batch.push(event3);
-        }
-      } catch (error) {
-        log.error(`Failed to run your 'handler' for event ${event2.id}`);
-        throw error;
+      if (!isHexEqual(parentHash, indexerFinalizedBlockHash)) {
+        throw new Error("Expected chain to match last finalized canonical anchor");
       }
-      if (batch.length === 0) {
-        return;
+      if (canonicalHeads.length !== finalizationBatchSize) {
+        throw new Error(`Expected to have ${finalizationBatchSize} heads, found ${canonicalHeads.length}`);
       }
-      await retry(() => event2.storage.delete(batch), 2).catch((error) => {
-        log.error(`Failed to run your 'delete' handler for event ${event2.id}`);
+      log.debug("Determined canonical chain");
+      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);
+        });
+        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);
+        });
+        const actionsWithoutCommit = allActions.filter((action2) => {
+          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 !commitExists;
+        });
+        if (eventsCommittedForHeight && processedOnlyCanonicalBlock && actionsWithoutCommit.length === 0 && blocksProcessedForHeight.length === 1) {
+          log.debug("Executed fast-path");
+          continue;
+        }
+        log.debug("Fast-path missed for head");
+        log.debug(`Events commited for height: ${eventsCommittedForHeight}`);
+        log.debug(`Processed only canonical block: ${processedOnlyCanonicalBlock}`);
+        log.debug(`Actions without commit (${actionsWithoutCommit.length}): ${actionsWithoutCommit.length === 0}`);
+        log.debug(`Blocks processed for height (${blocksProcessedForHeight.length}): ${blocksProcessedForHeight.length === 1}`);
+        const reorganisedHeads = blocksProcessedForHeight.flatMap((head) => {
+          if (isHexEqual(canonicalHead.hash, head.hash)) {
+            return [];
+          }
+          return { chain, number: head.number, hash: head.hash, parent_hash: head.parent_hash };
+        });
+        const reorganisedPromises = reorganisedHeads.map((head) => getBlockFromMetadataOrChain(head));
+        const [canonicalBlock, ...reorganisedBlocks] = await Promise.all([
+          getBlockFromMetadataOrChain(canonicalHead),
+          //
+          ...reorganisedPromises
+        ]);
+        log.debug("Re-processing heads");
+        await Promise.all([
+          writeFinalizedBlock(canonicalBlock, actionsWithoutCommit),
+          //
+          deleteReorganisedBlocksAndWriteCanonicalBlock(reorganisedBlocks, canonicalBlock)
+        ]);
+      }
+      const nextBatchFinalizingHeight = Math.min(chainFinalizedHeight, nextFinalizedHeight + FINALIZATION_BATCH_SIZE);
+      const updatedManifest2 = {
+        finalized_block_height: nextFinalizedHeight,
+        finalized_block_hash: nextFinalizedBlock.eth_getBlockByNumber.hash,
+        next_finalized_height: nextBatchFinalizingHeight,
+        updated_at: Date.now()
+      };
+      const manifestPutRes2 = await opts.metadataStorage.adapter.put(manifestKey, JSON.stringify(updatedManifest2), { ifMatch: latestManifestEtag }).catch((error) => {
+        if (error instanceof AdapterError) {
+          if (error.tag === "PreconditionFailed") {
+            return null;
+          }
+        }
         throw error;
       });
-    });
-    await Promise.all(promises);
-  }
-  async function cleanupFinalizedHeads(chain, finalized) {
-    const [_blocks, _commits, _heights] = await Promise.all([
-      metadata.blocks.list(chain),
-      //
-      metadata.commits.list(chain),
-      metadata.heights.list(chain)
-    ]);
-    const blocks = _blocks.filter((block) => {
-      return hexToNumber(block.number) <= hexToNumber(finalized);
-    });
-    const commits = _commits.filter((commit) => {
-      return hexToNumber(commit.number) <= hexToNumber(finalized);
-    });
-    const heights = _heights.filter((height) => {
-      return hexToNumber(height.number) < hexToNumber(finalized);
-    });
-    await Promise.all([
-      metadata.blocks.delete(blocks),
-      //
-      metadata.commits.delete(commits),
-      metadata.heights.delete(heights)
-    ]);
-  }
+      if (manifestPutRes2 === null) {
+        return log.debug("Failed to commit finalized batch, aborting...");
+      }
+      indexerFinalizedBlockHeight = nextFinalizedHeight;
+      indexerFinalizedBlockHash = nextFinalizedBlock.eth_getBlockByNumber.hash;
+      latestManifestEtag = manifestPutRes2.etag;
+    }
+    log.debug("Indexer finalized, returning...");
+  };
   const private_getMetadata = async () => {
     return {
       version,
@@ -656,7 +833,7 @@ function indexer(opts) {
     };
   };
   const private_getEvents = async () => {
-    return all_events.map((event2) => {
+    return allEvents.map((event2) => {
       const filters = event2.filters.map((filter) => {
         return {
           chain: filter.chain,
@@ -712,8 +889,8 @@ function indexer(opts) {
   };
   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));
+    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: [] };
     const failures = {};
@@ -722,7 +899,7 @@ function indexer(opts) {
       accessed_undefined_key = true;
       throw new Error(IncompleteBlockError);
     });
-    const promises = events_grouped_by_storage_map.entries().map(async ([storage, grouped_events]) => {
+    const promises = eventsGroupedByStorageMap.entries().map(async ([storage, grouped_events]) => {
       const batch = [];
       for (const event2 of grouped_events) {
         if (!params.events.includes(event2.id)) continue;
@@ -788,33 +965,19 @@ function indexer(opts) {
     return { failures: failures_array };
   };
   const private_writeEventsAndGetKeys = async (params) => {
-    if (all_events.length === 0) {
+    if (allEvents.length === 0) {
       return { results: [], keys: [] };
     }
     if (params.events.length === 0) {
       return { results: [], keys: [] };
     }
-    const relevant_events = all_events.filter((event2) => params.events.includes(event2.id));
+    const relevant_events = allEvents.filter((event2) => params.events.includes(event2.id));
     if (relevant_events.length === 0) {
       return { results: [], keys: [] };
     }
-    const block = await getBlock(params.head);
-    if (block === null) {
-      return {
-        keys: [],
-        results: relevant_events.map((event2) => {
-          return {
-            event_id: event2.id,
-            status: "block_error",
-            chain: params.head.chain,
-            hash: params.head.hash,
-            number: params.head.number,
-            parent_hash: params.head.parent_hash,
-            created_at: Date.now()
-          };
-        })
-      };
-    }
+    const block = await getBlockFromChain(params.head).catch(() => {
+      return null;
+    });
     const keys = /* @__PURE__ */ new Set();
     const results = {};
     function createProxyHandler(path) {
@@ -915,20 +1078,27 @@ function indexer(opts) {
     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.`);
     }
-    all_events.push(event2);
-    const group = events_grouped_by_storage_map.get(event2.storage) ?? [];
+    allEvents.push(event2);
+    const group = eventsGroupedByStorageMap.get(event2.storage) ?? [];
     group.push(event2);
-    events_grouped_by_storage_map.set(event2.storage, group);
+    eventsGroupedByStorageMap.set(event2.storage, group);
     return event2;
   };
   const action = (action2) => {
-    all_actions.push(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_writeFinalizedHeads,
+      public_writeFinalizedHead,
       public_writeUnfinalizedHead,
       public_deleteReorganisedHead,
       private_getEvents,
@@ -943,13 +1113,13 @@ function indexer(opts) {
     quiet: opts.quiet ?? false,
     signingKey: opts.signingKey
   });
-  const indexer2 = {
+  const indexer = {
     ...rpc,
     event,
     action,
     fetch: server.http
   };
-  return indexer2;
+  return indexer;
 }
 
-export { indexer };
+export { defineIndexer };