ponder 0.8.3 → 0.8.4

package/dist/bin/ponder.js

@@ -8956,7 +8956,7 @@ var createRealtimeSync = (args) => {
     block.transactions = void 0;
     await args.onEvent({
       type: "block",
-      filters: matchedFilters,
+      hasMatchedFilter: matchedFilters.size > 0,
       block,
       factoryLogs,
       logs,
@@ -9712,10 +9712,9 @@ var getChainCheckpoint = ({
   );
 };
 var createSync = async (args) => {
-  const localSyncContext = /* @__PURE__ */ new Map();
+  const perNetworkSync = /* @__PURE__ */ new Map();
   const status = {};
   let isKilled = false;
-  let pendingEvents = [];
   await Promise.all(
     args.networks.map(async (network) => {
       const requestQueue = createRequestQueue({
@@ -9790,18 +9789,18 @@ var createSync = async (args) => {
         { network: network.name },
         0
       );
-      localSyncContext.set(network, {
+      perNetworkSync.set(network, {
         requestQueue,
         syncProgress,
         historicalSync,
         realtimeSync,
-        unfinalizedEventData: []
+        unfinalizedBlocks: []
       });
       status[network.name] = { block: null, ready: false };
     })
   );
   const getOmnichainCheckpoint = (tag) => {
-    const checkpoints = Array.from(localSyncContext.entries()).map(
+    const checkpoints = Array.from(perNetworkSync.entries()).map(
       ([network, { syncProgress }]) => getChainCheckpoint({ syncProgress, network, tag })
     );
     if (tag === "end" && checkpoints.some((c) => c === void 0)) {
@@ -9840,7 +9839,7 @@ var createSync = async (args) => {
     checkpoint,
     network
   }) => {
-    const localBlock = localSyncContext.get(network).realtimeSync.unfinalizedBlocks.findLast(
+    const localBlock = perNetworkSync.get(network).realtimeSync.unfinalizedBlocks.findLast(
       (block) => encodeCheckpoint(blockToCheckpoint(block, network.chainId, "up")) <= checkpoint
     );
     if (localBlock !== void 0) {
@@ -9858,7 +9857,7 @@ var createSync = async (args) => {
     let showLogs = true;
     while (true) {
       const syncGenerator = mergeAsyncGenerators(
-        Array.from(localSyncContext.entries()).map(
+        Array.from(perNetworkSync.entries()).map(
           ([network, { syncProgress, historicalSync }]) => localHistoricalSyncGenerator({
             common: args.common,
             network,
@@ -9870,7 +9869,7 @@ var createSync = async (args) => {
       );
       showLogs = false;
       for await (const _ of syncGenerator) {
-        if (Array.from(localSyncContext.values()).some(
+        if (Array.from(perNetworkSync.values()).some(
           ({ syncProgress }) => syncProgress.current === void 0
         )) {
           continue;
@@ -9939,7 +9938,7 @@ var createSync = async (args) => {
         }
       }
       const allHistoricalSyncExhaustive = Array.from(
-        localSyncContext.values()
+        perNetworkSync.values()
       ).every(({ syncProgress }) => {
         if (isSyncEnd(syncProgress))
           return true;
@@ -9953,7 +9952,7 @@ var createSync = async (args) => {
         break;
       latestFinalizedFetch = Date.now();
       await Promise.all(
-        Array.from(localSyncContext.entries()).map(
+        Array.from(perNetworkSync.entries()).map(
           async ([network, { requestQueue, syncProgress }]) => {
             args.common.logger.debug({
               service: "sync",
@@ -9983,7 +9982,7 @@ var createSync = async (args) => {
     network,
     event
   }) => {
-    const { syncProgress, realtimeSync, unfinalizedEventData } = localSyncContext.get(network);
+    const { syncProgress, realtimeSync, unfinalizedBlocks } = perNetworkSync.get(network);
     switch (event.type) {
       case "block": {
         const from = getOmnichainCheckpoint("current");
@@ -9993,16 +9992,7 @@ var createSync = async (args) => {
           { network: network.name },
           hexToNumber7(syncProgress.current.number)
         );
-        const blockWithEventData = {
-          block: event.block,
-          filters: event.filters,
-          logs: event.logs,
-          factoryLogs: event.factoryLogs,
-          traces: event.traces,
-          transactions: event.transactions,
-          transactionReceipts: event.transactionReceipts
-        };
-        unfinalizedEventData.push(blockWithEventData);
+        const blockWithEventData = event;
         const events = buildEvents({
           sources: args.sources,
           chainId: network.chainId,
@@ -10010,14 +10000,23 @@ var createSync = async (args) => {
           finalizedChildAddresses: realtimeSync.finalizedChildAddresses,
           unfinalizedChildAddresses: realtimeSync.unfinalizedChildAddresses
         });
-        pendingEvents.push(...events);
+        unfinalizedBlocks.push({ ...blockWithEventData, events });
         if (to > from) {
           for (const network2 of args.networks) {
             updateRealtimeStatus({ checkpoint: to, network: network2 });
           }
-          const events2 = pendingEvents.filter(({ checkpoint }) => checkpoint <= to).sort((a, b) => a.checkpoint < b.checkpoint ? -1 : 1);
-          pendingEvents = pendingEvents.filter(
-            ({ checkpoint }) => checkpoint > to
+          const pendingEvents = [];
+          for (const { unfinalizedBlocks: unfinalizedBlocks2 } of perNetworkSync.values()) {
+            for (const { events: events3 } of unfinalizedBlocks2) {
+              for (const event2 of events3) {
+                if (event2.checkpoint > from && event2.checkpoint <= to) {
+                  pendingEvents.push(event2);
+                }
+              }
+            }
+          }
+          const events2 = pendingEvents.sort(
+            (a, b) => a.checkpoint < b.checkpoint ? -1 : 1
           );
           args.onRealtimeEvent({
             type: "block",
@@ -10046,39 +10045,40 @@ var createSync = async (args) => {
         if (checkpoint > prev) {
           args.onRealtimeEvent({ type: "finalize", checkpoint });
         }
-        const finalizedEventData = unfinalizedEventData.filter(
-          (ued) => hexToNumber7(ued.block.number) <= hexToNumber7(event.block.number)
-        );
-        localSyncContext.get(network).unfinalizedEventData = unfinalizedEventData.filter(
-          (ued) => hexToNumber7(ued.block.number) > hexToNumber7(event.block.number)
-        );
         if (getChainCheckpoint({ syncProgress, network, tag: "finalized" }) > getOmnichainCheckpoint("current")) {
           args.common.logger.warn({
             service: "sync",
             msg: `Finalized block for '${network.name}' has surpassed overall indexing checkpoint`
           });
+          return;
         }
+        const finalizedBlocks = unfinalizedBlocks.filter(
+          ({ block }) => hexToNumber7(block.number) <= hexToNumber7(event.block.number)
+        );
+        perNetworkSync.get(network).unfinalizedBlocks = unfinalizedBlocks.filter(
+          ({ block }) => hexToNumber7(block.number) > hexToNumber7(event.block.number)
+        );
         await Promise.all([
           args.syncStore.insertBlocks({
-            blocks: finalizedEventData.filter(({ filters }) => filters.size > 0).map(({ block }) => block),
+            blocks: finalizedBlocks.filter(({ hasMatchedFilter }) => hasMatchedFilter).map(({ block }) => block),
             chainId: network.chainId
           }),
           args.syncStore.insertLogs({
-            logs: finalizedEventData.flatMap(
+            logs: finalizedBlocks.flatMap(
               ({ logs, block }) => logs.map((log) => ({ log, block }))
             ),
             shouldUpdateCheckpoint: true,
             chainId: network.chainId
           }),
           args.syncStore.insertLogs({
-            logs: finalizedEventData.flatMap(
+            logs: finalizedBlocks.flatMap(
               ({ factoryLogs }) => factoryLogs.map((log) => ({ log }))
             ),
             shouldUpdateCheckpoint: false,
             chainId: network.chainId
           }),
           args.syncStore.insertTransactions({
-            transactions: finalizedEventData.flatMap(
+            transactions: finalizedBlocks.flatMap(
               ({ transactions, block }) => transactions.map((transaction) => ({
                 transaction,
                 block
@@ -10087,13 +10087,13 @@ var createSync = async (args) => {
             chainId: network.chainId
           }),
           args.syncStore.insertTransactionReceipts({
-            transactionReceipts: finalizedEventData.flatMap(
+            transactionReceipts: finalizedBlocks.flatMap(
               ({ transactionReceipts }) => transactionReceipts
             ),
             chainId: network.chainId
           }),
           args.syncStore.insertTraces({
-            traces: finalizedEventData.flatMap(
+            traces: finalizedBlocks.flatMap(
               ({ traces, block, transactions }) => traces.map((trace) => ({
                 trace,
                 block,
@@ -10134,15 +10134,8 @@ var createSync = async (args) => {
           { network: network.name },
           hexToNumber7(syncProgress.current.number)
         );
-        localSyncContext.get(network).unfinalizedEventData = unfinalizedEventData.filter(
-          (led) => hexToNumber7(led.block.number) <= hexToNumber7(event.block.number)
-        );
-        const reorgedHashes = /* @__PURE__ */ new Set();
-        for (const b of event.reorgedBlocks) {
-          reorgedHashes.add(b.hash);
-        }
-        pendingEvents = pendingEvents.filter(
-          (e) => reorgedHashes.has(e.block.hash) === false
+        perNetworkSync.get(network).unfinalizedBlocks = unfinalizedBlocks.filter(
+          ({ block }) => hexToNumber7(block.number) <= hexToNumber7(event.block.number)
         );
         await args.syncStore.pruneRpcRequestResult({
           blocks: event.reorgedBlocks,
@@ -10159,7 +10152,7 @@ var createSync = async (args) => {
     getEvents,
     async startRealtime() {
       for (const network of args.networks) {
-        const { syncProgress, realtimeSync } = localSyncContext.get(network);
+        const { syncProgress, realtimeSync } = perNetworkSync.get(network);
         status[network.name].block = {
           number: hexToNumber7(syncProgress.current.number),
           timestamp: hexToNumber7(syncProgress.current.timestamp)
@@ -10198,14 +10191,14 @@ var createSync = async (args) => {
       return status;
     },
     getCachedTransport(network) {
-      const { requestQueue } = localSyncContext.get(network);
+      const { requestQueue } = perNetworkSync.get(network);
       return cachedTransport({ requestQueue, syncStore: args.syncStore });
     },
     async kill() {
       isKilled = true;
       const promises = [];
       for (const network of args.networks) {
-        const { historicalSync, realtimeSync } = localSyncContext.get(network);
+        const { historicalSync, realtimeSync } = perNetworkSync.get(network);
         historicalSync.kill();
         promises.push(realtimeSync.kill());
       }