ponder 0.9.3 → 0.9.4-debug.1

package/dist/bin/ponder.js

@@ -1,15 +1,27 @@
 #!/usr/bin/env node
 import {
-  createQueue,
-  dedupe,
   getMetadataStore,
   never,
-  promiseWithResolvers,
   serialize
-} from "../chunk-LHCA5XFV.js";
+} from "../chunk-DZFRP3KH.js";
 import {
-  onchain
-} from "../chunk-K2TLRLX3.js";
+  BuildError,
+  NonRetryableError,
+  ShutdownError,
+  createHistoricalIndexingStore,
+  createRealtimeIndexingStore,
+  getColumnCasing,
+  getPrimaryKeyColumns,
+  getSql,
+  getTableNames,
+  prettyPrint
+} from "../chunk-6AOFLZJ4.js";
+import {
+  createQueue,
+  dedupe,
+  promiseWithResolvers
+} from "../chunk-MJKRYIBO.js";
+import "../chunk-K2TLRLX3.js";
 
 // src/bin/ponder.ts
 import { readFileSync as readFileSync4 } from "node:fs";
@@ -677,106 +689,6 @@ function hrTimeToMs(diff) {
 // src/internal/telemetry.ts
 import Conf from "conf";
 import { detect, getNpmVersion } from "detect-package-manager";
-
-// src/internal/errors.ts
-var BaseError = class _BaseError extends Error {
-  name = "BaseError";
-  meta = [];
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, _BaseError.prototype);
-  }
-};
-function getBaseError(err) {
-  if (err instanceof BaseError)
-    return err;
-  if (err instanceof Error)
-    return new BaseError(err.message);
-  if (typeof err?.message === "string")
-    return new BaseError(err.message);
-  if (typeof err === "string")
-    return new BaseError(err);
-  return new BaseError("unknown error");
-}
-var BuildError = class _BuildError extends BaseError {
-  name = "BuildError";
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, _BuildError.prototype);
-  }
-};
-var NonRetryableError = class _NonRetryableError extends BaseError {
-  name = "NonRetryableError";
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, _NonRetryableError.prototype);
-  }
-};
-var UniqueConstraintError = class _UniqueConstraintError extends NonRetryableError {
-  name = "UniqueConstraintError";
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, _UniqueConstraintError.prototype);
-  }
-};
-var NotNullConstraintError = class _NotNullConstraintError extends NonRetryableError {
-  name = "NotNullConstraintError";
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, _NotNullConstraintError.prototype);
-  }
-};
-var RecordNotFoundError = class _RecordNotFoundError extends NonRetryableError {
-  name = "RecordNotFoundError";
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, _RecordNotFoundError.prototype);
-  }
-};
-var CheckConstraintError = class _CheckConstraintError extends NonRetryableError {
-  name = "CheckConstraintError";
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, _CheckConstraintError.prototype);
-  }
-};
-var InvalidStoreMethodError = class _InvalidStoreMethodError extends NonRetryableError {
-  name = "InvalidStoreMethodError";
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, _InvalidStoreMethodError.prototype);
-  }
-};
-var UndefinedTableError = class _UndefinedTableError extends NonRetryableError {
-  name = "UndefinedTableError";
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, _UndefinedTableError.prototype);
-  }
-};
-var BigIntSerializationError = class _BigIntSerializationError extends NonRetryableError {
-  name = "BigIntSerializationError";
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, _BigIntSerializationError.prototype);
-  }
-};
-var FlushError = class _FlushError extends NonRetryableError {
-  name = "FlushError";
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, _FlushError.prototype);
-  }
-};
-var ShutdownError = class _ShutdownError extends NonRetryableError {
-  name = "ShutdownError";
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, _ShutdownError.prototype);
-  }
-};
-
-// src/internal/telemetry.ts
 var HEARTBEAT_INTERVAL_MS = 6e4;
 function createTelemetry({
   options,
@@ -1655,6 +1567,9 @@ var shouldGetTransactionReceipt = (filter) => {
   return false;
 };
 
+// src/build/configAndIndexingFunctions.ts
+import { BlockNotFoundError, hexToNumber as hexToNumber2 } from "viem";
+
 // src/utils/offset.ts
 import { InvalidAbiDecodingTypeError } from "viem";
 function getBytesConsumedByParam(param) {
@@ -1785,6 +1700,37 @@ async function buildConfigAndIndexingFunctions({
   rawIndexingFunctions
 }) {
   const logs = [];
+  const perNetworkLatestBlockNumber = /* @__PURE__ */ new Map();
+  const resolveBlockNumber = async (blockNumberOrTag, network) => {
+    if (blockNumberOrTag === void 0) {
+      return void 0;
+    }
+    if (Number.isNaN(blockNumberOrTag)) {
+      return void 0;
+    }
+    if (blockNumberOrTag === "latest") {
+      if (perNetworkLatestBlockNumber.has(network.name)) {
+        return perNetworkLatestBlockNumber.get(network.name);
+      } else {
+        const blockPromise = network.transport.request({
+          method: "eth_getBlockByNumber",
+          params: ["latest", false]
+        }).then((block) => {
+          if (!block)
+            throw new BlockNotFoundError({ blockNumber: "latest" });
+          return hexToNumber2(block.number);
+        }).catch((e) => {
+          throw new Error(
+            `Unable to fetch "latest" block for network '${network.name}':
+${e.message}`
+          );
+        });
+        perNetworkLatestBlockNumber.set(network.name, blockPromise);
+        return blockPromise;
+      }
+    }
+    return blockNumberOrTag;
+  };
   const networks = await Promise.all(
     Object.entries(config.networks).map(async ([networkName, network]) => {
       const { chainId, transport } = network;
@@ -1893,450 +1839,458 @@ async function buildConfigAndIndexingFunctions({
         `Validation failed: Network for '${source.name}' is null or undefined. Expected one of [${networks.map((n) => `'${n.name}'`).join(", ")}].`
       );
     }
-    const startBlockMaybeNan = source.startBlock;
-    const startBlock = Number.isNaN(startBlockMaybeNan) ? void 0 : startBlockMaybeNan;
-    const endBlockMaybeNan = source.endBlock;
-    const endBlock = Number.isNaN(endBlockMaybeNan) ? void 0 : endBlockMaybeNan;
-    if (startBlock !== void 0 && endBlock !== void 0 && endBlock < startBlock) {
-      throw new Error(
-        `Validation failed: Start block for '${source.name}' is after end block (${startBlock} > ${endBlock}).`
-      );
-    }
     const network = networks.find((n) => n.name === source.network);
     if (!network) {
       throw new Error(
         `Validation failed: Invalid network for '${source.name}'. Got '${source.network}', expected one of [${networks.map((n) => `'${n.name}'`).join(", ")}].`
       );
     }
+    const startBlock = await resolveBlockNumber(source.startBlock, network);
+    const endBlock = await resolveBlockNumber(source.endBlock, network);
+    if (startBlock !== void 0 && endBlock !== void 0 && endBlock < startBlock) {
+      throw new Error(
+        `Validation failed: Start block for '${source.name}' is after end block (${startBlock} > ${endBlock}).`
+      );
+    }
   }
-  const contractSources = flattenSources(
-    config.contracts ?? {}
-  ).flatMap((source) => {
-    const network = networks.find((n) => n.name === source.network);
-    const registeredLogEvents = [];
-    const registeredCallTraceEvents = [];
-    for (const eventName of Object.keys(indexingFunctions)) {
-      if (eventName.includes(":")) {
-        const [logContractName, logEventName] = eventName.split(":");
-        if (logContractName === source.name && logEventName !== "setup") {
-          registeredLogEvents.push(logEventName);
+  const contractSources = (await Promise.all(
+    flattenSources(config.contracts ?? {}).map(
+      async (source) => {
+        const network = networks.find((n) => n.name === source.network);
+        const registeredLogEvents = [];
+        const registeredCallTraceEvents = [];
+        for (const eventName of Object.keys(indexingFunctions)) {
+          if (eventName.includes(":")) {
+            const [logContractName, logEventName] = eventName.split(":");
+            if (logContractName === source.name && logEventName !== "setup") {
+              registeredLogEvents.push(logEventName);
+            }
+          }
+          if (eventName.includes(".")) {
+            const [functionContractName, functionName] = eventName.split(
+              "."
+            );
+            if (functionContractName === source.name) {
+              registeredCallTraceEvents.push(functionName);
+            }
+          }
         }
-      }
-      if (eventName.includes(".")) {
-        const [functionContractName, functionName] = eventName.split(".");
-        if (functionContractName === source.name) {
-          registeredCallTraceEvents.push(functionName);
+        const abiEvents = buildAbiEvents({ abi: source.abi });
+        const abiFunctions = buildAbiFunctions({ abi: source.abi });
+        const registeredEventSelectors = [];
+        for (const logEvent of registeredLogEvents) {
+          const abiEvent = abiEvents.bySafeName[logEvent];
+          if (abiEvent === void 0) {
+            throw new Error(
+              `Validation failed: Event name for event '${logEvent}' not found in the contract ABI. Got '${logEvent}', expected one of [${Object.keys(
+                abiEvents.bySafeName
+              ).map((eventName) => `'${eventName}'`).join(", ")}].`
+            );
+          }
+          registeredEventSelectors.push(abiEvent.selector);
         }
-      }
-    }
-    const abiEvents = buildAbiEvents({ abi: source.abi });
-    const abiFunctions = buildAbiFunctions({ abi: source.abi });
-    const registeredEventSelectors = [];
-    for (const logEvent of registeredLogEvents) {
-      const abiEvent = abiEvents.bySafeName[logEvent];
-      if (abiEvent === void 0) {
-        throw new Error(
-          `Validation failed: Event name for event '${logEvent}' not found in the contract ABI. Got '${logEvent}', expected one of [${Object.keys(
-            abiEvents.bySafeName
-          ).map((eventName) => `'${eventName}'`).join(", ")}].`
-        );
-      }
-      registeredEventSelectors.push(abiEvent.selector);
-    }
-    const registeredFunctionSelectors = [];
-    for (const _function of registeredCallTraceEvents) {
-      const abiFunction = abiFunctions.bySafeName[_function];
-      if (abiFunction === void 0) {
-        throw new Error(
-          `Validation failed: Function name for function '${_function}' not found in the contract ABI. Got '${_function}', expected one of [${Object.keys(
-            abiFunctions.bySafeName
-          ).map((eventName) => `'${eventName}'`).join(", ")}].`
-        );
-      }
-      registeredFunctionSelectors.push(abiFunction.selector);
-    }
-    const topicsArray = [];
-    if (source.filter !== void 0) {
-      const eventFilters = Array.isArray(source.filter) ? source.filter : [source.filter];
-      for (const filter of eventFilters) {
-        const abiEvent = abiEvents.bySafeName[filter.event];
-        if (!abiEvent) {
-          throw new Error(
-            `Validation failed: Invalid filter for contract '${source.name}'. Got event name '${filter.event}', expected one of [${Object.keys(
-              abiEvents.bySafeName
-            ).map((n) => `'${n}'`).join(", ")}].`
+        const registeredFunctionSelectors = [];
+        for (const _function of registeredCallTraceEvents) {
+          const abiFunction = abiFunctions.bySafeName[_function];
+          if (abiFunction === void 0) {
+            throw new Error(
+              `Validation failed: Function name for function '${_function}' not found in the contract ABI. Got '${_function}', expected one of [${Object.keys(
+                abiFunctions.bySafeName
+              ).map((eventName) => `'${eventName}'`).join(", ")}].`
+            );
+          }
+          registeredFunctionSelectors.push(abiFunction.selector);
+        }
+        const topicsArray = [];
+        if (source.filter !== void 0) {
+          const eventFilters = Array.isArray(source.filter) ? source.filter : [source.filter];
+          for (const filter of eventFilters) {
+            const abiEvent = abiEvents.bySafeName[filter.event];
+            if (!abiEvent) {
+              throw new Error(
+                `Validation failed: Invalid filter for contract '${source.name}'. Got event name '${filter.event}', expected one of [${Object.keys(
+                  abiEvents.bySafeName
+                ).map((n) => `'${n}'`).join(", ")}].`
+              );
+            }
+          }
+          topicsArray.push(...buildTopics(source.abi, eventFilters));
+          const filteredEventSelectors = topicsArray.map(
+            (t) => t.topic0
+          );
+          const excludedRegisteredEventSelectors = registeredEventSelectors.filter(
+            (s) => filteredEventSelectors.includes(s) === false
           );
+          for (const selector of filteredEventSelectors) {
+            if (registeredEventSelectors.includes(selector) === false) {
+              throw new Error(
+                `Validation failed: Event selector '${abiEvents.bySelector[selector]?.safeName}' is used in a filter but does not have a corresponding indexing function.`
+              );
+            }
+          }
+          if (excludedRegisteredEventSelectors.length > 0) {
+            topicsArray.push({
+              topic0: excludedRegisteredEventSelectors,
+              topic1: null,
+              topic2: null,
+              topic3: null
+            });
+          }
+        } else {
+          topicsArray.push({
+            topic0: registeredEventSelectors,
+            topic1: null,
+            topic2: null,
+            topic3: null
+          });
         }
-      }
-      topicsArray.push(...buildTopics(source.abi, eventFilters));
-      const filteredEventSelectors = topicsArray.map(
-        (t) => t.topic0
-      );
-      const excludedRegisteredEventSelectors = registeredEventSelectors.filter(
-        (s) => filteredEventSelectors.includes(s) === false
-      );
-      for (const selector of filteredEventSelectors) {
-        if (registeredEventSelectors.includes(selector) === false) {
-          throw new Error(
-            `Validation failed: Event selector '${abiEvents.bySelector[selector]?.safeName}' is used in a filter but does not have a corresponding indexing function.`
+        const fromBlock = await resolveBlockNumber(
+          source.startBlock,
+          network
+        );
+        const toBlock = await resolveBlockNumber(source.endBlock, network);
+        const contractMetadata = {
+          type: "contract",
+          abi: source.abi,
+          abiEvents,
+          abiFunctions,
+          name: source.name,
+          network
+        };
+        const resolvedAddress = source?.address;
+        if (typeof resolvedAddress === "object" && !Array.isArray(resolvedAddress)) {
+          const logFactory = buildLogFactory({
+            chainId: network.chainId,
+            ...resolvedAddress
+          });
+          const logSources2 = topicsArray.map(
+            (topics) => ({
+              ...contractMetadata,
+              filter: {
+                type: "log",
+                chainId: network.chainId,
+                address: logFactory,
+                topic0: topics.topic0,
+                topic1: topics.topic1,
+                topic2: topics.topic2,
+                topic3: topics.topic3,
+                fromBlock,
+                toBlock,
+                include: defaultLogFilterInclude.concat(
+                  source.includeTransactionReceipts ? defaultTransactionReceiptInclude : []
+                )
+              }
+            })
           );
+          if (source.includeCallTraces) {
+            return [
+              ...logSources2,
+              {
+                ...contractMetadata,
+                filter: {
+                  type: "trace",
+                  chainId: network.chainId,
+                  fromAddress: void 0,
+                  toAddress: logFactory,
+                  callType: "CALL",
+                  functionSelector: registeredFunctionSelectors,
+                  includeReverted: false,
+                  fromBlock,
+                  toBlock,
+                  include: defaultTraceFilterInclude.concat(
+                    source.includeTransactionReceipts ? defaultTransactionReceiptInclude : []
+                  )
+                }
+              }
+            ];
+          }
+          return logSources2;
+        } else if (resolvedAddress !== void 0) {
+          for (const address of Array.isArray(resolvedAddress) ? resolvedAddress : [resolvedAddress]) {
+            if (!address.startsWith("0x"))
+              throw new Error(
+                `Validation failed: Invalid prefix for address '${address}'. Got '${address.slice(
+                  0,
+                  2
+                )}', expected '0x'.`
+              );
+            if (address.length !== 42)
+              throw new Error(
+                `Validation failed: Invalid length for address '${address}'. Got ${address.length}, expected 42 characters.`
+              );
+          }
         }
+        const validatedAddress = Array.isArray(resolvedAddress) ? dedupe(resolvedAddress).map((r) => toLowerCase(r)) : resolvedAddress !== void 0 ? toLowerCase(resolvedAddress) : void 0;
+        const logSources = topicsArray.map(
+          (topics) => ({
+            ...contractMetadata,
+            filter: {
+              type: "log",
+              chainId: network.chainId,
+              address: validatedAddress,
+              topic0: topics.topic0,
+              topic1: topics.topic1,
+              topic2: topics.topic2,
+              topic3: topics.topic3,
+              fromBlock,
+              toBlock,
+              include: defaultLogFilterInclude.concat(
+                source.includeTransactionReceipts ? defaultTransactionReceiptInclude : []
+              )
+            }
+          })
+        );
+        if (source.includeCallTraces) {
+          return [
+            ...logSources,
+            {
+              ...contractMetadata,
+              filter: {
+                type: "trace",
+                chainId: network.chainId,
+                fromAddress: void 0,
+                toAddress: Array.isArray(validatedAddress) ? validatedAddress : validatedAddress === void 0 ? void 0 : [validatedAddress],
+                callType: "CALL",
+                functionSelector: registeredFunctionSelectors,
+                includeReverted: false,
+                fromBlock,
+                toBlock,
+                include: defaultTraceFilterInclude.concat(
+                  source.includeTransactionReceipts ? defaultTransactionReceiptInclude : []
+                )
+              }
+            }
+          ];
+        } else
+          return logSources;
       }
-      if (excludedRegisteredEventSelectors.length > 0) {
-        topicsArray.push({
-          topic0: excludedRegisteredEventSelectors,
-          topic1: null,
-          topic2: null,
-          topic3: null
-        });
-      }
-    } else {
-      topicsArray.push({
-        topic0: registeredEventSelectors,
-        topic1: null,
-        topic2: null,
-        topic3: null
+    )
+  )).flat().filter((source) => {
+    const hasNoRegisteredIndexingFunctions = source.filter.type === "trace" ? Array.isArray(source.filter.functionSelector) && source.filter.functionSelector.length === 0 : Array.isArray(source.filter.topic0) && source.filter.topic0?.length === 0;
+    if (hasNoRegisteredIndexingFunctions) {
+      logs.push({
+        level: "debug",
+        msg: `No indexing functions were registered for '${source.name}' ${source.filter.type === "trace" ? "traces" : "logs"}`
       });
     }
-    const startBlockMaybeNan = source.startBlock;
-    const fromBlock = Number.isNaN(startBlockMaybeNan) ? void 0 : startBlockMaybeNan;
-    const endBlockMaybeNan = source.endBlock;
-    const toBlock = Number.isNaN(endBlockMaybeNan) ? void 0 : endBlockMaybeNan;
-    const contractMetadata = {
-      type: "contract",
-      abi: source.abi,
-      abiEvents,
-      abiFunctions,
-      name: source.name,
-      network
-    };
-    const resolvedAddress = source?.address;
-    if (typeof resolvedAddress === "object" && !Array.isArray(resolvedAddress)) {
-      const logFactory = buildLogFactory({
-        chainId: network.chainId,
-        ...resolvedAddress
-      });
-      const logSources2 = topicsArray.map(
-        (topics) => ({
-          ...contractMetadata,
-          filter: {
-            type: "log",
+    return hasNoRegisteredIndexingFunctions === false;
+  });
+  const accountSources = (await Promise.all(
+    flattenSources(config.accounts ?? {}).map(
+      async (source) => {
+        const network = networks.find((n) => n.name === source.network);
+        const fromBlock = await resolveBlockNumber(
+          source.startBlock,
+          network
+        );
+        const toBlock = await resolveBlockNumber(source.endBlock, network);
+        const resolvedAddress = source?.address;
+        if (resolvedAddress === void 0) {
+          throw new Error(
+            `Validation failed: Account '${source.name}' must specify an 'address'.`
+          );
+        }
+        if (typeof resolvedAddress === "object" && !Array.isArray(resolvedAddress)) {
+          const logFactory = buildLogFactory({
             chainId: network.chainId,
-            address: logFactory,
-            topic0: topics.topic0,
-            topic1: topics.topic1,
-            topic2: topics.topic2,
-            topic3: topics.topic3,
-            fromBlock,
-            toBlock,
-            include: defaultLogFilterInclude.concat(
-              source.includeTransactionReceipts ? defaultTransactionReceiptInclude : []
-            )
-          }
-        })
-      );
-      if (source.includeCallTraces) {
+            ...resolvedAddress
+          });
+          return [
+            {
+              type: "account",
+              name: source.name,
+              network,
+              filter: {
+                type: "transaction",
+                chainId: network.chainId,
+                fromAddress: void 0,
+                toAddress: logFactory,
+                includeReverted: false,
+                fromBlock,
+                toBlock,
+                include: defaultTransactionFilterInclude
+              }
+            },
+            {
+              type: "account",
+              name: source.name,
+              network,
+              filter: {
+                type: "transaction",
+                chainId: network.chainId,
+                fromAddress: logFactory,
+                toAddress: void 0,
+                includeReverted: false,
+                fromBlock,
+                toBlock,
+                include: defaultTransactionFilterInclude
+              }
+            },
+            {
+              type: "account",
+              name: source.name,
+              network,
+              filter: {
+                type: "transfer",
+                chainId: network.chainId,
+                fromAddress: void 0,
+                toAddress: logFactory,
+                includeReverted: false,
+                fromBlock,
+                toBlock,
+                include: defaultTransferFilterInclude.concat(
+                  source.includeTransactionReceipts ? defaultTransactionReceiptInclude : []
+                )
+              }
+            },
+            {
+              type: "account",
+              name: source.name,
+              network,
+              filter: {
+                type: "transfer",
+                chainId: network.chainId,
+                fromAddress: logFactory,
+                toAddress: void 0,
+                includeReverted: false,
+                fromBlock,
+                toBlock,
+                include: defaultTransferFilterInclude.concat(
+                  source.includeTransactionReceipts ? defaultTransactionReceiptInclude : []
+                )
+              }
+            }
+          ];
+        }
+        for (const address of Array.isArray(resolvedAddress) ? resolvedAddress : [resolvedAddress]) {
+          if (!address.startsWith("0x"))
+            throw new Error(
+              `Validation failed: Invalid prefix for address '${address}'. Got '${address.slice(
+                0,
+                2
+              )}', expected '0x'.`
+            );
+          if (address.length !== 42)
+            throw new Error(
+              `Validation failed: Invalid length for address '${address}'. Got ${address.length}, expected 42 characters.`
+            );
+        }
+        const validatedAddress = Array.isArray(resolvedAddress) ? dedupe(resolvedAddress).map((r) => toLowerCase(r)) : resolvedAddress !== void 0 ? toLowerCase(resolvedAddress) : void 0;
         return [
-          ...logSources2,
           {
-            ...contractMetadata,
+            type: "account",
+            name: source.name,
+            network,
+            filter: {
+              type: "transaction",
+              chainId: network.chainId,
+              fromAddress: void 0,
+              toAddress: validatedAddress,
+              includeReverted: false,
+              fromBlock,
+              toBlock,
+              include: defaultTransactionFilterInclude
+            }
+          },
+          {
+            type: "account",
+            name: source.name,
+            network,
+            filter: {
+              type: "transaction",
+              chainId: network.chainId,
+              fromAddress: validatedAddress,
+              toAddress: void 0,
+              includeReverted: false,
+              fromBlock,
+              toBlock,
+              include: defaultTransactionFilterInclude
+            }
+          },
+          {
+            type: "account",
+            name: source.name,
+            network,
             filter: {
-              type: "trace",
+              type: "transfer",
               chainId: network.chainId,
               fromAddress: void 0,
-              toAddress: logFactory,
-              callType: "CALL",
-              functionSelector: registeredFunctionSelectors,
+              toAddress: validatedAddress,
+              includeReverted: false,
+              fromBlock,
+              toBlock,
+              include: defaultTransferFilterInclude.concat(
+                source.includeTransactionReceipts ? defaultTransactionReceiptInclude : []
+              )
+            }
+          },
+          {
+            type: "account",
+            name: source.name,
+            network,
+            filter: {
+              type: "transfer",
+              chainId: network.chainId,
+              fromAddress: validatedAddress,
+              toAddress: void 0,
               includeReverted: false,
               fromBlock,
               toBlock,
-              include: defaultTraceFilterInclude.concat(
+              include: defaultTransferFilterInclude.concat(
                 source.includeTransactionReceipts ? defaultTransactionReceiptInclude : []
               )
             }
           }
         ];
       }
-      return logSources2;
-    } else if (resolvedAddress !== void 0) {
-      for (const address of Array.isArray(resolvedAddress) ? resolvedAddress : [resolvedAddress]) {
-        if (!address.startsWith("0x"))
-          throw new Error(
-            `Validation failed: Invalid prefix for address '${address}'. Got '${address.slice(
-              0,
-              2
-            )}', expected '0x'.`
-          );
-        if (address.length !== 42)
-          throw new Error(
-            `Validation failed: Invalid length for address '${address}'. Got ${address.length}, expected 42 characters.`
-          );
-      }
+    )
+  )).flat().filter((source) => {
+    const eventName = source.filter.type === "transaction" ? source.filter.fromAddress === void 0 ? `${source.name}:transaction:to` : `${source.name}:transaction:from` : source.filter.fromAddress === void 0 ? `${source.name}:transfer:to` : `${source.name}:transfer:from`;
+    const hasRegisteredIndexingFunction = indexingFunctions[eventName] !== void 0;
+    if (!hasRegisteredIndexingFunction) {
+      logs.push({
+        level: "debug",
+        msg: `No indexing functions were registered for '${eventName}'`
+      });
     }
-    const validatedAddress = Array.isArray(resolvedAddress) ? dedupe(resolvedAddress).map((r) => toLowerCase(r)) : resolvedAddress !== void 0 ? toLowerCase(resolvedAddress) : void 0;
-    const logSources = topicsArray.map(
-      (topics) => ({
-        ...contractMetadata,
+    return hasRegisteredIndexingFunction;
+  });
+  const blockSources = (await Promise.all(
+    flattenSources(config.blocks ?? {}).map(async (source) => {
+      const network = networks.find((n) => n.name === source.network);
+      const intervalMaybeNan = source.interval ?? 1;
+      const interval = Number.isNaN(intervalMaybeNan) ? 0 : intervalMaybeNan;
+      if (!Number.isInteger(interval) || interval === 0) {
+        throw new Error(
+          `Validation failed: Invalid interval for block source '${source.name}'. Got ${interval}, expected a non-zero integer.`
+        );
+      }
+      const fromBlock = await resolveBlockNumber(source.startBlock, network);
+      const toBlock = await resolveBlockNumber(source.endBlock, network);
+      return {
+        type: "block",
+        name: source.name,
+        network,
         filter: {
-          type: "log",
+          type: "block",
           chainId: network.chainId,
-          address: validatedAddress,
-          topic0: topics.topic0,
-          topic1: topics.topic1,
-          topic2: topics.topic2,
-          topic3: topics.topic3,
+          interval,
+          offset: (fromBlock ?? 0) % interval,
           fromBlock,
           toBlock,
-          include: defaultLogFilterInclude.concat(
-            source.includeTransactionReceipts ? defaultTransactionReceiptInclude : []
-          )
-        }
-      })
-    );
-    if (source.includeCallTraces) {
-      return [
-        ...logSources,
-        {
-          ...contractMetadata,
-          filter: {
-            type: "trace",
-            chainId: network.chainId,
-            fromAddress: void 0,
-            toAddress: Array.isArray(validatedAddress) ? validatedAddress : validatedAddress === void 0 ? void 0 : [validatedAddress],
-            callType: "CALL",
-            functionSelector: registeredFunctionSelectors,
-            includeReverted: false,
-            fromBlock,
-            toBlock,
-            include: defaultTraceFilterInclude.concat(
-              source.includeTransactionReceipts ? defaultTransactionReceiptInclude : []
-            )
-          }
+          include: defaultBlockFilterInclude
         }
-      ];
-    } else
-      return logSources;
-  }).filter((source) => {
-    const hasNoRegisteredIndexingFunctions = source.filter.type === "trace" ? Array.isArray(source.filter.functionSelector) && source.filter.functionSelector.length === 0 : Array.isArray(source.filter.topic0) && source.filter.topic0?.length === 0;
-    if (hasNoRegisteredIndexingFunctions) {
+      };
+    })
+  )).flat().filter((blockSource) => {
+    const hasRegisteredIndexingFunction = indexingFunctions[`${blockSource.name}:block`] !== void 0;
+    if (!hasRegisteredIndexingFunction) {
       logs.push({
         level: "debug",
-        msg: `No indexing functions were registered for '${source.name}' ${source.filter.type === "trace" ? "traces" : "logs"}`
+        msg: `No indexing functions were registered for '${blockSource.name}' blocks`
       });
     }
-    return hasNoRegisteredIndexingFunctions === false;
-  });
-  const accountSources = flattenSources(config.accounts ?? {}).flatMap((source) => {
-    const network = networks.find((n) => n.name === source.network);
-    const startBlockMaybeNan = source.startBlock;
-    const fromBlock = Number.isNaN(startBlockMaybeNan) ? void 0 : startBlockMaybeNan;
-    const endBlockMaybeNan = source.endBlock;
-    const toBlock = Number.isNaN(endBlockMaybeNan) ? void 0 : endBlockMaybeNan;
-    const resolvedAddress = source?.address;
-    if (resolvedAddress === void 0) {
-      throw new Error(
-        `Validation failed: Account '${source.name}' must specify an 'address'.`
-      );
-    }
-    if (typeof resolvedAddress === "object" && !Array.isArray(resolvedAddress)) {
-      const logFactory = buildLogFactory({
-        chainId: network.chainId,
-        ...resolvedAddress
-      });
-      return [
-        {
-          type: "account",
-          name: source.name,
-          network,
-          filter: {
-            type: "transaction",
-            chainId: network.chainId,
-            fromAddress: void 0,
-            toAddress: logFactory,
-            includeReverted: false,
-            fromBlock,
-            toBlock,
-            include: defaultTransactionFilterInclude
-          }
-        },
-        {
-          type: "account",
-          name: source.name,
-          network,
-          filter: {
-            type: "transaction",
-            chainId: network.chainId,
-            fromAddress: logFactory,
-            toAddress: void 0,
-            includeReverted: false,
-            fromBlock,
-            toBlock,
-            include: defaultTransactionFilterInclude
-          }
-        },
-        {
-          type: "account",
-          name: source.name,
-          network,
-          filter: {
-            type: "transfer",
-            chainId: network.chainId,
-            fromAddress: void 0,
-            toAddress: logFactory,
-            includeReverted: false,
-            fromBlock,
-            toBlock,
-            include: defaultTransferFilterInclude.concat(
-              source.includeTransactionReceipts ? defaultTransactionReceiptInclude : []
-            )
-          }
-        },
-        {
-          type: "account",
-          name: source.name,
-          network,
-          filter: {
-            type: "transfer",
-            chainId: network.chainId,
-            fromAddress: logFactory,
-            toAddress: void 0,
-            includeReverted: false,
-            fromBlock,
-            toBlock,
-            include: defaultTransferFilterInclude.concat(
-              source.includeTransactionReceipts ? defaultTransactionReceiptInclude : []
-            )
-          }
-        }
-      ];
-    }
-    for (const address of Array.isArray(resolvedAddress) ? resolvedAddress : [resolvedAddress]) {
-      if (!address.startsWith("0x"))
-        throw new Error(
-          `Validation failed: Invalid prefix for address '${address}'. Got '${address.slice(
-            0,
-            2
-          )}', expected '0x'.`
-        );
-      if (address.length !== 42)
-        throw new Error(
-          `Validation failed: Invalid length for address '${address}'. Got ${address.length}, expected 42 characters.`
-        );
-    }
-    const validatedAddress = Array.isArray(resolvedAddress) ? dedupe(resolvedAddress).map((r) => toLowerCase(r)) : resolvedAddress !== void 0 ? toLowerCase(resolvedAddress) : void 0;
-    return [
-      {
-        type: "account",
-        name: source.name,
-        network,
-        filter: {
-          type: "transaction",
-          chainId: network.chainId,
-          fromAddress: void 0,
-          toAddress: validatedAddress,
-          includeReverted: false,
-          fromBlock,
-          toBlock,
-          include: defaultTransactionFilterInclude
-        }
-      },
-      {
-        type: "account",
-        name: source.name,
-        network,
-        filter: {
-          type: "transaction",
-          chainId: network.chainId,
-          fromAddress: validatedAddress,
-          toAddress: void 0,
-          includeReverted: false,
-          fromBlock,
-          toBlock,
-          include: defaultTransactionFilterInclude
-        }
-      },
-      {
-        type: "account",
-        name: source.name,
-        network,
-        filter: {
-          type: "transfer",
-          chainId: network.chainId,
-          fromAddress: void 0,
-          toAddress: validatedAddress,
-          includeReverted: false,
-          fromBlock,
-          toBlock,
-          include: defaultTransferFilterInclude.concat(
-            source.includeTransactionReceipts ? defaultTransactionReceiptInclude : []
-          )
-        }
-      },
-      {
-        type: "account",
-        name: source.name,
-        network,
-        filter: {
-          type: "transfer",
-          chainId: network.chainId,
-          fromAddress: validatedAddress,
-          toAddress: void 0,
-          includeReverted: false,
-          fromBlock,
-          toBlock,
-          include: defaultTransferFilterInclude.concat(
-            source.includeTransactionReceipts ? defaultTransactionReceiptInclude : []
-          )
-        }
-      }
-    ];
-  }).filter((source) => {
-    const eventName = source.filter.type === "transaction" ? source.filter.fromAddress === void 0 ? `${source.name}:transaction:to` : `${source.name}:transaction:from` : source.filter.fromAddress === void 0 ? `${source.name}:transfer:to` : `${source.name}:transfer:from`;
-    const hasRegisteredIndexingFunction = indexingFunctions[eventName] !== void 0;
-    if (!hasRegisteredIndexingFunction) {
-      logs.push({
-        level: "debug",
-        msg: `No indexing functions were registered for '${eventName}'`
-      });
-    }
-    return hasRegisteredIndexingFunction;
-  });
-  const blockSources = flattenSources(config.blocks ?? {}).map((source) => {
-    const network = networks.find((n) => n.name === source.network);
-    const intervalMaybeNan = source.interval ?? 1;
-    const interval = Number.isNaN(intervalMaybeNan) ? 0 : intervalMaybeNan;
-    if (!Number.isInteger(interval) || interval === 0) {
-      throw new Error(
-        `Validation failed: Invalid interval for block source '${source.name}'. Got ${interval}, expected a non-zero integer.`
-      );
-    }
-    const startBlockMaybeNan = source.startBlock;
-    const fromBlock = Number.isNaN(startBlockMaybeNan) ? void 0 : startBlockMaybeNan;
-    const endBlockMaybeNan = source.endBlock;
-    const toBlock = Number.isNaN(endBlockMaybeNan) ? void 0 : endBlockMaybeNan;
-    return {
-      type: "block",
-      name: source.name,
-      network,
-      filter: {
-        type: "block",
-        chainId: network.chainId,
-        interval,
-        offset: (fromBlock ?? 0) % interval,
-        fromBlock,
-        toBlock,
-        include: defaultBlockFilterInclude
-      }
-    };
-  }).filter((blockSource) => {
-    const hasRegisteredIndexingFunction = indexingFunctions[`${blockSource.name}:block`] !== void 0;
-    if (!hasRegisteredIndexingFunction) {
-      logs.push({
-        level: "debug",
-        msg: `No indexing functions were registered for '${blockSource.name}' blocks`
-      });
-    }
-    return hasRegisteredIndexingFunction;
+    return hasRegisteredIndexingFunction;
   });
   const sources = [...contractSources, ...accountSources, ...blockSources];
   const networksWithSources = networks.filter((network) => {
@@ -2530,617 +2484,22 @@ function safeBuildPre({
   }
 }
 
-// src/drizzle/kit/index.ts
-import { SQL, is } from "drizzle-orm";
-import { CasingCache, toCamelCase, toSnakeCase } from "drizzle-orm/casing";
-import {
-  PgDialect,
-  PgEnumColumn,
-  PgMaterializedView,
-  PgSchema,
-  PgTable,
-  PgView,
-  getTableConfig,
-  integer,
-  isPgEnum,
-  isPgSequence,
-  pgTable,
-  serial,
-  varchar
-} from "drizzle-orm/pg-core";
-var sqlToReorgTableName = (tableName) => `_reorg__${tableName}`;
-var getSql = (schema) => {
-  const { tables, enums, schemas } = prepareFromExports(schema);
-  const json = generatePgSnapshot(tables, enums, schemas, "snake_case");
-  const squashed = squashPgScheme(json);
-  const jsonCreateIndexesForCreatedTables = Object.values(
-    squashed.tables
-  ).flatMap((it) => {
-    return preparePgCreateIndexesJson(it.name, it.schema, it.indexes);
-  });
-  const jsonCreateEnums = Object.values(squashed.enums).map((it) => {
-    return prepareCreateEnumJson(it.name, it.schema, it.values);
-  }) ?? [];
-  const jsonCreateTables = Object.values(squashed.tables).map((it) => {
-    return preparePgCreateTableJson(it, json);
-  });
-  const fromJson = (statements) => statements.flatMap((statement) => {
-    const filtered = convertors.filter((it) => {
-      return it.can(statement, "postgresql");
-    });
-    const convertor = filtered.length === 1 ? filtered[0] : void 0;
-    if (!convertor) {
-      return "";
-    }
-    return convertor.convert(statement);
-  }).filter((it) => it !== "");
-  const combinedTables = jsonCreateTables.flatMap((statement) => [
-    statement,
-    createReorgTableStatement(statement)
-  ]);
-  return {
-    tables: {
-      sql: fromJson(combinedTables),
-      json: combinedTables
-    },
-    enums: { sql: fromJson(jsonCreateEnums), json: jsonCreateEnums },
-    indexes: {
-      sql: fromJson(jsonCreateIndexesForCreatedTables),
-      json: jsonCreateIndexesForCreatedTables
-    }
-  };
-};
-var createReorgTableStatement = (statement) => {
-  const reorgStatement = structuredClone(statement);
-  reorgStatement.compositePkName = void 0;
-  reorgStatement.compositePKs = [];
-  for (const column of reorgStatement.columns) {
-    column.primaryKey = false;
-  }
-  const reorgColumns = Object.values(
-    squashPgScheme(
-      generatePgSnapshot(
-        [
-          pgTable("", {
-            operation_id: serial().notNull().primaryKey(),
-            operation: integer().notNull(),
-            checkpoint: varchar({
-              length: 75
-            }).notNull()
-          })
-        ],
-        [],
-        [],
-        "snake_case"
-      )
-    ).tables
-    //@ts-ignore
-  )[0].columns;
-  reorgStatement.columns.push(...Object.values(reorgColumns));
-  reorgStatement.tableName = sqlToReorgTableName(reorgStatement.tableName);
-  return reorgStatement;
-};
-var PgSquasher = {
-  squashIdx: (idx) => {
-    return `${idx.name};${idx.columns.map(
-      (c) => `${c.expression}--${c.isExpression}--${c.asc}--${c.nulls}--${c.opclass && ""}`
-    ).join(
-      ",,"
-    )};${idx.isUnique};${idx.concurrently};${idx.method};${idx.where};${JSON.stringify(idx.with)}`;
-  },
-  unsquashIdx: (input) => {
-    const [
-      name,
-      columnsString,
-      isUnique,
-      concurrently,
-      method,
-      where,
-      idxWith
-    ] = input.split(";");
-    const columnString = columnsString.split(",,");
-    const columns = [];
-    for (const column of columnString) {
-      const [expression, isExpression, asc, nulls, opclass] = column.split("--");
-      columns.push({
-        nulls,
-        isExpression: isExpression === "true",
-        asc: asc === "true",
-        expression,
-        opclass: opclass === "undefined" ? void 0 : opclass
-      });
-    }
-    return {
-      name,
-      columns,
-      isUnique: isUnique === "true",
-      concurrently: concurrently === "true",
-      method,
-      where: where === "undefined" ? void 0 : where,
-      with: !idxWith || idxWith === "undefined" ? void 0 : JSON.parse(idxWith)
-    };
-  },
-  squashPK: (pk) => {
-    return `${pk.columns.join(",")};${pk.name}`;
-  },
-  unsquashPK: (pk) => {
-    const splitted = pk.split(";");
-    return { name: splitted[1], columns: splitted[0].split(",") };
-  }
-};
-var parseType = (schemaPrefix, type) => {
-  const pgNativeTypes = [
-    "uuid",
-    "smallint",
-    "integer",
-    "bigint",
-    "boolean",
-    "text",
-    "varchar",
-    "serial",
-    "bigserial",
-    "decimal",
-    "numeric",
-    "real",
-    "json",
-    "jsonb",
-    "time",
-    "time with time zone",
-    "time without time zone",
-    "time",
-    "timestamp",
-    "timestamp with time zone",
-    "timestamp without time zone",
-    "date",
-    "interval",
-    "bigint",
-    "bigserial",
-    "double precision",
-    "interval year",
-    "interval month",
-    "interval day",
-    "interval hour",
-    "interval minute",
-    "interval second",
-    "interval year to month",
-    "interval day to hour",
-    "interval day to minute",
-    "interval day to second",
-    "interval hour to minute",
-    "interval hour to second",
-    "interval minute to second"
-  ];
-  const arrayDefinitionRegex = /\[\d*(?:\[\d*\])*\]/g;
-  const arrayDefinition = (type.match(arrayDefinitionRegex) ?? []).join("");
-  const withoutArrayDefinition = type.replace(arrayDefinitionRegex, "");
-  return pgNativeTypes.some((it) => type.startsWith(it)) ? `${withoutArrayDefinition}${arrayDefinition}` : `${schemaPrefix}"${withoutArrayDefinition}"${arrayDefinition}`;
-};
-var Convertor = class {
-};
-var PgCreateTableConvertor = class extends Convertor {
-  can(statement, dialect) {
-    return statement.type === "create_table" && dialect === "postgresql";
-  }
-  convert(st) {
-    const { tableName, schema, columns, compositePKs } = st;
-    let statement = "";
-    const name = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
-    statement += `CREATE TABLE ${name} (
-`;
-    for (let i = 0; i < columns.length; i++) {
-      const column = columns[i];
-      const primaryKeyStatement = column.primaryKey ? " PRIMARY KEY" : "";
-      const notNullStatement = column.notNull && !column.identity ? " NOT NULL" : "";
-      const defaultStatement = column.default !== void 0 ? ` DEFAULT ${column.default}` : "";
-      const schemaPrefix = column.typeSchema && column.typeSchema !== "public" ? `"${column.typeSchema}".` : "";
-      const type = parseType(schemaPrefix, column.type);
-      statement += `	"${column.name}" ${type}${primaryKeyStatement}${defaultStatement}${notNullStatement}`;
-      statement += i === columns.length - 1 ? "" : ",\n";
-    }
-    if (typeof compositePKs !== "undefined" && compositePKs.length > 0) {
-      statement += ",\n";
-      const compositePK = PgSquasher.unsquashPK(compositePKs[0]);
-      statement += `	CONSTRAINT "${st.compositePkName}" PRIMARY KEY("${compositePK.columns.join(`","`)}")`;
-    }
-    statement += "\n);";
-    statement += "\n";
-    return statement;
-  }
-};
-var CreateTypeEnumConvertor = class extends Convertor {
-  can(statement) {
-    return statement.type === "create_type_enum";
-  }
-  convert(st) {
-    const { name, values, schema } = st;
-    const enumNameWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
-    let valuesStatement = "(";
-    valuesStatement += values.map((it) => `'${it}'`).join(", ");
-    valuesStatement += ")";
-    const statement = `CREATE TYPE ${enumNameWithSchema} AS ENUM${valuesStatement};`;
-    return statement;
-  }
-};
-var CreatePgIndexConvertor = class extends Convertor {
-  can(statement, dialect) {
-    return statement.type === "create_index_pg" && dialect === "postgresql";
-  }
-  convert(statement) {
-    const {
-      name,
-      columns,
-      isUnique,
-      concurrently,
-      with: withMap,
-      method,
-      where
-    } = statement.data;
-    const indexPart = isUnique ? "UNIQUE INDEX" : "INDEX";
-    const value = columns.map(
-      (it) => `${it.isExpression ? it.expression : `"${it.expression}"`}${it.opclass ? ` ${it.opclass}` : it.asc ? "" : " DESC"}${it.asc && it.nulls && it.nulls === "last" || it.opclass ? "" : ` NULLS ${it.nulls.toUpperCase()}`}`
-    ).join(",");
-    const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
-    function reverseLogic(mappedWith) {
-      let reversedString = "";
-      for (const key in mappedWith) {
-        if (mappedWith.hasOwnProperty(key)) {
-          reversedString += `${key}=${mappedWith[key]},`;
-        }
-      }
-      reversedString = reversedString.slice(0, -1);
-      return reversedString;
-    }
-    return `CREATE ${indexPart}${concurrently ? " CONCURRENTLY" : ""} IF NOT EXISTS "${name}" ON ${tableNameWithSchema} USING ${method} (${value})${Object.keys(withMap).length !== 0 ? ` WITH (${reverseLogic(withMap)})` : ""}${where ? ` WHERE ${where}` : ""};`;
-  }
-};
-var PgCreateSchemaConvertor = class extends Convertor {
-  can(statement, dialect) {
-    return statement.type === "create_schema" && dialect === "postgresql";
-  }
-  convert(statement) {
-    const { name } = statement;
-    return `CREATE SCHEMA IF NOT EXISTS"${name}";
-`;
-  }
-};
-var convertors = [];
-convertors.push(new PgCreateTableConvertor());
-convertors.push(new CreateTypeEnumConvertor());
-convertors.push(new CreatePgIndexConvertor());
-convertors.push(new PgCreateSchemaConvertor());
-var preparePgCreateTableJson = (table, json) => {
-  const { name, schema, columns, compositePrimaryKeys } = table;
-  const tableKey = `${schema || "public"}.${name}`;
-  const compositePkName = Object.values(compositePrimaryKeys).length > 0 ? json.tables[tableKey].compositePrimaryKeys[`${PgSquasher.unsquashPK(Object.values(compositePrimaryKeys)[0]).name}`].name : "";
-  return {
-    type: "create_table",
-    tableName: name,
-    schema,
-    columns: Object.values(columns),
-    compositePKs: Object.values(compositePrimaryKeys),
-    compositePkName
-  };
-};
-var preparePgCreateIndexesJson = (tableName, schema, indexes) => {
-  return Object.values(indexes).map((indexData) => {
-    return {
-      type: "create_index_pg",
-      tableName,
-      data: PgSquasher.unsquashIdx(indexData),
-      schema
-    };
-  });
-};
-var prepareCreateEnumJson = (name, schema, values) => {
-  return {
-    type: "create_type_enum",
-    name,
-    schema,
-    values
-  };
-};
-var prepareFromExports = (exports) => {
-  const tables = [];
-  const enums = [];
-  const schemas = [];
-  const sequences = [];
-  const views = [];
-  const matViews = [];
-  const i0values = Object.values(exports);
-  i0values.forEach((t) => {
-    if (isPgEnum(t)) {
-      enums.push(t);
-      return;
-    }
-    if (is(t, PgTable)) {
-      tables.push(t);
-    }
-    if (is(t, PgSchema)) {
-      schemas.push(t);
-    }
-    if (is(t, PgView)) {
-      views.push(t);
-    }
-    if (is(t, PgMaterializedView)) {
-      matViews.push(t);
-    }
-    if (isPgSequence(t)) {
-      sequences.push(t);
-    }
-  });
-  return { tables, enums, schemas, sequences, views, matViews };
-};
-function getColumnCasing(column, casing) {
-  if (!column.name)
-    return "";
-  return !column.keyAsName || casing === void 0 ? column.name : casing === "camelCase" ? toCamelCase(column.name) : toSnakeCase(column.name);
-}
-var sqlToStr = (sql5, casing) => {
-  return sql5.toQuery({
-    escapeName: () => {
-      throw new Error("we don't support params for `sql` default values");
-    },
-    escapeParam: () => {
-      throw new Error("we don't support params for `sql` default values");
-    },
-    escapeString: () => {
-      throw new Error("we don't support params for `sql` default values");
-    },
-    casing: new CasingCache(casing)
-  }).sql;
-};
-function isPgArrayType(sqlType) {
-  return sqlType.match(/.*\[\d*\].*|.*\[\].*/g) !== null;
-}
-function buildArrayString(array, sqlType) {
-  sqlType = sqlType.split("[")[0];
-  const values = array.map((value) => {
-    if (typeof value === "number" || typeof value === "bigint") {
-      return value.toString();
-    } else if (typeof value === "boolean") {
-      return value ? "true" : "false";
-    } else if (Array.isArray(value)) {
-      return buildArrayString(value, sqlType);
-    } else if (value instanceof Date) {
-      if (sqlType === "date") {
-        return `"${value.toISOString().split("T")[0]}"`;
-      } else if (sqlType === "timestamp") {
-        return `"${value.toISOString().replace("T", " ").slice(0, 23)}"`;
-      } else {
-        return `"${value.toISOString()}"`;
-      }
-    } else if (typeof value === "object") {
-      return `"${JSON.stringify(value).replaceAll('"', '\\"')}"`;
-    }
-    return `"${value}"`;
-  }).join(",");
-  return `{${values}}`;
-}
-var indexName = (tableName, columns) => {
-  return `${tableName}_${columns.join("_")}_index`;
-};
-var generatePgSnapshot = (tables, enums, schemas, casing) => {
-  const dialect = new PgDialect({ casing });
-  const result = {};
-  const indexesInSchema = {};
-  for (const table of tables) {
-    const {
-      name: tableName,
-      columns,
-      indexes,
-      schema,
-      primaryKeys
-    } = getTableConfig(table);
-    const columnsObject = {};
-    const indexesObject = {};
-    const primaryKeysObject = {};
-    columns.forEach((column) => {
-      const name = getColumnCasing(column, casing);
-      const notNull = column.notNull;
-      const primaryKey = column.primary;
-      const sqlTypeLowered = column.getSQLType().toLowerCase();
-      const typeSchema = is(column, PgEnumColumn) ? column.enum.schema || "public" : void 0;
-      const columnToSet = {
-        name,
-        type: column.getSQLType(),
-        typeSchema,
-        primaryKey,
-        notNull
-      };
-      if (column.default !== void 0) {
-        if (is(column.default, SQL)) {
-          columnToSet.default = sqlToStr(column.default, casing);
-        } else {
-          if (typeof column.default === "string") {
-            columnToSet.default = `'${column.default}'`;
-          } else {
-            if (sqlTypeLowered === "jsonb" || sqlTypeLowered === "json") {
-              columnToSet.default = `'${JSON.stringify(column.default)}'::${sqlTypeLowered}`;
-            } else if (column.default instanceof Date) {
-              if (sqlTypeLowered === "date") {
-                columnToSet.default = `'${column.default.toISOString().split("T")[0]}'`;
-              } else if (sqlTypeLowered === "timestamp") {
-                columnToSet.default = `'${column.default.toISOString().replace("T", " ").slice(0, 23)}'`;
-              } else {
-                columnToSet.default = `'${column.default.toISOString()}'`;
-              }
-            } else if (isPgArrayType(sqlTypeLowered) && Array.isArray(column.default)) {
-              columnToSet.default = `'${buildArrayString(column.default, sqlTypeLowered)}'`;
-            } else {
-              columnToSet.default = column.default;
-            }
-          }
-        }
-      }
-      columnsObject[name] = columnToSet;
-    });
-    primaryKeys.map((pk) => {
-      const originalColumnNames = pk.columns.map((c) => c.name);
-      const columnNames = pk.columns.map((c) => getColumnCasing(c, casing));
-      let name = pk.getName();
-      if (casing !== void 0) {
-        for (let i = 0; i < originalColumnNames.length; i++) {
-          name = name.replace(originalColumnNames[i], columnNames[i]);
-        }
-      }
-      primaryKeysObject[name] = {
-        name,
-        columns: columnNames
-      };
-    });
-    indexes.forEach((value) => {
-      const columns2 = value.config.columns;
-      const indexColumnNames = [];
-      columns2.forEach((it) => {
-        const name2 = getColumnCasing(it, casing);
-        indexColumnNames.push(name2);
-      });
-      const name = value.config.name ? value.config.name : indexName(tableName, indexColumnNames);
-      const indexColumns = columns2.map(
-        (it) => {
-          if (is(it, SQL)) {
-            return {
-              expression: dialect.sqlToQuery(it, "indexes").sql,
-              asc: true,
-              isExpression: true,
-              nulls: "last"
-            };
-          } else {
-            it = it;
-            return {
-              expression: getColumnCasing(it, casing),
-              isExpression: false,
-              // @ts-ignore
-              asc: it.indexConfig?.order === "asc",
-              // @ts-ignore
-              nulls: it.indexConfig?.nulls ? (
-                // @ts-ignore
-                it.indexConfig?.nulls
-              ) : (
-                // @ts-ignore
-                it.indexConfig?.order === "desc" ? "first" : "last"
-              ),
-              // @ts-ignore
-              opclass: it.indexConfig?.opClass
-            };
-          }
-        }
-      );
-      if (typeof indexesInSchema[schema ?? "public"] !== "undefined") {
-        indexesInSchema[schema ?? "public"].push(name);
-      } else {
-        indexesInSchema[schema ?? "public"] = [name];
-      }
-      indexesObject[name] = {
-        name,
-        columns: indexColumns,
-        isUnique: value.config.unique ?? false,
-        where: value.config.where ? dialect.sqlToQuery(value.config.where).sql : void 0,
-        concurrently: value.config.concurrently ?? false,
-        method: value.config.method ?? "btree",
-        with: value.config.with ?? {}
-      };
-    });
-    const tableKey = `${schema ?? "public"}.${tableName}`;
-    result[tableKey] = {
-      name: tableName,
-      schema: schema ?? "",
-      columns: columnsObject,
-      indexes: indexesObject,
-      compositePrimaryKeys: primaryKeysObject
-    };
-  }
-  const enumsToReturn = enums.reduce((map, obj) => {
-    const enumSchema = obj.schema || "public";
-    const key = `${enumSchema}.${obj.enumName}`;
-    map[key] = {
-      name: obj.enumName,
-      schema: enumSchema,
-      values: obj.enumValues
-    };
-    return map;
-  }, {});
-  const schemasObject = Object.fromEntries(
-    schemas.filter((it) => {
-      return it.schemaName !== "public";
-    }).map((it) => [it.schemaName, it.schemaName])
-  );
-  return {
-    version: "7",
-    dialect: "postgresql",
-    tables: result,
-    enums: enumsToReturn,
-    schemas: schemasObject
-  };
-};
-var mapValues = (obj, map) => {
-  const result = Object.keys(obj).reduce(
-    (result2, key) => {
-      result2[key] = map(obj[key]);
-      return result2;
-    },
-    {}
-  );
-  return result;
-};
-var squashPgScheme = (json) => {
-  const mappedTables = Object.fromEntries(
-    Object.entries(json.tables).map((it) => {
-      const squashedIndexes = mapValues(it[1].indexes, (index) => {
-        return PgSquasher.squashIdx(index);
-      });
-      const squashedPKs = mapValues(it[1].compositePrimaryKeys, (pk) => {
-        return PgSquasher.squashPK(pk);
-      });
-      const mappedColumns = Object.fromEntries(
-        Object.entries(it[1].columns).map((it2) => {
-          return [
-            it2[0],
-            {
-              ...it2[1],
-              identity: void 0
-            }
-          ];
-        })
-      );
-      return [
-        it[0],
-        {
-          name: it[1].name,
-          schema: it[1].schema,
-          columns: mappedColumns,
-          indexes: squashedIndexes,
-          compositePrimaryKeys: squashedPKs
-        }
-      ];
-    })
-  );
-  return {
-    version: "7",
-    dialect: json.dialect,
-    tables: mappedTables,
-    enums: json.enums,
-    schemas: json.schemas,
-    views: json.views
-  };
-};
-
 // src/build/schema.ts
-import { SQL as SQL2, getTableColumns, is as is2 } from "drizzle-orm";
+import { SQL, getTableColumns, is } from "drizzle-orm";
 import {
   PgBigSerial53,
   PgBigSerial64,
   PgSequence,
   PgSerial,
   PgSmallSerial,
-  PgTable as PgTable2,
-  PgView as PgView2,
-  getTableConfig as getTableConfig2
+  PgTable,
+  PgView,
+  getTableConfig
 } from "drizzle-orm/pg-core";
 var buildSchema = ({ schema }) => {
   const statements = getSql(schema);
   for (const [name, s] of Object.entries(schema)) {
-    if (is2(s, PgTable2)) {
+    if (is(s, PgTable)) {
       let hasPrimaryKey = false;
       for (const [columnName, column] of Object.entries(getTableColumns(s))) {
         if (column.primary) {
@@ -3173,60 +2532,60 @@ var buildSchema = ({ schema }) => {
           );
         }
         if (column.hasDefault) {
-          if (column.default && column.default instanceof SQL2) {
+          if (column.default && column.default instanceof SQL) {
             throw new Error(
               `Schema validation failed: '${name}.${columnName}' is a default column and default columns with raw sql are unsupported.`
             );
           }
-          if (column.defaultFn && column.defaultFn() instanceof SQL2) {
+          if (column.defaultFn && column.defaultFn() instanceof SQL) {
             throw new Error(
               `Schema validation failed: '${name}.${columnName}' is a default column and default columns with raw sql are unsupported.`
             );
           }
-          if (column.onUpdateFn && column.onUpdateFn() instanceof SQL2) {
+          if (column.onUpdateFn && column.onUpdateFn() instanceof SQL) {
             throw new Error(
               `Schema validation failed: '${name}.${columnName}' is a default column and default columns with raw sql are unsupported.`
             );
           }
         }
       }
-      if (getTableConfig2(s).primaryKeys.length > 1) {
+      if (getTableConfig(s).primaryKeys.length > 1) {
         throw new Error(
           `Schema validation failed: '${name}' has multiple primary keys.`
         );
       }
-      if (getTableConfig2(s).primaryKeys.length === 1 && hasPrimaryKey) {
+      if (getTableConfig(s).primaryKeys.length === 1 && hasPrimaryKey) {
         throw new Error(
           `Schema validation failed: '${name}' has multiple primary keys.`
         );
       }
-      if (getTableConfig2(s).primaryKeys.length === 0 && hasPrimaryKey === false) {
+      if (getTableConfig(s).primaryKeys.length === 0 && hasPrimaryKey === false) {
         throw new Error(
           `Schema validation failed: '${name}' has no primary key. Declare one with ".primaryKey()".`
         );
       }
-      if (getTableConfig2(s).foreignKeys.length > 0) {
+      if (getTableConfig(s).foreignKeys.length > 0) {
         throw new Error(
           `Schema validation failed: '${name}' has a foreign key constraint and foreign key constraints are unsupported.`
         );
       }
-      if (getTableConfig2(s).checks.length > 0) {
+      if (getTableConfig(s).checks.length > 0) {
         throw new Error(
           `Schema validation failed: '${name}' has a check constraint and check constraints are unsupported.`
         );
       }
-      if (getTableConfig2(s).uniqueConstraints.length > 0) {
+      if (getTableConfig(s).uniqueConstraints.length > 0) {
         throw new Error(
           `Schema validation failed: '${name}' has a unique constraint and unique constraints are unsupported.`
         );
       }
     }
-    if (is2(s, PgSequence)) {
+    if (is(s, PgSequence)) {
       throw new Error(
         `Schema validation failed: '${name}' is a sequence and sequences are unsupported.`
       );
     }
-    if (is2(s, PgView2)) {
+    if (is(s, PgView)) {
       throw new Error(
         `Schema validation failed: '${name}' is a view and views are unsupported.`
       );
@@ -3495,6 +2854,7 @@ var createBuild = async ({
     async executeApi({ indexingBuild, database }) {
       globalThis.PONDER_INDEXING_BUILD = indexingBuild;
       globalThis.PONDER_DATABASE = database;
+      globalThis.COMMON = common;
       if (!fs.existsSync(common.options.apiFile)) {
         const error = new BuildError(
           `API function file not found. Create a file at ${common.options.apiFile}. Read more: https://ponder-docs-git-v09-ponder-sh.vercel.app/docs/query/api-functions`
@@ -3737,49 +3097,6 @@ var createBuild = async ({
 // src/database/index.ts
 import { randomUUID } from "node:crypto";
 
-// src/drizzle/index.ts
-import { getTableColumns as getTableColumns2, getTableName, is as is3 } from "drizzle-orm";
-import { PgTable as PgTable3, getTableConfig as getTableConfig3 } from "drizzle-orm/pg-core";
-var getTableNames = (schema) => {
-  const tableNames = Object.entries(schema).filter(([, table]) => is3(table, PgTable3)).map(([js, table]) => {
-    const sql5 = getTableName(table);
-    return {
-      sql: sql5,
-      reorg: sqlToReorgTableName(sql5),
-      trigger: sqlToReorgTableName(sql5),
-      triggerFn: `operation_reorg__${sql5}()`,
-      js
-    };
-  });
-  return tableNames;
-};
-var getPrimaryKeyColumns = (table) => {
-  const primaryKeys = getTableConfig3(table).primaryKeys;
-  const findJsName = (column) => {
-    const name = column.name;
-    for (const [js, column2] of Object.entries(getTableColumns2(table))) {
-      if (column2.name === name)
-        return js;
-    }
-    throw "unreachable";
-  };
-  if (primaryKeys.length > 0) {
-    return primaryKeys[0].columns.map((column) => ({
-      sql: getColumnCasing(column, "snake_case"),
-      js: findJsName(column)
-    }));
-  }
-  const pkColumn = Object.values(getTableColumns2(table)).find(
-    (c) => c.primary
-  );
-  return [
-    {
-      sql: getColumnCasing(pkColumn, "snake_case"),
-      js: findJsName(pkColumn)
-    }
-  ];
-};
-
 // src/sync-store/migrations.ts
 import { sql } from "kysely";
 var migrations = {
@@ -4490,27 +3807,6 @@ var formatPercentage = (cacheRate) => {
 
 // src/utils/pg.ts
 import pg from "pg";
-
-// src/utils/print.ts
-function prettyPrint(args) {
-  if (args === void 0)
-    return "(undefined)";
-  const entries = Object.entries(args).map(([key, value]) => {
-    if (value === void 0)
-      return null;
-    const trimmedValue = typeof value === "string" && value.length > 80 ? value.slice(0, 80).concat("...") : value;
-    return [key, trimmedValue];
-  }).filter(Boolean);
-  if (entries.length === 0)
-    return "  (empty object)";
-  const maxLength = entries.reduce(
-    (acc, [key]) => Math.max(acc, key.length),
-    0
-  );
-  return entries.map(([key, value]) => `  ${`${key}`.padEnd(maxLength + 1)}  ${value}`).join("\n");
-}
-
-// src/utils/pg.ts
 var bigIntArrayParser = pg.types.getTypeParser(1016);
 pg.types.setTypeParser(1231, bigIntArrayParser);
 var originalClientQuery = pg.Client.prototype.query;
@@ -4706,7 +4002,7 @@ async function wait(milliseconds) {
 }
 
 // src/database/index.ts
-import { getTableColumns as getTableColumns3 } from "drizzle-orm";
+import { getTableColumns as getTableColumns2 } from "drizzle-orm";
 import { drizzle as drizzleNodePg } from "drizzle-orm/node-postgres";
 import { drizzle as drizzlePglite } from "drizzle-orm/pglite";
 import {
@@ -4942,8 +4238,8 @@ var createDatabase = async ({
     for (const log of reversed) {
       if (log.operation === 0) {
         await tx.deleteFrom(tableName.sql).$call((qb2) => {
-          for (const { sql: sql5 } of primaryKeyColumns) {
-            qb2 = qb2.where(sql5, "=", log[sql5]);
+          for (const { sql: sql4 } of primaryKeyColumns) {
+            qb2 = qb2.where(sql4, "=", log[sql4]);
           }
           return qb2;
         }).execute();
@@ -4952,8 +4248,8 @@ var createDatabase = async ({
         log.checkpoint = void 0;
         log.operation = void 0;
         await tx.updateTable(tableName.sql).set(log).$call((qb2) => {
-          for (const { sql: sql5 } of primaryKeyColumns) {
-            qb2 = qb2.where(sql5, "=", log[sql5]);
+          for (const { sql: sql4 } of primaryKeyColumns) {
+            qb2 = qb2.where(sql4, "=", log[sql4]);
           }
           return qb2;
         }).execute();
@@ -4962,7 +4258,7 @@ var createDatabase = async ({
         log.checkpoint = void 0;
         log.operation = void 0;
         await tx.insertInto(tableName.sql).values(log).onConflict(
-          (oc) => oc.columns(primaryKeyColumns.map(({ sql: sql5 }) => sql5)).doNothing()
+          (oc) => oc.columns(primaryKeyColumns.map(({ sql: sql4 }) => sql4)).doNothing()
         ).execute();
       }
     }
@@ -5217,7 +4513,7 @@ var createDatabase = async ({
           if (createdTables) {
             common.logger.info({
               service: "database",
-              msg: `Created tables [${getTableNames(schemaBuild.schema).map(({ sql: sql5 }) => sql5).join(", ")}]`
+              msg: `Created tables [${getTableNames(schemaBuild.schema).map(({ sql: sql4 }) => sql4).join(", ")}]`
             });
             const newApp = {
               is_locked: 1,
@@ -5226,7 +4522,7 @@ var createDatabase = async ({
               build_id: buildId,
               checkpoint: ZERO_CHECKPOINT_STRING,
               table_names: getTableNames(schemaBuild.schema).map(
-                ({ sql: sql5 }) => sql5
+                ({ sql: sql4 }) => sql4
               ),
               version: VERSION
             };
@@ -5347,7 +4643,7 @@ var createDatabase = async ({
         { method: "createTriggers", includeTraceLogs: true },
         async () => {
           for (const tableName of getTableNames(schemaBuild.schema)) {
-            const columns = getTableColumns3(
+            const columns = getTableColumns2(
               schemaBuild.schema[tableName.js]
             );
             const columnNames = Object.values(columns).map(
@@ -5647,921 +4943,6 @@ var mergeResults = (results) => {
   return { status: "success", result: results.map((result) => result.result) };
 };
 
-// src/indexing-store/historical.ts
-import {
-  and,
-  eq,
-  getTableColumns as getTableColumns4,
-  getTableName as getTableName2,
-  sql as sql3
-} from "drizzle-orm";
-import { getTableConfig as getTableConfig4 } from "drizzle-orm/pg-core";
-import { drizzle } from "drizzle-orm/pg-proxy";
-
-// src/indexing-store/index.ts
-var parseSqlError = (e) => {
-  let error = getBaseError(e);
-  if (error?.message?.includes("violates not-null constraint")) {
-    error = new NotNullConstraintError(error.message);
-  } else if (error?.message?.includes("violates unique constraint")) {
-    error = new UniqueConstraintError(error.message);
-  } else if (error?.message.includes("violates check constraint")) {
-    error = new CheckConstraintError(error.message);
-  } else if (error?.message?.includes("Do not know how to serialize a BigInt")) {
-    error = new BigIntSerializationError(error.message);
-    error.meta.push(
-      "Hint:\n  The JSON column type does not support BigInt values. Use the replaceBigInts() helper function before inserting into the database. Docs: https://ponder.sh/docs/utilities/replace-bigints"
-    );
-  }
-  return error;
-};
-
-// src/indexing-store/historical.ts
-var checkOnchainTable = (table, method) => {
-  if (table === void 0)
-    throw new UndefinedTableError(
-      `Table object passed to db.${method}() is undefined`
-    );
-  if (onchain in table)
-    return;
-  throw new InvalidStoreMethodError(
-    method === "find" ? `db.find() can only be used with onchain tables, and '${getTableConfig4(table).name}' is an offchain table.` : `Indexing functions can only write to onchain tables, and '${getTableConfig4(table).name}' is an offchain table.`
-  );
-};
-var hasEmptyValue = (column) => {
-  return column.hasDefault;
-};
-var getEmptyValue = (column, type) => {
-  if (type === 1 /* UPDATE */ && column.onUpdateFn) {
-    return column.onUpdateFn();
-  }
-  if (column.default !== void 0)
-    return column.default;
-  if (column.defaultFn !== void 0)
-    return column.defaultFn();
-  if (column.onUpdateFn !== void 0)
-    return column.onUpdateFn();
-  return void 0;
-};
-var normalizeColumn = (column, value, type) => {
-  if (value === void 0) {
-    if (hasEmptyValue(column))
-      return getEmptyValue(column, type);
-    return null;
-  }
-  if (column.mapToDriverValue === void 0)
-    return value;
-  try {
-    return column.mapFromDriverValue(column.mapToDriverValue(value));
-  } catch (e) {
-    if (e?.message?.includes("Do not know how to serialize a BigInt")) {
-      const error = new BigIntSerializationError(e.message);
-      error.meta.push(
-        "Hint:\n  The JSON column type does not support BigInt values. Use the replaceBigInts() helper function before inserting into the database. Docs: https://ponder.sh/docs/utilities/replace-bigints"
-      );
-      throw error;
-    }
-  }
-};
-var createHistoricalIndexingStore = ({
-  common,
-  schemaBuild: { schema },
-  database,
-  isDatabaseEmpty
-}) => {
-  const queue = createQueue({
-    browser: false,
-    initialStart: true,
-    concurrency: 1,
-    worker: (fn) => {
-      return fn();
-    }
-  });
-  const primaryKeysCache = /* @__PURE__ */ new Map();
-  const cache = /* @__PURE__ */ new Map();
-  for (const tableName of getTableNames(schema)) {
-    primaryKeysCache.set(
-      schema[tableName.js],
-      getPrimaryKeyColumns(schema[tableName.js])
-    );
-    cache.set(schema[tableName.js], /* @__PURE__ */ new Map());
-  }
-  const getCacheKey = (table, row) => {
-    const primaryKeys = primaryKeysCache.get(table);
-    return primaryKeys.map((pk) => normalizeColumn(table[pk.js], row[pk.js])).join("_");
-  };
-  const getCacheEntry = (table, row) => {
-    return cache.get(table).get(getCacheKey(table, row));
-  };
-  const setCacheEntry = (table, userRow, entryType, existingRow) => {
-    let row = structuredClone(userRow);
-    if (existingRow) {
-      for (const [key, value] of Object.entries(row)) {
-        existingRow[key] = value;
-      }
-      existingRow = normalizeRow(table, existingRow, entryType);
-      const bytes = getBytes(existingRow);
-      cacheBytes += bytes;
-      cache.get(table).set(getCacheKey(table, existingRow), {
-        type: entryType,
-        row: existingRow,
-        operationIndex: totalCacheOps++,
-        bytes
-      });
-      return structuredClone(existingRow);
-    } else {
-      row = normalizeRow(table, row, entryType);
-      const bytes = getBytes(row);
-      cacheBytes += bytes;
-      cache.get(table).set(getCacheKey(table, row), {
-        type: entryType,
-        bytes,
-        operationIndex: totalCacheOps++,
-        row
-      });
-      return structuredClone(row);
-    }
-  };
-  const deleteCacheEntry = (table, row) => {
-    const entry = getCacheEntry(table, row);
-    if (entry) {
-      cacheBytes -= entry.bytes;
-    }
-    return cache.get(table).delete(getCacheKey(table, row));
-  };
-  const normalizeRow = (table, row, type) => {
-    for (const [columnName, column] of Object.entries(getTableColumns4(table))) {
-      if (type === 0 /* INSERT */ && (row[columnName] === void 0 || row[columnName] === null) && column.notNull && hasEmptyValue(column) === false) {
-        const error = new NotNullConstraintError(
-          `Column '${getTableName2(table)}.${columnName}' violates not-null constraint.`
-        );
-        error.meta.push(
-          `db.${type === 0 /* INSERT */ ? "insert" : "update"} arguments:
-${prettyPrint(row)}`
-        );
-        throw error;
-      }
-      row[columnName] = normalizeColumn(column, row[columnName], type);
-    }
-    return row;
-  };
-  const getBytes = (value) => {
-    let size = 13;
-    if (typeof value === "number") {
-      size += 8;
-    } else if (typeof value === "string") {
-      size += 2 * value.length;
-    } else if (typeof value === "boolean") {
-      size += 4;
-    } else if (typeof value === "bigint") {
-      size += 48;
-    } else if (value === null || value === void 0) {
-      size += 8;
-    } else if (Array.isArray(value)) {
-      for (const e of value) {
-        size += getBytes(e);
-      }
-    } else {
-      for (const col of Object.values(value)) {
-        size += getBytes(col);
-      }
-    }
-    return size;
-  };
-  let cacheBytes = 0;
-  let totalCacheOps = 0;
-  const maxBytes = common.options.indexingCacheMaxBytes;
-  common.logger.debug({
-    service: "indexing",
-    msg: `Using a ${Math.round(maxBytes / (1024 * 1024))} MB indexing cache`
-  });
-  const getWhereCondition = (table, key) => {
-    primaryKeysCache.get(table);
-    const conditions = [];
-    for (const { js } of primaryKeysCache.get(table)) {
-      conditions.push(eq(table[js], key[js]));
-    }
-    return and(...conditions);
-  };
-  const find = (table, key) => {
-    return database.qb.drizzle.select().from(table).where(getWhereCondition(table, key)).then((res) => res.length === 0 ? null : res[0]);
-  };
-  const indexingStore = {
-    // @ts-ignore
-    find: (table, key) => queue.add(
-      () => database.wrap(
-        { method: `${getTableName2(table) ?? "unknown"}.find()` },
-        async () => {
-          checkOnchainTable(table, "find");
-          const entry = getCacheEntry(table, key);
-          if (entry) {
-            getCacheEntry(table, key).operationIndex = totalCacheOps++;
-            return entry.row;
-          } else {
-            if (isDatabaseEmpty)
-              return null;
-            const row = await find(table, key);
-            const bytes = getBytes(row);
-            cacheBytes += bytes;
-            cache.get(table).set(getCacheKey(table, key), {
-              type: 2 /* FIND */,
-              bytes,
-              operationIndex: totalCacheOps++,
-              row
-            });
-            return find(table, key);
-          }
-        }
-      )
-    ),
-    // @ts-ignore
-    insert(table) {
-      return {
-        values: (values) => {
-          const inner = {
-            onConflictDoNothing: () => queue.add(
-              () => database.wrap(
-                {
-                  method: `${getTableName2(table) ?? "unknown"}.insert()`
-                },
-                async () => {
-                  checkOnchainTable(table, "insert");
-                  if (Array.isArray(values)) {
-                    const rows = [];
-                    for (const value of values) {
-                      const entry = getCacheEntry(table, value);
-                      let row;
-                      if (entry?.row) {
-                        row = entry.row;
-                      } else {
-                        if (isDatabaseEmpty)
-                          row = null;
-                        else
-                          row = await find(table, value);
-                      }
-                      if (row === null) {
-                        rows.push(
-                          setCacheEntry(table, value, 0 /* INSERT */)
-                        );
-                      } else {
-                        rows.push(null);
-                      }
-                    }
-                    return rows;
-                  } else {
-                    const entry = getCacheEntry(table, values);
-                    let row;
-                    if (entry?.row) {
-                      row = entry.row;
-                    } else {
-                      if (isDatabaseEmpty)
-                        row = null;
-                      else
-                        row = await find(table, values);
-                    }
-                    if (row === null) {
-                      return setCacheEntry(table, values, 0 /* INSERT */);
-                    }
-                    return null;
-                  }
-                }
-              )
-            ),
-            onConflictDoUpdate: (valuesU) => queue.add(
-              () => database.wrap(
-                {
-                  method: `${getTableName2(table) ?? "unknown"}.insert()`
-                },
-                async () => {
-                  checkOnchainTable(table, "insert");
-                  if (Array.isArray(values)) {
-                    const rows = [];
-                    for (const value of values) {
-                      const entry = getCacheEntry(table, value);
-                      deleteCacheEntry(table, value);
-                      let row;
-                      if (entry?.row) {
-                        row = entry.row;
-                      } else {
-                        if (isDatabaseEmpty)
-                          row = null;
-                        else
-                          row = await find(table, value);
-                      }
-                      if (row === null) {
-                        rows.push(
-                          setCacheEntry(table, value, 0 /* INSERT */)
-                        );
-                      } else {
-                        if (typeof valuesU === "function") {
-                          rows.push(
-                            setCacheEntry(
-                              table,
-                              valuesU(row),
-                              entry?.type === 0 /* INSERT */ ? 0 /* INSERT */ : 1 /* UPDATE */,
-                              row
-                            )
-                          );
-                        } else {
-                          rows.push(
-                            setCacheEntry(
-                              table,
-                              valuesU,
-                              entry?.type === 0 /* INSERT */ ? 0 /* INSERT */ : 1 /* UPDATE */,
-                              row
-                            )
-                          );
-                        }
-                      }
-                    }
-                    return rows;
-                  } else {
-                    const entry = getCacheEntry(table, values);
-                    deleteCacheEntry(table, values);
-                    let row;
-                    if (entry?.row) {
-                      row = entry.row;
-                    } else {
-                      if (isDatabaseEmpty)
-                        row = null;
-                      else
-                        row = await find(table, values);
-                    }
-                    if (row === null) {
-                      return setCacheEntry(table, values, 0 /* INSERT */);
-                    } else {
-                      if (typeof valuesU === "function") {
-                        return setCacheEntry(
-                          table,
-                          valuesU(row),
-                          entry?.type === 0 /* INSERT */ ? 0 /* INSERT */ : 1 /* UPDATE */,
-                          row
-                        );
-                      } else {
-                        return setCacheEntry(
-                          table,
-                          valuesU,
-                          entry?.type === 0 /* INSERT */ ? 0 /* INSERT */ : 1 /* UPDATE */,
-                          row
-                        );
-                      }
-                    }
-                  }
-                }
-              )
-            ),
-            // biome-ignore lint/suspicious/noThenProperty: <explanation>
-            then: (onFulfilled, onRejected) => queue.add(
-              () => database.wrap(
-                {
-                  method: `${getTableName2(table) ?? "unknown"}.insert()`
-                },
-                async () => {
-                  checkOnchainTable(table, "insert");
-                  if (Array.isArray(values)) {
-                    const rows = [];
-                    for (const value of values) {
-                      if (getCacheEntry(table, value)?.row) {
-                        const error = new UniqueConstraintError(
-                          `Unique constraint failed for '${getTableName2(table)}'.`
-                        );
-                        error.meta.push(
-                          `db.insert arguments:
-${prettyPrint(value)}`
-                        );
-                        throw error;
-                      } else if (isDatabaseEmpty === false) {
-                        const findResult = await find(table, value);
-                        if (findResult) {
-                          const error = new UniqueConstraintError(
-                            `Unique constraint failed for '${getTableName2(table)}'.`
-                          );
-                          error.meta.push(
-                            `db.insert arguments:
-${prettyPrint(value)}`
-                          );
-                          throw error;
-                        }
-                      }
-                      rows.push(
-                        setCacheEntry(table, value, 0 /* INSERT */)
-                      );
-                    }
-                    return rows;
-                  } else {
-                    if (getCacheEntry(table, values)?.row) {
-                      const error = new UniqueConstraintError(
-                        `Unique constraint failed for '${getTableName2(table)}'.`
-                      );
-                      error.meta.push(
-                        `db.insert arguments:
-${prettyPrint(values)}`
-                      );
-                      throw error;
-                    } else if (isDatabaseEmpty === false) {
-                      const findResult = await find(table, values);
-                      if (findResult) {
-                        const error = new UniqueConstraintError(
-                          `Unique constraint failed for '${getTableName2(table)}'.`
-                        );
-                        error.meta.push(
-                          `db.insert arguments:
-${prettyPrint(values)}`
-                        );
-                        throw error;
-                      }
-                    }
-                    return setCacheEntry(table, values, 0 /* INSERT */);
-                  }
-                }
-              )
-            ).then(onFulfilled, onRejected),
-            catch: (onRejected) => inner.then(void 0, onRejected),
-            finally: (onFinally) => inner.then(
-              (value) => {
-                onFinally?.();
-                return value;
-              },
-              (reason) => {
-                onFinally?.();
-                throw reason;
-              }
-            )
-            // @ts-ignore
-          };
-          return inner;
-        }
-      };
-    },
-    // @ts-ignore
-    update(table, key) {
-      return {
-        set: (values) => queue.add(
-          () => database.wrap(
-            { method: `${getTableName2(table) ?? "unknown"}.update()` },
-            async () => {
-              checkOnchainTable(table, "update");
-              const entry = getCacheEntry(table, key);
-              deleteCacheEntry(table, key);
-              let row;
-              if (entry?.row) {
-                row = entry.row;
-              } else {
-                if (isDatabaseEmpty) {
-                  const error = new RecordNotFoundError(
-                    `No existing record found in table '${getTableName2(table)}'`
-                  );
-                  error.meta.push(
-                    `db.update arguments:
-${prettyPrint(key)}`
-                  );
-                  throw error;
-                }
-                const findResult = await find(table, key);
-                if (findResult) {
-                  row = findResult;
-                } else {
-                  const error = new RecordNotFoundError(
-                    `No existing record found in table '${getTableName2(table)}'`
-                  );
-                  error.meta.push(
-                    `db.update arguments:
-${prettyPrint(key)}`
-                  );
-                  throw error;
-                }
-              }
-              if (typeof values === "function") {
-                return setCacheEntry(
-                  table,
-                  values(row),
-                  entry?.type === 0 /* INSERT */ ? 0 /* INSERT */ : 1 /* UPDATE */,
-                  row
-                );
-              } else {
-                return setCacheEntry(
-                  table,
-                  values,
-                  entry?.type === 0 /* INSERT */ ? 0 /* INSERT */ : 1 /* UPDATE */,
-                  row
-                );
-              }
-            }
-          )
-        )
-      };
-    },
-    // @ts-ignore
-    delete: (table, key) => queue.add(
-      () => database.wrap(
-        { method: `${getTableName2(table) ?? "unknown"}.delete()` },
-        async () => {
-          checkOnchainTable(table, "delete");
-          const entry = getCacheEntry(table, key);
-          deleteCacheEntry(table, key);
-          if (entry?.row) {
-            if (entry.type === 0 /* INSERT */) {
-              return true;
-            }
-            await database.qb.drizzle.delete(table).where(getWhereCondition(table, key));
-            return true;
-          } else {
-            if (isDatabaseEmpty) {
-              return false;
-            }
-            const deleteResult = await database.qb.drizzle.delete(table).where(getWhereCondition(table, key)).returning();
-            return deleteResult.length > 0;
-          }
-        }
-      )
-    ),
-    // @ts-ignore
-    sql: drizzle(
-      async (_sql, params, method, typings) => {
-        await database.createTriggers();
-        await indexingStore.flush();
-        await database.removeTriggers();
-        isDatabaseEmpty = false;
-        const query2 = { sql: _sql, params, typings };
-        const res = await database.wrap({ method: "sql" }, async () => {
-          try {
-            return await database.qb.drizzle._.session.prepareQuery(query2, void 0, void 0, method === "all").execute();
-          } catch (e) {
-            throw parseSqlError(e);
-          }
-        });
-        return { rows: res.rows.map((row) => Object.values(row)) };
-      },
-      { schema, casing: "snake_case" }
-    ),
-    async flush() {
-      await queue.add(async () => {
-        let cacheSize = 0;
-        for (const c of cache.values())
-          cacheSize += c.size;
-        const flushIndex = totalCacheOps - cacheSize * (1 - common.options.indexingCacheFlushRatio);
-        const shouldDelete = cacheBytes > maxBytes;
-        if (shouldDelete)
-          isDatabaseEmpty = false;
-        const promises = [];
-        for (const [table, tableCache] of cache) {
-          const batchSize = Math.round(
-            common.options.databaseMaxQueryParameters / Object.keys(getTableColumns4(table)).length
-          );
-          const insertValues = [];
-          const updateValues = [];
-          for (const [key, entry] of tableCache) {
-            if (entry.type === 0 /* INSERT */) {
-              insertValues.push(entry.row);
-            }
-            if (entry.type === 1 /* UPDATE */) {
-              updateValues.push(entry.row);
-            }
-            if (shouldDelete && entry.operationIndex < flushIndex) {
-              tableCache.delete(key);
-              cacheBytes -= entry.bytes;
-            }
-            entry.type = 2 /* FIND */;
-          }
-          if (insertValues.length > 0) {
-            common.logger.debug({
-              service: "indexing",
-              msg: `Inserting ${insertValues.length} cached '${getTableName2(table)}' rows into the database`
-            });
-            while (insertValues.length > 0) {
-              const values = insertValues.splice(0, batchSize);
-              promises.push(
-                database.wrap(
-                  { method: `${getTableName2(table)}.flush()` },
-                  async () => {
-                    await database.qb.drizzle.insert(table).values(values).catch((_error) => {
-                      const error = _error;
-                      common.logger.error({
-                        service: "indexing",
-                        msg: "Internal error occurred while flushing cache. Please report this error here: https://github.com/ponder-sh/ponder/issues"
-                      });
-                      throw new FlushError(error.message);
-                    });
-                  }
-                )
-              );
-            }
-          }
-          if (updateValues.length > 0) {
-            common.logger.debug({
-              service: "indexing",
-              msg: `Updating ${updateValues.length} cached '${getTableName2(table)}' rows in the database`
-            });
-            const primaryKeys = primaryKeysCache.get(table);
-            const set = {};
-            for (const [columnName, column] of Object.entries(
-              getTableColumns4(table)
-            )) {
-              set[columnName] = sql3.raw(
-                `excluded."${getColumnCasing(column, "snake_case")}"`
-              );
-            }
-            while (updateValues.length > 0) {
-              const values = updateValues.splice(0, batchSize);
-              promises.push(
-                database.wrap(
-                  {
-                    method: `${getTableName2(table)}.flush()`
-                  },
-                  async () => {
-                    await database.qb.drizzle.insert(table).values(values).onConflictDoUpdate({
-                      // @ts-ignore
-                      target: primaryKeys.map(({ js }) => table[js]),
-                      set
-                    }).catch((_error) => {
-                      const error = _error;
-                      common.logger.error({
-                        service: "indexing",
-                        msg: "Internal error occurred while flushing cache. Please report this error here: https://github.com/ponder-sh/ponder/issues"
-                      });
-                      throw new FlushError(error.message);
-                    });
-                  }
-                )
-              );
-            }
-          }
-        }
-        await Promise.all(promises);
-      });
-    },
-    isCacheFull() {
-      return cacheBytes > maxBytes;
-    }
-  };
-  return indexingStore;
-};
-
-// src/indexing-store/realtime.ts
-import {
-  and as and2,
-  eq as eq2,
-  getTableName as getTableName3
-} from "drizzle-orm";
-import { getTableConfig as getTableConfig5 } from "drizzle-orm/pg-core";
-import { drizzle as drizzle2 } from "drizzle-orm/pg-proxy";
-var checkOnchainTable2 = (table, method) => {
-  if (table === void 0)
-    throw new UndefinedTableError(
-      `Table object passed to db.${method}() is undefined`
-    );
-  if (onchain in table)
-    return;
-  throw new InvalidStoreMethodError(
-    method === "find" ? `db.find() can only be used with onchain tables, and '${getTableConfig5(table).name}' is an offchain table.` : `Indexing functions can only write to onchain tables, and '${getTableConfig5(table).name}' is an offchain table.`
-  );
-};
-var createRealtimeIndexingStore = ({
-  schemaBuild: { schema },
-  database
-}) => {
-  const queue = createQueue({
-    browser: false,
-    initialStart: true,
-    concurrency: 1,
-    worker: (fn) => {
-      return fn();
-    }
-  });
-  const primaryKeysCache = /* @__PURE__ */ new Map();
-  for (const tableName of getTableNames(schema)) {
-    primaryKeysCache.set(
-      schema[tableName.js],
-      getPrimaryKeyColumns(schema[tableName.js])
-    );
-  }
-  const getCacheKey = (table, row) => {
-    const primaryKeys = primaryKeysCache.get(table);
-    return primaryKeys.map((pk) => normalizeColumn(table[pk.js], row[pk.js])).join("_");
-  };
-  const getWhereCondition = (table, key) => {
-    primaryKeysCache.get(table);
-    const conditions = [];
-    for (const { js } of primaryKeysCache.get(table)) {
-      conditions.push(eq2(table[js], key[js]));
-    }
-    return and2(...conditions);
-  };
-  const find = (table, key) => {
-    return database.qb.drizzle.select().from(table).where(getWhereCondition(table, key)).then((res) => res.length === 0 ? null : res[0]);
-  };
-  const indexingStore = {
-    // @ts-ignore
-    find: (table, key) => queue.add(
-      () => database.wrap(
-        { method: `${getTableName3(table) ?? "unknown"}.find()` },
-        async () => {
-          checkOnchainTable2(table, "find");
-          return find(table, key);
-        }
-      )
-    ),
-    // @ts-ignore
-    insert(table) {
-      return {
-        values: (values) => {
-          const inner = {
-            onConflictDoNothing: () => queue.add(
-              () => database.wrap(
-                {
-                  method: `${getTableName3(table) ?? "unknown"}.insert()`
-                },
-                async () => {
-                  checkOnchainTable2(table, "insert");
-                  const parseResult = (result) => {
-                    if (Array.isArray(values) === false) {
-                      return result.length === 1 ? result[0] : null;
-                    }
-                    const rows = [];
-                    let resultIndex = 0;
-                    for (let i = 0; i < values.length; i++) {
-                      if (getCacheKey(table, values[i]) === getCacheKey(table, result[resultIndex])) {
-                        rows.push(result[resultIndex++]);
-                      } else {
-                        rows.push(null);
-                      }
-                    }
-                    return rows;
-                  };
-                  try {
-                    return await database.qb.drizzle.insert(table).values(values).onConflictDoNothing().returning().then(parseResult);
-                  } catch (e) {
-                    throw parseSqlError(e);
-                  }
-                }
-              )
-            ),
-            onConflictDoUpdate: (valuesU) => queue.add(
-              () => database.wrap(
-                {
-                  method: `${getTableName3(table) ?? "unknown"}.insert()`
-                },
-                async () => {
-                  checkOnchainTable2(table, "insert");
-                  if (typeof valuesU === "object") {
-                    try {
-                      return await database.qb.drizzle.insert(table).values(values).onConflictDoUpdate({
-                        target: primaryKeysCache.get(table).map(({ js }) => table[js]),
-                        set: valuesU
-                      }).returning().then(
-                        (res) => Array.isArray(values) ? res : res[0]
-                      );
-                    } catch (e) {
-                      throw parseSqlError(e);
-                    }
-                  }
-                  if (Array.isArray(values)) {
-                    const rows = [];
-                    for (const value of values) {
-                      const row = await find(table, value);
-                      if (row === null) {
-                        try {
-                          rows.push(
-                            await database.qb.drizzle.insert(table).values(value).returning().then((res) => res[0])
-                          );
-                        } catch (e) {
-                          throw parseSqlError(e);
-                        }
-                      } else {
-                        try {
-                          rows.push(
-                            await database.qb.drizzle.update(table).set(valuesU(row)).where(getWhereCondition(table, value)).returning().then((res) => res[0])
-                          );
-                        } catch (e) {
-                          throw parseSqlError(e);
-                        }
-                      }
-                    }
-                    return rows;
-                  } else {
-                    const row = await find(table, values);
-                    if (row === null) {
-                      try {
-                        return await database.qb.drizzle.insert(table).values(values).returning().then((res) => res[0]);
-                      } catch (e) {
-                        throw parseSqlError(e);
-                      }
-                    } else {
-                      try {
-                        return await database.qb.drizzle.update(table).set(valuesU(row)).where(getWhereCondition(table, values)).returning().then((res) => res[0]);
-                      } catch (e) {
-                        throw parseSqlError(e);
-                      }
-                    }
-                  }
-                }
-              )
-            ),
-            // biome-ignore lint/suspicious/noThenProperty: <explanation>
-            then: (onFulfilled, onRejected) => queue.add(
-              () => database.wrap(
-                {
-                  method: `${getTableName3(table) ?? "unknown"}.insert()`
-                },
-                async () => {
-                  checkOnchainTable2(table, "insert");
-                  try {
-                    return await database.qb.drizzle.insert(table).values(values).returning().then(
-                      (res) => Array.isArray(values) ? res : res[0]
-                    );
-                  } catch (e) {
-                    throw parseSqlError(e);
-                  }
-                }
-              )
-            ).then(onFulfilled, onRejected),
-            catch: (onRejected) => inner.then(void 0, onRejected),
-            finally: (onFinally) => inner.then(
-              (value) => {
-                onFinally?.();
-                return value;
-              },
-              (reason) => {
-                onFinally?.();
-                throw reason;
-              }
-            )
-            // @ts-ignore
-          };
-          return inner;
-        }
-      };
-    },
-    // @ts-ignore
-    update(table, key) {
-      return {
-        set: (values) => queue.add(
-          () => database.wrap(
-            { method: `${getTableName3(table) ?? "unknown"}.update()` },
-            async () => {
-              checkOnchainTable2(table, "update");
-              if (typeof values === "function") {
-                const row = await find(table, key);
-                if (row === null) {
-                  const error = new RecordNotFoundError(
-                    `No existing record found in table '${getTableName3(table)}'`
-                  );
-                  error.meta.push(
-                    `db.update arguments:
-${prettyPrint(key)}`
-                  );
-                  throw error;
-                }
-                try {
-                  return await database.qb.drizzle.update(table).set(values(row)).where(getWhereCondition(table, key)).returning().then((res) => res[0]);
-                } catch (e) {
-                  throw parseSqlError(e);
-                }
-              } else {
-                try {
-                  return await database.qb.drizzle.update(table).set(values).where(getWhereCondition(table, key)).returning().then((res) => res[0]);
-                } catch (e) {
-                  throw parseSqlError(e);
-                }
-              }
-            }
-          )
-        )
-      };
-    },
-    // @ts-ignore
-    delete: (table, key) => queue.add(
-      () => database.wrap(
-        { method: `${getTableName3(table) ?? "unknown"}.delete()` },
-        async () => {
-          checkOnchainTable2(table, "delete");
-          const deleted = await database.qb.drizzle.delete(table).where(getWhereCondition(table, key)).returning();
-          return deleted.length > 0;
-        }
-      )
-    ),
-    // @ts-ignore
-    sql: drizzle2(
-      (_sql, params, method, typings) => (
-        // @ts-ignore
-        queue.add(async () => {
-          const query2 = { sql: _sql, params, typings };
-          const res = await database.wrap({ method: "sql" }, async () => {
-            try {
-              return await database.qb.drizzle._.session.prepareQuery(query2, void 0, void 0, method === "all").execute();
-            } catch (e) {
-              throw parseSqlError(e);
-            }
-          });
-          return { rows: res.rows.map((row) => Object.values(row)) };
-        })
-      ),
-      { schema, casing: "snake_case" }
-    )
-  };
-  return indexingStore;
-};
-
 // src/utils/extend.ts
 var extend = (create2, _methods) => {
   return (...params) => {
@@ -7528,7 +5909,7 @@ import {
 } from "viem";
 
 // src/sync-store/encoding.ts
-import { hexToBigInt as hexToBigInt3, hexToNumber as hexToNumber2 } from "viem";
+import { hexToBigInt as hexToBigInt3, hexToNumber as hexToNumber3 } from "viem";
 var encodeBlock = ({
   block,
   chainId
@@ -7537,7 +5918,7 @@ var encodeBlock = ({
     hash: block.hash,
     chainId,
     checkpoint: encodeCheckpoint({
-      blockTimestamp: hexToNumber2(block.timestamp),
+      blockTimestamp: hexToNumber3(block.timestamp),
       chainId: BigInt(chainId),
       blockNumber: hexToBigInt3(block.number),
       transactionIndex: MAX_CHECKPOINT.transactionIndex,
@@ -7573,7 +5954,7 @@ var encodeLog = ({
     id: `${log.blockHash}-${log.logIndex}`,
     chainId,
     checkpoint: block === void 0 ? null : encodeCheckpoint({
-      blockTimestamp: hexToNumber2(block.timestamp),
+      blockTimestamp: hexToNumber3(block.timestamp),
       chainId: BigInt(chainId),
       blockNumber: hexToBigInt3(log.blockNumber),
       transactionIndex: hexToBigInt3(log.transactionIndex),
@@ -7582,9 +5963,9 @@ var encodeLog = ({
     }),
     blockHash: log.blockHash,
     blockNumber: hexToBigInt3(log.blockNumber),
-    logIndex: hexToNumber2(log.logIndex),
+    logIndex: hexToNumber3(log.logIndex),
     transactionHash: log.transactionHash,
-    transactionIndex: hexToNumber2(log.transactionIndex),
+    transactionIndex: hexToNumber3(log.transactionIndex),
     address: toLowerCase(log.address),
     topic0: log.topics[0] ? log.topics[0] : null,
     topic1: log.topics[1] ? log.topics[1] : null,
@@ -7601,7 +5982,7 @@ var encodeTransaction = ({
   return {
     hash: transaction.hash,
     checkpoint: encodeCheckpoint({
-      blockTimestamp: hexToNumber2(block.timestamp),
+      blockTimestamp: hexToNumber3(block.timestamp),
       chainId: BigInt(chainId),
       blockNumber: hexToBigInt3(transaction.blockNumber),
       transactionIndex: hexToBigInt3(transaction.transactionIndex),
@@ -7618,11 +5999,11 @@ var encodeTransaction = ({
     input: transaction.input,
     maxFeePerGas: transaction.maxFeePerGas ? hexToBigInt3(transaction.maxFeePerGas) : null,
     maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? hexToBigInt3(transaction.maxPriorityFeePerGas) : null,
-    nonce: hexToNumber2(transaction.nonce),
+    nonce: hexToNumber3(transaction.nonce),
     r: transaction.r ?? null,
     s: transaction.s ?? null,
     to: transaction.to ? toLowerCase(transaction.to) : null,
-    transactionIndex: hexToNumber2(transaction.transactionIndex),
+    transactionIndex: hexToNumber3(transaction.transactionIndex),
     type: transaction.type ?? "0x0",
     value: hexToBigInt3(transaction.value),
     v: transaction.v ? hexToBigInt3(transaction.v) : null
@@ -7645,7 +6026,7 @@ var encodeTransactionReceipt = ({
     logsBloom: transactionReceipt.logsBloom,
     status: transactionReceipt.status,
     to: transactionReceipt.to ? toLowerCase(transactionReceipt.to) : null,
-    transactionIndex: hexToNumber2(transactionReceipt.transactionIndex),
+    transactionIndex: hexToNumber3(transactionReceipt.transactionIndex),
     type: transactionReceipt.type
   };
 };
@@ -7659,7 +6040,7 @@ function encodeTrace({
     id: `${transaction.hash}-${trace.index}`,
     chainId,
     checkpoint: encodeCheckpoint({
-      blockTimestamp: hexToNumber2(block.timestamp),
+      blockTimestamp: hexToNumber3(block.timestamp),
       chainId: BigInt(chainId),
       blockNumber: hexToBigInt3(block.number),
       transactionIndex: hexToBigInt3(transaction.transactionIndex),
@@ -8346,7 +6727,7 @@ import {
   decodeFunctionData,
   decodeFunctionResult,
   hexToBigInt as hexToBigInt5,
-  hexToNumber as hexToNumber3
+  hexToNumber as hexToNumber4
 } from "viem";
 var buildEvents = ({
   sources,
@@ -8388,7 +6769,7 @@ var buildEvents = ({
                   chainId: filter.chainId,
                   sourceIndex: i,
                   checkpoint: encodeCheckpoint({
-                    blockTimestamp: hexToNumber3(block.timestamp),
+                    blockTimestamp: hexToNumber4(block.timestamp),
                     chainId: BigInt(filter.chainId),
                     blockNumber: hexToBigInt5(log.blockNumber),
                     transactionIndex: hexToBigInt5(log.transactionIndex),
@@ -8436,7 +6817,7 @@ var buildEvents = ({
                   chainId: filter.chainId,
                   sourceIndex: i,
                   checkpoint: encodeCheckpoint({
-                    blockTimestamp: hexToNumber3(block.timestamp),
+                    blockTimestamp: hexToNumber4(block.timestamp),
                     chainId: BigInt(filter.chainId),
                     blockNumber: hexToBigInt5(block.number),
                     transactionIndex: BigInt(transaction.transactionIndex),
@@ -8479,7 +6860,7 @@ var buildEvents = ({
                   chainId: filter.chainId,
                   sourceIndex: i,
                   checkpoint: encodeCheckpoint({
-                    blockTimestamp: hexToNumber3(block.timestamp),
+                    blockTimestamp: hexToNumber4(block.timestamp),
                     chainId: BigInt(filter.chainId),
                     blockNumber: hexToBigInt5(block.number),
                     transactionIndex: BigInt(transaction.transactionIndex),
@@ -8525,7 +6906,7 @@ var buildEvents = ({
                   chainId: filter.chainId,
                   sourceIndex: i,
                   checkpoint: encodeCheckpoint({
-                    blockTimestamp: hexToNumber3(block.timestamp),
+                    blockTimestamp: hexToNumber4(block.timestamp),
                     chainId: BigInt(filter.chainId),
                     blockNumber: hexToBigInt5(block.number),
                     transactionIndex: BigInt(transaction.transactionIndex),
@@ -8551,7 +6932,7 @@ var buildEvents = ({
             chainId: filter.chainId,
             sourceIndex: i,
             checkpoint: encodeCheckpoint({
-              blockTimestamp: hexToNumber3(block.timestamp),
+              blockTimestamp: hexToNumber4(block.timestamp),
               chainId: BigInt(filter.chainId),
               blockNumber: hexToBigInt5(block.number),
               transactionIndex: MAX_CHECKPOINT.transactionIndex,
@@ -9020,7 +7401,7 @@ function intervalRange(interval) {
 
 // src/utils/rpc.ts
 import {
-  BlockNotFoundError,
+  BlockNotFoundError as BlockNotFoundError2,
   TransactionReceiptNotFoundError,
   numberToHex
 } from "viem";
@@ -9035,7 +7416,7 @@ var _eth_getBlockByNumber = (requestQueue, {
   ]
 }).then((_block) => {
   if (!_block)
-    throw new BlockNotFoundError({
+    throw new BlockNotFoundError2({
       blockNumber: blockNumber ?? blockTag
     });
   return _block;
@@ -9045,7 +7426,7 @@ var _eth_getBlockByHash = (requestQueue, { hash }) => requestQueue.request({
   params: [hash, true]
 }).then((_block) => {
   if (!_block)
-    throw new BlockNotFoundError({
+    throw new BlockNotFoundError2({
       blockHash: hash
     });
   return _block;
@@ -9171,7 +7552,7 @@ var _debug_traceBlockByHash = (requestQueue, {
 import { getLogsRetryHelper } from "@ponder/utils";
 import {
   hexToBigInt as hexToBigInt6,
-  hexToNumber as hexToNumber4,
+  hexToNumber as hexToNumber5,
   toHex,
   zeroHash
 } from "viem";
@@ -9258,7 +7639,7 @@ var createHistoricalSync = async (args) => {
             });
             if (getLogsErrorResponse.shouldRetry === false)
               throw error;
-            const range2 = hexToNumber4(getLogsErrorResponse.ranges[0].toBlock) - hexToNumber4(getLogsErrorResponse.ranges[0].fromBlock);
+            const range2 = hexToNumber5(getLogsErrorResponse.ranges[0].toBlock) - hexToNumber5(getLogsErrorResponse.ranges[0].fromBlock);
             args.common.logger.debug({
               service: "sync",
               msg: `Caught eth_getLogs error on '${args.network.name}', updating recommended range to ${range2}.`
@@ -9407,7 +7788,7 @@ var createHistoricalSync = async (args) => {
     const address = isAddressFactory(filter.address) ? await syncAddressFactory(filter.address, interval) : filter.address;
     const logs = await syncLogsDynamic({ filter, interval, address });
     const blocks = await Promise.all(
-      logs.map((log) => syncBlock(hexToNumber4(log.blockNumber)))
+      logs.map((log) => syncBlock(hexToNumber5(log.blockNumber)))
     );
     const requiredBlocks = new Set(blocks.map((b) => b.hash));
     for (let i = 0; i < logs.length; i++) {
@@ -9422,7 +7803,7 @@ var createHistoricalSync = async (args) => {
         if (log.transactionHash === zeroHash) {
           args.common.logger.warn({
             service: "sync",
-            msg: `Detected log with empty transaction hash in block ${block.hash} at log index ${hexToNumber4(log.logIndex)}. This is expected for some networks like ZKsync.`
+            msg: `Detected log with empty transaction hash in block ${block.hash} at log index ${hexToNumber5(log.logIndex)}. This is expected for some networks like ZKsync.`
           });
         } else {
           throw new Error(
@@ -9449,7 +7830,7 @@ var createHistoricalSync = async (args) => {
               if (log.transactionHash === zeroHash) {
                 args.common.logger.warn({
                   service: "sync",
-                  msg: `Detected log with empty transaction hash in block ${log.blockHash} at log index ${hexToNumber4(log.logIndex)}. This is expected for some networks like ZKsync.`
+                  msg: `Detected log with empty transaction hash in block ${log.blockHash} at log index ${hexToNumber5(log.logIndex)}. This is expected for some networks like ZKsync.`
                 });
               } else {
                 blockTransactionHashes.add(log.transactionHash);
@@ -9715,10 +8096,10 @@ var createMutex = () => {
 };
 
 // src/sync-realtime/index.ts
-import { hexToNumber as hexToNumber6, zeroHash as zeroHash2 } from "viem";
+import { hexToNumber as hexToNumber7, zeroHash as zeroHash2 } from "viem";
 
 // src/sync-realtime/bloom.ts
-import { hexToBytes, hexToNumber as hexToNumber5, keccak256 } from "viem";
+import { hexToBytes, hexToNumber as hexToNumber6, keccak256 } from "viem";
 var zeroLogsBloom = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
 var BLOOM_SIZE_BYTES = 256;
 var isInBloom = (_bloom, input) => {
@@ -9735,7 +8116,7 @@ function isFilterInBloom({
   block,
   filter
 }) {
-  if (hexToNumber5(block.number) < (filter.fromBlock ?? 0) || hexToNumber5(block.number) > (filter.toBlock ?? Number.POSITIVE_INFINITY)) {
+  if (hexToNumber6(block.number) < (filter.fromBlock ?? 0) || hexToNumber6(block.number) > (filter.toBlock ?? Number.POSITIVE_INFINITY)) {
     return false;
   }
   const isTopicsInBloom = [
@@ -9861,7 +8242,7 @@ var createRealtimeSync = (args) => {
   }) => {
     args.common.logger.debug({
       service: "realtime",
-      msg: `Started syncing '${args.network.name}' block ${hexToNumber6(block.number)}`
+      msg: `Started syncing '${args.network.name}' block ${hexToNumber7(block.number)}`
     });
     for (const log of factoryLogs) {
       for (const filter of factories) {
@@ -9996,12 +8377,12 @@ var createRealtimeSync = (args) => {
       const text = _text.filter((t) => t !== void 0).join(" and ");
       args.common.logger.info({
         service: "realtime",
-        msg: `Synced ${text} from '${args.network.name}' block ${hexToNumber6(block.number)}`
+        msg: `Synced ${text} from '${args.network.name}' block ${hexToNumber7(block.number)}`
       });
     } else {
       args.common.logger.info({
         service: "realtime",
-        msg: `Synced block ${hexToNumber6(block.number)} from '${args.network.name}' `
+        msg: `Synced block ${hexToNumber7(block.number)} from '${args.network.name}' `
       });
     }
     unfinalizedBlocks.push(syncBlockToLightBlock(block));
@@ -10017,20 +8398,20 @@ var createRealtimeSync = (args) => {
       transactionReceipts,
       endClock
     });
-    const blockMovesFinality = hexToNumber6(block.number) >= hexToNumber6(finalizedBlock.number) + 2 * args.network.finalityBlockCount;
+    const blockMovesFinality = hexToNumber7(block.number) >= hexToNumber7(finalizedBlock.number) + 2 * args.network.finalityBlockCount;
     if (blockMovesFinality) {
       const pendingFinalizedBlock = unfinalizedBlocks.find(
-        (lb) => hexToNumber6(lb.number) === hexToNumber6(block.number) - args.network.finalityBlockCount
+        (lb) => hexToNumber7(lb.number) === hexToNumber7(block.number) - args.network.finalityBlockCount
       );
       args.common.logger.debug({
         service: "realtime",
-        msg: `Finalized ${hexToNumber6(pendingFinalizedBlock.number) - hexToNumber6(finalizedBlock.number) + 1} '${args.network.name}' blocks [${hexToNumber6(finalizedBlock.number) + 1}, ${hexToNumber6(pendingFinalizedBlock.number)}]`
+        msg: `Finalized ${hexToNumber7(pendingFinalizedBlock.number) - hexToNumber7(finalizedBlock.number) + 1} '${args.network.name}' blocks [${hexToNumber7(finalizedBlock.number) + 1}, ${hexToNumber7(pendingFinalizedBlock.number)}]`
       });
       const finalizedBlocks = unfinalizedBlocks.filter(
-        (lb) => hexToNumber6(lb.number) <= hexToNumber6(pendingFinalizedBlock.number)
+        (lb) => hexToNumber7(lb.number) <= hexToNumber7(pendingFinalizedBlock.number)
       );
       unfinalizedBlocks = unfinalizedBlocks.filter(
-        (lb) => hexToNumber6(lb.number) > hexToNumber6(pendingFinalizedBlock.number)
+        (lb) => hexToNumber7(lb.number) > hexToNumber7(pendingFinalizedBlock.number)
       );
       for (const filter of factories) {
         for (const { hash } of finalizedBlocks) {
@@ -10068,13 +8449,13 @@ var createRealtimeSync = (args) => {
   const handleReorg = async (block) => {
     args.common.logger.warn({
       service: "realtime",
-      msg: `Detected forked '${args.network.name}' block at height ${hexToNumber6(block.number)}`
+      msg: `Detected forked '${args.network.name}' block at height ${hexToNumber7(block.number)}`
     });
     const reorgedBlocks = unfinalizedBlocks.filter(
-      (lb) => hexToNumber6(lb.number) >= hexToNumber6(block.number)
+      (lb) => hexToNumber7(lb.number) >= hexToNumber7(block.number)
     );
     unfinalizedBlocks = unfinalizedBlocks.filter(
-      (lb) => hexToNumber6(lb.number) < hexToNumber6(block.number)
+      (lb) => hexToNumber7(lb.number) < hexToNumber7(block.number)
     );
     let remoteBlock = block;
     while (true) {
@@ -10082,7 +8463,7 @@ var createRealtimeSync = (args) => {
       if (parentBlock.hash === remoteBlock.parentHash)
         break;
       if (unfinalizedBlocks.length === 0) {
-        const msg = `Encountered unrecoverable '${args.network.name}' reorg beyond finalized block ${hexToNumber6(finalizedBlock.number)}`;
+        const msg = `Encountered unrecoverable '${args.network.name}' reorg beyond finalized block ${hexToNumber7(finalizedBlock.number)}`;
         args.common.logger.warn({ service: "realtime", msg });
         throw new Error(msg);
       } else {
@@ -10096,7 +8477,7 @@ var createRealtimeSync = (args) => {
     await args.onEvent({ type: "reorg", block: commonAncestor, reorgedBlocks });
     args.common.logger.warn({
       service: "realtime",
-      msg: `Reconciled ${reorgedBlocks.length}-block '${args.network.name}' reorg with common ancestor block ${hexToNumber6(commonAncestor.number)}`
+      msg: `Reconciled ${reorgedBlocks.length}-block '${args.network.name}' reorg with common ancestor block ${hexToNumber7(commonAncestor.number)}`
     });
     unfinalizedChildAddresses.clear();
     for (const filter of factories) {
@@ -10188,7 +8569,7 @@ var createRealtimeSync = (args) => {
           if (log.transactionHash === zeroHash2) {
             args.common.logger.warn({
               service: "sync",
-              msg: `Detected '${args.network.name}' log with empty transaction hash in block ${block.hash} at log index ${hexToNumber6(log.logIndex)}. This is expected for some networks like ZKsync.`
+              msg: `Detected '${args.network.name}' log with empty transaction hash in block ${block.hash} at log index ${hexToNumber7(log.logIndex)}. This is expected for some networks like ZKsync.`
             });
           } else {
             throw new Error(
@@ -10201,7 +8582,7 @@ var createRealtimeSync = (args) => {
     if (shouldRequestLogs === false && args.sources.some((s) => s.filter.type === "log")) {
       args.common.logger.debug({
         service: "realtime",
-        msg: `Skipped fetching '${args.network.name}' logs for block ${hexToNumber6(block.number)} due to bloom filter result`
+        msg: `Skipped fetching '${args.network.name}' logs for block ${hexToNumber7(block.number)} due to bloom filter result`
       });
     }
     const shouldRequestTraces = traceFilters.length > 0 || transferFilters.length > 0;
@@ -10246,7 +8627,7 @@ var createRealtimeSync = (args) => {
           if (log.transactionHash === zeroHash2) {
             args.common.logger.warn({
               service: "sync",
-              msg: `Detected '${args.network.name}' log with empty transaction hash in block ${block.hash} at log index ${hexToNumber6(log.logIndex)}. This is expected for some networks like ZKsync.`
+              msg: `Detected '${args.network.name}' log with empty transaction hash in block ${block.hash} at log index ${hexToNumber7(log.logIndex)}. This is expected for some networks like ZKsync.`
             });
           } else {
             requiredTransactions.add(log.transactionHash);
@@ -10344,22 +8725,22 @@ var createRealtimeSync = (args) => {
           if (latestBlock.hash === block.hash) {
             args.common.logger.trace({
               service: "realtime",
-              msg: `Skipped processing '${args.network.name}' block ${hexToNumber6(block.number)}, already synced`
+              msg: `Skipped processing '${args.network.name}' block ${hexToNumber7(block.number)}, already synced`
             });
             return;
           }
           try {
-            if (hexToNumber6(latestBlock.number) >= hexToNumber6(block.number)) {
+            if (hexToNumber7(latestBlock.number) >= hexToNumber7(block.number)) {
               await handleReorg(block);
               processBlock.clear();
               return;
             }
-            if (hexToNumber6(latestBlock.number) + 1 < hexToNumber6(block.number)) {
+            if (hexToNumber7(latestBlock.number) + 1 < hexToNumber7(block.number)) {
               const missingBlockRange = range(
-                hexToNumber6(latestBlock.number) + 1,
+                hexToNumber7(latestBlock.number) + 1,
                 Math.min(
-                  hexToNumber6(block.number),
-                  hexToNumber6(latestBlock.number) + MAX_QUEUED_BLOCKS
+                  hexToNumber7(block.number),
+                  hexToNumber7(latestBlock.number) + MAX_QUEUED_BLOCKS
                 )
               );
               const pendingBlocks = await Promise.all(
@@ -10371,9 +8752,9 @@ var createRealtimeSync = (args) => {
               );
               args.common.logger.debug({
                 service: "realtime",
-                msg: `Fetched ${missingBlockRange.length} missing '${args.network.name}' blocks [${hexToNumber6(latestBlock.number) + 1}, ${Math.min(
-                  hexToNumber6(block.number),
-                  hexToNumber6(latestBlock.number) + MAX_QUEUED_BLOCKS
+                msg: `Fetched ${missingBlockRange.length} missing '${args.network.name}' blocks [${hexToNumber7(latestBlock.number) + 1}, ${Math.min(
+                  hexToNumber7(block.number),
+                  hexToNumber7(latestBlock.number) + MAX_QUEUED_BLOCKS
                 )}]`
               });
               processBlock.clear();
@@ -10398,7 +8779,7 @@ var createRealtimeSync = (args) => {
             }
             args.common.logger.warn({
               service: "realtime",
-              msg: `Failed to process '${args.network.name}' block ${hexToNumber6(block.number)}`,
+              msg: `Failed to process '${args.network.name}' block ${hexToNumber7(block.number)}`,
               error
             });
             const duration = ERROR_TIMEOUT[consecutiveErrors];
@@ -10411,7 +8792,7 @@ var createRealtimeSync = (args) => {
             if (++consecutiveErrors === ERROR_TIMEOUT.length) {
               args.common.logger.error({
                 service: "realtime",
-                msg: `Fatal error: Unable to process '${args.network.name}' block ${hexToNumber6(block.number)} after ${ERROR_TIMEOUT.length} attempts.`,
+                msg: `Fatal error: Unable to process '${args.network.name}' block ${hexToNumber7(block.number)} after ${ERROR_TIMEOUT.length} attempts.`,
                 error
               });
               args.onFatalError(error);
@@ -10426,13 +8807,13 @@ var createRealtimeSync = (args) => {
           });
           args.common.logger.debug({
             service: "realtime",
-            msg: `Received latest '${args.network.name}' block ${hexToNumber6(block.number)}`
+            msg: `Received latest '${args.network.name}' block ${hexToNumber7(block.number)}`
           });
           const latestBlock = getLatestUnfinalizedBlock();
           if (latestBlock.hash === block.hash) {
             args.common.logger.trace({
               service: "realtime",
-              msg: `Skipped processing '${args.network.name}' block ${hexToNumber6(block.number)}, already synced`
+              msg: `Skipped processing '${args.network.name}' block ${hexToNumber7(block.number)}, already synced`
             });
             return;
           }
@@ -10601,7 +8982,7 @@ var zipperMany = (arrays, compare) => {
 };
 
 // src/sync/index.ts
-import { hexToBigInt as hexToBigInt7, hexToNumber as hexToNumber7, toHex as toHex2 } from "viem";
+import { hexToBigInt as hexToBigInt7, hexToNumber as hexToNumber8, toHex as toHex2 } from "viem";
 var syncBlockToLightBlock = ({
   hash,
   parentHash,
@@ -10616,7 +8997,7 @@ var syncBlockToLightBlock = ({
 var blockToCheckpoint = (block, chainId, rounding) => {
   return {
     ...rounding === "up" ? MAX_CHECKPOINT : ZERO_CHECKPOINT,
-    blockTimestamp: hexToNumber7(block.timestamp),
+    blockTimestamp: hexToNumber8(block.timestamp),
     chainId: BigInt(chainId),
     blockNumber: hexToBigInt7(block.number)
   };
@@ -10625,16 +9006,16 @@ var isSyncEnd = (syncProgress) => {
   if (syncProgress.end === void 0 || syncProgress.current === void 0) {
     return false;
   }
-  return hexToNumber7(syncProgress.current.number) >= hexToNumber7(syncProgress.end.number);
+  return hexToNumber8(syncProgress.current.number) >= hexToNumber8(syncProgress.end.number);
 };
 var isSyncFinalized = (syncProgress) => {
   if (syncProgress.current === void 0) {
     return false;
   }
-  return hexToNumber7(syncProgress.current.number) >= hexToNumber7(syncProgress.finalized.number);
+  return hexToNumber8(syncProgress.current.number) >= hexToNumber8(syncProgress.finalized.number);
 };
 var getHistoricalLast = (syncProgress) => {
-  return syncProgress.end === void 0 ? syncProgress.finalized : hexToNumber7(syncProgress.end.number) > hexToNumber7(syncProgress.finalized.number) ? syncProgress.finalized : syncProgress.end;
+  return syncProgress.end === void 0 ? syncProgress.finalized : hexToNumber8(syncProgress.end.number) > hexToNumber8(syncProgress.finalized.number) ? syncProgress.finalized : syncProgress.end;
 };
 var splitEvents = (events) => {
   let hash;
@@ -10735,8 +9116,8 @@ var createSync = async (params) => {
     );
     if (localBlock !== void 0) {
       status[network.name].block = {
-        timestamp: hexToNumber7(localBlock.timestamp),
-        number: hexToNumber7(localBlock.number)
+        timestamp: hexToNumber8(localBlock.timestamp),
+        number: hexToNumber8(localBlock.number)
       };
     }
   };
@@ -10820,7 +9201,7 @@ var createSync = async (params) => {
         });
         params.common.logger.debug({
           service: "sync",
-          msg: `Extracted ${events.length} '${network.name}' events for block ${hexToNumber7(event.block.number)}`
+          msg: `Extracted ${events.length} '${network.name}' events for block ${hexToNumber8(event.block.number)}`
         });
         if (params.ordering === "multichain") {
           const checkpoint = getMultichainCheckpoint({
@@ -10828,15 +9209,15 @@ var createSync = async (params) => {
             network
           });
           status[network.name].block = {
-            timestamp: hexToNumber7(event.block.timestamp),
-            number: hexToNumber7(event.block.number)
+            timestamp: hexToNumber8(event.block.timestamp),
+            number: hexToNumber8(event.block.number)
           };
           const readyEvents = events.concat(pendingEvents);
           pendingEvents = [];
           executedEvents = executedEvents.concat(readyEvents);
           params.common.logger.debug({
             service: "sync",
-            msg: `Sequenced ${readyEvents.length} '${network.name}' events for block ${hexToNumber7(event.block.number)}`
+            msg: `Sequenced ${readyEvents.length} '${network.name}' events for block ${hexToNumber8(event.block.number)}`
           });
           params.onRealtimeEvent({
             type: "block",
@@ -10930,7 +9311,7 @@ var createSync = async (params) => {
       case "reorg": {
         let reorgedEvents = 0;
         const isReorgedEvent = ({ chainId, block }) => {
-          if (chainId === network.chainId && Number(block.number) > hexToNumber7(event.block.number)) {
+          if (chainId === network.chainId && Number(block.number) > hexToNumber8(event.block.number)) {
             reorgedEvents++;
             return true;
           }
@@ -11041,7 +9422,7 @@ var createSync = async (params) => {
               );
               params.common.logger.info({
                 service: "sync",
-                msg: `Killing '${network.name}' live indexing because the end block ${hexToNumber7(syncProgress.end.number)} has been finalized`
+                msg: `Killing '${network.name}' live indexing because the end block ${hexToNumber8(syncProgress.end.number)} has been finalized`
               });
               realtimeSync.kill();
             }
@@ -11119,8 +9500,8 @@ var createSync = async (params) => {
         const { syncProgress, realtimeSync } = perNetworkSync.get(network);
         const filters = params.indexingBuild.sources.filter(({ filter }) => filter.chainId === network.chainId).map(({ filter }) => filter);
         status[network.name].block = {
-          number: hexToNumber7(syncProgress.current.number),
-          timestamp: hexToNumber7(syncProgress.current.timestamp)
+          number: hexToNumber8(syncProgress.current.number),
+          timestamp: hexToNumber8(syncProgress.current.timestamp)
         };
         status[network.name].ready = true;
         const from = getOmnichainCheckpoint({ tag: "finalized" });
@@ -11223,30 +9604,30 @@ var getPerChainOnRealtimeSyncEvent = ({
         syncProgress.current = event.block;
         common.logger.debug({
           service: "sync",
-          msg: `Updated '${network.name}' current block to ${hexToNumber7(event.block.number)}`
+          msg: `Updated '${network.name}' current block to ${hexToNumber8(event.block.number)}`
         });
         common.metrics.ponder_sync_block.set(
           { network: network.name },
-          hexToNumber7(syncProgress.current.number)
+          hexToNumber8(syncProgress.current.number)
         );
         unfinalizedBlocks.push(event);
         return event;
       }
       case "finalize": {
         const finalizedInterval = [
-          hexToNumber7(syncProgress.finalized.number),
-          hexToNumber7(event.block.number)
+          hexToNumber8(syncProgress.finalized.number),
+          hexToNumber8(event.block.number)
         ];
         syncProgress.finalized = event.block;
         common.logger.debug({
           service: "sync",
-          msg: `Updated '${network.name}' finalized block to ${hexToNumber7(event.block.number)}`
+          msg: `Updated '${network.name}' finalized block to ${hexToNumber8(event.block.number)}`
         });
         const finalizedBlocks = unfinalizedBlocks.filter(
-          ({ block }) => hexToNumber7(block.number) <= hexToNumber7(event.block.number)
+          ({ block }) => hexToNumber8(block.number) <= hexToNumber8(event.block.number)
         );
         unfinalizedBlocks = unfinalizedBlocks.filter(
-          ({ block }) => hexToNumber7(block.number) > hexToNumber7(event.block.number)
+          ({ block }) => hexToNumber8(block.number) > hexToNumber8(event.block.number)
         );
         await Promise.all([
           syncStore.insertBlocks({
@@ -11322,14 +9703,14 @@ var getPerChainOnRealtimeSyncEvent = ({
         syncProgress.current = event.block;
         common.logger.debug({
           service: "sync",
-          msg: `Updated '${network.name}' current block to ${hexToNumber7(event.block.number)}`
+          msg: `Updated '${network.name}' current block to ${hexToNumber8(event.block.number)}`
         });
         common.metrics.ponder_sync_block.set(
           { network: network.name },
-          hexToNumber7(syncProgress.current.number)
+          hexToNumber8(syncProgress.current.number)
         );
         unfinalizedBlocks = unfinalizedBlocks.filter(
-          ({ block }) => hexToNumber7(block.number) <= hexToNumber7(event.block.number)
+          ({ block }) => hexToNumber8(block.number) <= hexToNumber8(event.block.number)
         );
         await syncStore.pruneRpcRequestResult({
           chainId: network.chainId,
@@ -11414,10 +9795,10 @@ async function* getLocalSyncGenerator({
   historicalSync
 }) {
   const label = { network: network.name };
-  let cursor = hexToNumber7(syncProgress.start.number);
+  let cursor = hexToNumber8(syncProgress.start.number);
   const last = getHistoricalLast(syncProgress);
   let estimateRange = 25;
-  if (hexToNumber7(syncProgress.start.number) > hexToNumber7(syncProgress.finalized.number)) {
+  if (hexToNumber8(syncProgress.start.number) > hexToNumber8(syncProgress.finalized.number)) {
     syncProgress.current = syncProgress.finalized;
     common.logger.warn({
       service: "sync",
@@ -11425,15 +9806,15 @@ async function* getLocalSyncGenerator({
     });
     common.metrics.ponder_sync_block.set(
       label,
-      hexToNumber7(syncProgress.current.number)
+      hexToNumber8(syncProgress.current.number)
     );
     common.metrics.ponder_historical_total_blocks.set(label, 0);
     common.metrics.ponder_historical_cached_blocks.set(label, 0);
     return;
   }
   const totalInterval = [
-    hexToNumber7(syncProgress.start.number),
-    hexToNumber7(last.number)
+    hexToNumber8(syncProgress.start.number),
+    hexToNumber8(last.number)
   ];
   common.logger.debug({
     service: "sync",
@@ -11464,12 +9845,12 @@ async function* getLocalSyncGenerator({
   if (syncProgress.current !== void 0) {
     common.metrics.ponder_sync_block.set(
       label,
-      hexToNumber7(syncProgress.current.number)
+      hexToNumber8(syncProgress.current.number)
     );
     yield encodeCheckpoint(
       blockToCheckpoint(syncProgress.current, network.chainId, "up")
     );
-    if (hexToNumber7(syncProgress.current.number) === hexToNumber7(last.number)) {
+    if (hexToNumber8(syncProgress.current.number) === hexToNumber8(last.number)) {
       common.logger.info({
         service: "sync",
         msg: `Skipped '${network.name}' historical sync because all blocks are cached`
@@ -11483,7 +9864,7 @@ async function* getLocalSyncGenerator({
         )} cached`
       });
     }
-    cursor = hexToNumber7(syncProgress.current.number) + 1;
+    cursor = hexToNumber8(syncProgress.current.number) + 1;
   } else {
     common.logger.info({
       service: "historical",
@@ -11492,8 +9873,8 @@ async function* getLocalSyncGenerator({
   }
   while (true) {
     const interval = [
-      Math.min(cursor, hexToNumber7(last.number)),
-      Math.min(cursor + estimateRange, hexToNumber7(last.number))
+      Math.min(cursor, hexToNumber8(last.number)),
+      Math.min(cursor + estimateRange, hexToNumber8(last.number))
     ];
     const endClock = startClock();
     const synced = await historicalSync.sync(interval);
@@ -11503,13 +9884,13 @@ async function* getLocalSyncGenerator({
     });
     cursor = interval[1] + 1;
     if (synced === void 0) {
-      if (interval[1] === hexToNumber7(last.number)) {
+      if (interval[1] === hexToNumber8(last.number)) {
         syncProgress.current = last;
       } else {
         continue;
       }
     } else {
-      if (interval[1] === hexToNumber7(last.number)) {
+      if (interval[1] === hexToNumber8(last.number)) {
         syncProgress.current = last;
       } else {
         syncProgress.current = synced;
@@ -11517,7 +9898,7 @@ async function* getLocalSyncGenerator({
       const duration = endClock();
       common.metrics.ponder_sync_block.set(
         label,
-        hexToNumber7(syncProgress.current.number)
+        hexToNumber8(syncProgress.current.number)
       );
       common.metrics.ponder_historical_duration.observe(label, duration);
       common.metrics.ponder_historical_completed_blocks.inc(
@@ -11574,7 +9955,7 @@ var getLocalSyncProgress = async ({
   );
   const finalized = Math.max(
     0,
-    hexToNumber7(diagnostics[1].number) - network.finalityBlockCount
+    hexToNumber8(diagnostics[1].number) - network.finalityBlockCount
   );
   syncProgress.finalized = await _eth_getBlockByNumber(requestQueue, {
     blockNumber: finalized
@@ -11583,7 +9964,7 @@ var getLocalSyncProgress = async ({
   if (diagnostics.length === 4) {
     syncProgress.current = diagnostics[3];
   }
-  if (hexToNumber7(diagnostics[0]) !== network.chainId) {
+  if (hexToNumber8(diagnostics[0]) !== network.chainId) {
     common.logger.warn({
       service: "sync",
       msg: `Remote chain ID (${diagnostics[0]}) does not match configured chain ID (${network.chainId}) for network "${network.name}"`
@@ -11593,7 +9974,7 @@ var getLocalSyncProgress = async ({
     return syncProgress;
   }
   const end = Math.max(...filters.map((filter) => filter.toBlock));
-  if (end > hexToNumber7(diagnostics[1].number)) {
+  if (end > hexToNumber8(diagnostics[1].number)) {
     syncProgress.end = {
       number: toHex2(end),
       hash: "0x",
@@ -12474,7 +10855,7 @@ async function dev({ cliOptions }) {
 }
 
 // src/bin/commands/list.ts
-import { sql as sql4 } from "kysely";
+import { sql as sql3 } from "kysely";
 var emptySchemaBuild = {
   schema: {},
   statements: {
@@ -12520,7 +10901,7 @@ async function list({ cliOptions }) {
   ).execute();
   let union;
   for (const row of ponderSchemas) {
-    const query2 = database.qb.internal.selectFrom(`${row.table_schema}._ponder_meta`).select(["value", sql4`${row.table_schema}`.as("schema")]).where("key", "=", "app");
+    const query2 = database.qb.internal.selectFrom(`${row.table_schema}._ponder_meta`).select(["value", sql3`${row.table_schema}`.as("schema")]).where("key", "=", "app");
     if (union === void 0) {
       union = query2;
     } else {