@mikeatlast/ponder 0.16.1-fork.1

package/src/indexing/index.ts

@@ -0,0 +1,976 @@
+import util from "node:util";
+import type { IndexingCache } from "@/indexing-store/cache.js";
+import type { IndexingStore } from "@/indexing-store/index.js";
+import type { CachedViemClient } from "@/indexing/client.js";
+import type { Common } from "@/internal/common.js";
+import {
+  BaseError,
+  IndexingFunctionError,
+  InvalidEventAccessError,
+  ShutdownError,
+} from "@/internal/errors.js";
+import type {
+  Chain,
+  Contract,
+  Event,
+  Filter,
+  IndexingBuild,
+  IndexingErrorHandler,
+  Schema,
+  SetupEvent,
+  UserBlock,
+  UserLog,
+  UserTrace,
+  UserTransaction,
+} from "@/internal/types.js";
+import {
+  defaultBlockFilterInclude,
+  defaultBlockInclude,
+  defaultLogFilterInclude,
+  defaultTraceFilterInclude,
+  defaultTraceInclude,
+  defaultTransactionFilterInclude,
+  defaultTransactionInclude,
+  defaultTransactionReceiptInclude,
+  defaultTransferFilterInclude,
+  requiredBlockFilterInclude,
+  requiredLogFilterInclude,
+  requiredTraceFilterInclude,
+  requiredTransactionFilterInclude,
+  requiredTransactionReceiptInclude,
+  requiredTransferFilterInclude,
+} from "@/runtime/filter.js";
+import type { Db } from "@/types/db.js";
+import type {
+  Block,
+  Trace,
+  Transaction,
+  TransactionReceipt,
+} from "@/types/eth.js";
+import type { DeepPartial } from "@/types/utils.js";
+import {
+  ZERO_CHECKPOINT,
+  decodeCheckpoint,
+  encodeCheckpoint,
+} from "@/utils/checkpoint.js";
+import { dedupe } from "@/utils/dedupe.js";
+import { prettyPrint } from "@/utils/print.js";
+import { startClock } from "@/utils/timer.js";
+import type { Abi, Address } from "viem";
+import { addStackTrace } from "./addStackTrace.js";
+import type { ReadonlyClient } from "./client.js";
+
+declare global {
+  var DISABLE_EVENT_PROXY: boolean;
+}
+globalThis.DISABLE_EVENT_PROXY = false;
+
+const EVENT_LOOP_UPDATE_INTERVAL = 25;
+const METRICS_UPDATE_INTERVAL = 100;
+
+export type Context = {
+  chain: { id: number; name: string };
+  client: ReadonlyClient;
+  db: Db<Schema>;
+  contracts: Record<
+    string,
+    {
+      abi: Abi;
+      address?: Address | readonly Address[];
+      startBlock?: number;
+      endBlock?: number;
+    }
+  >;
+};
+
+export type Indexing = {
+  processSetupEvents: () => Promise<void>;
+  processHistoricalEvents: (params: {
+    events: Event[];
+    updateIndexingSeconds: (event: Event, chain: Chain) => void;
+  }) => Promise<void>;
+  processRealtimeEvents: (params: { events: Event[] }) => Promise<void>;
+};
+
+export const getEventCount = (
+  indexingFunctions: IndexingBuild["indexingFunctions"],
+) => {
+  const eventCount: { [eventName: string]: number } = {};
+  for (const { name: eventName } of indexingFunctions) {
+    eventCount[eventName] = 0;
+  }
+  return eventCount;
+};
+
+export type ColumnAccessProfile = {
+  block: Set<keyof Block>;
+  trace: Set<keyof Trace>;
+  transaction: Set<keyof Transaction>;
+  transactionReceipt: Set<keyof TransactionReceipt>;
+  resolved: boolean;
+  count: number;
+};
+
+export type ColumnAccessPattern = Map<string, ColumnAccessProfile>;
+
+export const createColumnAccessPattern = ({
+  indexingBuild,
+}: {
+  indexingBuild: Pick<IndexingBuild, "indexingFunctions">;
+}): ColumnAccessPattern => {
+  const columnAccessPattern = new Map<string, ColumnAccessProfile>();
+
+  for (const { name: eventName } of indexingBuild.indexingFunctions) {
+    columnAccessPattern.set(eventName, {
+      block: new Set(),
+      trace: new Set(),
+      transaction: new Set(),
+      transactionReceipt: new Set(),
+      resolved: false,
+      count: 0,
+    });
+  }
+
+  return columnAccessPattern;
+};
+
+export const createIndexing = ({
+  common,
+  indexingBuild: {
+    eventCallbacks,
+    setupCallbacks,
+    chains,
+    contracts,
+    indexingFunctions,
+  },
+  indexingStore,
+  indexingCache,
+  client,
+  indexingErrorHandler,
+  columnAccessPattern,
+  eventCount,
+}: {
+  common: Common;
+  indexingBuild: Pick<
+    IndexingBuild,
+    | "eventCallbacks"
+    | "setupCallbacks"
+    | "chains"
+    | "contracts"
+    | "indexingFunctions"
+  >;
+  indexingStore: IndexingStore;
+  indexingCache: IndexingCache;
+  client: CachedViemClient;
+  indexingErrorHandler: IndexingErrorHandler;
+  columnAccessPattern: ColumnAccessPattern;
+  eventCount: { [eventName: string]: number };
+}): Indexing => {
+  const indexingFunctionArg = {
+    event: undefined as Event | SetupEvent | undefined,
+    context: {
+      chain: { name: undefined!, id: undefined! },
+      contracts: undefined!,
+      client: undefined!,
+      db: indexingStore.db,
+    } as Context,
+  };
+
+  let lastChainId: number | undefined;
+  const clientByChainId: { [chainId: number]: ReadonlyClient } = {};
+  const contractsByChainId: {
+    [chainId: number]: { [name: string]: Contract };
+  } = {};
+
+  for (const chain of chains) {
+    clientByChainId[chain.id] = client.getClient(chain);
+  }
+
+  for (let i = 0; i < chains.length; i++) {
+    const chain = chains[i]!;
+    contractsByChainId[chain.id] = contracts[i]!;
+  }
+
+  const metricLabels: { [event: string]: { event: string } } = {};
+  for (const { name } of indexingFunctions) {
+    metricLabels[name] = { event: name };
+  }
+
+  const executeSetup = async (event: SetupEvent): Promise<void> => {
+    try {
+      if (event.chain.id !== lastChainId) {
+        indexingFunctionArg.context.chain.id = event.chain.id;
+        indexingFunctionArg.context.chain.name = event.chain.name;
+        indexingFunctionArg.context.contracts =
+          contractsByChainId[event.chain.id]!;
+        indexingFunctionArg.context.client = clientByChainId[event.chain.id]!;
+
+        lastChainId = event.chain.id;
+      }
+
+      const endClock = startClock();
+
+      await event.setupCallback.fn(indexingFunctionArg);
+
+      // Note: Check `getRetryableError` to handle user-code catching errors
+      // from the indexing store.
+
+      if (indexingErrorHandler.getRetryableError()) {
+        const retryableError = indexingErrorHandler.getRetryableError()!;
+        indexingErrorHandler.clearRetryableError();
+        throw retryableError;
+      }
+
+      common.metrics.ponder_indexing_function_duration.observe(
+        metricLabels[event.setupCallback.name]!,
+        endClock(),
+      );
+    } catch (_error) {
+      let error = _error instanceof Error ? _error : new Error(String(_error));
+
+      // Note: Use `getRetryableError` rather than `error` to avoid
+      // issues with the user-code augmenting errors from the indexing store.
+
+      if (indexingErrorHandler.getRetryableError()) {
+        const retryableError = indexingErrorHandler.getRetryableError()!;
+        indexingErrorHandler.clearRetryableError();
+        error = retryableError;
+      }
+
+      if (common.shutdown.isKilled) {
+        throw new ShutdownError();
+      }
+
+      addStackTrace(error, common.options);
+      addErrorMeta(error, toErrorMeta(event));
+
+      const decodedCheckpoint = decodeCheckpoint(event.checkpoint);
+      common.logger.error({
+        msg: "Error while processing event",
+        event: event.setupCallback.name,
+        chain: event.chain.name,
+        chain_id: event.chain.id,
+        block_number: decodedCheckpoint.blockNumber,
+        error,
+      });
+
+      common.metrics.hasError = true;
+
+      if (error instanceof BaseError === false) {
+        error = new IndexingFunctionError(error.message);
+      }
+
+      throw error;
+    }
+  };
+
+  // metric label for "ponder_indexing_function_duration"
+  const executeEvent = async (event: Event): Promise<void> => {
+    try {
+      if (event.chain.id !== lastChainId) {
+        indexingFunctionArg.context.chain.id = event.chain.id;
+        indexingFunctionArg.context.chain.name = event.chain.name;
+        indexingFunctionArg.context.contracts =
+          contractsByChainId[event.chain.id]!;
+        indexingFunctionArg.context.client = clientByChainId[event.chain.id]!;
+
+        lastChainId = event.chain.id;
+      }
+      // @ts-ignore
+      indexingFunctionArg.event = event.event;
+
+      const endClock = startClock();
+
+      await event.eventCallback.fn(indexingFunctionArg);
+
+      common.metrics.ponder_indexing_function_duration.observe(
+        metricLabels[event.eventCallback.name]!,
+        endClock(),
+      );
+
+      // Note: Check `getRetryableError` to handle user-code catching errors
+      // from the indexing store.
+
+      if (indexingErrorHandler.getRetryableError()) {
+        const retryableError = indexingErrorHandler.getRetryableError()!;
+        indexingErrorHandler.clearRetryableError();
+        throw retryableError;
+      }
+    } catch (_error) {
+      let error = _error instanceof Error ? _error : new Error(String(_error));
+
+      // Note: Use `getRetryableError` rather than `error` to avoid
+      // issues with the user-code augmenting errors from the indexing store.
+
+      if (indexingErrorHandler.getRetryableError()) {
+        const retryableError = indexingErrorHandler.getRetryableError()!;
+        indexingErrorHandler.clearRetryableError();
+        error = retryableError;
+      }
+
+      if (common.shutdown.isKilled) {
+        throw new ShutdownError();
+      }
+
+      if (error instanceof InvalidEventAccessError) {
+        throw error;
+      }
+
+      addStackTrace(error, common.options);
+      addErrorMeta(error, toErrorMeta(event));
+
+      const decodedCheckpoint = decodeCheckpoint(event.checkpoint);
+
+      common.logger.error({
+        msg: "Error while processing event",
+        event: event.eventCallback.name,
+        chain: event.chain.name,
+        chain_id: event.chain.id,
+        block_number: decodedCheckpoint.blockNumber,
+        error,
+      });
+
+      common.metrics.hasError = true;
+
+      if (error instanceof BaseError === false) {
+        error = new IndexingFunctionError(error.message);
+      }
+
+      throw error;
+    }
+  };
+
+  const resetFilterInclude = (eventName: string) => {
+    const filters = perEventFilters.get(eventName)!;
+    let include: Filter["include"];
+
+    // Note: It's an invariant that all filters have the same type.
+    switch (filters[0]!.type) {
+      case "block": {
+        include = defaultBlockFilterInclude;
+        break;
+      }
+      case "transaction": {
+        include = defaultTransactionFilterInclude;
+        break;
+      }
+      case "trace": {
+        include = defaultTraceFilterInclude.concat(
+          filters[0]!.hasTransactionReceipt
+            ? defaultTransactionReceiptInclude.map(
+                (value) => `transactionReceipt.${value}` as const,
+              )
+            : [],
+        );
+        break;
+      }
+      case "log": {
+        include = defaultLogFilterInclude.concat(
+          filters[0]!.hasTransactionReceipt
+            ? defaultTransactionReceiptInclude.map(
+                (value) => `transactionReceipt.${value}` as const,
+              )
+            : [],
+        );
+        break;
+      }
+      case "transfer": {
+        include = defaultTransferFilterInclude.concat(
+          filters[0]!.hasTransactionReceipt
+            ? defaultTransactionReceiptInclude.map(
+                (value) => `transactionReceipt.${value}` as const,
+              )
+            : [],
+        );
+        break;
+      }
+    }
+    for (const filter of filters) {
+      isFilterResolved.set(filter, false);
+      filter.include = include;
+    }
+    columnAccessPattern.get(eventName)!.count = 0;
+  };
+
+  const blockProxy = createEventProxy<Block>(
+    columnAccessPattern,
+    "block",
+    indexingErrorHandler,
+    resetFilterInclude,
+  );
+  const transactionProxy = createEventProxy<Transaction>(
+    columnAccessPattern,
+    "transaction",
+    indexingErrorHandler,
+    resetFilterInclude,
+  );
+  const transactionReceiptProxy = createEventProxy<TransactionReceipt>(
+    columnAccessPattern,
+    "transactionReceipt",
+    indexingErrorHandler,
+    resetFilterInclude,
+  );
+  const traceProxy = createEventProxy<Trace>(
+    columnAccessPattern,
+    "trace",
+    indexingErrorHandler,
+    resetFilterInclude,
+  );
+  // Note: There is no `log` proxy because all log columns are required.
+
+  // Note: Indexing functions map to one or more filters.
+  const perEventFilters = new Map<string, Filter[]>();
+  const isFilterResolved = new Map<Filter, boolean>();
+  for (const eventCallback of eventCallbacks.flat()) {
+    if (perEventFilters.has(eventCallback.name) === false) {
+      perEventFilters.set(eventCallback.name, [eventCallback.filter]);
+    } else {
+      perEventFilters.get(eventCallback.name)!.push(eventCallback.filter);
+    }
+
+    isFilterResolved.set(eventCallback.filter, false);
+  }
+
+  return {
+    async processSetupEvents() {
+      for (const setupCallback of setupCallbacks.flat()) {
+        const event = {
+          type: "setup",
+          chain: setupCallback.chain,
+          setupCallback,
+          checkpoint: encodeCheckpoint({
+            ...ZERO_CHECKPOINT,
+            chainId: BigInt(setupCallback.chain.id),
+            blockNumber: BigInt(setupCallback.block ?? 0),
+          }),
+          block: BigInt(setupCallback.block ?? 0),
+        } satisfies SetupEvent;
+
+        client.event = event;
+
+        await executeSetup(event);
+      }
+    },
+    async processHistoricalEvents({ events, updateIndexingSeconds }) {
+      let lastEventLoopUpdate = performance.now();
+      let lastMetricsUpdate = performance.now();
+
+      for (let i = 0; i < events.length; i++) {
+        const event = events[i]!;
+
+        client.event = event;
+        indexingCache.event = event;
+
+        // Note: Create a new event object instead of mutuating the original one because
+        // the event object could be reused across multiple indexing functions.
+        const proxyEvent: typeof event.event = { ...event.event };
+
+        switch (event.type) {
+          case "block": {
+            blockProxy.eventName = event.eventCallback.name;
+            blockProxy.underlying = event.event.block as Block;
+            proxyEvent.block = blockProxy.proxy;
+
+            break;
+          }
+          case "transaction": {
+            blockProxy.eventName = event.eventCallback.name;
+            blockProxy.underlying = event.event.block as Block;
+            proxyEvent.block = blockProxy.proxy;
+
+            transactionProxy.eventName = event.eventCallback.name;
+            transactionProxy.underlying = event.event
+              .transaction as Transaction;
+            // @ts-expect-error
+            proxyEvent.transaction = transactionProxy.proxy;
+
+            if (event.event.transactionReceipt !== undefined) {
+              transactionReceiptProxy.eventName = event.eventCallback.name;
+              transactionReceiptProxy.underlying = event.event
+                .transactionReceipt as TransactionReceipt;
+              // @ts-expect-error
+              proxyEvent.transactionReceipt = transactionReceiptProxy.proxy;
+            }
+
+            break;
+          }
+          case "trace":
+          case "transfer": {
+            blockProxy.eventName = event.eventCallback.name;
+            blockProxy.underlying = event.event.block as Block;
+            proxyEvent.block = blockProxy.proxy;
+
+            transactionProxy.eventName = event.eventCallback.name;
+            transactionProxy.underlying = event.event
+              .transaction as Transaction;
+            // @ts-expect-error
+            proxyEvent.transaction = transactionProxy.proxy;
+
+            if (event.event.transactionReceipt !== undefined) {
+              transactionReceiptProxy.eventName = event.eventCallback.name;
+              transactionReceiptProxy.underlying = event.event
+                .transactionReceipt as TransactionReceipt;
+              // @ts-expect-error
+              proxyEvent.transactionReceipt = transactionReceiptProxy.proxy;
+            }
+
+            traceProxy.eventName = event.eventCallback.name;
+            traceProxy.underlying = event.event.trace as Trace;
+            // @ts-expect-error
+            proxyEvent.trace = traceProxy.proxy;
+
+            break;
+          }
+          case "log": {
+            blockProxy.eventName = event.eventCallback.name;
+            blockProxy.underlying = event.event.block as Block;
+            proxyEvent.block = blockProxy.proxy;
+
+            if (event.event.transaction !== undefined) {
+              transactionProxy.eventName = event.eventCallback.name;
+              transactionProxy.underlying = event.event
+                .transaction as Transaction;
+              // @ts-expect-error
+              proxyEvent.transaction = transactionProxy.proxy;
+            }
+
+            if (event.event.transactionReceipt !== undefined) {
+              transactionReceiptProxy.eventName = event.eventCallback.name;
+              transactionReceiptProxy.underlying = event.event
+                .transactionReceipt as TransactionReceipt;
+              // @ts-expect-error
+              proxyEvent.transactionReceipt = transactionReceiptProxy.proxy;
+            }
+
+            break;
+          }
+        }
+
+        // @ts-expect-error
+        await executeEvent({ ...event, event: proxyEvent });
+
+        common.metrics.ponder_indexing_completed_events.inc(
+          { event: event.eventCallback.name },
+          1,
+        );
+        columnAccessPattern.get(event.eventCallback.name)!.count++;
+        eventCount[event.eventCallback.name]++;
+
+        const now = performance.now();
+
+        if (now - lastEventLoopUpdate > EVENT_LOOP_UPDATE_INTERVAL) {
+          lastEventLoopUpdate = now;
+          await new Promise(setImmediate);
+        }
+
+        if (now - lastMetricsUpdate > METRICS_UPDATE_INTERVAL) {
+          lastMetricsUpdate = now;
+          updateIndexingSeconds(event, event.chain);
+        }
+      }
+
+      let isEveryFilterResolvedBefore = true;
+      let isEveryFilterResolvedAfter = true;
+
+      for (const eventCallback of eventCallbacks.flat()) {
+        if (isFilterResolved.get(eventCallback.filter)) continue;
+
+        isEveryFilterResolvedBefore = false;
+
+        if (columnAccessPattern.get(eventCallback.name)!.count < 100) {
+          isEveryFilterResolvedAfter = false;
+          continue;
+        }
+        isFilterResolved.set(eventCallback.filter, true);
+
+        const filterInclude: Filter["include"] = [];
+
+        const columnAccessProfile = columnAccessPattern.get(
+          eventCallback.name,
+        )!;
+        columnAccessProfile.resolved = true;
+
+        for (const column of columnAccessProfile.block) {
+          filterInclude.push(`block.${column}` as const);
+        }
+        for (const column of columnAccessProfile.transaction) {
+          // @ts-expect-error
+          filterInclude.push(`transaction.${column}` as const);
+        }
+        for (const column of columnAccessProfile.transactionReceipt) {
+          // @ts-expect-error
+          filterInclude.push(`transactionReceipt.${column}` as const);
+        }
+        for (const column of columnAccessProfile.trace) {
+          // @ts-expect-error
+          filterInclude.push(`trace.${column}` as const);
+        }
+
+        switch (eventCallback.filter.type) {
+          case "block": {
+            filterInclude.push(...requiredBlockFilterInclude);
+            break;
+          }
+          case "transaction": {
+            // @ts-expect-error
+            filterInclude.push(...requiredTransactionFilterInclude);
+            break;
+          }
+          case "trace": {
+            // @ts-expect-error
+            filterInclude.push(...requiredTraceFilterInclude);
+            if (eventCallback.filter.hasTransactionReceipt) {
+              filterInclude.push(
+                // @ts-expect-error
+                ...requiredTransactionReceiptInclude.map(
+                  (value) => `transactionReceipt.${value}` as const,
+                ),
+              );
+            }
+            break;
+          }
+          case "log": {
+            // @ts-expect-error
+            filterInclude.push(...requiredLogFilterInclude);
+            if (eventCallback.filter.hasTransactionReceipt) {
+              filterInclude.push(
+                // @ts-expect-error
+                ...requiredTransactionReceiptInclude.map(
+                  (value) => `transactionReceipt.${value}` as const,
+                ),
+              );
+            }
+            break;
+          }
+          case "transfer": {
+            // @ts-expect-error
+            filterInclude.push(...requiredTransferFilterInclude);
+            if (eventCallback.filter.hasTransactionReceipt) {
+              filterInclude.push(
+                // @ts-expect-error
+                ...requiredTransactionReceiptInclude.map(
+                  (value) => `transactionReceipt.${value}` as const,
+                ),
+              );
+            }
+            break;
+          }
+        }
+
+        // @ts-expect-error
+        eventCallback.filter.include = dedupe(filterInclude);
+      }
+
+      if (isEveryFilterResolvedBefore === false && isEveryFilterResolvedAfter) {
+        const blockInclude = new Set<keyof Block>();
+        const transactionInclude = new Set<keyof Transaction>();
+        const transactionReceiptInclude = new Set<keyof TransactionReceipt>();
+        const traceInclude = new Set<keyof Trace>();
+
+        for (const [_, columnAccessProfile] of columnAccessPattern) {
+          for (const blockAccess of columnAccessProfile.block) {
+            blockInclude.add(blockAccess);
+          }
+          for (const transactionAccess of columnAccessProfile.transaction) {
+            transactionInclude.add(transactionAccess);
+          }
+          for (const transactionReceiptAccess of columnAccessProfile.transactionReceipt) {
+            transactionReceiptInclude.add(transactionReceiptAccess);
+          }
+          for (const traceAccess of columnAccessProfile.trace) {
+            traceInclude.add(traceAccess);
+          }
+        }
+
+        common.logger.debug(
+          {
+            msg: "Resolved event property access",
+            total_access_count:
+              blockInclude.size +
+              transactionInclude.size +
+              transactionReceiptInclude.size +
+              traceInclude.size,
+            block_count: blockInclude.size,
+            transaction_count: transactionInclude.size,
+            transaction_receipt_count: transactionReceiptInclude.size,
+            trace_count: traceInclude.size,
+          },
+          ["total_access_count"],
+        );
+      }
+
+      await new Promise(setImmediate);
+      if (events.length > 0) {
+        updateIndexingSeconds(
+          events[events.length - 1]!,
+          events[events.length - 1]!.chain,
+        );
+      }
+    },
+    async processRealtimeEvents({ events }) {
+      for (let i = 0; i < events.length; i++) {
+        const event = events[i]!;
+
+        client.event = event;
+
+        await executeEvent(event);
+
+        common.metrics.ponder_indexing_completed_events.inc(
+          { event: event.eventCallback.name },
+          1,
+        );
+        eventCount[event.eventCallback.name]++;
+      }
+    },
+  };
+};
+
+export const createEventProxy = <
+  T extends Block | Transaction | TransactionReceipt | Trace,
+>(
+  columnAccessPattern: ColumnAccessPattern,
+  type: "block" | "trace" | "transaction" | "transactionReceipt",
+  indexingErrorHandler: IndexingErrorHandler,
+  resetFilterInclude: (eventName: string) => void,
+): { proxy: T; underlying: T; eventName: string } => {
+  let underlying: T = undefined!;
+  let eventName: string = undefined!;
+
+  // Note: We rely on the fact that `default[type]Include` is the entire set of possible columns.
+  let defaultInclude: Set<keyof T>;
+  if (type === "block") {
+    // @ts-expect-error
+    defaultInclude = new Set(defaultBlockInclude);
+  } else if (type === "trace") {
+    // @ts-expect-error
+    defaultInclude = new Set(defaultTraceInclude);
+  } else if (type === "transaction") {
+    // @ts-expect-error
+    defaultInclude = new Set(defaultTransactionInclude);
+  } else if (type === "transactionReceipt") {
+    // @ts-expect-error
+    defaultInclude = new Set(defaultTransactionReceiptInclude);
+  }
+
+  const proxy = new Proxy<T>(
+    // @ts-expect-error
+    {
+      [util.inspect.custom]: (): T => {
+        const printableObject = {} as T;
+
+        for (const prop of defaultInclude) {
+          printableObject[prop] = proxy[prop];
+        }
+
+        return printableObject;
+      },
+    },
+    {
+      deleteProperty(_, prop) {
+        if (
+          // @ts-expect-error
+          defaultInclude.has(prop) === false ||
+          globalThis.DISABLE_EVENT_PROXY
+        ) {
+          return Reflect.deleteProperty(underlying, prop);
+        }
+
+        const profile = columnAccessPattern.get(eventName)!;
+        const isInvalidAccess = prop in underlying === false;
+        // @ts-expect-error
+        profile[type].add(prop);
+
+        if (isInvalidAccess) {
+          profile.resolved = false;
+          resetFilterInclude(eventName);
+          // @ts-expect-error
+          const error = new InvalidEventAccessError(`${type}.${prop}`);
+          indexingErrorHandler.setRetryableError(error);
+          throw error;
+        }
+
+        return Reflect.deleteProperty(underlying, prop);
+      },
+      has(_, prop) {
+        // @ts-expect-error
+        return defaultInclude.has(prop);
+      },
+      ownKeys() {
+        return Array.from(defaultInclude);
+      },
+      set(_, prop, value) {
+        if (
+          // @ts-expect-error
+          defaultInclude.has(prop) === false ||
+          globalThis.DISABLE_EVENT_PROXY
+        ) {
+          return Reflect.set(underlying, prop, value);
+        }
+
+        const profile = columnAccessPattern.get(eventName)!;
+        const isInvalidAccess = prop in underlying === false;
+        // @ts-expect-error
+        profile[type].add(prop);
+
+        if (isInvalidAccess) {
+          profile.resolved = false;
+          resetFilterInclude(eventName);
+          // @ts-expect-error
+          const error = new InvalidEventAccessError(`${type}.${prop}`);
+          indexingErrorHandler.setRetryableError(error);
+          throw error;
+        }
+
+        return Reflect.set(underlying, prop, value);
+      },
+      get(_, prop, receiver) {
+        if (
+          // @ts-expect-error
+          defaultInclude.has(prop) === false ||
+          globalThis.DISABLE_EVENT_PROXY
+        ) {
+          return Reflect.get(underlying, prop, receiver);
+        }
+
+        const profile = columnAccessPattern.get(eventName)!;
+        const isInvalidAccess = prop in underlying === false;
+        // @ts-expect-error
+        profile[type].add(prop);
+
+        if (isInvalidAccess) {
+          profile.resolved = false;
+          resetFilterInclude(eventName);
+          // @ts-expect-error
+          const error = new InvalidEventAccessError(`${type}.${prop}`);
+          indexingErrorHandler.setRetryableError(error);
+          throw error;
+        }
+
+        return Reflect.get(underlying, prop, receiver);
+      },
+    },
+  );
+
+  return {
+    proxy,
+    set underlying(_underlying: T) {
+      underlying = _underlying;
+    },
+    set eventName(_eventName: string) {
+      eventName = _eventName;
+    },
+  };
+};
+
+export const toErrorMeta = (
+  event: DeepPartial<Event> | DeepPartial<SetupEvent>,
+) => {
+  globalThis.DISABLE_EVENT_PROXY = true;
+  switch (event?.type) {
+    case "setup": {
+      const meta = `Block:\n${prettyPrint({
+        number: event?.block,
+      })}`;
+      globalThis.DISABLE_EVENT_PROXY = false;
+      return meta;
+    }
+
+    case "log": {
+      const meta = [
+        `Event arguments:\n${prettyPrint(Array.isArray(event.event?.args) ? undefined : event.event?.args)}`,
+        logText(event?.event?.log),
+        transactionText(event?.event?.transaction),
+        blockText(event?.event?.block),
+      ].join("\n");
+      globalThis.DISABLE_EVENT_PROXY = false;
+      return meta;
+    }
+
+    case "trace": {
+      const meta = [
+        `Call trace arguments:\n${prettyPrint(Array.isArray(event.event?.args) ? undefined : event.event?.args)}`,
+        traceText(event?.event?.trace),
+        transactionText(event?.event?.transaction),
+        blockText(event?.event?.block),
+      ].join("\n");
+      globalThis.DISABLE_EVENT_PROXY = false;
+      return meta;
+    }
+
+    case "transfer": {
+      const meta = [
+        `Transfer arguments:\n${prettyPrint(event?.event?.transfer)}`,
+        traceText(event?.event?.trace),
+        transactionText(event?.event?.transaction),
+        blockText(event?.event?.block),
+      ].join("\n");
+      globalThis.DISABLE_EVENT_PROXY = false;
+      return meta;
+    }
+
+    case "block": {
+      const meta = blockText(event?.event?.block);
+      globalThis.DISABLE_EVENT_PROXY = false;
+      return meta;
+    }
+
+    case "transaction": {
+      const meta = [
+        transactionText(event?.event?.transaction),
+        blockText(event?.event?.block),
+      ].join("\n");
+      globalThis.DISABLE_EVENT_PROXY = false;
+      return meta;
+    }
+
+    default: {
+      return undefined;
+    }
+  }
+};
+
+export const addErrorMeta = (error: unknown, meta: string | undefined) => {
+  // If error isn't an object we can modify, do nothing
+  if (typeof error !== "object" || error === null) return;
+  if (meta === undefined) return;
+
+  try {
+    const errorObj = error as { meta?: unknown };
+    // If meta exists and is an array, try to add to it
+    if (Array.isArray(errorObj.meta)) {
+      errorObj.meta = [...errorObj.meta, meta];
+    } else {
+      // Otherwise set meta to be a new array with the meta string
+      errorObj.meta = [meta];
+    }
+  } catch {
+    // Ignore errors
+  }
+};
+
+const blockText = (block?: DeepPartial<UserBlock>) =>
+  `Block:\n${prettyPrint({
+    hash: block?.hash,
+    number: block?.number,
+    timestamp: block?.timestamp,
+  })}`;
+
+const transactionText = (transaction?: DeepPartial<UserTransaction>) =>
+  `Transaction:\n${prettyPrint({
+    hash: transaction?.hash,
+    from: transaction?.from,
+    to: transaction?.to,
+  })}`;
+
+const logText = (log?: DeepPartial<UserLog>) =>
+  `Log:\n${prettyPrint({
+    index: log?.logIndex,
+    address: log?.address,
+  })}`;
+
+const traceText = (trace?: DeepPartial<UserTrace>) =>
+  `Trace:\n${prettyPrint({
+    traceIndex: trace?.traceIndex,
+    from: trace?.from,
+    to: trace?.to,
+  })}`;