ponder 0.17.2 → 0.17.4

package/dist/types/runtime/omnichain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"omnichain.d.ts","sourceRoot":"","sources":["../../../src/runtime/omnichain.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,KAAK,QAAQ,EAGd,MAAM,qBAAqB,CAAC;AAU7B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAOnD,OAAO,KAAK,EACV,KAAK,EACL,uBAAuB,EAEvB,aAAa,EAEb,cAAc,EACd,QAAQ,EACR,WAAW,EAEZ,MAAM,qBAAqB,CAAC;AAsB7B,OAAO,EAML,KAAK,YAAY,EAClB,MAAM,YAAY,CAAC;AAGpB,wBAAsB,YAAY,CAAC,EACjC,MAAM,EACN,QAAQ,EACR,cAAc,EACd,WAAW,EACX,aAAa,EACb,uBAAuB,EACvB,QAAQ,GACT,EAAE;IACD,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,QAAQ,CAAC;IACnB,cAAc,EAAE,cAAc,CAAC;IAC/B,WAAW,EAAE,WAAW,CAAC;IACzB,aAAa,EAAE,aAAa,CAAC;IAC7B,uBAAuB,EAAE,uBAAuB,CAAC;IACjD,QAAQ,EAAE,QAAQ,CAAC;CACpB,iBAkxBA;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB;kBAMnB,IAAI,KAAK,EAAE;QAAE,YAAY,EAAE,YAAY,CAAA;KAAE,CAAC;;qDAqCzD,CAAC"}
+{"version":3,"file":"omnichain.d.ts","sourceRoot":"","sources":["../../../src/runtime/omnichain.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,KAAK,QAAQ,EAGd,MAAM,qBAAqB,CAAC;AAU7B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAOnD,OAAO,KAAK,EACV,KAAK,EACL,uBAAuB,EAEvB,aAAa,EAEb,cAAc,EACd,QAAQ,EACR,WAAW,EAEZ,MAAM,qBAAqB,CAAC;AAsB7B,OAAO,EAML,KAAK,YAAY,EAClB,MAAM,YAAY,CAAC;AAGpB,wBAAsB,YAAY,CAAC,EACjC,MAAM,EACN,QAAQ,EACR,cAAc,EACd,WAAW,EACX,aAAa,EACb,uBAAuB,EACvB,QAAQ,GACT,EAAE;IACD,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,QAAQ,CAAC;IACnB,cAAc,EAAE,cAAc,CAAC;IAC/B,WAAW,EAAE,WAAW,CAAC;IACzB,aAAa,EAAE,aAAa,CAAC;IAC7B,uBAAuB,EAAE,uBAAuB,CAAC;IACjD,QAAQ,EAAE,QAAQ,CAAC;CACpB,iBAmxBA;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB;kBAMnB,IAAI,KAAK,EAAE;QAAE,YAAY,EAAE,YAAY,CAAA;KAAE,CAAC;;qDAqCzD,CAAC"}

package/dist/types/utils/copy.d.ts

@@ -12,5 +12,5 @@ export declare const copyOnWrite: <T extends object>(obj: T) => T;
  * @dev This function supports copying objects that
  * have been created with `copyOnWrite`.
  */
-export declare const copy: <T>(obj: T) => T;
+export declare const copy: <T>(obj: T, fast: boolean) => T;
 //# sourceMappingURL=copy.d.ts.map

package/dist/types/utils/copy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"copy.d.ts","sourceRoot":"","sources":["../../../src/utils/copy.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,aAAa,eAAmC,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,WAAW,0BAA2B,CAAC,KAAG,CAsDtD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,IAAI,WAAY,CAAC,KAAG,CA8EhC,CAAC"}
+{"version":3,"file":"copy.d.ts","sourceRoot":"","sources":["../../../src/utils/copy.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,aAAa,eAAmC,CAAC;AAQ9D;;GAEG;AACH,eAAO,MAAM,WAAW,0BAA2B,CAAC,KAAG,CA4DtD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,IAAI,WAAY,CAAC,QAAQ,OAAO,KAAG,CAoC/C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ponder",
-  "version": "0.17.2",
+  "version": "0.17.4",
   "description": "An open-source TypeScript framework for EVM data indexing",
   "license": "MIT",
   "type": "module",
@@ -102,7 +102,7 @@
     "rimraf": "^5.0.5",
     "tsx": "^4.19.2",
     "vitest": "1.6.1",
-    "@ponder/client": "0.17.2"
+    "@ponder/client": "0.17.4"
   },
   "engines": {
     "node": ">=22"

package/src/indexing/index.ts

@@ -549,9 +549,8 @@ export const createIndexing = ({
         // @ts-expect-error
         await executeEvent({ ...event, event: proxyEvent });
 
-        common.metrics.ponder_indexing_completed_events.inc(
-          { event: event.eventCallback.name },
-          1,
+        common.metrics.incrementIndexingCompletedEvents(
+          event.eventCallback.name,
         );
         columnAccessPattern.get(event.eventCallback.name)!.count++;
         eventCount[event.eventCallback.name] =
@@ -716,9 +715,8 @@ export const createIndexing = ({
 
         await executeEvent(event);
 
-        common.metrics.ponder_indexing_completed_events.inc(
-          { event: event.eventCallback.name },
-          1,
+        common.metrics.incrementIndexingCompletedEvents(
+          event.eventCallback.name,
         );
         eventCount[event.eventCallback.name] =
           eventCount[event.eventCallback.name]! + 1;

package/src/indexing-store/cache.ts

@@ -435,10 +435,10 @@ export const createIndexingCache = ({
         updateBuffer.get(table)!.get(ck) ?? insertBuffer.get(table)!.get(ck);
 
       if (bufferEntry) {
-        common.metrics.ponder_indexing_cache_requests_total.inc({
-          table: getTableName(table),
-          type: cache.get(table)!.isCacheComplete ? "complete" : "hit",
-        });
+        common.metrics.incrementIndexingCacheRequests(
+          getTableName(table),
+          cache.get(table)!.isCacheComplete ? "complete" : "hit",
+        );
         return bufferEntry.row;
       }
 
@@ -452,29 +452,29 @@ export const createIndexingCache = ({
           cache.get(table)!.spillover.add(ck);
         }
 
-        common.metrics.ponder_indexing_cache_requests_total.inc({
-          table: getTableName(table),
-          type: cache.get(table)!.isCacheComplete ? "complete" : "hit",
-        });
+        common.metrics.incrementIndexingCacheRequests(
+          getTableName(table),
+          cache.get(table)!.isCacheComplete ? "complete" : "hit",
+        );
         return entry;
       }
 
       cache.get(table)!.diskReads++;
 
       if (cache.get(table)!.isCacheComplete) {
-        common.metrics.ponder_indexing_cache_requests_total.inc({
-          table: getTableName(table),
-          type: "complete",
-        });
+        common.metrics.incrementIndexingCacheRequests(
+          getTableName(table),
+          "complete",
+        );
         return null;
       }
 
       cache.get(table)!.spillover.add(ck);
 
-      common.metrics.ponder_indexing_cache_requests_total.inc({
-        table: getTableName(table),
-        type: "miss",
-      });
+      common.metrics.incrementIndexingCacheRequests(
+        getTableName(table),
+        "miss",
+      );
 
       const endClock = startClock();
 
@@ -502,7 +502,7 @@ export const createIndexingCache = ({
       return result;
     },
     set({ table, key, row: _row, isUpdate }) {
-      const row = normalizeRow(table, _row, isUpdate);
+      const row = isUpdate ? _row : normalizeRow(table, _row, false);
       const ck = getCacheKey(table, key, primaryKeyCache);
 
       if (isUpdate) {
@@ -964,11 +964,9 @@ export const createIndexingCache = ({
       }
 
       for (const [table, tablePredictions] of prediction) {
-        common.metrics.ponder_indexing_cache_requests_total.inc(
-          {
-            table: getTableName(table),
-            type: "prefetch",
-          },
+        common.metrics.incrementIndexingCacheRequests(
+          getTableName(table),
+          "prefetch",
           tablePredictions.size,
         );
       }

package/src/indexing-store/index.ts

@@ -1,5 +1,6 @@
 import {
   type Column,
+  getTableColumns,
   getTableName,
   getViewName,
   isTable,
@@ -35,7 +36,7 @@ import { prettyPrint } from "@/utils/print.js";
 import { getSQLQueryRelations, isReadonlySQLQuery } from "@/utils/sql-parse.js";
 import { startClock } from "@/utils/timer.js";
 import type { IndexingCache, Row } from "./cache.js";
-import { getPrimaryKeyCache } from "./utils.js";
+import { getPrimaryKeyCache, normalizeUpdateSet } from "./utils.js";
 
 export type IndexingStore = {
   db: Db<Schema>;
@@ -117,6 +118,14 @@ export const createIndexingStore = ({
   const tables = Object.values(schema).filter(isTable);
   const views = Object.values(schema).filter(isView);
   const primaryKeyCache = getPrimaryKeyCache(tables);
+  const isCopyFast = new Map(
+    tables.map((table) => [
+      table,
+      Object.values(getTableColumns(table)).every((column) =>
+        ["string", "number", "boolean", "bigint"].includes(column.dataType),
+      ),
+    ]),
+  );
 
   const lock = createLock();
 
@@ -161,10 +170,10 @@ export const createIndexingStore = ({
   return {
     db: {
       find: storeMethodWrapper(async (table: Table, key) => {
-        common.metrics.ponder_indexing_store_queries_total.inc({
-          table: getTableName(table),
-          method: "find",
-        });
+        common.metrics.incrementIndexingStoreQueries(
+          getTableName(table),
+          "find",
+        );
         checkOnchainTable(table, "find");
         checkTableAccess(table, "find", key, chainId);
         const ponderRow = await indexingCache.get({ table, key });
@@ -177,13 +186,17 @@ export const createIndexingStore = ({
           values: (userValues: any) => {
             const inner = {
               onConflictDoNothing: storeMethodWrapper(async () => {
-                common.metrics.ponder_indexing_store_queries_total.inc({
-                  table: getTableName(table),
-                  method: "insert",
-                });
+                common.metrics.incrementIndexingStoreQueries(
+                  getTableName(table),
+                  "insert",
+                );
                 checkOnchainTable(table, "insert");
 
-                const ponderValues = copy(userValues);
+                const ponderValues = Array.isArray(userValues)
+                  ? userValues.map((value) =>
+                      copy(value, isCopyFast.get(table)!),
+                    )
+                  : copy(userValues, isCopyFast.get(table)!);
 
                 if (Array.isArray(ponderValues)) {
                   const ponderRows = [];
@@ -232,10 +245,10 @@ export const createIndexingStore = ({
               }),
               onConflictDoUpdate: storeMethodWrapper(
                 async (userUpdateValues: any) => {
-                  common.metrics.ponder_indexing_store_queries_total.inc({
-                    table: getTableName(table),
-                    method: "insert",
-                  });
+                  common.metrics.incrementIndexingStoreQueries(
+                    getTableName(table),
+                    "insert",
+                  );
                   checkOnchainTable(table, "insert");
 
                   if (Array.isArray(userValues)) {
@@ -248,17 +261,24 @@ export const createIndexingStore = ({
                       });
 
                       if (ponderRowUpdate) {
-                        ponderRowUpdate = copy(ponderRowUpdate);
+                        ponderRowUpdate = copy(
+                          ponderRowUpdate,
+                          isCopyFast.get(table)!,
+                        );
                         if (typeof userUpdateValues === "function") {
                           const userRowUpdate = copyOnWrite(ponderRowUpdate);
                           const userSet = userUpdateValues(userRowUpdate);
-                          const ponderSet = copy(userSet);
+                          const ponderSet = copy(
+                            userSet,
+                            isCopyFast.get(table)!,
+                          );
                           validateUpdateSet(
                             table,
                             ponderSet,
                             ponderRowUpdate,
                             primaryKeyCache,
                           );
+                          normalizeUpdateSet(table, ponderSet);
                           for (const [key, value] of Object.entries(
                             ponderSet,
                           )) {
@@ -267,13 +287,17 @@ export const createIndexingStore = ({
                           }
                         } else {
                           const userSet = userUpdateValues;
-                          const ponderSet = copy(userSet);
+                          const ponderSet = copy(
+                            userSet,
+                            isCopyFast.get(table)!,
+                          );
                           validateUpdateSet(
                             table,
                             ponderSet,
                             ponderRowUpdate,
                             primaryKeyCache,
                           );
+                          normalizeUpdateSet(table, ponderSet);
                           for (const [key, value] of Object.entries(
                             ponderSet,
                           )) {
@@ -290,7 +314,7 @@ export const createIndexingStore = ({
                           }),
                         );
                       } else {
-                        const ponderValue = copy(value);
+                        const ponderValue = copy(value, isCopyFast.get(table)!);
                         ponderRows.push(
                           indexingCache.set({
                             table,
@@ -313,30 +337,35 @@ export const createIndexingStore = ({
                     });
 
                     if (ponderRowUpdate) {
-                      ponderRowUpdate = copy(ponderRowUpdate);
+                      ponderRowUpdate = copy(
+                        ponderRowUpdate,
+                        isCopyFast.get(table)!,
+                      );
                       if (typeof userUpdateValues === "function") {
                         const userRowUpdate = copyOnWrite(ponderRowUpdate);
                         const userSet = userUpdateValues(userRowUpdate);
-                        const ponderSet = copy(userSet);
+                        const ponderSet = copy(userSet, isCopyFast.get(table)!);
                         validateUpdateSet(
                           table,
                           ponderSet,
                           ponderRowUpdate,
                           primaryKeyCache,
                         );
+                        normalizeUpdateSet(table, ponderSet);
                         for (const [key, value] of Object.entries(ponderSet)) {
                           if (value === undefined) continue;
                           ponderRowUpdate[key] = value;
                         }
                       } else {
                         const userSet = userUpdateValues;
-                        const ponderSet = copy(userSet);
+                        const ponderSet = copy(userSet, isCopyFast.get(table)!);
                         validateUpdateSet(
                           table,
                           ponderSet,
                           ponderRowUpdate,
                           primaryKeyCache,
                         );
+                        normalizeUpdateSet(table, ponderSet);
                         for (const [key, value] of Object.entries(ponderSet)) {
                           if (value === undefined) continue;
                           ponderRowUpdate[key] = value;
@@ -352,7 +381,10 @@ export const createIndexingStore = ({
                       return userRow;
                     }
 
-                    const ponderValues = copy(userValues);
+                    const ponderValues = copy(
+                      userValues,
+                      isCopyFast.get(table)!,
+                    );
 
                     const ponderRowInsert = indexingCache.set({
                       table,
@@ -369,12 +401,16 @@ export const createIndexingStore = ({
               // biome-ignore lint/suspicious/noThenProperty: The returned object is intentionally thenable for the query API.
               then: (onFulfilled, onRejected) =>
                 storeMethodWrapper(async () => {
-                  common.metrics.ponder_indexing_store_queries_total.inc({
-                    table: getTableName(table),
-                    method: "insert",
-                  });
+                  common.metrics.incrementIndexingStoreQueries(
+                    getTableName(table),
+                    "insert",
+                  );
                   checkOnchainTable(table, "insert");
-                  const ponderValues = copy(userValues);
+                  const ponderValues = Array.isArray(userValues)
+                    ? userValues.map((value) =>
+                        copy(value, isCopyFast.get(table)!),
+                      )
+                    : copy(userValues, isCopyFast.get(table)!);
 
                   if (Array.isArray(ponderValues)) {
                     const ponderRows = [];
@@ -488,10 +524,10 @@ export const createIndexingStore = ({
       update(table: Table, key) {
         return {
           set: storeMethodWrapper(async (userValues: any) => {
-            common.metrics.ponder_indexing_store_queries_total.inc({
-              table: getTableName(table),
-              method: "update",
-            });
+            common.metrics.incrementIndexingStoreQueries(
+              getTableName(table),
+              "update",
+            );
             checkOnchainTable(table, "update");
             checkTableAccess(table, "update", key, chainId);
 
@@ -507,31 +543,33 @@ export const createIndexingStore = ({
               throw error;
             }
 
-            ponderRowUpdate = copy(ponderRowUpdate);
+            ponderRowUpdate = copy(ponderRowUpdate, isCopyFast.get(table)!);
 
             if (typeof userValues === "function") {
               const userRow = copyOnWrite(ponderRowUpdate);
               const userSet = userValues(userRow);
-              const ponderSet = copy(userSet);
+              const ponderSet = copy(userSet, isCopyFast.get(table)!);
               validateUpdateSet(
                 table,
                 ponderSet,
                 ponderRowUpdate,
                 primaryKeyCache,
               );
+              normalizeUpdateSet(table, ponderSet);
               for (const [key, value] of Object.entries(ponderSet)) {
                 if (value === undefined) continue;
                 ponderRowUpdate[key] = value;
               }
             } else {
               const userSet = userValues;
-              const ponderSet = copy(userSet);
+              const ponderSet = copy(userSet, isCopyFast.get(table)!);
               validateUpdateSet(
                 table,
                 ponderSet,
                 ponderRowUpdate,
                 primaryKeyCache,
               );
+              normalizeUpdateSet(table, ponderSet);
               for (const [key, value] of Object.entries(ponderSet)) {
                 if (value === undefined) continue;
                 ponderRowUpdate[key] = value;
@@ -550,10 +588,10 @@ export const createIndexingStore = ({
         };
       },
       delete: storeMethodWrapper(async (table: Table, key) => {
-        common.metrics.ponder_indexing_store_queries_total.inc({
-          table: getTableName(table),
-          method: "delete",
-        });
+        common.metrics.incrementIndexingStoreQueries(
+          getTableName(table),
+          "delete",
+        );
         checkOnchainTable(table, "delete");
         checkTableAccess(table, "delete", key, chainId);
         return indexingCache.delete({ table, key });

package/src/indexing-store/utils.ts

@@ -16,6 +16,21 @@ import {
 } from "@/internal/errors.js";
 import { prettyPrint } from "@/utils/print.js";
 
+const tableColumnCache = new WeakMap<
+  Table,
+  { columns: Record<string, Column>; entries: [string, Column][] }
+>();
+
+const getCachedTableColumns = (table: Table) => {
+  let cached = tableColumnCache.get(table);
+  if (cached === undefined) {
+    const columns = getTableColumns(table);
+    cached = { columns, entries: Object.entries(columns) };
+    tableColumnCache.set(table, cached);
+  }
+  return cached;
+};
+
 /**
  * Returns true if the column has a "default" value that is used when no value is passed.
  * Handles `.default`, `.$defaultFn()`, `.$onUpdateFn()`.
@@ -102,7 +117,7 @@ export const normalizeRow = (
   row: { [key: string]: unknown },
   isUpdate: boolean,
 ) => {
-  for (const [columnName, column] of Object.entries(getTableColumns(table))) {
+  for (const [columnName, column] of getCachedTableColumns(table).entries) {
     // not-null constraint
     if (
       isUpdate === false &&
@@ -127,6 +142,19 @@ export const normalizeRow = (
   return row;
 };
 
+export const normalizeUpdateSet = (
+  table: Table,
+  row: { [key: string]: unknown },
+) => {
+  const { columns } = getCachedTableColumns(table);
+  for (const [columnName, value] of Object.entries(row)) {
+    const column = columns[columnName];
+    if (value === undefined || column === undefined) continue;
+    row[columnName] = normalizeColumn(column, value, true);
+  }
+  return row;
+};
+
 export const getCacheKey = (
   table: Table,
   key: object,

package/src/internal/metrics.ts

@@ -25,6 +25,9 @@ const httpRequestSizeBytes = [
 const GET_METRICS_REQ = "prom-client:getMetricsReq";
 const GET_METRICS_RES = "prom-client:getMetricsRes";
 
+type IndexingCacheRequestType = "complete" | "hit" | "miss" | "prefetch";
+type IndexingStoreMethod = "find" | "insert" | "update" | "delete";
+
 export class MetricsService {
   registry: prometheus.Registry;
   start_timestamp: number;
@@ -112,6 +115,16 @@ export class MetricsService {
   ponder_postgres_query_queue_size: prometheus.Gauge<"pool"> = null!;
   ponder_postgres_pool_connections: prometheus.Gauge<"pool" | "kind"> = null!;
 
+  private indexingCompletedEvents = new Map<string, number>();
+  private indexingCacheRequests = new Map<
+    string,
+    Map<IndexingCacheRequestType, number>
+  >();
+  private indexingStoreQueries = new Map<
+    string,
+    Map<IndexingStoreMethod, number>
+  >();
+
   constructor() {
     this.registry = new prometheus.Registry();
     this.start_timestamp = Date.now();
@@ -206,6 +219,7 @@ export class MetricsService {
       labelNames: ["chain", "event"] as const,
       registers: [this.registry],
       aggregator: "sum",
+      collect: () => this.flushIndexingCompletedEvents(),
     });
     this.ponder_indexing_timestamp = new prometheus.Gauge({
       name: "ponder_indexing_timestamp",
@@ -258,6 +272,7 @@ export class MetricsService {
       labelNames: ["table", "type"] as const,
       registers: [this.registry],
       aggregator: "sum",
+      collect: () => this.flushIndexingCacheRequests(),
     });
     this.ponder_indexing_store_queries_total = new prometheus.Counter({
       name: "ponder_indexing_store_queries_total",
@@ -265,6 +280,7 @@ export class MetricsService {
       labelNames: ["table", "method"] as const,
       registers: [this.registry],
       aggregator: "sum",
+      collect: () => this.flushIndexingStoreQueries(),
     });
     this.ponder_indexing_store_raw_sql_duration = new prometheus.Histogram({
       name: "ponder_indexing_store_raw_sql_duration",
@@ -449,6 +465,70 @@ export class MetricsService {
     return this.registry;
   }
 
+  incrementIndexingCompletedEvents(event: string, value = 1) {
+    this.indexingCompletedEvents.set(
+      event,
+      (this.indexingCompletedEvents.get(event) ?? 0) + value,
+    );
+  }
+
+  incrementIndexingCacheRequests(
+    table: string,
+    type: IndexingCacheRequestType,
+    value = 1,
+  ) {
+    let requests = this.indexingCacheRequests.get(table);
+    if (requests === undefined) {
+      requests = new Map();
+      this.indexingCacheRequests.set(table, requests);
+    }
+    requests.set(type, (requests.get(type) ?? 0) + value);
+  }
+
+  incrementIndexingStoreQueries(
+    table: string,
+    method: IndexingStoreMethod,
+    value = 1,
+  ) {
+    let queries = this.indexingStoreQueries.get(table);
+    if (queries === undefined) {
+      queries = new Map();
+      this.indexingStoreQueries.set(table, queries);
+    }
+    queries.set(method, (queries.get(method) ?? 0) + value);
+  }
+
+  flushIndexingMetrics() {
+    this.flushIndexingCompletedEvents();
+    this.flushIndexingCacheRequests();
+    this.flushIndexingStoreQueries();
+  }
+
+  private flushIndexingCompletedEvents() {
+    for (const [event, value] of this.indexingCompletedEvents) {
+      this.ponder_indexing_completed_events.inc({ event }, value);
+    }
+    this.indexingCompletedEvents.clear();
+  }
+
+  private flushIndexingCacheRequests() {
+    for (const [table, requests] of this.indexingCacheRequests) {
+      for (const [type, value] of requests) {
+        this.ponder_indexing_cache_requests_total.inc({ table, type }, value);
+      }
+    }
+    this.indexingCacheRequests.clear();
+  }
+
+  private flushIndexingStoreQueries() {
+    for (const [table, queries] of this.indexingStoreQueries) {
+      for (const [method, value] of queries) {
+        this.ponder_indexing_store_queries_total.inc({ table, method }, value);
+      }
+    }
+    this.indexingStoreQueries.clear();
+  }
+
   initializeIndexingMetrics({
     indexingBuild,
     schemaBuild,
@@ -480,6 +560,7 @@ export class MetricsService {
   }
 
   resetIndexingMetrics() {
+    this.flushIndexingMetrics();
     this.start_timestamp = Date.now();
     this.rps = {};
     this.progressMetadata = {

package/src/runtime/isolated.ts

@@ -398,6 +398,7 @@ export async function runIsolated({
         } catch (error) {
           // Note: This can cause a bug with "dev" command, because there are multiple instances
           // updating the same metric.
+          common.metrics.flushIndexingMetrics();
           for (const value of initialCompletedEvents.values) {
             common.metrics.ponder_indexing_completed_events.set(
               value.labels,

package/src/runtime/multichain.ts

@@ -451,6 +451,7 @@ export async function runMultichain({
           );
           endClock = startClock();
         } catch (error) {
+          common.metrics.flushIndexingMetrics();
           for (const value of initialCompletedEvents.values) {
             common.metrics.ponder_indexing_completed_events.set(
               value.labels,

package/src/runtime/omnichain.ts

@@ -470,6 +470,7 @@ export async function runOmnichain({
           );
           endClock = startClock();
         } catch (error) {
+          common.metrics.flushIndexingMetrics();
           for (const value of initialCompletedEvents.values) {
             common.metrics.ponder_indexing_completed_events.set(
               value.labels,

package/src/sync-realtime/index.ts

@@ -1138,7 +1138,7 @@ export const createRealtimeSync = (
 
     // Make sure `transactions` can be garbage collected
     blockWithEventData.block.transactions =
-      blockWithFilteredEventData.block.transactions;
+      blockWithFilteredEventData.transactions;
 
     yield {
       type: "block",