ponder 0.9.4 → 0.9.5

package/dist/bin/ponder.js

@@ -8379,567 +8379,6 @@ var traceSQL = (filter, db, index) => db.selectFrom("traces").select([
   (qb) => qb.where("blockNumber", "<=", filter.toBlock.toString())
 );
 
-// src/sync/events.ts
-import {
-  DecodeLogDataMismatch,
-  DecodeLogTopicsMismatch,
-  checksumAddress as checksumAddress3,
-  decodeAbiParameters,
-  decodeFunctionData,
-  decodeFunctionResult,
-  hexToBigInt as hexToBigInt5,
-  hexToNumber as hexToNumber4
-} from "viem";
-var buildEvents = ({
-  sources,
-  blockWithEventData: {
-    block,
-    logs,
-    transactions,
-    transactionReceipts,
-    traces
-  },
-  finalizedChildAddresses,
-  unfinalizedChildAddresses,
-  chainId
-}) => {
-  const events = [];
-  const transactionCache = /* @__PURE__ */ new Map();
-  const transactionReceiptCache = /* @__PURE__ */ new Map();
-  for (const transaction of transactions) {
-    transactionCache.set(transaction.hash, transaction);
-  }
-  for (const transactionReceipt of transactionReceipts) {
-    transactionReceiptCache.set(
-      transactionReceipt.transactionHash,
-      transactionReceipt
-    );
-  }
-  for (let i = 0; i < sources.length; i++) {
-    const source = sources[i];
-    const filter = source.filter;
-    if (chainId !== filter.chainId)
-      continue;
-    switch (source.type) {
-      case "contract": {
-        switch (filter.type) {
-          case "log": {
-            for (const log of logs) {
-              if (isLogFilterMatched({ filter, block, log }) && (isAddressFactory(filter.address) ? finalizedChildAddresses.get(filter.address).has(log.address) || unfinalizedChildAddresses.get(filter.address).has(log.address) : true)) {
-                events.push({
-                  chainId: filter.chainId,
-                  sourceIndex: i,
-                  checkpoint: encodeCheckpoint({
-                    blockTimestamp: hexToNumber4(block.timestamp),
-                    chainId: BigInt(filter.chainId),
-                    blockNumber: hexToBigInt5(log.blockNumber),
-                    transactionIndex: hexToBigInt5(log.transactionIndex),
-                    eventType: EVENT_TYPES.logs,
-                    eventIndex: hexToBigInt5(log.logIndex)
-                  }),
-                  log: convertLog(log),
-                  block: convertBlock(block),
-                  transaction: transactionCache.has(log.transactionHash) ? convertTransaction(
-                    transactionCache.get(log.transactionHash)
-                  ) : void 0,
-                  transactionReceipt: transactionReceiptCache.has(log.transactionHash) && shouldGetTransactionReceipt(filter) ? convertTransactionReceipt(
-                    transactionReceiptCache.get(log.transactionHash)
-                  ) : void 0,
-                  trace: void 0
-                });
-              }
-            }
-            break;
-          }
-          case "trace": {
-            for (const trace of traces) {
-              const fromChildAddresses = isAddressFactory(filter.fromAddress) ? [
-                finalizedChildAddresses.get(filter.fromAddress),
-                unfinalizedChildAddresses.get(filter.fromAddress)
-              ] : void 0;
-              const toChildAddresses = isAddressFactory(filter.toAddress) ? [
-                finalizedChildAddresses.get(filter.toAddress),
-                unfinalizedChildAddresses.get(filter.toAddress)
-              ] : void 0;
-              if (isTraceFilterMatched({
-                filter,
-                block,
-                trace: trace.trace,
-                fromChildAddresses,
-                toChildAddresses
-              }) && (filter.callType === void 0 ? true : filter.callType === trace.trace.type) && (filter.includeReverted ? true : trace.trace.error === void 0)) {
-                const transaction = transactionCache.get(
-                  trace.transactionHash
-                );
-                const transactionReceipt = transactionReceiptCache.get(
-                  trace.transactionHash
-                );
-                events.push({
-                  chainId: filter.chainId,
-                  sourceIndex: i,
-                  checkpoint: encodeCheckpoint({
-                    blockTimestamp: hexToNumber4(block.timestamp),
-                    chainId: BigInt(filter.chainId),
-                    blockNumber: hexToBigInt5(block.number),
-                    transactionIndex: BigInt(transaction.transactionIndex),
-                    eventType: EVENT_TYPES.traces,
-                    eventIndex: BigInt(trace.trace.index)
-                  }),
-                  log: void 0,
-                  trace: convertTrace(trace),
-                  block: convertBlock(block),
-                  transaction: convertTransaction(transaction),
-                  transactionReceipt: shouldGetTransactionReceipt(filter) ? convertTransactionReceipt(transactionReceipt) : void 0
-                });
-              }
-            }
-            break;
-          }
-        }
-        break;
-      }
-      case "account": {
-        switch (filter.type) {
-          case "transaction": {
-            for (const transaction of transactions) {
-              const fromChildAddresses = isAddressFactory(filter.fromAddress) ? [
-                finalizedChildAddresses.get(filter.fromAddress),
-                unfinalizedChildAddresses.get(filter.fromAddress)
-              ] : void 0;
-              const toChildAddresses = isAddressFactory(filter.toAddress) ? [
-                finalizedChildAddresses.get(filter.toAddress),
-                unfinalizedChildAddresses.get(filter.toAddress)
-              ] : void 0;
-              if (isTransactionFilterMatched({
-                filter,
-                block,
-                transaction,
-                fromChildAddresses,
-                toChildAddresses
-              }) && (filter.includeReverted ? true : transactionReceiptCache.get(transaction.hash).status === "0x1")) {
-                events.push({
-                  chainId: filter.chainId,
-                  sourceIndex: i,
-                  checkpoint: encodeCheckpoint({
-                    blockTimestamp: hexToNumber4(block.timestamp),
-                    chainId: BigInt(filter.chainId),
-                    blockNumber: hexToBigInt5(block.number),
-                    transactionIndex: BigInt(transaction.transactionIndex),
-                    eventType: EVENT_TYPES.transactions,
-                    eventIndex: 0n
-                  }),
-                  log: void 0,
-                  trace: void 0,
-                  block: convertBlock(block),
-                  transaction: convertTransaction(transaction),
-                  transactionReceipt: convertTransactionReceipt(
-                    transactionReceiptCache.get(transaction.hash)
-                  )
-                });
-              }
-            }
-            break;
-          }
-          case "transfer": {
-            for (const trace of traces) {
-              const fromChildAddresses = isAddressFactory(filter.fromAddress) ? [
-                finalizedChildAddresses.get(filter.fromAddress),
-                unfinalizedChildAddresses.get(filter.fromAddress)
-              ] : void 0;
-              const toChildAddresses = isAddressFactory(filter.toAddress) ? [
-                finalizedChildAddresses.get(filter.toAddress),
-                unfinalizedChildAddresses.get(filter.toAddress)
-              ] : void 0;
-              if (isTransferFilterMatched({
-                filter,
-                block,
-                trace: trace.trace,
-                fromChildAddresses,
-                toChildAddresses
-              }) && (filter.includeReverted ? true : trace.trace.error === void 0)) {
-                const transaction = transactionCache.get(
-                  trace.transactionHash
-                );
-                const transactionReceipt = transactionReceiptCache.get(
-                  trace.transactionHash
-                );
-                events.push({
-                  chainId: filter.chainId,
-                  sourceIndex: i,
-                  checkpoint: encodeCheckpoint({
-                    blockTimestamp: hexToNumber4(block.timestamp),
-                    chainId: BigInt(filter.chainId),
-                    blockNumber: hexToBigInt5(block.number),
-                    transactionIndex: BigInt(transaction.transactionIndex),
-                    eventType: EVENT_TYPES.traces,
-                    eventIndex: BigInt(trace.trace.index)
-                  }),
-                  log: void 0,
-                  trace: convertTrace(trace),
-                  block: convertBlock(block),
-                  transaction: convertTransaction(transaction),
-                  transactionReceipt: shouldGetTransactionReceipt(filter) ? convertTransactionReceipt(transactionReceipt) : void 0
-                });
-              }
-            }
-            break;
-          }
-        }
-        break;
-      }
-      case "block": {
-        if (isBlockFilterMatched({ filter, block })) {
-          events.push({
-            chainId: filter.chainId,
-            sourceIndex: i,
-            checkpoint: encodeCheckpoint({
-              blockTimestamp: hexToNumber4(block.timestamp),
-              chainId: BigInt(filter.chainId),
-              blockNumber: hexToBigInt5(block.number),
-              transactionIndex: MAX_CHECKPOINT.transactionIndex,
-              eventType: EVENT_TYPES.blocks,
-              eventIndex: ZERO_CHECKPOINT.eventIndex
-            }),
-            block: convertBlock(block),
-            log: void 0,
-            trace: void 0,
-            transaction: void 0,
-            transactionReceipt: void 0
-          });
-        }
-        break;
-      }
-      default:
-        never(source);
-    }
-  }
-  return events.sort((a, b) => a.checkpoint < b.checkpoint ? -1 : 1);
-};
-var decodeEvents = (common, sources, rawEvents) => {
-  const events = [];
-  const endClock = startClock();
-  for (const event of rawEvents) {
-    const source = sources[event.sourceIndex];
-    switch (source.type) {
-      case "contract": {
-        switch (source.filter.type) {
-          case "log": {
-            try {
-              if (event.log.topics[0] === void 0 || source.abiEvents.bySelector[event.log.topics[0]] === void 0) {
-                throw new Error();
-              }
-              const { safeName, item } = source.abiEvents.bySelector[event.log.topics[0]];
-              const args = decodeEventLog({
-                abiItem: item,
-                data: event.log.data,
-                topics: event.log.topics
-              });
-              events.push({
-                type: "log",
-                chainId: event.chainId,
-                checkpoint: event.checkpoint,
-                name: `${source.name}:${safeName}`,
-                event: {
-                  name: safeName,
-                  args: removeNullCharacters(args),
-                  log: event.log,
-                  block: event.block,
-                  transaction: event.transaction,
-                  transactionReceipt: event.transactionReceipt
-                }
-              });
-            } catch (err) {
-              if (source.filter.address === void 0) {
-                common.logger.debug({
-                  service: "app",
-                  msg: `Unable to decode log, skipping it. id: ${event.log?.id}, data: ${event.log?.data}, topics: ${event.log?.topics}`
-                });
-              } else {
-                common.logger.warn({
-                  service: "app",
-                  msg: `Unable to decode log, skipping it. id: ${event.log?.id}, data: ${event.log?.data}, topics: ${event.log?.topics}`
-                });
-              }
-            }
-            break;
-          }
-          case "trace": {
-            try {
-              const selector = event.trace.input.slice(0, 10).toLowerCase();
-              if (source.abiFunctions.bySelector[selector] === void 0) {
-                throw new Error();
-              }
-              const { item, safeName } = source.abiFunctions.bySelector[selector];
-              const { args, functionName } = decodeFunctionData({
-                abi: [item],
-                data: event.trace.input
-              });
-              const result = decodeFunctionResult({
-                abi: [item],
-                data: event.trace.output,
-                functionName
-              });
-              events.push({
-                type: "trace",
-                chainId: event.chainId,
-                checkpoint: event.checkpoint,
-                // NOTE: `safename` includes ()
-                name: `${source.name}.${safeName}`,
-                event: {
-                  args: removeNullCharacters(args),
-                  result: removeNullCharacters(result),
-                  trace: event.trace,
-                  block: event.block,
-                  transaction: event.transaction,
-                  transactionReceipt: event.transactionReceipt
-                }
-              });
-            } catch (err) {
-              if (source.filter.toAddress === void 0) {
-                common.logger.debug({
-                  service: "app",
-                  msg: `Unable to decode trace, skipping it. id: ${event.trace?.id}, input: ${event.trace?.input}, output: ${event.trace?.output}`
-                });
-              } else {
-                common.logger.warn({
-                  service: "app",
-                  msg: `Unable to decode trace, skipping it. id: ${event.trace?.id}, input: ${event.trace?.input}, output: ${event.trace?.output}`
-                });
-              }
-            }
-            break;
-          }
-          default:
-            never(source.filter);
-        }
-        break;
-      }
-      case "account": {
-        switch (source.filter.type) {
-          case "transaction": {
-            const isFrom = source.filter.toAddress === void 0;
-            events.push({
-              type: "transaction",
-              chainId: event.chainId,
-              checkpoint: event.checkpoint,
-              name: `${source.name}:transaction:${isFrom ? "from" : "to"}`,
-              event: {
-                block: event.block,
-                transaction: event.transaction,
-                transactionReceipt: event.transactionReceipt
-              }
-            });
-            break;
-          }
-          case "transfer": {
-            const isFrom = source.filter.toAddress === void 0;
-            events.push({
-              type: "transfer",
-              chainId: event.chainId,
-              checkpoint: event.checkpoint,
-              name: `${source.name}:transfer:${isFrom ? "from" : "to"}`,
-              event: {
-                transfer: {
-                  from: event.trace.from,
-                  to: event.trace.to,
-                  value: event.trace.value
-                },
-                block: event.block,
-                transaction: event.transaction,
-                transactionReceipt: event.transactionReceipt,
-                trace: event.trace
-              }
-            });
-            break;
-          }
-        }
-        break;
-      }
-      case "block": {
-        events.push({
-          type: "block",
-          chainId: event.chainId,
-          checkpoint: event.checkpoint,
-          name: `${source.name}:block`,
-          event: {
-            block: event.block
-          }
-        });
-        break;
-      }
-      default:
-        never(source);
-    }
-  }
-  common.metrics.ponder_indexing_abi_decoding_duration.observe(endClock());
-  return events;
-};
-function decodeEventLog({
-  abiItem,
-  topics,
-  data
-}) {
-  const { inputs } = abiItem;
-  const isUnnamed = inputs?.some((x) => !("name" in x && x.name));
-  let args = isUnnamed ? [] : {};
-  const [, ...argTopics] = topics;
-  const indexedInputs = inputs.filter((x) => "indexed" in x && x.indexed);
-  for (let i = 0; i < indexedInputs.length; i++) {
-    const param = indexedInputs[i];
-    const topic = argTopics[i];
-    if (!topic)
-      throw new DecodeLogTopicsMismatch({
-        abiItem,
-        param
-      });
-    args[isUnnamed ? i : param.name || i] = decodeTopic({
-      param,
-      value: topic
-    });
-  }
-  const nonIndexedInputs = inputs.filter((x) => !("indexed" in x && x.indexed));
-  if (nonIndexedInputs.length > 0) {
-    if (data && data !== "0x") {
-      const decodedData = decodeAbiParameters(nonIndexedInputs, data);
-      if (decodedData) {
-        if (isUnnamed)
-          args = [...args, ...decodedData];
-        else {
-          for (let i = 0; i < nonIndexedInputs.length; i++) {
-            args[nonIndexedInputs[i].name] = decodedData[i];
-          }
-        }
-      }
-    } else {
-      throw new DecodeLogDataMismatch({
-        abiItem,
-        data: "0x",
-        params: nonIndexedInputs,
-        size: 0
-      });
-    }
-  }
-  return Object.values(args).length > 0 ? args : void 0;
-}
-function decodeTopic({ param, value }) {
-  if (param.type === "string" || param.type === "bytes" || param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
-    return value;
-  const decodedArg = decodeAbiParameters([param], value) || [];
-  return decodedArg[0];
-}
-function removeNullCharacters(obj) {
-  if (typeof obj === "string") {
-    return obj.replace(/\0/g, "");
-  }
-  if (Array.isArray(obj)) {
-    return obj.map(removeNullCharacters);
-  }
-  if (obj && typeof obj === "object") {
-    const newObj = {};
-    for (const [key, val] of Object.entries(obj)) {
-      newObj[key] = removeNullCharacters(val);
-    }
-    return newObj;
-  }
-  return obj;
-}
-var convertBlock = (block) => ({
-  baseFeePerGas: block.baseFeePerGas ? hexToBigInt5(block.baseFeePerGas) : null,
-  difficulty: hexToBigInt5(block.difficulty),
-  extraData: block.extraData,
-  gasLimit: hexToBigInt5(block.gasLimit),
-  gasUsed: hexToBigInt5(block.gasUsed),
-  hash: block.hash,
-  logsBloom: block.logsBloom,
-  miner: checksumAddress3(block.miner),
-  mixHash: block.mixHash,
-  nonce: block.nonce,
-  number: hexToBigInt5(block.number),
-  parentHash: block.parentHash,
-  receiptsRoot: block.receiptsRoot,
-  sha3Uncles: block.sha3Uncles,
-  size: hexToBigInt5(block.size),
-  stateRoot: block.stateRoot,
-  timestamp: hexToBigInt5(block.timestamp),
-  totalDifficulty: block.totalDifficulty ? hexToBigInt5(block.totalDifficulty) : null,
-  transactionsRoot: block.transactionsRoot
-});
-var convertLog = (log) => ({
-  id: `${log.blockHash}-${log.logIndex}`,
-  address: checksumAddress3(log.address),
-  data: log.data,
-  logIndex: Number(log.logIndex),
-  removed: false,
-  topics: log.topics
-});
-var convertTransaction = (transaction) => ({
-  from: checksumAddress3(transaction.from),
-  gas: hexToBigInt5(transaction.gas),
-  hash: transaction.hash,
-  input: transaction.input,
-  nonce: Number(transaction.nonce),
-  r: transaction.r,
-  s: transaction.s,
-  to: transaction.to ? checksumAddress3(transaction.to) : transaction.to,
-  transactionIndex: Number(transaction.transactionIndex),
-  value: hexToBigInt5(transaction.value),
-  v: transaction.v ? hexToBigInt5(transaction.v) : null,
-  ...transaction.type === "0x0" ? {
-    type: "legacy",
-    gasPrice: hexToBigInt5(transaction.gasPrice)
-  } : transaction.type === "0x1" ? {
-    type: "eip2930",
-    gasPrice: hexToBigInt5(transaction.gasPrice),
-    accessList: transaction.accessList
-  } : transaction.type === "0x2" ? {
-    type: "eip1559",
-    maxFeePerGas: hexToBigInt5(transaction.maxFeePerGas),
-    maxPriorityFeePerGas: hexToBigInt5(transaction.maxPriorityFeePerGas)
-  } : (
-    // @ts-ignore
-    transaction.type === "0x7e" ? {
-      type: "deposit",
-      // @ts-ignore
-      maxFeePerGas: transaction.maxFeePerGas ? (
-        // @ts-ignore
-        hexToBigInt5(transaction.maxFeePerGas)
-      ) : void 0,
-      // @ts-ignore
-      maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? (
-        // @ts-ignore
-        hexToBigInt5(transaction.maxPriorityFeePerGas)
-      ) : void 0
-    } : {
-      // @ts-ignore
-      type: transaction.type
-    }
-  )
-});
-var convertTransactionReceipt = (transactionReceipt) => ({
-  contractAddress: transactionReceipt.contractAddress ? checksumAddress3(transactionReceipt.contractAddress) : null,
-  cumulativeGasUsed: hexToBigInt5(transactionReceipt.cumulativeGasUsed),
-  effectiveGasPrice: hexToBigInt5(transactionReceipt.effectiveGasPrice),
-  from: checksumAddress3(transactionReceipt.from),
-  gasUsed: hexToBigInt5(transactionReceipt.gasUsed),
-  logsBloom: transactionReceipt.logsBloom,
-  status: transactionReceipt.status === "0x1" ? "success" : transactionReceipt.status === "0x0" ? "reverted" : transactionReceipt.status,
-  to: transactionReceipt.to ? checksumAddress3(transactionReceipt.to) : null,
-  type: transactionReceipt.type === "0x0" ? "legacy" : transactionReceipt.type === "0x1" ? "eip2930" : transactionReceipt.type === "0x2" ? "eip1559" : transactionReceipt.type === "0x7e" ? "deposit" : transactionReceipt.type
-});
-var convertTrace = (trace) => ({
-  id: `${trace.transactionHash}-${trace.trace.index}`,
-  type: trace.trace.type,
-  from: checksumAddress3(trace.trace.from),
-  to: trace.trace.to ? checksumAddress3(trace.trace.to) : null,
-  input: trace.trace.input,
-  output: trace.trace.output,
-  gas: hexToBigInt5(trace.trace.gas),
-  gasUsed: hexToBigInt5(trace.trace.gasUsed),
-  value: trace.trace.value ? hexToBigInt5(trace.trace.value) : null,
-  traceIndex: trace.trace.index,
-  subcalls: trace.trace.subcalls
-});
-
 // src/utils/range.ts
 var range = (start2, stop) => Array.from({ length: stop - start2 }, (_, i) => start2 + i);
 
@@ -9212,8 +8651,8 @@ var _debug_traceBlockByHash = (requestQueue, {
 // src/sync-historical/index.ts
 import { getLogsRetryHelper } from "@ponder/utils";
 import {
-  hexToBigInt as hexToBigInt6,
-  hexToNumber as hexToNumber5,
+  hexToBigInt as hexToBigInt5,
+  hexToNumber as hexToNumber4,
   toHex,
   zeroHash
 } from "viem";
@@ -9224,7 +8663,9 @@ var createHistoricalSync = async (args) => {
   const transactionsCache = /* @__PURE__ */ new Set();
   const blockReceiptsCache = /* @__PURE__ */ new Map();
   const transactionReceiptsCache = /* @__PURE__ */ new Map();
-  const getLogsRequestMetadata = /* @__PURE__ */ new Map();
+  let logsRequestMetadata = {
+    estimatedRange: 500
+  };
   let intervalsCache;
   if (args.network.disableCache) {
     intervalsCache = /* @__PURE__ */ new Map();
@@ -9242,11 +8683,10 @@ var createHistoricalSync = async (args) => {
     address,
     interval
   }) => {
-    const metadata = getLogsRequestMetadata.get(filter);
-    const intervals = metadata ? getChunks({
+    const intervals = getChunks({
       interval,
-      maxChunkSize: metadata.confirmedRange ?? metadata.estimatedRange
-    }) : [interval];
+      maxChunkSize: logsRequestMetadata.confirmedRange ?? logsRequestMetadata.estimatedRange
+    });
     const topics = "eventSelector" in filter ? [filter.eventSelector] : [
       filter.topic0 ?? null,
       filter.topic1 ?? null,
@@ -9300,15 +8740,15 @@ var createHistoricalSync = async (args) => {
             });
             if (getLogsErrorResponse.shouldRetry === false)
               throw error;
-            const range2 = hexToNumber5(getLogsErrorResponse.ranges[0].toBlock) - hexToNumber5(getLogsErrorResponse.ranges[0].fromBlock);
+            const range2 = hexToNumber4(getLogsErrorResponse.ranges[0].toBlock) - hexToNumber4(getLogsErrorResponse.ranges[0].fromBlock);
             args.common.logger.debug({
               service: "sync",
               msg: `Caught eth_getLogs error on '${args.network.name}', updating recommended range to ${range2}.`
             });
-            getLogsRequestMetadata.set(filter, {
+            logsRequestMetadata = {
               estimatedRange: range2,
               confirmedRange: getLogsErrorResponse.isSuggestedRange ? range2 : void 0
-            });
+            };
             return syncLogsDynamic({ address: address2, interval: interval2, filter });
           })
         )
@@ -9326,9 +8766,9 @@ var createHistoricalSync = async (args) => {
         logIds.add(id);
       }
     }
-    if (getLogsRequestMetadata.has(filter) && getLogsRequestMetadata.get(filter).confirmedRange === void 0) {
-      getLogsRequestMetadata.get(filter).estimatedRange = Math.round(
-        getLogsRequestMetadata.get(filter).estimatedRange * 1.05
+    if (logsRequestMetadata.confirmedRange === void 0) {
+      logsRequestMetadata.estimatedRange = Math.round(
+        logsRequestMetadata.estimatedRange * 1.05
       );
     }
     return logs;
@@ -9343,7 +8783,7 @@ var createHistoricalSync = async (args) => {
       });
       blockCache.set(number, _block);
       block = await _block;
-      if (hexToBigInt6(block.number) >= hexToBigInt6(latestBlock?.number ?? "0x0")) {
+      if (hexToBigInt5(block.number) >= hexToBigInt5(latestBlock?.number ?? "0x0")) {
         latestBlock = block;
       }
     }
@@ -9449,7 +8889,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(hexToNumber5(log.blockNumber)))
+      logs.map((log) => syncBlock(hexToNumber4(log.blockNumber)))
     );
     const requiredBlocks = new Set(blocks.map((b) => b.hash));
     for (let i = 0; i < logs.length; i++) {
@@ -9464,7 +8904,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 ${hexToNumber5(log.logIndex)}. This is expected for some networks like ZKsync.`
+            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.`
           });
         } else {
           throw new Error(
@@ -9491,7 +8931,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 ${hexToNumber5(log.logIndex)}. This is expected for some networks like ZKsync.`
+                  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.`
                 });
               } else {
                 blockTransactionHashes.add(log.transactionHash);
@@ -9691,6 +9131,9 @@ var createHistoricalSync = async (args) => {
             }
           } catch (_error) {
             const error = _error;
+            if (args.common.shutdown.isKilled) {
+              throw new ShutdownError();
+            }
             args.common.logger.error({
               service: "sync",
               msg: `Fatal error: Unable to sync '${args.network.name}' from ${interval[0]} to ${interval[1]}.`,
@@ -9757,10 +9200,10 @@ var createMutex = () => {
 };
 
 // src/sync-realtime/index.ts
-import { hexToNumber as hexToNumber7, zeroHash as zeroHash2 } from "viem";
+import { hexToNumber as hexToNumber6, zeroHash as zeroHash2 } from "viem";
 
 // src/sync-realtime/bloom.ts
-import { hexToBytes, hexToNumber as hexToNumber6, keccak256 } from "viem";
+import { hexToBytes, hexToNumber as hexToNumber5, keccak256 } from "viem";
 var zeroLogsBloom = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
 var BLOOM_SIZE_BYTES = 256;
 var isInBloom = (_bloom, input) => {
@@ -9777,7 +9220,7 @@ function isFilterInBloom({
   block,
   filter
 }) {
-  if (hexToNumber6(block.number) < (filter.fromBlock ?? 0) || hexToNumber6(block.number) > (filter.toBlock ?? Number.POSITIVE_INFINITY)) {
+  if (hexToNumber5(block.number) < (filter.fromBlock ?? 0) || hexToNumber5(block.number) > (filter.toBlock ?? Number.POSITIVE_INFINITY)) {
     return false;
   }
   const isTopicsInBloom = [
@@ -9903,7 +9346,7 @@ var createRealtimeSync = (args) => {
   }) => {
     args.common.logger.debug({
       service: "realtime",
-      msg: `Started syncing '${args.network.name}' block ${hexToNumber7(block.number)}`
+      msg: `Started syncing '${args.network.name}' block ${hexToNumber6(block.number)}`
     });
     for (const log of factoryLogs) {
       for (const filter of factories) {
@@ -10038,12 +9481,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 ${hexToNumber7(block.number)}`
+        msg: `Synced ${text} from '${args.network.name}' block ${hexToNumber6(block.number)}`
       });
     } else {
       args.common.logger.info({
         service: "realtime",
-        msg: `Synced block ${hexToNumber7(block.number)} from '${args.network.name}' `
+        msg: `Synced block ${hexToNumber6(block.number)} from '${args.network.name}' `
       });
     }
     unfinalizedBlocks.push(syncBlockToLightBlock(block));
@@ -10059,20 +9502,20 @@ var createRealtimeSync = (args) => {
       transactionReceipts,
       endClock
     });
-    const blockMovesFinality = hexToNumber7(block.number) >= hexToNumber7(finalizedBlock.number) + 2 * args.network.finalityBlockCount;
+    const blockMovesFinality = hexToNumber6(block.number) >= hexToNumber6(finalizedBlock.number) + 2 * args.network.finalityBlockCount;
     if (blockMovesFinality) {
       const pendingFinalizedBlock = unfinalizedBlocks.find(
-        (lb) => hexToNumber7(lb.number) === hexToNumber7(block.number) - args.network.finalityBlockCount
+        (lb) => hexToNumber6(lb.number) === hexToNumber6(block.number) - args.network.finalityBlockCount
       );
       args.common.logger.debug({
         service: "realtime",
-        msg: `Finalized ${hexToNumber7(pendingFinalizedBlock.number) - hexToNumber7(finalizedBlock.number) + 1} '${args.network.name}' blocks [${hexToNumber7(finalizedBlock.number) + 1}, ${hexToNumber7(pendingFinalizedBlock.number)}]`
+        msg: `Finalized ${hexToNumber6(pendingFinalizedBlock.number) - hexToNumber6(finalizedBlock.number) + 1} '${args.network.name}' blocks [${hexToNumber6(finalizedBlock.number) + 1}, ${hexToNumber6(pendingFinalizedBlock.number)}]`
       });
       const finalizedBlocks = unfinalizedBlocks.filter(
-        (lb) => hexToNumber7(lb.number) <= hexToNumber7(pendingFinalizedBlock.number)
+        (lb) => hexToNumber6(lb.number) <= hexToNumber6(pendingFinalizedBlock.number)
       );
       unfinalizedBlocks = unfinalizedBlocks.filter(
-        (lb) => hexToNumber7(lb.number) > hexToNumber7(pendingFinalizedBlock.number)
+        (lb) => hexToNumber6(lb.number) > hexToNumber6(pendingFinalizedBlock.number)
       );
       for (const filter of factories) {
         for (const { hash } of finalizedBlocks) {
@@ -10100,550 +9543,1113 @@ var createRealtimeSync = (args) => {
           }
         }
       }
-      for (const { hash } of finalizedBlocks) {
-        factoryLogsPerBlock.delete(hash);
+      for (const { hash } of finalizedBlocks) {
+        factoryLogsPerBlock.delete(hash);
+      }
+      finalizedBlock = pendingFinalizedBlock;
+      await args.onEvent({ type: "finalize", block: pendingFinalizedBlock });
+    }
+  };
+  const handleReorg = async (block) => {
+    args.common.logger.warn({
+      service: "realtime",
+      msg: `Detected forked '${args.network.name}' block at height ${hexToNumber6(block.number)}`
+    });
+    const reorgedBlocks = unfinalizedBlocks.filter(
+      (lb) => hexToNumber6(lb.number) >= hexToNumber6(block.number)
+    );
+    unfinalizedBlocks = unfinalizedBlocks.filter(
+      (lb) => hexToNumber6(lb.number) < hexToNumber6(block.number)
+    );
+    let remoteBlock = block;
+    while (true) {
+      const parentBlock = getLatestUnfinalizedBlock();
+      if (parentBlock.hash === remoteBlock.parentHash)
+        break;
+      if (unfinalizedBlocks.length === 0) {
+        const msg = `Encountered unrecoverable '${args.network.name}' reorg beyond finalized block ${hexToNumber6(finalizedBlock.number)}`;
+        args.common.logger.warn({ service: "realtime", msg });
+        throw new Error(msg);
+      } else {
+        remoteBlock = await _eth_getBlockByHash(args.requestQueue, {
+          hash: remoteBlock.parentHash
+        });
+        reorgedBlocks.push(unfinalizedBlocks.pop());
+      }
+    }
+    const commonAncestor = getLatestUnfinalizedBlock();
+    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)}`
+    });
+    unfinalizedChildAddresses.clear();
+    for (const filter of factories) {
+      unfinalizedChildAddresses.set(filter, /* @__PURE__ */ new Set());
+      for (const { hash } of unfinalizedBlocks) {
+        const factoryLogs = factoryLogsPerBlock.get(hash);
+        if (factoryLogs !== void 0) {
+          for (const log of factoryLogs) {
+            if (isLogFactoryMatched({ filter, log })) {
+              unfinalizedChildAddresses.get(filter).add(getChildAddress({ log, factory: filter }));
+            }
+          }
+        }
+      }
+    }
+    for (const { hash } of reorgedBlocks) {
+      factoryLogsPerBlock.delete(hash);
+    }
+  };
+  const syncTransactionReceipts = async (blockHash, transactionHashes) => {
+    if (transactionHashes.size === 0) {
+      return [];
+    }
+    if (isBlockReceipts === false) {
+      const transactionReceipts2 = await Promise.all(
+        Array.from(transactionHashes).map(
+          async (hash) => _eth_getTransactionReceipt(args.requestQueue, { hash })
+        )
+      );
+      return transactionReceipts2;
+    }
+    let blockReceipts;
+    try {
+      blockReceipts = await _eth_getBlockReceipts(args.requestQueue, {
+        blockHash
+      });
+    } catch (_error) {
+      const error = _error;
+      args.common.logger.warn({
+        service: "realtime",
+        msg: `Caught eth_getBlockReceipts error on '${args.network.name}', switching to eth_getTransactionReceipt method.`,
+        error
+      });
+      isBlockReceipts = false;
+      return syncTransactionReceipts(blockHash, transactionHashes);
+    }
+    const blockReceiptsTransactionHashes = new Set(
+      blockReceipts.map((r) => r.transactionHash)
+    );
+    for (const hash of Array.from(transactionHashes)) {
+      if (blockReceiptsTransactionHashes.has(hash) === false) {
+        throw new Error(
+          `Detected inconsistent RPC responses. 'transaction.hash' ${hash} not found in eth_getBlockReceipts response for block '${blockHash}'`
+        );
+      }
+    }
+    const transactionReceipts = blockReceipts.filter(
+      (receipt) => transactionHashes.has(receipt.transactionHash)
+    );
+    return transactionReceipts;
+  };
+  const fetchBlockEventData = async (block) => {
+    const shouldRequestLogs = block.logsBloom === zeroLogsBloom || logFilters.some((filter) => isFilterInBloom({ block, filter }));
+    let logs = [];
+    if (shouldRequestLogs) {
+      logs = await _eth_getLogs(args.requestQueue, { blockHash: block.hash });
+      if (block.logsBloom !== zeroLogsBloom && logs.length === 0) {
+        throw new Error(
+          "Detected invalid eth_getLogs response. `block.logsBloom` is not empty but zero logs were returned."
+        );
+      }
+      const logIds = /* @__PURE__ */ new Set();
+      for (const log of logs) {
+        if (log.blockHash !== block.hash) {
+          throw new Error(
+            `Detected invalid eth_getLogs response. 'log.blockHash' ${log.blockHash} does not match requested block hash ${block.hash}`
+          );
+        }
+        const id = `${log.blockHash}-${log.logIndex}`;
+        if (logIds.has(id)) {
+          args.common.logger.warn({
+            service: "sync",
+            msg: `Detected invalid eth_getLogs response. Duplicate log index ${log.logIndex} for block ${log.blockHash}.`
+          });
+        } else {
+          logIds.add(id);
+        }
+        if (block.transactions.find((t) => t.hash === log.transactionHash) === void 0) {
+          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.`
+            });
+          } else {
+            throw new Error(
+              `Detected inconsistent '${args.network.name}' RPC responses. 'log.transactionHash' ${log.transactionHash} not found in 'block.transactions' ${block.hash}`
+            );
+          }
+        }
+      }
+    }
+    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`
+      });
+    }
+    const shouldRequestTraces = traceFilters.length > 0 || transferFilters.length > 0;
+    let traces = [];
+    if (shouldRequestTraces) {
+      traces = await _debug_traceBlockByHash(args.requestQueue, {
+        hash: block.hash
+      });
+      if (block.transactions.length !== 0 && traces.length === 0) {
+        throw new Error(
+          "Detected invalid debug_traceBlock response. `block.transactions` is not empty but zero traces were returned."
+        );
+      }
+    }
+    for (const trace of traces) {
+      if (block.transactions.find((t) => t.hash === trace.transactionHash) === void 0) {
+        throw new Error(
+          `Detected inconsistent RPC responses. 'trace.txHash' ${trace.transactionHash} not found in 'block' ${block.hash}`
+        );
+      }
+    }
+    const factoryLogs = logs.filter((log) => {
+      let isMatched = false;
+      for (const filter of factories) {
+        if (isLogFactoryMatched({ filter, log })) {
+          if (factoryLogsPerBlock.has(block.hash) === false) {
+            factoryLogsPerBlock.set(block.hash, []);
+          }
+          factoryLogsPerBlock.get(block.hash).push(log);
+          isMatched = true;
+        }
+      }
+      return isMatched;
+    });
+    const requiredTransactions = /* @__PURE__ */ new Set();
+    const requiredTransactionReceipts = /* @__PURE__ */ new Set();
+    logs = logs.filter((log) => {
+      let isMatched = false;
+      for (const filter of logFilters) {
+        if (isLogFilterMatched({ filter, block, log })) {
+          isMatched = true;
+          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.`
+            });
+          } else {
+            requiredTransactions.add(log.transactionHash);
+            if (shouldGetTransactionReceipt(filter)) {
+              requiredTransactionReceipts.add(log.transactionHash);
+              break;
+            }
+          }
+        }
+      }
+      return isMatched;
+    });
+    traces = traces.filter((trace) => {
+      let isMatched = false;
+      for (const filter of transferFilters) {
+        if (isTransferFilterMatched({
+          filter,
+          block: { number: block.number },
+          trace: trace.trace
+        })) {
+          requiredTransactions.add(trace.transactionHash);
+          isMatched = true;
+          if (shouldGetTransactionReceipt(filter)) {
+            requiredTransactionReceipts.add(trace.transactionHash);
+            break;
+          }
+        }
+      }
+      for (const filter of traceFilters) {
+        if (isTraceFilterMatched({
+          filter,
+          block: { number: block.number },
+          trace: trace.trace
+        })) {
+          requiredTransactions.add(trace.transactionHash);
+          isMatched = true;
+          if (shouldGetTransactionReceipt(filter)) {
+            requiredTransactionReceipts.add(trace.transactionHash);
+            break;
+          }
+        }
+      }
+      return isMatched;
+    });
+    const transactions = block.transactions.filter((transaction) => {
+      let isMatched = requiredTransactions.has(transaction.hash);
+      for (const filter of transactionFilters) {
+        if (isTransactionFilterMatched({ filter, block, transaction })) {
+          requiredTransactions.add(transaction.hash);
+          requiredTransactionReceipts.add(transaction.hash);
+          isMatched = true;
+        }
       }
-      finalizedBlock = pendingFinalizedBlock;
-      await args.onEvent({ type: "finalize", block: pendingFinalizedBlock });
-    }
-  };
-  const handleReorg = async (block) => {
-    args.common.logger.warn({
-      service: "realtime",
-      msg: `Detected forked '${args.network.name}' block at height ${hexToNumber7(block.number)}`
+      return isMatched;
     });
-    const reorgedBlocks = unfinalizedBlocks.filter(
-      (lb) => hexToNumber7(lb.number) >= hexToNumber7(block.number)
-    );
-    unfinalizedBlocks = unfinalizedBlocks.filter(
-      (lb) => hexToNumber7(lb.number) < hexToNumber7(block.number)
+    const blockTransactionsHashes = new Set(
+      block.transactions.map((t) => t.hash)
     );
-    let remoteBlock = block;
-    while (true) {
-      const parentBlock = getLatestUnfinalizedBlock();
-      if (parentBlock.hash === remoteBlock.parentHash)
-        break;
-      if (unfinalizedBlocks.length === 0) {
-        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 {
-        remoteBlock = await _eth_getBlockByHash(args.requestQueue, {
-          hash: remoteBlock.parentHash
-        });
-        reorgedBlocks.push(unfinalizedBlocks.pop());
+    for (const hash of Array.from(requiredTransactions)) {
+      if (blockTransactionsHashes.has(hash) === false) {
+        throw new Error(
+          `Detected inconsistent RPC responses. 'transaction.hash' ${hash} not found in eth_getBlockReceipts response for block '${block.hash}'.`
+        );
       }
     }
-    const commonAncestor = getLatestUnfinalizedBlock();
-    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 ${hexToNumber7(commonAncestor.number)}`
-    });
-    unfinalizedChildAddresses.clear();
-    for (const filter of factories) {
-      unfinalizedChildAddresses.set(filter, /* @__PURE__ */ new Set());
-      for (const { hash } of unfinalizedBlocks) {
-        const factoryLogs = factoryLogsPerBlock.get(hash);
-        if (factoryLogs !== void 0) {
-          for (const log of factoryLogs) {
-            if (isLogFactoryMatched({ filter, log })) {
-              unfinalizedChildAddresses.get(filter).add(getChildAddress({ log, factory: filter }));
+    const transactionReceipts = await syncTransactionReceipts(
+      block.hash,
+      requiredTransactionReceipts
+    );
+    return {
+      block,
+      logs,
+      factoryLogs,
+      traces,
+      transactions,
+      transactionReceipts
+    };
+  };
+  const getLatestUnfinalizedBlock = () => {
+    if (unfinalizedBlocks.length === 0) {
+      return finalizedBlock;
+    } else
+      return unfinalizedBlocks[unfinalizedBlocks.length - 1];
+  };
+  return {
+    start(startArgs) {
+      finalizedBlock = startArgs.syncProgress.finalized;
+      finalizedChildAddresses = startArgs.initialChildAddresses;
+      const processBlock = mutex(
+        async ({
+          block,
+          ...rest
+        }) => {
+          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`
+            });
+            return;
+          }
+          try {
+            if (hexToNumber6(latestBlock.number) >= hexToNumber6(block.number)) {
+              await handleReorg(block);
+              processBlock.clear();
+              return;
+            }
+            if (hexToNumber6(latestBlock.number) + 1 < hexToNumber6(block.number)) {
+              const missingBlockRange = range(
+                hexToNumber6(latestBlock.number) + 1,
+                Math.min(
+                  hexToNumber6(block.number),
+                  hexToNumber6(latestBlock.number) + MAX_QUEUED_BLOCKS
+                )
+              );
+              const pendingBlocks = await Promise.all(
+                missingBlockRange.map(
+                  (blockNumber) => _eth_getBlockByNumber(args.requestQueue, {
+                    blockNumber
+                  }).then((block2) => fetchBlockEventData(block2))
+                )
+              );
+              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
+                )}]`
+              });
+              processBlock.clear();
+              for (const pendingBlock of pendingBlocks) {
+                processBlock(pendingBlock);
+              }
+              processBlock({ block, ...rest });
+              return;
+            }
+            if (block.parentHash !== latestBlock.hash) {
+              await handleReorg(block);
+              processBlock.clear();
+              return;
+            }
+            await handleBlock({ block, ...rest });
+            consecutiveErrors = 0;
+            return;
+          } catch (_error) {
+            const error = _error;
+            if (args.common.shutdown.isKilled) {
+              throw new ShutdownError();
+            }
+            args.common.logger.warn({
+              service: "realtime",
+              msg: `Failed to process '${args.network.name}' block ${hexToNumber6(block.number)}`,
+              error
+            });
+            const duration = ERROR_TIMEOUT[consecutiveErrors];
+            args.common.logger.warn({
+              service: "realtime",
+              msg: `Retrying '${args.network.name}' sync after ${duration} ${duration === 1 ? "second" : "seconds"}.`
+            });
+            await wait(duration * 1e3);
+            processBlock.clear();
+            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.`,
+                error
+              });
+              args.onFatalError(error);
             }
           }
         }
-      }
-    }
-    for (const { hash } of reorgedBlocks) {
-      factoryLogsPerBlock.delete(hash);
+      );
+      const enqueue = async () => {
+        try {
+          const block = await _eth_getBlockByNumber(args.requestQueue, {
+            blockTag: "latest"
+          });
+          args.common.logger.debug({
+            service: "realtime",
+            msg: `Received latest '${args.network.name}' block ${hexToNumber6(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`
+            });
+            return;
+          }
+          const endClock = startClock();
+          const blockWithEventData = await fetchBlockEventData(block);
+          consecutiveErrors = 0;
+          return processBlock({ ...blockWithEventData, endClock });
+        } catch (_error) {
+          const error = _error;
+          if (args.common.shutdown.isKilled) {
+            throw new ShutdownError();
+          }
+          args.common.logger.warn({
+            service: "realtime",
+            msg: `Failed to fetch latest '${args.network.name}' block`,
+            error
+          });
+          if (++consecutiveErrors === ERROR_TIMEOUT.length) {
+            args.common.logger.error({
+              service: "realtime",
+              msg: `Fatal error: Unable to fetch latest '${args.network.name}' block after ${ERROR_TIMEOUT.length} attempts.`,
+              error
+            });
+            args.onFatalError(error);
+          }
+        }
+      };
+      interval = setInterval(enqueue, args.network.pollingInterval);
+      args.common.shutdown.add(() => {
+        clearInterval(interval);
+      });
+      return enqueue().then(() => processBlock);
+    },
+    get unfinalizedBlocks() {
+      return unfinalizedBlocks;
+    },
+    get finalizedChildAddresses() {
+      return finalizedChildAddresses;
+    },
+    get unfinalizedChildAddresses() {
+      return unfinalizedChildAddresses;
+    },
+    async kill() {
+      clearInterval(interval);
     }
   };
-  const syncTransactionReceipts = async (blockHash, transactionHashes) => {
-    if (transactionHashes.size === 0) {
-      return [];
+};
+
+// src/utils/estimate.ts
+var estimate = ({
+  from,
+  to,
+  target,
+  result,
+  min: min2,
+  max,
+  prev,
+  maxIncrease
+}) => {
+  const density = (to - from) / (result || 1);
+  return Math.min(
+    Math.max(min2, Math.round(target * density)),
+    Math.round(prev * maxIncrease),
+    max
+  );
+};
+
+// src/utils/generators.ts
+async function* mergeAsyncGenerators(generators) {
+  const results = [];
+  let count = generators.length;
+  let pwr = promiseWithResolvers();
+  generators.map(async (generator) => {
+    for await (const result of generator) {
+      results.push(result);
+      pwr.resolve();
+    }
+    count--;
+    pwr.resolve();
+  });
+  while (count > 0 || results.length > 0) {
+    if (results.length > 0) {
+      yield results.shift();
+    } else {
+      await pwr.promise;
+      pwr = promiseWithResolvers();
     }
-    if (isBlockReceipts === false) {
-      const transactionReceipts2 = await Promise.all(
-        Array.from(transactionHashes).map(
-          async (hash) => _eth_getTransactionReceipt(args.requestQueue, { hash })
-        )
-      );
-      return transactionReceipts2;
+  }
+}
+async function* bufferAsyncGenerator(generator, size) {
+  const buffer = [];
+  let done = false;
+  let pwr1 = promiseWithResolvers();
+  let pwr2 = promiseWithResolvers();
+  (async () => {
+    for await (const result of generator) {
+      buffer.push(result);
+      pwr1.resolve();
+      if (buffer.length > size)
+        await pwr2.promise;
+      pwr2 = promiseWithResolvers();
     }
-    let blockReceipts;
-    try {
-      blockReceipts = await _eth_getBlockReceipts(args.requestQueue, {
-        blockHash
-      });
-    } catch (_error) {
-      const error = _error;
-      args.common.logger.warn({
-        service: "realtime",
-        msg: `Caught eth_getBlockReceipts error on '${args.network.name}', switching to eth_getTransactionReceipt method.`,
-        error
-      });
-      isBlockReceipts = false;
-      return syncTransactionReceipts(blockHash, transactionHashes);
+    done = true;
+    pwr1.resolve();
+  })();
+  while (done === false || buffer.length > 0) {
+    if (buffer.length > 0) {
+      pwr2.resolve();
+      yield buffer.shift();
+    } else {
+      await pwr1.promise;
+      pwr1 = promiseWithResolvers();
     }
-    const blockReceiptsTransactionHashes = new Set(
-      blockReceipts.map((r) => r.transactionHash)
-    );
-    for (const hash of Array.from(transactionHashes)) {
-      if (blockReceiptsTransactionHashes.has(hash) === false) {
-        throw new Error(
-          `Detected inconsistent RPC responses. 'transaction.hash' ${hash} not found in eth_getBlockReceipts response for block '${blockHash}'`
-        );
-      }
+  }
+}
+
+// src/utils/partition.ts
+var partition = (array, predicate) => {
+  let low = 0;
+  let high = array.length;
+  while (low < high) {
+    const mid = Math.floor((low + high) / 2);
+    if (predicate(array[mid])) {
+      low = mid + 1;
+    } else {
+      high = mid;
     }
-    const transactionReceipts = blockReceipts.filter(
-      (receipt) => transactionHashes.has(receipt.transactionHash)
+  }
+  const left = array.slice(0, low);
+  const right = array.slice(low);
+  return [left, right];
+};
+
+// src/utils/zipper.ts
+var zipper = (array1, array2, compare) => {
+  const result = [];
+  let i = 0;
+  let j = 0;
+  while (i < array1.length && j < array2.length) {
+    if (compare ? compare(array1[i], array2[j]) < 0 : array1[i] < array2[j]) {
+      result.push(array1[i]);
+      i++;
+    } else {
+      result.push(array2[j]);
+      j++;
+    }
+  }
+  if (i < array1.length) {
+    result.push(...array1.slice(i));
+  }
+  if (j < array2.length) {
+    result.push(...array2.slice(j));
+  }
+  return result;
+};
+var zipperMany = (arrays, compare) => {
+  if (arrays.length === 0)
+    return [];
+  if (arrays.length === 1)
+    return arrays[0];
+  let result = arrays[0];
+  for (let i = 1; i < arrays.length; i++) {
+    result = zipper(result, arrays[i], compare);
+  }
+  return result;
+};
+
+// src/sync/index.ts
+import { hexToBigInt as hexToBigInt7, hexToNumber as hexToNumber8, toHex as toHex2 } from "viem";
+
+// src/sync/events.ts
+import {
+  DecodeLogDataMismatch,
+  DecodeLogTopicsMismatch,
+  checksumAddress as checksumAddress3,
+  decodeAbiParameters,
+  decodeFunctionData,
+  decodeFunctionResult,
+  hexToBigInt as hexToBigInt6,
+  hexToNumber as hexToNumber7
+} from "viem";
+var buildEvents = ({
+  sources,
+  blockWithEventData: {
+    block,
+    logs,
+    transactions,
+    transactionReceipts,
+    traces
+  },
+  finalizedChildAddresses,
+  unfinalizedChildAddresses,
+  chainId
+}) => {
+  const events = [];
+  const transactionCache = /* @__PURE__ */ new Map();
+  const transactionReceiptCache = /* @__PURE__ */ new Map();
+  for (const transaction of transactions) {
+    transactionCache.set(transaction.hash, transaction);
+  }
+  for (const transactionReceipt of transactionReceipts) {
+    transactionReceiptCache.set(
+      transactionReceipt.transactionHash,
+      transactionReceipt
     );
-    return transactionReceipts;
-  };
-  const fetchBlockEventData = async (block) => {
-    const shouldRequestLogs = block.logsBloom === zeroLogsBloom || logFilters.some((filter) => isFilterInBloom({ block, filter }));
-    let logs = [];
-    if (shouldRequestLogs) {
-      logs = await _eth_getLogs(args.requestQueue, { blockHash: block.hash });
-      if (block.logsBloom !== zeroLogsBloom && logs.length === 0) {
-        throw new Error(
-          "Detected invalid eth_getLogs response. `block.logsBloom` is not empty but zero logs were returned."
-        );
-      }
-      const logIds = /* @__PURE__ */ new Set();
-      for (const log of logs) {
-        if (log.blockHash !== block.hash) {
-          throw new Error(
-            `Detected invalid eth_getLogs response. 'log.blockHash' ${log.blockHash} does not match requested block hash ${block.hash}`
-          );
-        }
-        const id = `${log.blockHash}-${log.logIndex}`;
-        if (logIds.has(id)) {
-          args.common.logger.warn({
-            service: "sync",
-            msg: `Detected invalid eth_getLogs response. Duplicate log index ${log.logIndex} for block ${log.blockHash}.`
-          });
-        } else {
-          logIds.add(id);
-        }
-        if (block.transactions.find((t) => t.hash === log.transactionHash) === void 0) {
-          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 ${hexToNumber7(log.logIndex)}. This is expected for some networks like ZKsync.`
-            });
-          } else {
-            throw new Error(
-              `Detected inconsistent '${args.network.name}' RPC responses. 'log.transactionHash' ${log.transactionHash} not found in 'block.transactions' ${block.hash}`
-            );
+  }
+  for (let i = 0; i < sources.length; i++) {
+    const source = sources[i];
+    const filter = source.filter;
+    if (chainId !== filter.chainId)
+      continue;
+    switch (source.type) {
+      case "contract": {
+        switch (filter.type) {
+          case "log": {
+            for (const log of logs) {
+              if (isLogFilterMatched({ filter, block, log }) && (isAddressFactory(filter.address) ? finalizedChildAddresses.get(filter.address).has(log.address) || unfinalizedChildAddresses.get(filter.address).has(log.address) : true)) {
+                events.push({
+                  chainId: filter.chainId,
+                  sourceIndex: i,
+                  checkpoint: encodeCheckpoint({
+                    blockTimestamp: hexToNumber7(block.timestamp),
+                    chainId: BigInt(filter.chainId),
+                    blockNumber: hexToBigInt6(log.blockNumber),
+                    transactionIndex: hexToBigInt6(log.transactionIndex),
+                    eventType: EVENT_TYPES.logs,
+                    eventIndex: hexToBigInt6(log.logIndex)
+                  }),
+                  log: convertLog(log),
+                  block: convertBlock(block),
+                  transaction: transactionCache.has(log.transactionHash) ? convertTransaction(
+                    transactionCache.get(log.transactionHash)
+                  ) : void 0,
+                  transactionReceipt: transactionReceiptCache.has(log.transactionHash) && shouldGetTransactionReceipt(filter) ? convertTransactionReceipt(
+                    transactionReceiptCache.get(log.transactionHash)
+                  ) : void 0,
+                  trace: void 0
+                });
+              }
+            }
+            break;
+          }
+          case "trace": {
+            for (const trace of traces) {
+              const fromChildAddresses = isAddressFactory(filter.fromAddress) ? [
+                finalizedChildAddresses.get(filter.fromAddress),
+                unfinalizedChildAddresses.get(filter.fromAddress)
+              ] : void 0;
+              const toChildAddresses = isAddressFactory(filter.toAddress) ? [
+                finalizedChildAddresses.get(filter.toAddress),
+                unfinalizedChildAddresses.get(filter.toAddress)
+              ] : void 0;
+              if (isTraceFilterMatched({
+                filter,
+                block,
+                trace: trace.trace,
+                fromChildAddresses,
+                toChildAddresses
+              }) && (filter.callType === void 0 ? true : filter.callType === trace.trace.type) && (filter.includeReverted ? true : trace.trace.error === void 0)) {
+                const transaction = transactionCache.get(
+                  trace.transactionHash
+                );
+                const transactionReceipt = transactionReceiptCache.get(
+                  trace.transactionHash
+                );
+                events.push({
+                  chainId: filter.chainId,
+                  sourceIndex: i,
+                  checkpoint: encodeCheckpoint({
+                    blockTimestamp: hexToNumber7(block.timestamp),
+                    chainId: BigInt(filter.chainId),
+                    blockNumber: hexToBigInt6(block.number),
+                    transactionIndex: BigInt(transaction.transactionIndex),
+                    eventType: EVENT_TYPES.traces,
+                    eventIndex: BigInt(trace.trace.index)
+                  }),
+                  log: void 0,
+                  trace: convertTrace(trace),
+                  block: convertBlock(block),
+                  transaction: convertTransaction(transaction),
+                  transactionReceipt: shouldGetTransactionReceipt(filter) ? convertTransactionReceipt(transactionReceipt) : void 0
+                });
+              }
+            }
+            break;
           }
         }
+        break;
       }
-    }
-    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 ${hexToNumber7(block.number)} due to bloom filter result`
-      });
-    }
-    const shouldRequestTraces = traceFilters.length > 0 || transferFilters.length > 0;
-    let traces = [];
-    if (shouldRequestTraces) {
-      traces = await _debug_traceBlockByHash(args.requestQueue, {
-        hash: block.hash
-      });
-      if (block.transactions.length !== 0 && traces.length === 0) {
-        throw new Error(
-          "Detected invalid debug_traceBlock response. `block.transactions` is not empty but zero traces were returned."
-        );
-      }
-    }
-    for (const trace of traces) {
-      if (block.transactions.find((t) => t.hash === trace.transactionHash) === void 0) {
-        throw new Error(
-          `Detected inconsistent RPC responses. 'trace.txHash' ${trace.transactionHash} not found in 'block' ${block.hash}`
-        );
-      }
-    }
-    const factoryLogs = logs.filter((log) => {
-      let isMatched = false;
-      for (const filter of factories) {
-        if (isLogFactoryMatched({ filter, log })) {
-          if (factoryLogsPerBlock.has(block.hash) === false) {
-            factoryLogsPerBlock.set(block.hash, []);
+      case "account": {
+        switch (filter.type) {
+          case "transaction": {
+            for (const transaction of transactions) {
+              const fromChildAddresses = isAddressFactory(filter.fromAddress) ? [
+                finalizedChildAddresses.get(filter.fromAddress),
+                unfinalizedChildAddresses.get(filter.fromAddress)
+              ] : void 0;
+              const toChildAddresses = isAddressFactory(filter.toAddress) ? [
+                finalizedChildAddresses.get(filter.toAddress),
+                unfinalizedChildAddresses.get(filter.toAddress)
+              ] : void 0;
+              if (isTransactionFilterMatched({
+                filter,
+                block,
+                transaction,
+                fromChildAddresses,
+                toChildAddresses
+              }) && (filter.includeReverted ? true : transactionReceiptCache.get(transaction.hash).status === "0x1")) {
+                events.push({
+                  chainId: filter.chainId,
+                  sourceIndex: i,
+                  checkpoint: encodeCheckpoint({
+                    blockTimestamp: hexToNumber7(block.timestamp),
+                    chainId: BigInt(filter.chainId),
+                    blockNumber: hexToBigInt6(block.number),
+                    transactionIndex: BigInt(transaction.transactionIndex),
+                    eventType: EVENT_TYPES.transactions,
+                    eventIndex: 0n
+                  }),
+                  log: void 0,
+                  trace: void 0,
+                  block: convertBlock(block),
+                  transaction: convertTransaction(transaction),
+                  transactionReceipt: convertTransactionReceipt(
+                    transactionReceiptCache.get(transaction.hash)
+                  )
+                });
+              }
+            }
+            break;
           }
-          factoryLogsPerBlock.get(block.hash).push(log);
-          isMatched = true;
-        }
-      }
-      return isMatched;
-    });
-    const requiredTransactions = /* @__PURE__ */ new Set();
-    const requiredTransactionReceipts = /* @__PURE__ */ new Set();
-    logs = logs.filter((log) => {
-      let isMatched = false;
-      for (const filter of logFilters) {
-        if (isLogFilterMatched({ filter, block, log })) {
-          isMatched = true;
-          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 ${hexToNumber7(log.logIndex)}. This is expected for some networks like ZKsync.`
-            });
-          } else {
-            requiredTransactions.add(log.transactionHash);
-            if (shouldGetTransactionReceipt(filter)) {
-              requiredTransactionReceipts.add(log.transactionHash);
-              break;
+          case "transfer": {
+            for (const trace of traces) {
+              const fromChildAddresses = isAddressFactory(filter.fromAddress) ? [
+                finalizedChildAddresses.get(filter.fromAddress),
+                unfinalizedChildAddresses.get(filter.fromAddress)
+              ] : void 0;
+              const toChildAddresses = isAddressFactory(filter.toAddress) ? [
+                finalizedChildAddresses.get(filter.toAddress),
+                unfinalizedChildAddresses.get(filter.toAddress)
+              ] : void 0;
+              if (isTransferFilterMatched({
+                filter,
+                block,
+                trace: trace.trace,
+                fromChildAddresses,
+                toChildAddresses
+              }) && (filter.includeReverted ? true : trace.trace.error === void 0)) {
+                const transaction = transactionCache.get(
+                  trace.transactionHash
+                );
+                const transactionReceipt = transactionReceiptCache.get(
+                  trace.transactionHash
+                );
+                events.push({
+                  chainId: filter.chainId,
+                  sourceIndex: i,
+                  checkpoint: encodeCheckpoint({
+                    blockTimestamp: hexToNumber7(block.timestamp),
+                    chainId: BigInt(filter.chainId),
+                    blockNumber: hexToBigInt6(block.number),
+                    transactionIndex: BigInt(transaction.transactionIndex),
+                    eventType: EVENT_TYPES.traces,
+                    eventIndex: BigInt(trace.trace.index)
+                  }),
+                  log: void 0,
+                  trace: convertTrace(trace),
+                  block: convertBlock(block),
+                  transaction: convertTransaction(transaction),
+                  transactionReceipt: shouldGetTransactionReceipt(filter) ? convertTransactionReceipt(transactionReceipt) : void 0
+                });
+              }
             }
+            break;
           }
         }
+        break;
       }
-      return isMatched;
-    });
-    traces = traces.filter((trace) => {
-      let isMatched = false;
-      for (const filter of transferFilters) {
-        if (isTransferFilterMatched({
-          filter,
-          block: { number: block.number },
-          trace: trace.trace
-        })) {
-          requiredTransactions.add(trace.transactionHash);
-          isMatched = true;
-          if (shouldGetTransactionReceipt(filter)) {
-            requiredTransactionReceipts.add(trace.transactionHash);
-            break;
-          }
+      case "block": {
+        if (isBlockFilterMatched({ filter, block })) {
+          events.push({
+            chainId: filter.chainId,
+            sourceIndex: i,
+            checkpoint: encodeCheckpoint({
+              blockTimestamp: hexToNumber7(block.timestamp),
+              chainId: BigInt(filter.chainId),
+              blockNumber: hexToBigInt6(block.number),
+              transactionIndex: MAX_CHECKPOINT.transactionIndex,
+              eventType: EVENT_TYPES.blocks,
+              eventIndex: ZERO_CHECKPOINT.eventIndex
+            }),
+            block: convertBlock(block),
+            log: void 0,
+            trace: void 0,
+            transaction: void 0,
+            transactionReceipt: void 0
+          });
         }
+        break;
       }
-      for (const filter of traceFilters) {
-        if (isTraceFilterMatched({
-          filter,
-          block: { number: block.number },
-          trace: trace.trace
-        })) {
-          requiredTransactions.add(trace.transactionHash);
-          isMatched = true;
-          if (shouldGetTransactionReceipt(filter)) {
-            requiredTransactionReceipts.add(trace.transactionHash);
+      default:
+        never(source);
+    }
+  }
+  return events.sort((a, b) => a.checkpoint < b.checkpoint ? -1 : 1);
+};
+var decodeEvents = (common, sources, rawEvents) => {
+  const events = [];
+  const endClock = startClock();
+  for (const event of rawEvents) {
+    const source = sources[event.sourceIndex];
+    switch (source.type) {
+      case "contract": {
+        switch (source.filter.type) {
+          case "log": {
+            try {
+              if (event.log.topics[0] === void 0 || source.abiEvents.bySelector[event.log.topics[0]] === void 0) {
+                throw new Error();
+              }
+              const { safeName, item } = source.abiEvents.bySelector[event.log.topics[0]];
+              const args = decodeEventLog({
+                abiItem: item,
+                data: event.log.data,
+                topics: event.log.topics
+              });
+              events.push({
+                type: "log",
+                chainId: event.chainId,
+                checkpoint: event.checkpoint,
+                name: `${source.name}:${safeName}`,
+                event: {
+                  name: safeName,
+                  args: removeNullCharacters(args),
+                  log: event.log,
+                  block: event.block,
+                  transaction: event.transaction,
+                  transactionReceipt: event.transactionReceipt
+                }
+              });
+            } catch (err) {
+              if (source.filter.address === void 0) {
+                common.logger.debug({
+                  service: "app",
+                  msg: `Unable to decode log, skipping it. id: ${event.log?.id}, data: ${event.log?.data}, topics: ${event.log?.topics}`
+                });
+              } else {
+                common.logger.warn({
+                  service: "app",
+                  msg: `Unable to decode log, skipping it. id: ${event.log?.id}, data: ${event.log?.data}, topics: ${event.log?.topics}`
+                });
+              }
+            }
+            break;
+          }
+          case "trace": {
+            try {
+              const selector = event.trace.input.slice(0, 10).toLowerCase();
+              if (source.abiFunctions.bySelector[selector] === void 0) {
+                throw new Error();
+              }
+              const { item, safeName } = source.abiFunctions.bySelector[selector];
+              const { args, functionName } = decodeFunctionData({
+                abi: [item],
+                data: event.trace.input
+              });
+              const result = decodeFunctionResult({
+                abi: [item],
+                data: event.trace.output,
+                functionName
+              });
+              events.push({
+                type: "trace",
+                chainId: event.chainId,
+                checkpoint: event.checkpoint,
+                // NOTE: `safename` includes ()
+                name: `${source.name}.${safeName}`,
+                event: {
+                  args: removeNullCharacters(args),
+                  result: removeNullCharacters(result),
+                  trace: event.trace,
+                  block: event.block,
+                  transaction: event.transaction,
+                  transactionReceipt: event.transactionReceipt
+                }
+              });
+            } catch (err) {
+              if (source.filter.toAddress === void 0) {
+                common.logger.debug({
+                  service: "app",
+                  msg: `Unable to decode trace, skipping it. id: ${event.trace?.id}, input: ${event.trace?.input}, output: ${event.trace?.output}`
+                });
+              } else {
+                common.logger.warn({
+                  service: "app",
+                  msg: `Unable to decode trace, skipping it. id: ${event.trace?.id}, input: ${event.trace?.input}, output: ${event.trace?.output}`
+                });
+              }
+            }
             break;
           }
+          default:
+            never(source.filter);
         }
+        break;
       }
-      return isMatched;
-    });
-    const transactions = block.transactions.filter((transaction) => {
-      let isMatched = requiredTransactions.has(transaction.hash);
-      for (const filter of transactionFilters) {
-        if (isTransactionFilterMatched({ filter, block, transaction })) {
-          requiredTransactions.add(transaction.hash);
-          requiredTransactionReceipts.add(transaction.hash);
-          isMatched = true;
-        }
-      }
-      return isMatched;
-    });
-    const blockTransactionsHashes = new Set(
-      block.transactions.map((t) => t.hash)
-    );
-    for (const hash of Array.from(requiredTransactions)) {
-      if (blockTransactionsHashes.has(hash) === false) {
-        throw new Error(
-          `Detected inconsistent RPC responses. 'transaction.hash' ${hash} not found in eth_getBlockReceipts response for block '${block.hash}'.`
-        );
-      }
-    }
-    const transactionReceipts = await syncTransactionReceipts(
-      block.hash,
-      requiredTransactionReceipts
-    );
-    return {
-      block,
-      logs,
-      factoryLogs,
-      traces,
-      transactions,
-      transactionReceipts
-    };
-  };
-  const getLatestUnfinalizedBlock = () => {
-    if (unfinalizedBlocks.length === 0) {
-      return finalizedBlock;
-    } else
-      return unfinalizedBlocks[unfinalizedBlocks.length - 1];
-  };
-  return {
-    start(startArgs) {
-      finalizedBlock = startArgs.syncProgress.finalized;
-      finalizedChildAddresses = startArgs.initialChildAddresses;
-      const processBlock = mutex(
-        async ({
-          block,
-          ...rest
-        }) => {
-          const latestBlock = getLatestUnfinalizedBlock();
-          if (latestBlock.hash === block.hash) {
-            args.common.logger.trace({
-              service: "realtime",
-              msg: `Skipped processing '${args.network.name}' block ${hexToNumber7(block.number)}, already synced`
+      case "account": {
+        switch (source.filter.type) {
+          case "transaction": {
+            const isFrom = source.filter.toAddress === void 0;
+            events.push({
+              type: "transaction",
+              chainId: event.chainId,
+              checkpoint: event.checkpoint,
+              name: `${source.name}:transaction:${isFrom ? "from" : "to"}`,
+              event: {
+                block: event.block,
+                transaction: event.transaction,
+                transactionReceipt: event.transactionReceipt
+              }
             });
-            return;
+            break;
           }
-          try {
-            if (hexToNumber7(latestBlock.number) >= hexToNumber7(block.number)) {
-              await handleReorg(block);
-              processBlock.clear();
-              return;
-            }
-            if (hexToNumber7(latestBlock.number) + 1 < hexToNumber7(block.number)) {
-              const missingBlockRange = range(
-                hexToNumber7(latestBlock.number) + 1,
-                Math.min(
-                  hexToNumber7(block.number),
-                  hexToNumber7(latestBlock.number) + MAX_QUEUED_BLOCKS
-                )
-              );
-              const pendingBlocks = await Promise.all(
-                missingBlockRange.map(
-                  (blockNumber) => _eth_getBlockByNumber(args.requestQueue, {
-                    blockNumber
-                  }).then((block2) => fetchBlockEventData(block2))
-                )
-              );
-              args.common.logger.debug({
-                service: "realtime",
-                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();
-              for (const pendingBlock of pendingBlocks) {
-                processBlock(pendingBlock);
+          case "transfer": {
+            const isFrom = source.filter.toAddress === void 0;
+            events.push({
+              type: "transfer",
+              chainId: event.chainId,
+              checkpoint: event.checkpoint,
+              name: `${source.name}:transfer:${isFrom ? "from" : "to"}`,
+              event: {
+                transfer: {
+                  from: event.trace.from,
+                  to: event.trace.to,
+                  value: event.trace.value
+                },
+                block: event.block,
+                transaction: event.transaction,
+                transactionReceipt: event.transactionReceipt,
+                trace: event.trace
               }
-              processBlock({ block, ...rest });
-              return;
-            }
-            if (block.parentHash !== latestBlock.hash) {
-              await handleReorg(block);
-              processBlock.clear();
-              return;
-            }
-            await handleBlock({ block, ...rest });
-            consecutiveErrors = 0;
-            return;
-          } catch (_error) {
-            const error = _error;
-            if (args.common.shutdown.isKilled) {
-              throw new ShutdownError();
-            }
-            args.common.logger.warn({
-              service: "realtime",
-              msg: `Failed to process '${args.network.name}' block ${hexToNumber7(block.number)}`,
-              error
-            });
-            const duration = ERROR_TIMEOUT[consecutiveErrors];
-            args.common.logger.warn({
-              service: "realtime",
-              msg: `Retrying '${args.network.name}' sync after ${duration} ${duration === 1 ? "second" : "seconds"}.`
             });
-            await wait(duration * 1e3);
-            processBlock.clear();
-            if (++consecutiveErrors === ERROR_TIMEOUT.length) {
-              args.common.logger.error({
-                service: "realtime",
-                msg: `Fatal error: Unable to process '${args.network.name}' block ${hexToNumber7(block.number)} after ${ERROR_TIMEOUT.length} attempts.`,
-                error
-              });
-              args.onFatalError(error);
-            }
+            break;
           }
         }
-      );
-      const enqueue = async () => {
-        try {
-          const block = await _eth_getBlockByNumber(args.requestQueue, {
-            blockTag: "latest"
-          });
-          args.common.logger.debug({
-            service: "realtime",
-            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 ${hexToNumber7(block.number)}, already synced`
-            });
-            return;
-          }
-          const endClock = startClock();
-          const blockWithEventData = await fetchBlockEventData(block);
-          consecutiveErrors = 0;
-          return processBlock({ ...blockWithEventData, endClock });
-        } catch (_error) {
-          const error = _error;
-          if (args.common.shutdown.isKilled) {
-            throw new ShutdownError();
+        break;
+      }
+      case "block": {
+        events.push({
+          type: "block",
+          chainId: event.chainId,
+          checkpoint: event.checkpoint,
+          name: `${source.name}:block`,
+          event: {
+            block: event.block
           }
-          args.common.logger.warn({
-            service: "realtime",
-            msg: `Failed to fetch latest '${args.network.name}' block`,
-            error
-          });
-          if (++consecutiveErrors === ERROR_TIMEOUT.length) {
-            args.common.logger.error({
-              service: "realtime",
-              msg: `Fatal error: Unable to fetch latest '${args.network.name}' block after ${ERROR_TIMEOUT.length} attempts.`,
-              error
-            });
-            args.onFatalError(error);
+        });
+        break;
+      }
+      default:
+        never(source);
+    }
+  }
+  common.metrics.ponder_indexing_abi_decoding_duration.observe(endClock());
+  return events;
+};
+function decodeEventLog({
+  abiItem,
+  topics,
+  data
+}) {
+  const { inputs } = abiItem;
+  const isUnnamed = inputs?.some((x) => !("name" in x && x.name));
+  let args = isUnnamed ? [] : {};
+  const [, ...argTopics] = topics;
+  const indexedInputs = inputs.filter((x) => "indexed" in x && x.indexed);
+  for (let i = 0; i < indexedInputs.length; i++) {
+    const param = indexedInputs[i];
+    const topic = argTopics[i];
+    if (!topic)
+      throw new DecodeLogTopicsMismatch({
+        abiItem,
+        param
+      });
+    args[isUnnamed ? i : param.name || i] = decodeTopic({
+      param,
+      value: topic
+    });
+  }
+  const nonIndexedInputs = inputs.filter((x) => !("indexed" in x && x.indexed));
+  if (nonIndexedInputs.length > 0) {
+    if (data && data !== "0x") {
+      const decodedData = decodeAbiParameters(nonIndexedInputs, data);
+      if (decodedData) {
+        if (isUnnamed)
+          args = [...args, ...decodedData];
+        else {
+          for (let i = 0; i < nonIndexedInputs.length; i++) {
+            args[nonIndexedInputs[i].name] = decodedData[i];
           }
         }
-      };
-      interval = setInterval(enqueue, args.network.pollingInterval);
-      args.common.shutdown.add(() => {
-        clearInterval(interval);
-      });
-      return enqueue().then(() => processBlock);
-    },
-    get unfinalizedBlocks() {
-      return unfinalizedBlocks;
-    },
-    get finalizedChildAddresses() {
-      return finalizedChildAddresses;
-    },
-    get unfinalizedChildAddresses() {
-      return unfinalizedChildAddresses;
-    },
-    async kill() {
-      clearInterval(interval);
-    }
-  };
-};
-
-// src/utils/estimate.ts
-var estimate = ({
-  from,
-  to,
-  target,
-  result,
-  min: min2,
-  max,
-  prev,
-  maxIncrease
-}) => {
-  const density = (to - from) / (result || 1);
-  return Math.min(
-    Math.max(min2, Math.round(target * density)),
-    Math.round(prev * maxIncrease),
-    max
-  );
-};
-
-// src/utils/generators.ts
-async function* mergeAsyncGenerators(generators) {
-  const results = [];
-  let count = generators.length;
-  let pwr = promiseWithResolvers();
-  generators.map(async (generator) => {
-    for await (const result of generator) {
-      results.push(result);
-      pwr.resolve();
-    }
-    count--;
-    pwr.resolve();
-  });
-  while (count > 0 || results.length > 0) {
-    if (results.length > 0) {
-      yield results.shift();
+      }
     } else {
-      await pwr.promise;
-      pwr = promiseWithResolvers();
+      throw new DecodeLogDataMismatch({
+        abiItem,
+        data: "0x",
+        params: nonIndexedInputs,
+        size: 0
+      });
     }
   }
+  return Object.values(args).length > 0 ? args : void 0;
 }
-async function* bufferAsyncGenerator(generator, size) {
-  const buffer = [];
-  let done = false;
-  let pwr1 = promiseWithResolvers();
-  let pwr2 = promiseWithResolvers();
-  (async () => {
-    for await (const result of generator) {
-      buffer.push(result);
-      pwr1.resolve();
-      if (buffer.length > size)
-        await pwr2.promise;
-      pwr2 = promiseWithResolvers();
-    }
-    done = true;
-    pwr1.resolve();
-  })();
-  while (done === false || buffer.length > 0) {
-    if (buffer.length > 0) {
-      pwr2.resolve();
-      yield buffer.shift();
-    } else {
-      await pwr1.promise;
-      pwr1 = promiseWithResolvers();
-    }
-  }
+function decodeTopic({ param, value }) {
+  if (param.type === "string" || param.type === "bytes" || param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
+    return value;
+  const decodedArg = decodeAbiParameters([param], value) || [];
+  return decodedArg[0];
 }
-
-// src/utils/partition.ts
-var partition = (array, predicate) => {
-  let low = 0;
-  let high = array.length;
-  while (low < high) {
-    const mid = Math.floor((low + high) / 2);
-    if (predicate(array[mid])) {
-      low = mid + 1;
-    } else {
-      high = mid;
-    }
-  }
-  const left = array.slice(0, low);
-  const right = array.slice(low);
-  return [left, right];
-};
-
-// src/utils/zipper.ts
-var zipper = (array1, array2, compare) => {
-  const result = [];
-  let i = 0;
-  let j = 0;
-  while (i < array1.length && j < array2.length) {
-    if (compare ? compare(array1[i], array2[j]) < 0 : array1[i] < array2[j]) {
-      result.push(array1[i]);
-      i++;
-    } else {
-      result.push(array2[j]);
-      j++;
-    }
-  }
-  if (i < array1.length) {
-    result.push(...array1.slice(i));
+function removeNullCharacters(obj) {
+  if (typeof obj === "string") {
+    return obj.replace(/\0/g, "");
   }
-  if (j < array2.length) {
-    result.push(...array2.slice(j));
+  if (Array.isArray(obj)) {
+    return obj.map(removeNullCharacters);
   }
-  return result;
-};
-var zipperMany = (arrays, compare) => {
-  if (arrays.length === 0)
-    return [];
-  if (arrays.length === 1)
-    return arrays[0];
-  let result = arrays[0];
-  for (let i = 1; i < arrays.length; i++) {
-    result = zipper(result, arrays[i], compare);
+  if (obj && typeof obj === "object") {
+    const newObj = {};
+    for (const [key, val] of Object.entries(obj)) {
+      newObj[key] = removeNullCharacters(val);
+    }
+    return newObj;
   }
-  return result;
-};
+  return obj;
+}
+var convertBlock = (block) => ({
+  baseFeePerGas: block.baseFeePerGas ? hexToBigInt6(block.baseFeePerGas) : null,
+  difficulty: hexToBigInt6(block.difficulty),
+  extraData: block.extraData,
+  gasLimit: hexToBigInt6(block.gasLimit),
+  gasUsed: hexToBigInt6(block.gasUsed),
+  hash: block.hash,
+  logsBloom: block.logsBloom,
+  miner: checksumAddress3(block.miner),
+  mixHash: block.mixHash,
+  nonce: block.nonce,
+  number: hexToBigInt6(block.number),
+  parentHash: block.parentHash,
+  receiptsRoot: block.receiptsRoot,
+  sha3Uncles: block.sha3Uncles,
+  size: hexToBigInt6(block.size),
+  stateRoot: block.stateRoot,
+  timestamp: hexToBigInt6(block.timestamp),
+  totalDifficulty: block.totalDifficulty ? hexToBigInt6(block.totalDifficulty) : null,
+  transactionsRoot: block.transactionsRoot
+});
+var convertLog = (log) => ({
+  id: `${log.blockHash}-${log.logIndex}`,
+  address: checksumAddress3(log.address),
+  data: log.data,
+  logIndex: Number(log.logIndex),
+  removed: false,
+  topics: log.topics
+});
+var convertTransaction = (transaction) => ({
+  from: checksumAddress3(transaction.from),
+  gas: hexToBigInt6(transaction.gas),
+  hash: transaction.hash,
+  input: transaction.input,
+  nonce: Number(transaction.nonce),
+  r: transaction.r,
+  s: transaction.s,
+  to: transaction.to ? checksumAddress3(transaction.to) : transaction.to,
+  transactionIndex: Number(transaction.transactionIndex),
+  value: hexToBigInt6(transaction.value),
+  v: transaction.v ? hexToBigInt6(transaction.v) : null,
+  ...transaction.type === "0x0" ? {
+    type: "legacy",
+    gasPrice: hexToBigInt6(transaction.gasPrice)
+  } : transaction.type === "0x1" ? {
+    type: "eip2930",
+    gasPrice: hexToBigInt6(transaction.gasPrice),
+    accessList: transaction.accessList
+  } : transaction.type === "0x2" ? {
+    type: "eip1559",
+    maxFeePerGas: hexToBigInt6(transaction.maxFeePerGas),
+    maxPriorityFeePerGas: hexToBigInt6(transaction.maxPriorityFeePerGas)
+  } : (
+    // @ts-ignore
+    transaction.type === "0x7e" ? {
+      type: "deposit",
+      // @ts-ignore
+      maxFeePerGas: transaction.maxFeePerGas ? (
+        // @ts-ignore
+        hexToBigInt6(transaction.maxFeePerGas)
+      ) : void 0,
+      // @ts-ignore
+      maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? (
+        // @ts-ignore
+        hexToBigInt6(transaction.maxPriorityFeePerGas)
+      ) : void 0
+    } : {
+      // @ts-ignore
+      type: transaction.type
+    }
+  )
+});
+var convertTransactionReceipt = (transactionReceipt) => ({
+  contractAddress: transactionReceipt.contractAddress ? checksumAddress3(transactionReceipt.contractAddress) : null,
+  cumulativeGasUsed: hexToBigInt6(transactionReceipt.cumulativeGasUsed),
+  effectiveGasPrice: hexToBigInt6(transactionReceipt.effectiveGasPrice),
+  from: checksumAddress3(transactionReceipt.from),
+  gasUsed: hexToBigInt6(transactionReceipt.gasUsed),
+  logsBloom: transactionReceipt.logsBloom,
+  status: transactionReceipt.status === "0x1" ? "success" : transactionReceipt.status === "0x0" ? "reverted" : transactionReceipt.status,
+  to: transactionReceipt.to ? checksumAddress3(transactionReceipt.to) : null,
+  type: transactionReceipt.type === "0x0" ? "legacy" : transactionReceipt.type === "0x1" ? "eip2930" : transactionReceipt.type === "0x2" ? "eip1559" : transactionReceipt.type === "0x7e" ? "deposit" : transactionReceipt.type
+});
+var convertTrace = (trace) => ({
+  id: `${trace.transactionHash}-${trace.trace.index}`,
+  type: trace.trace.type,
+  from: checksumAddress3(trace.trace.from),
+  to: trace.trace.to ? checksumAddress3(trace.trace.to) : null,
+  input: trace.trace.input,
+  output: trace.trace.output,
+  gas: hexToBigInt6(trace.trace.gas),
+  gasUsed: hexToBigInt6(trace.trace.gasUsed),
+  value: trace.trace.value ? hexToBigInt6(trace.trace.value) : null,
+  traceIndex: trace.trace.index,
+  subcalls: trace.trace.subcalls
+});
 
 // src/sync/index.ts
-import { hexToBigInt as hexToBigInt7, hexToNumber as hexToNumber8, toHex as toHex2 } from "viem";
 var syncBlockToLightBlock = ({
   hash,
   parentHash,
@@ -10682,17 +10688,17 @@ var splitEvents = (events) => {
   let hash;
   const result = [];
   for (const event of events) {
-    if (hash === void 0 || hash !== event.block.hash) {
+    if (hash === void 0 || hash !== event.event.block.hash) {
       result.push({
         checkpoint: encodeCheckpoint({
           ...MAX_CHECKPOINT,
-          blockTimestamp: Number(event.block.timestamp),
+          blockTimestamp: Number(event.event.block.timestamp),
           chainId: BigInt(event.chainId),
-          blockNumber: event.block.number
+          blockNumber: event.event.block.number
         }),
         events: []
       });
-      hash = event.block.hash;
+      hash = event.event.block.hash;
     }
     result[result.length - 1].events.push(event);
   }
@@ -10811,7 +10817,17 @@ var createSync = async (params) => {
             params.common.options.syncEventsQuerySize / (params.indexingBuild.networks.length * 2)
           )
         });
-        return bufferAsyncGenerator(localEventGenerator, 1);
+        async function* decodeEventGenerator() {
+          for await (const { events, checkpoint } of localEventGenerator) {
+            const decodedEvents = decodeEvents(params.common, sources, events);
+            params.common.logger.debug({
+              service: "app",
+              msg: `Decoded ${decodedEvents.length} '${network.name}' events`
+            });
+            yield { events: decodedEvents, checkpoint };
+          }
+        }
+        return bufferAsyncGenerator(decodeEventGenerator(), 1);
       }
     );
     const mergeAsync = params.ordering === "multichain" ? mergeAsyncGenerators : mergeAsyncGeneratorsWithEventOrder;
@@ -10848,6 +10864,7 @@ var createSync = async (params) => {
   const latencyTimers = /* @__PURE__ */ new Map();
   const onRealtimeSyncEvent = (event, {
     network,
+    sources,
     syncProgress,
     realtimeSync
   }) => {
@@ -10876,15 +10893,24 @@ var createSync = async (params) => {
           const readyEvents = events.concat(pendingEvents);
           pendingEvents = [];
           executedEvents = executedEvents.concat(readyEvents);
+          const decodedEvents = decodeEvents(
+            params.common,
+            sources,
+            readyEvents
+          );
           params.common.logger.debug({
             service: "sync",
-            msg: `Sequenced ${readyEvents.length} '${network.name}' events for block ${hexToNumber8(event.block.number)}`
+            msg: `Decoded ${decodedEvents.length} '${network.name}' events for block ${hexToNumber8(event.block.number)}`
+          });
+          params.common.logger.debug({
+            service: "sync",
+            msg: `Sequenced ${decodedEvents.length} '${network.name}' events for block ${hexToNumber8(event.block.number)}`
           });
           params.onRealtimeEvent({
             type: "block",
             checkpoint,
             status: structuredClone(status),
-            events: readyEvents.sort(
+            events: decodedEvents.sort(
               (a, b) => a.checkpoint < b.checkpoint ? -1 : 1
             ),
             network
@@ -10915,15 +10941,24 @@ var createSync = async (params) => {
             const readyEvents = pendingEvents.concat(events).filter(({ checkpoint }) => checkpoint < to);
             pendingEvents = pendingEvents.concat(events).filter(({ checkpoint }) => checkpoint > to);
             executedEvents = executedEvents.concat(readyEvents);
+            const decodedEvents = decodeEvents(
+              params.common,
+              sources,
+              readyEvents
+            );
+            params.common.logger.debug({
+              service: "sync",
+              msg: `Decoded ${decodedEvents.length} '${network.name}' events for block ${hexToNumber8(event.block.number)}`
+            });
             params.common.logger.debug({
               service: "sync",
-              msg: `Sequenced ${readyEvents.length} '${network.name}' events for timestamp range [${decodeCheckpoint(from).blockTimestamp}, ${decodeCheckpoint(to).blockTimestamp}]`
+              msg: `Sequenced ${decodedEvents.length} '${network.name}' events for timestamp range [${decodeCheckpoint(from).blockTimestamp}, ${decodeCheckpoint(to).blockTimestamp}]`
             });
             params.onRealtimeEvent({
               type: "block",
               checkpoint: to,
               status: structuredClone(status),
-              events: readyEvents.sort(
+              events: decodedEvents.sort(
                 (a, b) => a.checkpoint < b.checkpoint ? -1 : 1
               ),
               network
@@ -11069,6 +11104,7 @@ var createSync = async (params) => {
           (event) => perChainOnRealtimeSyncEvent(event).then((event2) => {
             onRealtimeSyncEvent(event2, {
               network,
+              sources,
               syncProgress,
               realtimeSync
             });
@@ -11433,6 +11469,9 @@ async function* getLocalEventGenerator(params) {
         cursor = queryCursor;
         yield { events, checkpoint: cursor };
       } catch (error) {
+        if (params.common.shutdown.isKilled) {
+          throw error;
+        }
         params.common.logger.warn({
           service: "sync",
           msg: `Failed '${params.network.name}' extract query for timestamp range [${decodeCheckpoint(cursor).blockTimestamp}, ${decodeCheckpoint(to).blockTimestamp}]`,
@@ -11938,12 +11977,7 @@ async function run({
   let lastFlush = Date.now();
   for await (const events of sync.getEvents()) {
     if (events.length > 0) {
-      const decodedEvents = decodeEvents(common, indexingBuild.sources, events);
-      const eventChunks = chunk(decodedEvents, 93);
-      common.logger.debug({
-        service: "app",
-        msg: `Decoded ${decodedEvents.length} events`
-      });
+      const eventChunks = chunk(events, 93);
       for (const eventChunk of eventChunks) {
         const result = await indexingService.processEvents({
           events: eventChunk
@@ -11991,12 +12025,12 @@ async function run({
       if (eta === void 0 || progress === void 0) {
         common.logger.info({
           service: "app",
-          msg: `Indexed ${decodedEvents.length} events`
+          msg: `Indexed ${events.length} events`
         });
       } else {
         common.logger.info({
           service: "app",
-          msg: `Indexed ${decodedEvents.length} events with ${formatPercentage(progress)} complete and ${formatEta(eta * 1e3)} remaining`
+          msg: `Indexed ${events.length} events with ${formatPercentage(progress)} complete and ${formatEta(eta * 1e3)} remaining`
         });
       }
       if (historicalIndexingStore.isCacheFull() && events.length > 0 || common.options.command === "dev" && lastFlush + 5e3 < Date.now() && events.length > 0) {
@@ -12065,21 +12099,16 @@ async function run({
             const network = indexingBuild.networks.find(
               (network2) => network2.chainId === Number(decodeCheckpoint(checkpoint).chainId)
             );
-            const decodedEvents = decodeEvents(
-              common,
-              indexingBuild.sources,
-              events
-            );
             common.logger.debug({
               service: "app",
-              msg: `Decoded ${decodedEvents.length} '${network.name}' events for block ${Number(decodeCheckpoint(checkpoint).blockNumber)}`
+              msg: `Decoded ${events.length} '${network.name}' events for block ${Number(decodeCheckpoint(checkpoint).blockNumber)}`
             });
             const result = await indexingService.processEvents({
-              events: decodedEvents
+              events
             });
             common.logger.info({
               service: "app",
-              msg: `Indexed ${decodedEvents.length} '${network.name}' events for block ${Number(decodeCheckpoint(checkpoint).blockNumber)}`
+              msg: `Indexed ${events.length} '${network.name}' events for block ${Number(decodeCheckpoint(checkpoint).blockNumber)}`
             });
             if (result.status === "error")
               onReloadableError(result.error);