ponder 0.8.13 → 0.8.15

package/dist/bin/ponder.js

@@ -8233,6 +8233,10 @@ var _eth_getTransactionReceipt = (requestQueue, { hash }) => requestQueue.reques
     });
   return receipt;
 });
+var _eth_getBlockReceipts = (requestQueue, { blockHash }) => requestQueue.request({
+  method: "eth_getBlockReceipts",
+  params: [blockHash]
+}).then((receipts) => receipts);
 var _debug_traceBlockByNumber = (requestQueue, {
   blockNumber
 }) => requestQueue.request({
@@ -8320,9 +8324,12 @@ import {
 } from "viem";
 var createHistoricalSync = async (args) => {
   let isKilled = false;
+  let isBlockReceipts = true;
   const blockCache = /* @__PURE__ */ new Map();
   const traceCache = /* @__PURE__ */ new Map();
   const transactionsCache = /* @__PURE__ */ new Set();
+  const blockReceiptsCache = /* @__PURE__ */ new Map();
+  const transactionReceiptsCache = /* @__PURE__ */ new Map();
   const getLogsRequestMetadata = /* @__PURE__ */ new Map();
   let intervalsCache;
   if (args.network.disableCache) {
@@ -8459,6 +8466,65 @@ var createHistoricalSync = async (args) => {
       return await traces;
     }
   };
+  const syncTransactionReceipts = async (block, transactionHashes) => {
+    if (isBlockReceipts === false) {
+      const transactionReceipts2 = await Promise.all(
+        Array.from(transactionHashes).map(
+          (hash) => syncTransactionReceipt(hash)
+        )
+      );
+      return transactionReceipts2;
+    }
+    let blockReceipts;
+    try {
+      blockReceipts = await syncBlockReceipts(block);
+    } catch (_error) {
+      const error = _error;
+      args.common.logger.warn({
+        service: "sync",
+        msg: `Caught eth_getBlockReceipts error on '${args.network.name}', switching to eth_getTransactionReceipt method.`,
+        error
+      });
+      isBlockReceipts = false;
+      return syncTransactionReceipts(block, 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 '${block}'`
+        );
+      }
+    }
+    const transactionReceipts = blockReceipts.filter(
+      (receipt) => transactionHashes.has(receipt.transactionHash)
+    );
+    return transactionReceipts;
+  };
+  const syncTransactionReceipt = async (transaction) => {
+    if (transactionReceiptsCache.has(transaction)) {
+      return await transactionReceiptsCache.get(transaction);
+    } else {
+      const receipt = _eth_getTransactionReceipt(args.requestQueue, {
+        hash: transaction
+      });
+      transactionReceiptsCache.set(transaction, receipt);
+      return await receipt;
+    }
+  };
+  const syncBlockReceipts = async (block) => {
+    if (blockReceiptsCache.has(block)) {
+      return await blockReceiptsCache.get(block);
+    } else {
+      const blockReceipts = _eth_getBlockReceipts(args.requestQueue, {
+        blockHash: block
+      });
+      blockReceiptsCache.set(block, blockReceipts);
+      return await blockReceipts;
+    }
+  };
   const syncLogFactory = async (filter, interval) => {
     const logs = await syncLogsDynamic({
       filter,
@@ -8494,6 +8560,7 @@ var createHistoricalSync = async (args) => {
     const blocks = await Promise.all(
       logs.map((log) => syncBlock(hexToNumber4(log.blockNumber)))
     );
+    const requiredBlocks = new Set(blocks.map((b) => b.hash));
     for (let i = 0; i < logs.length; i++) {
       const log = logs[i];
       const block = blocks[i];
@@ -8523,10 +8590,13 @@ var createHistoricalSync = async (args) => {
       return;
     if (shouldGetTransactionReceipt(filter)) {
       const transactionReceipts = await Promise.all(
-        Array.from(transactionHashes).map(
-          (hash) => _eth_getTransactionReceipt(args.requestQueue, { hash })
-        )
-      );
+        Array.from(requiredBlocks).map((blockHash) => {
+          const blockTransactionHashes = new Set(
+            logs.filter((l) => l.blockHash === blockHash).map((l) => l.transactionHash)
+          );
+          return syncTransactionReceipts(blockHash, blockTransactionHashes);
+        })
+      ).then((receipts) => receipts.flat());
       if (isKilled)
         return;
       await args.syncStore.insertTransactionReceipts({
@@ -8559,6 +8629,7 @@ var createHistoricalSync = async (args) => {
     if (isKilled)
       return;
     const transactionHashes = /* @__PURE__ */ new Set();
+    const requiredBlocks = /* @__PURE__ */ new Set();
     for (const block of blocks) {
       block.transactions.map((transaction) => {
         if (isTransactionFilterMatched({
@@ -8569,6 +8640,7 @@ var createHistoricalSync = async (args) => {
           toChildAddresses
         })) {
           transactionHashes.add(transaction.hash);
+          requiredBlocks.add(block);
         }
       });
     }
@@ -8578,10 +8650,13 @@ var createHistoricalSync = async (args) => {
     if (isKilled)
       return;
     const transactionReceipts = await Promise.all(
-      Array.from(transactionHashes).map(
-        (hash) => _eth_getTransactionReceipt(args.requestQueue, { hash })
-      )
-    );
+      Array.from(requiredBlocks).map((block) => {
+        const blockTransactionHashes = new Set(
+          block.transactions.filter((t) => transactionHashes.has(t.hash)).map((t) => t.hash)
+        );
+        return syncTransactionReceipts(block.hash, blockTransactionHashes);
+      })
+    ).then((receipts) => receipts.flat());
     if (isKilled)
       return;
     await args.syncStore.insertTransactionReceipts({
@@ -8592,6 +8667,7 @@ var createHistoricalSync = async (args) => {
   const syncTraceOrTransferFilter = async (filter, interval) => {
     const fromChildAddresses = isAddressFactory(filter.fromAddress) ? await syncAddressFactory(filter.fromAddress, interval) : void 0;
     const toChildAddresses = isAddressFactory(filter.toAddress) ? await syncAddressFactory(filter.toAddress, interval) : void 0;
+    const requiredBlocks = /* @__PURE__ */ new Set();
     const traces = await Promise.all(
       intervalRange(interval).map(async (number) => {
         let traces2 = await syncTrace(number);
@@ -8613,6 +8689,7 @@ var createHistoricalSync = async (args) => {
         if (traces2.length === 0)
           return [];
         const block = await syncBlock(number);
+        requiredBlocks.add(block.hash);
         return traces2.map((trace) => {
           const transaction = block.transactions.find(
             (t) => t.hash === trace.transactionHash
@@ -8629,9 +8706,6 @@ var createHistoricalSync = async (args) => {
     ).then((traces2) => traces2.flat());
     if (isKilled)
       return;
-    const transactionHashes = new Set(
-      traces.map(({ transaction }) => transaction.hash)
-    );
     await args.syncStore.insertTraces({
       traces,
       chainId: args.network.chainId
@@ -8640,10 +8714,13 @@ var createHistoricalSync = async (args) => {
       return;
     if (shouldGetTransactionReceipt(filter)) {
       const transactionReceipts = await Promise.all(
-        Array.from(transactionHashes).map(
-          (hash) => _eth_getTransactionReceipt(args.requestQueue, { hash })
-        )
-      );
+        Array.from(requiredBlocks).map((blockHash) => {
+          const blockTransactionHashes = new Set(
+            traces.filter((t) => t.block.hash === blockHash).map((t) => t.transaction.hash)
+          );
+          return syncTransactionReceipts(blockHash, blockTransactionHashes);
+        })
+      ).then((receipts) => receipts.flat());
       if (isKilled)
         return;
       await args.syncStore.insertTransactionReceipts({
@@ -8738,6 +8815,8 @@ var createHistoricalSync = async (args) => {
       blockCache.clear();
       traceCache.clear();
       transactionsCache.clear();
+      blockReceiptsCache.clear();
+      transactionReceiptsCache.clear();
       return latestBlock;
     },
     kill() {
@@ -8828,6 +8907,7 @@ var ERROR_TIMEOUT = [
 var MAX_QUEUED_BLOCKS = 25;
 var createRealtimeSync = (args) => {
   let isKilled = false;
+  let isBlockReceipts = true;
   let finalizedBlock;
   let finalizedChildAddresses;
   const unfinalizedChildAddresses = /* @__PURE__ */ new Map();
@@ -9151,6 +9231,45 @@ var createRealtimeSync = (args) => {
       factoryLogsPerBlock.delete(hash);
     }
   };
+  const syncTransactionReceipts = async (blockHash, transactionHashes) => {
+    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 receipt with transactionHash ${hash} is missing in \`blockReceipts\`.`
+        );
+      }
+    }
+    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 = [];
@@ -9272,14 +9391,13 @@ var createRealtimeSync = (args) => {
     for (const hash of Array.from(requiredTransactions)) {
       if (blockTransactionsHashes.has(hash) === false) {
         throw new Error(
-          `Detected inconsistent RPC responses. Transaction with hash ${hash} is missing in \`block.transactions\`.`
+          `Detected inconsistent RPC responses. 'transaction.hash' ${hash} not found in eth_getBlockReceipts response for block '${block.hash}'.`
         );
       }
     }
-    const transactionReceipts = await Promise.all(
-      block.transactions.filter(({ hash }) => requiredTransactionReceipts.has(hash)).map(
-        ({ hash }) => _eth_getTransactionReceipt(args.requestQueue, { hash })
-      )
+    const transactionReceipts = await syncTransactionReceipts(
+      block.hash,
+      requiredTransactionReceipts
     );
     return {
       block,
@@ -9775,10 +9893,18 @@ var splitEvents = (events) => {
   const result = [];
   for (const event of events) {
     if (prevHash === void 0 || prevHash !== event.block.hash) {
-      result.push([]);
+      result.push({
+        checkpoint: encodeCheckpoint({
+          ...maxCheckpoint,
+          blockTimestamp: Number(event.block.timestamp),
+          chainId: BigInt(event.chainId),
+          blockNumber: event.block.number
+        }),
+        events: []
+      });
       prevHash = event.block.hash;
     }
-    result[result.length - 1].push(event);
+    result[result.length - 1].events.push(event);
   }
   return result;
 };
@@ -10535,14 +10661,14 @@ async function run({
     worker: async (event) => {
       switch (event.type) {
         case "block": {
-          for (const events of splitEvents(event.events)) {
+          for (const { checkpoint, events } of splitEvents(event.events)) {
             const result = await handleEvents(
               decodeEvents(common, indexingBuild.sources, events),
               event.checkpoint
             );
             if (result.status === "error")
               onReloadableError(result.error);
-            await database.complete({ checkpoint: event.checkpoint });
+            await database.complete({ checkpoint });
           }
           await metadataStore.setStatus(event.status);
           break;