ponder 0.8.19 → 0.8.21

package/dist/bin/ponder.js

@@ -3887,6 +3887,8 @@ function prettyPrint(args) {
     const trimmedValue = typeof value === "string" && value.length > 80 ? value.slice(0, 80).concat("...") : value;
     return [key, trimmedValue];
   }).filter(Boolean);
+  if (entries.length === 0)
+    return "  (empty object)";
   const maxLength = entries.reduce(
     (acc, [key]) => Math.max(acc, key.length),
     0
@@ -6227,47 +6229,24 @@ var executeSetup = async (indexingService, { event }) => {
   } catch (_error) {
     if (indexingService.isKilled)
       return { status: "killed" };
-    const error = _error;
-    const decodedCheckpoint = decodeCheckpoint(event.checkpoint);
+    const error = _error instanceof Error ? _error : new Error(String(_error));
     addStackTrace(error, common.options);
-    common.metrics.ponder_indexing_has_error.set(1);
+    if (error instanceof BaseError) {
+      error.meta.push(toErrorMeta(event));
+    } else {
+      error.meta = [toErrorMeta(event)];
+    }
+    const decodedCheckpoint = decodeCheckpoint(event.checkpoint);
     common.logger.error({
       service: "indexing",
       msg: `Error while processing '${event.name}' event in '${networkByChainId[event.chainId].name}' block ${decodedCheckpoint.blockNumber}`,
       error
     });
+    common.metrics.ponder_indexing_has_error.set(1);
     return { status: "error", error };
   }
   return { status: "success" };
 };
-var toErrorMeta = (event) => {
-  switch (event.type) {
-    case "log":
-    case "trace": {
-      return `Event arguments:
-${prettyPrint(event.event.args)}`;
-    }
-    case "transfer": {
-      return `Event arguments:
-${prettyPrint(event.event.transfer)}`;
-    }
-    case "block": {
-      return `Block:
-${prettyPrint({
-        hash: event.event.block.hash,
-        number: event.event.block.number,
-        timestamp: event.event.block.timestamp
-      })}`;
-    }
-    case "transaction": {
-      return `Transaction:
-${prettyPrint({
-        hash: event.event.transaction.hash,
-        block: event.event.block.number
-      })}`;
-    }
-  }
-};
 var executeEvent = async (indexingService, { event }) => {
   const {
     common,
@@ -6297,13 +6276,14 @@ var executeEvent = async (indexingService, { event }) => {
   } catch (_error) {
     if (indexingService.isKilled)
       return { status: "killed" };
-    const error = _error;
-    const decodedCheckpoint = decodeCheckpoint(event.checkpoint);
+    const error = _error instanceof Error ? _error : new Error(String(_error));
     addStackTrace(error, common.options);
-    error.meta = Array.isArray(error.meta) ? error.meta : [];
-    if (error.meta.length === 0) {
+    if (error instanceof BaseError) {
       error.meta.push(toErrorMeta(event));
+    } else {
+      error.meta = [toErrorMeta(event)];
     }
+    const decodedCheckpoint = decodeCheckpoint(event.checkpoint);
     common.logger.error({
       service: "indexing",
       msg: `Error while processing '${event.name}' event in '${networkByChainId[event.chainId].name}' block ${decodedCheckpoint.blockNumber}`,
@@ -6314,6 +6294,75 @@ var executeEvent = async (indexingService, { event }) => {
   }
   return { status: "success" };
 };
+var blockText = (block) => `Block:
+${prettyPrint({
+  hash: block.hash,
+  number: block.number,
+  timestamp: block.timestamp
+})}`;
+var transactionText = (transaction) => `Transaction:
+${prettyPrint({
+  hash: transaction.hash,
+  from: transaction.from,
+  to: transaction.to
+})}`;
+var logText = (log) => `Log:
+${prettyPrint({
+  index: log.logIndex,
+  address: log.address
+})}`;
+var traceText = (trace) => `Trace:
+${prettyPrint({
+  traceIndex: trace.traceIndex,
+  from: trace.from,
+  to: trace.to
+})}`;
+var toErrorMeta = (event) => {
+  switch (event.type) {
+    case "setup": {
+      return `Block:
+${prettyPrint({
+        number: event.block
+      })}`;
+    }
+    case "log": {
+      return [
+        `Event arguments:
+${prettyPrint(event.event.args)}`,
+        logText(event.event.log),
+        transactionText(event.event.transaction),
+        blockText(event.event.block)
+      ].join("\n");
+    }
+    case "trace": {
+      return [
+        `Call trace arguments:
+${prettyPrint(event.event.args)}`,
+        traceText(event.event.trace),
+        transactionText(event.event.transaction),
+        blockText(event.event.block)
+      ].join("\n");
+    }
+    case "transfer": {
+      return [
+        `Transfer arguments:
+${prettyPrint(event.event.transfer)}`,
+        traceText(event.event.trace),
+        transactionText(event.event.transaction),
+        blockText(event.event.block)
+      ].join("\n");
+    }
+    case "block": {
+      return blockText(event.event.block);
+    }
+    case "transaction": {
+      return [
+        transactionText(event.event.transaction),
+        blockText(event.event.block)
+      ].join("\n");
+    }
+  }
+};
 
 // src/indexing/index.ts
 var methods = {
@@ -7237,7 +7286,7 @@ var createSyncStore = ({
           "transactionReceipts.status as txr_status",
           "transactionReceipts.to as txr_to",
           "transactionReceipts.type as txr_type"
-        ]).where("event.checkpoint", ">", from).where("event.checkpoint", "<=", to).orderBy("event.checkpoint", "asc").orderBy("event.filterIndex", "asc").limit(limit).execute();
+        ]).where("event.checkpoint", ">", from).where("event.checkpoint", "<=", to).orderBy("event.checkpoint", "asc").orderBy("event.filterIndex", "asc").$if(limit !== void 0, (qb) => qb.limit(limit)).execute();
       }
     );
     const events = rows.map((_row) => {
@@ -8489,6 +8538,9 @@ var createHistoricalSync = async (args) => {
     }
   };
   const syncTransactionReceipts = async (block, transactionHashes) => {
+    if (transactionHashes.size === 0) {
+      return [];
+    }
     if (isBlockReceipts === false) {
       const transactionReceipts2 = await Promise.all(
         Array.from(transactionHashes).map(
@@ -9261,6 +9313,9 @@ var createRealtimeSync = (args) => {
     }
   };
   const syncTransactionReceipts = async (blockHash, transactionHashes) => {
+    if (transactionHashes.size === 0) {
+      return [];
+    }
     if (isBlockReceipts === false) {
       const transactionReceipts2 = await Promise.all(
         Array.from(transactionHashes).map(
@@ -9973,6 +10028,8 @@ var getChainCheckpoint = ({
 };
 var createSync = async (args) => {
   const perNetworkSync = /* @__PURE__ */ new Map();
+  let executedEvents = [];
+  let pendingEvents = [];
   const status = {};
   let isKilled = false;
   await Promise.all(
@@ -10246,42 +10303,34 @@ var createSync = async (args) => {
           { network: network.name },
           hexToNumber7(syncProgress.current.number)
         );
-        const blockWithEventData = event;
-        const events = buildEvents({
+        const newEvents = buildEvents({
           sources: args.sources,
           chainId: network.chainId,
-          blockWithEventData,
+          blockWithEventData: event,
           finalizedChildAddresses: realtimeSync.finalizedChildAddresses,
           unfinalizedChildAddresses: realtimeSync.unfinalizedChildAddresses
         });
-        unfinalizedBlocks.push({ ...blockWithEventData, events });
+        unfinalizedBlocks.push(event);
+        pendingEvents.push(...newEvents);
         if (to > from) {
           for (const network2 of args.networks) {
             updateRealtimeStatus({ checkpoint: to, network: network2 });
           }
-          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
+          const events = pendingEvents.filter((event2) => event2.checkpoint < to).sort((a, b) => a.checkpoint < b.checkpoint ? -1 : 1);
+          pendingEvents = pendingEvents.filter(
+            ({ checkpoint }) => checkpoint > to
           );
+          executedEvents.push(...events);
           args.onRealtimeEvent({
             type: "block",
             checkpoint: to,
             status: structuredClone(status),
-            events: events2
+            events
           }).then(() => {
-            if (events2.length > 0 && isKilled === false) {
+            if (events.length > 0 && isKilled === false) {
               args.common.logger.info({
                 service: "app",
-                msg: `Indexed ${events2.length} events`
+                msg: `Indexed ${events.length} events`
               });
             }
           });
@@ -10304,7 +10353,6 @@ var createSync = async (args) => {
             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)
@@ -10312,6 +10360,9 @@ var createSync = async (args) => {
         perNetworkSync.get(network).unfinalizedBlocks = unfinalizedBlocks.filter(
           ({ block }) => hexToNumber7(block.number) > hexToNumber7(event.block.number)
         );
+        executedEvents = executedEvents.filter(
+          (e) => e.checkpoint > checkpoint
+        );
         await Promise.all([
           args.syncStore.insertBlocks({
             blocks: finalizedBlocks.filter(({ hasMatchedFilter }) => hasMatchedFilter).map(({ block }) => block),
@@ -10392,9 +10443,21 @@ var createSync = async (args) => {
         perNetworkSync.get(network).unfinalizedBlocks = unfinalizedBlocks.filter(
           ({ block }) => hexToNumber7(block.number) <= hexToNumber7(event.block.number)
         );
+        const isReorgedEvent = ({ chainId, block }) => chainId === network.chainId && Number(block.number) > hexToNumber7(event.block.number);
+        pendingEvents = pendingEvents.filter(
+          (e) => isReorgedEvent(e) === false
+        );
+        executedEvents = executedEvents.filter(
+          (e) => isReorgedEvent(e) === false
+        );
+        const events = executedEvents.filter((e) => e.checkpoint > checkpoint);
+        executedEvents = executedEvents.filter(
+          (e) => e.checkpoint < checkpoint
+        );
+        pendingEvents.push(...events);
         await args.syncStore.pruneRpcRequestResult({
-          blocks: event.reorgedBlocks,
-          chainId: network.chainId
+          chainId: network.chainId,
+          blocks: event.reorgedBlocks
         });
         args.onRealtimeEvent({ type: "reorg", checkpoint });
         break;
@@ -10408,11 +10471,28 @@ var createSync = async (args) => {
     async startRealtime() {
       for (const network of args.networks) {
         const { syncProgress, realtimeSync } = perNetworkSync.get(network);
+        const filters = args.sources.filter(({ filter }) => filter.chainId === network.chainId).map(({ filter }) => filter);
         status[network.name].block = {
           number: hexToNumber7(syncProgress.current.number),
           timestamp: hexToNumber7(syncProgress.current.timestamp)
         };
         status[network.name].ready = true;
+        const from = getOmnichainCheckpoint("finalized");
+        const finalized = getChainCheckpoint({
+          syncProgress,
+          network,
+          tag: "finalized"
+        });
+        const end = getChainCheckpoint({
+          syncProgress,
+          network,
+          tag: "end"
+        });
+        const to = min(finalized, end);
+        if (to > from) {
+          const events = await args.syncStore.getEvents({ filters, from, to });
+          pendingEvents.push(...events.events);
+        }
         if (isSyncEnd(syncProgress)) {
           args.common.metrics.ponder_sync_is_complete.set(
             { network: network.name },
@@ -10424,8 +10504,8 @@ var createSync = async (args) => {
             1
           );
           const initialChildAddresses = /* @__PURE__ */ new Map();
-          for (const { filter } of args.sources) {
-            if (filter.chainId === network.chainId && "address" in filter && isAddressFactory(filter.address)) {
+          for (const filter of filters) {
+            if ("address" in filter && isAddressFactory(filter.address)) {
               const addresses = await args.syncStore.getChildAddresses({
                 filter: filter.address
               });