envio 3.3.0-alpha.8 → 3.3.0-rc.0

package/src/EffectState.resi

@@ -0,0 +1,32 @@
+type effectRateLimitState = {
+  callsPerDuration: int,
+  durationMs: int,
+  mutable availableCalls: int,
+  mutable windowStartTime: float,
+  mutable queueCount: int,
+  mutable nextWindowPromise: option<promise<unit>>,
+}
+
+type effectCacheInMemTable = {
+  mutable idsToStore: array<string>,
+  mutable invalidationsCount: int,
+  mutable dict: dict<Change.t<Internal.effectOutput>>,
+  mutable changesCount: float,
+  effect: Internal.effect,
+  scope: Internal.chainScope,
+  table: Table.table,
+  rateLimitState: option<effectRateLimitState>,
+  mutable activeCallsCount: int,
+  mutable prevCallStartTimerRef: Performance.timeRef,
+}
+
+// Opaque store of all per-(effect, scope) runtime state.
+type t
+
+let make: unit => t
+// Get, or lazily create, the in-mem table for an (effect, scope). Reuses the
+// surviving rate-limit window when the table is recreated after a rollback.
+let getTable: (t, ~effect: Internal.effect, ~scope: Internal.chainScope) => effectCacheInMemTable
+let forEach: (t, effectCacheInMemTable => unit) => unit
+// Drop the cache tables but keep the rate-limit windows across a rollback.
+let resetForRollback: t => unit

package/src/Envio.res

@@ -186,11 +186,19 @@ and effectOptions<'input, 'output> = {
   rateLimit: rateLimit,
   /** Whether the effect should be cached. */
   cache?: bool,
+  /** Whether the effect's cache is shared across all chains. Defaults to `true`.
+   Set to `false` to isolate the cache (and rate limiting) per chain and enable
+   `context.chain.id` inside the handler. */
+  crossChain?: bool,
 }
+and effectChain = {id: int}
 and effectContext = {
   log: logger,
   effect: 'input 'output. (effect<'input, 'output>, 'input) => promise<'output>,
   mutable cache: bool,
+  /** The chain the effect was called on. Only available on effects created with
+   `crossChain: false`; accessing it on a cross-chain effect throws. */
+  chain: effectChain,
 }
 and effectArgs<'input> = {
   input: 'input,
@@ -205,10 +213,23 @@ let durationToMs = (duration: rateLimitDuration) =>
   | Milliseconds(ms) => ms
   }
 
+// The name becomes both a Postgres cache-table suffix and a .envio/cache file
+// path segment. Path separators are excluded from the charset and a leading dot
+// is disallowed, so a name can never be "." / ".." or otherwise traverse out of
+// the cache dir; dots elsewhere are fine and keep existing names like
+// "token.metadata" working, since the (name, scope) <-> table <-> path mapping
+// stays reversible.
+let effectNameRe = /^[A-Za-z0-9_-][A-Za-z0-9_.-]*$/
+
 let createEffect = (
   options: effectOptions<'input, 'output>,
   handler: effectArgs<'input> => promise<'output>,
 ) => {
+  if !(effectNameRe->RegExp.test(options.name)) {
+    JsError.throwWithMessage(
+      `Invalid effect name "${options.name}". Effect names may contain letters, numbers, underscores, hyphens and dots (but must not start with a dot or contain a path separator), because the name is used as the cache table name and cache file path.`,
+    )
+  }
   let outputSchema =
     S.schema(_ => options.output)->(Utils.magic: S.t<S.t<'output>> => S.t<Internal.effectOutput>)
   let itemSchema = S.schema((s): Internal.effectCacheItem => {
@@ -222,8 +243,6 @@ let createEffect = (
         Internal.effectOutput,
       >
     ),
-    activeCallsCount: 0,
-    prevCallStartTimerRef: %raw(`null`),
     // This is the way to make the createEffect API
     // work without the need for users to call S.schema themselves,
     // but simply pass the desired object/tuple/etc.
@@ -233,7 +252,6 @@ let createEffect = (
     ),
     output: outputSchema,
     storageMeta: {
-      table: Internal.makeCacheTable(~effectName=options.name),
       outputSchema,
       itemSchema,
     },
@@ -241,16 +259,16 @@ let createEffect = (
     | Some(true) => true
     | _ => false
     },
+    crossChain: switch options.crossChain {
+    | Some(false) => false
+    | _ => true
+    },
     rateLimit: switch options.rateLimit {
     | Disable => None
     | Enable({calls, per}) =>
       Some({
         callsPerDuration: calls,
         durationMs: per->durationToMs,
-        availableCalls: calls,
-        windowStartTime: Date.now(),
-        queueCount: 0,
-        nextWindowPromise: None,
       })
     },
   }->(Utils.magic: Internal.effect => effect<'input, 'output>)

package/src/Envio.res.mjs

@@ -2,8 +2,8 @@
 
 import * as Address from "./Address.res.mjs";
 import * as Process from "process";
-import * as Internal from "./Internal.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
 function durationToMs(duration) {
@@ -18,41 +18,36 @@ function durationToMs(duration) {
   }
 }
 
+let effectNameRe = /^[A-Za-z0-9_-][A-Za-z0-9_.-]*$/;
+
 function createEffect(options, handler) {
+  if (!effectNameRe.test(options.name)) {
+    Stdlib_JsError.throwWithMessage(`Invalid effect name "` + options.name + `". Effect names may contain letters, numbers, underscores, hyphens and dots (but must not start with a dot or contain a path separator), because the name is used as the cache table name and cache file path.`);
+  }
   let outputSchema = S$RescriptSchema.schema(param => options.output);
   let itemSchema = S$RescriptSchema.schema(s => ({
     id: s.m(S$RescriptSchema.string),
     output: s.m(outputSchema)
   }));
   let match = options.cache;
-  let match$1 = options.rateLimit;
+  let match$1 = options.crossChain;
+  let match$2 = options.rateLimit;
   let tmp;
-  if (match$1 === false) {
-    tmp = undefined;
-  } else {
-    let calls = match$1.calls;
-    tmp = {
-      callsPerDuration: calls,
-      durationMs: durationToMs(match$1.per),
-      availableCalls: calls,
-      windowStartTime: Date.now(),
-      queueCount: 0,
-      nextWindowPromise: undefined
-    };
-  }
+  tmp = match$2 === false ? undefined : ({
+      callsPerDuration: match$2.calls,
+      durationMs: durationToMs(match$2.per)
+    });
   return {
     name: options.name,
     handler: handler,
     storageMeta: {
       itemSchema: itemSchema,
-      outputSchema: outputSchema,
-      table: Internal.makeCacheTable(options.name)
+      outputSchema: outputSchema
     },
     defaultShouldCache: match !== undefined ? match : false,
+    crossChain: match$1 !== undefined ? match$1 : true,
     output: outputSchema,
     input: S$RescriptSchema.schema(param => options.input),
-    activeCallsCount: 0,
-    prevCallStartTimerRef: null,
     rateLimit: tmp
   };
 }
@@ -102,6 +97,7 @@ let TestHelpers = {
 
 export {
   durationToMs,
+  effectNameRe,
   createEffect,
   isNonInteractive,
   TestHelpers,

package/src/EnvioGlobal.res

@@ -0,0 +1,53 @@
+// The single process-wide mutable state record, stashed on `globalThis` so a
+// duplicate envio module instance — e.g. when the CLI's `bin.mjs` resolves
+// envio from one path but the user's handlers resolve it from
+// `node_modules/envio` — shares one state. Without this, each copy keeps its
+// own module-level state: registration would read an empty registry and the
+// `indexer.chains` getters would silently fall back to static config values.
+//
+// Slots are opaque (`unknown`) so this module stays at the bottom of the
+// dependency graph; each owning module casts its slot to the real type once
+// (`HandlerRegister` for the registration slots, `Main` for the runtime
+// slots, `RollbackCommit` for its callbacks).
+//
+// Version-gated: the slot shapes can evolve between envio versions, so the
+// guard uses strict full-version equality. On mismatch we throw with a
+// deduplication hint instead of silently mixing shapes across builds.
+type t = {
+  version: string,
+  eventRegistrations: dict<unknown>,
+  mutable activeRegistration: option<unknown>,
+  preRegistered: array<unknown>,
+  rollbackCommitCallbacks: array<unknown>,
+  mutable indexerState: option<unknown>,
+  mutable persistence: option<unknown>,
+}
+
+// Record type with `mutable` so assignment typechecks; ReScript keeps the
+// field name verbatim in the generated JS so the globalThis slot is
+// `__envioGlobal`.
+type globalThis = {mutable __envioGlobal: Nullable.t<t>}
+@val external globalThis: globalThis = "globalThis"
+
+let value: t = {
+  let version = Utils.EnvioPackage.value.version
+  switch globalThis.__envioGlobal->Nullable.toOption {
+  | Some(existing) if existing.version === version => existing
+  | Some(existing) =>
+    JsError.throwWithMessage(
+      `Multiple incompatible envio versions loaded in the same process: ${existing.version} and ${version}. Deduplicate the 'envio' dependency in your project.`,
+    )
+  | None =>
+    let fresh = {
+      version,
+      eventRegistrations: Dict.make(),
+      activeRegistration: None,
+      preRegistered: [],
+      rollbackCommitCallbacks: [],
+      indexerState: None,
+      persistence: None,
+    }
+    globalThis.__envioGlobal = Nullable.make(fresh)
+    fresh
+  }
+}

package/src/EnvioGlobal.res.mjs

@@ -0,0 +1,31 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "./Utils.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+
+let version = Utils.EnvioPackage.value.version;
+
+let existing = globalThis.__envioGlobal;
+
+let value;
+
+if (existing == null) {
+  let fresh = {
+    version: version,
+    eventRegistrations: {},
+    activeRegistration: undefined,
+    preRegistered: [],
+    rollbackCommitCallbacks: [],
+    indexerState: undefined,
+    persistence: undefined
+  };
+  globalThis.__envioGlobal = fresh;
+  value = fresh;
+} else {
+  value = existing.version === version ? existing : Stdlib_JsError.throwWithMessage(`Multiple incompatible envio versions loaded in the same process: ` + existing.version + ` and ` + version + `. Deduplicate the 'envio' dependency in your project.`);
+}
+
+export {
+  value,
+}
+/* existing Not a pure module */

package/src/EventConfigBuilder.res

@@ -236,54 +236,30 @@ let buildSimulateParamsSchema = (params: array<paramMeta>): S.t<Internal.eventPa
 
 // ============== Build topic filter getters ==============
 
-let getTopicEncoder = (abiType: string): (unknown => EvmTypes.Hex.t) => {
-  // Handle array/tuple types - these get keccak256'd
-  if abiType->String.endsWith("]") || abiType->String.startsWith("(") {
-    TopicFilter.castToHexUnsafe->(Utils.magic: ('a => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t)
-  } else {
-    switch abiType {
-    | "address" =>
-      TopicFilter.fromAddress->(
-        Utils.magic: (Address.t => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t
-      )
-
-    | "bool" =>
-      TopicFilter.fromBool->(Utils.magic: (bool => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t)
-    | "string" =>
-      TopicFilter.fromDynamicString->(
-        Utils.magic: (string => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t
-      )
-
-    | "bytes" =>
-      TopicFilter.fromDynamicBytes->(
-        Utils.magic: (string => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t
-      )
-
-    | t if t->String.startsWith("uint") =>
-      TopicFilter.fromBigInt->(Utils.magic: (bigint => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t)
-    | t if t->String.startsWith("int") =>
-      TopicFilter.fromSignedBigInt->(
-        Utils.magic: (bigint => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t
-      )
-
-    | t if t->String.startsWith("bytes") =>
-      TopicFilter.castToHexUnsafe->(
-        Utils.magic: ('a => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t
-      )
-
-    | other => JsError.throwWithMessage(`Unsupported topic filter ABI type: ${other}`)
-    }
-  }
-}
+let getTopicEncoder = (abiType: string): (unknown => EvmTypes.Hex.t) => value =>
+  Core.getAddon().encodeIndexedTopic(~abiType, ~value)
 
 let buildTopicGetter = (p: paramMeta) => {
   let encoder = getTopicEncoder(p.abiType)
+  let isTuple = p.abiType->String.startsWith("(")
   (eventFilter: dict<JSON.t>) =>
     eventFilter
     ->Utils.Dict.dangerouslyGetNonOption(p.name)
-    ->Option.mapOr([], topicFilters =>
-      topicFilters->(Utils.magic: JSON.t => unknown)->normalizeOrThrow->Array.map(encoder)
-    )
+    ->Option.mapOr([], topicFilters => {
+      let raw = topicFilters->(Utils.magic: JSON.t => unknown)
+      // A tuple filter value is itself an array, so a directly-passed tuple is
+      // indistinguishable from an OR-list by shape alone. A single tuple is
+      // the common case, so try it first; when the value doesn't ABI-encode as
+      // one tuple it must be an OR-list of tuples.
+      if isTuple {
+        switch encoder(raw) {
+        | encoded => [encoded]
+        | exception _ => raw->normalizeOrThrow->Array.map(encoder)
+        }
+      } else {
+        raw->normalizeOrThrow->Array.map(encoder)
+      }
+    })
 }
 
 // ============== Field selection ==============
@@ -413,31 +389,26 @@ let buildEvmEventConfig = (
 }
 
 // Enrich an EVM definition into a per-(event,chain) registration: resolve the
-// registered `where` (with `probeChainId`) into the lazy `getEventFiltersOrThrow`
-// closure + address filters, and override `startBlock` with `where.block._gte`.
+// registered `where` for this chain into `resolvedWhere` + address filters,
+// and override `startBlock` with `where.block._gte`.
 let buildEvmOnEventRegistration = (
   ~eventConfig: Internal.evmEventConfig,
   ~isWildcard: bool,
   ~handler: option<Internal.handler>,
   ~contractRegister: option<Internal.contractRegister>,
-  ~eventFilters: option<JSON.t>,
-  ~probeChainId: int,
+  ~where: option<JSON.t>,
+  ~chainId: int,
   ~onEventBlockFilterSchema: S.t<option<unknown>>,
   ~startBlock: option<int>=?,
 ): Internal.evmOnEventRegistration => {
   let indexedParams = eventConfig.paramsMetadata->Array.filter(p => p.indexed)
 
-  let {
-    getEventFiltersOrThrow,
-    filterByAddresses,
-    addressFilterParamGroups,
-    startBlock: whereStartBlock,
-  } = LogSelection.parseEventFiltersOrThrow(
-    ~eventFilters,
+  let {resolvedWhere, filterByAddresses, addressFilterParamGroups} = LogSelection.parseWhereOrThrow(
+    ~where,
     ~sighash=eventConfig.sighash,
     ~params=indexedParams->Array.map(p => p.name),
     ~contractName=eventConfig.contractName,
-    ~probeChainId,
+    ~chainId,
     ~onEventBlockFilterSchema,
     ~topic1=?indexedParams->Array.get(0)->Option.map(buildTopicGetter),
     ~topic2=?indexedParams->Array.get(1)->Option.map(buildTopicGetter),
@@ -447,17 +418,18 @@ let buildEvmOnEventRegistration = (
   // `where.block.number._gte` overrides the contract-level startBlock when
   // present (an explicit per-event opt-in that wins over `config.yaml`);
   // otherwise the contract/chain value passes through.
-  let resolvedStartBlock = switch whereStartBlock {
+  let resolvedStartBlock = switch resolvedWhere.startBlock {
   | Some(_) as sb => sb
   | None => startBlock
   }
 
   {
+    index: -1,
     eventConfig: (eventConfig :> Internal.eventConfig),
     isWildcard,
     handler,
     contractRegister,
-    getEventFiltersOrThrow,
+    resolvedWhere,
     filterByAddresses,
     clientAddressFilter: ?buildAddressFilter(addressFilterParamGroups, ~isWildcard),
     dependsOnAddresses: Internal.dependsOnAddresses(~isWildcard, ~filterByAddresses),
@@ -537,6 +509,7 @@ let buildSvmOnEventRegistration = (
   ~contractRegister: option<Internal.contractRegister>,
   ~startBlock: option<int>=?,
 ): Internal.svmOnEventRegistration => {
+  index: -1,
   eventConfig: (eventConfig :> Internal.eventConfig),
   handler,
   contractRegister,
@@ -614,6 +587,7 @@ let buildFuelOnEventRegistration = (
   ~contractRegister: option<Internal.contractRegister>,
   ~startBlock: option<int>=?,
 ): Internal.fuelOnEventRegistration => {
+  index: -1,
   eventConfig: (eventConfig :> Internal.eventConfig),
   handler,
   contractRegister,

package/src/EventConfigBuilder.res.mjs

@@ -2,11 +2,11 @@
 
 import * as Evm from "./sources/Evm.res.mjs";
 import * as Svm from "./sources/Svm.res.mjs";
+import * as Core from "./Core.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Address from "./Address.res.mjs";
 import * as FuelSDK from "./sources/FuelSDK.res.mjs";
 import * as Internal from "./Internal.res.mjs";
-import * as TopicFilter from "./TopicFilter.res.mjs";
 import * as LogSelection from "./LogSelection.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
@@ -208,34 +208,24 @@ function buildSimulateParamsSchema(params) {
 }
 
 function getTopicEncoder(abiType) {
-  if (abiType.endsWith("]") || abiType.startsWith("(")) {
-    return TopicFilter.castToHexUnsafe;
-  }
-  switch (abiType) {
-    case "address" :
-      return TopicFilter.fromAddress;
-    case "bool" :
-      return TopicFilter.fromBool;
-    case "bytes" :
-      return TopicFilter.fromDynamicBytes;
-    case "string" :
-      return TopicFilter.fromDynamicString;
-    default:
-      if (abiType.startsWith("uint")) {
-        return TopicFilter.fromBigInt;
-      } else if (abiType.startsWith("int")) {
-        return TopicFilter.fromSignedBigInt;
-      } else if (abiType.startsWith("bytes")) {
-        return TopicFilter.castToHexUnsafe;
-      } else {
-        return Stdlib_JsError.throwWithMessage(`Unsupported topic filter ABI type: ` + abiType);
-      }
-  }
+  return value => Core.getAddon().encodeIndexedTopic(abiType, value);
 }
 
 function buildTopicGetter(p) {
   let encoder = getTopicEncoder(p.abiType);
-  return eventFilter => Stdlib_Option.mapOr(eventFilter[p.name], [], topicFilters => normalizeOrThrow(topicFilters).map(encoder));
+  let isTuple = p.abiType.startsWith("(");
+  return eventFilter => Stdlib_Option.mapOr(eventFilter[p.name], [], topicFilters => {
+    if (!isTuple) {
+      return normalizeOrThrow(topicFilters).map(encoder);
+    }
+    let encoded;
+    try {
+      encoded = encoder(topicFilters);
+    } catch (exn) {
+      return normalizeOrThrow(topicFilters).map(encoder);
+    }
+    return [encoded];
+  });
 }
 
 let alwaysIncludedBlockFields = [
@@ -309,13 +299,15 @@ function buildEvmEventConfig(contractName, eventName, sighash, params, blockFiel
   };
 }
 
-function buildEvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, eventFilters, probeChainId, onEventBlockFilterSchema, startBlock) {
+function buildEvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, where, chainId, onEventBlockFilterSchema, startBlock) {
   let indexedParams = eventConfig.paramsMetadata.filter(p => p.indexed);
-  let match = LogSelection.parseEventFiltersOrThrow(eventFilters, eventConfig.sighash, indexedParams.map(p => p.name), eventConfig.contractName, probeChainId, onEventBlockFilterSchema, Stdlib_Option.map(indexedParams[0], buildTopicGetter), Stdlib_Option.map(indexedParams[1], buildTopicGetter), Stdlib_Option.map(indexedParams[2], buildTopicGetter));
-  let whereStartBlock = match.startBlock;
+  let match = LogSelection.parseWhereOrThrow(where, eventConfig.sighash, indexedParams.map(p => p.name), eventConfig.contractName, chainId, onEventBlockFilterSchema, Stdlib_Option.map(indexedParams[0], buildTopicGetter), Stdlib_Option.map(indexedParams[1], buildTopicGetter), Stdlib_Option.map(indexedParams[2], buildTopicGetter));
   let filterByAddresses = match.filterByAddresses;
-  let resolvedStartBlock = whereStartBlock !== undefined ? whereStartBlock : startBlock;
+  let resolvedWhere = match.resolvedWhere;
+  let sb = resolvedWhere.startBlock;
+  let resolvedStartBlock = sb !== undefined ? sb : startBlock;
   return {
+    index: -1,
     eventConfig: eventConfig,
     handler: handler,
     contractRegister: contractRegister,
@@ -324,7 +316,7 @@ function buildEvmOnEventRegistration(eventConfig, isWildcard, handler, contractR
     dependsOnAddresses: Internal.dependsOnAddresses(isWildcard, filterByAddresses),
     clientAddressFilter: buildAddressFilter(match.addressFilterParamGroups, isWildcard, undefined),
     startBlock: resolvedStartBlock,
-    getEventFiltersOrThrow: match.getEventFiltersOrThrow
+    resolvedWhere: resolvedWhere
   };
 }
 
@@ -368,6 +360,7 @@ function buildSvmInstructionEventConfig(contractName, instructionName, programId
 
 function buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, startBlock) {
   return {
+    index: -1,
     eventConfig: eventConfig,
     handler: handler,
     contractRegister: contractRegister,
@@ -437,6 +430,7 @@ function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi) {
 
 function buildFuelOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, startBlock) {
   return {
+    index: -1,
     eventConfig: eventConfig,
     handler: handler,
     contractRegister: contractRegister,

package/src/EventProcessing.res

@@ -73,9 +73,10 @@ let runEventHandlerOrThrow = async (
     )
   }
   let handlerDuration = timeBeforeHandler->Performance.secondsSince
+  let eventConfig = eventItem.onEventRegistration.eventConfig
   Prometheus.ProcessingHandler.increment(
-    ~contract=eventItem.onEventRegistration.eventConfig.contractName,
-    ~event=eventItem.onEventRegistration.eventConfig.name,
+    ~contract=eventConfig.contractName,
+    ~event=eventConfig.name,
     ~duration=handlerDuration,
   )
 }
@@ -121,8 +122,8 @@ let runHandlerOrThrow = async (
         }),
       )
     }
-  | Event({onEventRegistration}) =>
-    switch onEventRegistration.handler {
+  | Event(_) =>
+    switch (item->Internal.castUnsafeEventItem).onEventRegistration.handler {
     | Some(handler) =>
       await item->runEventHandlerOrThrow(
         ~handler,
@@ -161,7 +162,9 @@ let preloadBatchOrThrow = async (
     for idx in 0 to checkpointEventsProcessed - 1 {
       let item = batch.items->Array.getUnsafe(itemIdx.contents + idx)
       switch item {
-      | Event({onEventRegistration: {handler, eventConfig: {contractName, name: eventName}}}) =>
+      | Event(_) =>
+        let {handler, eventConfig: {contractName, name: eventName}} =
+          (item->Internal.castUnsafeEventItem).onEventRegistration
         switch handler {
         | None => ()
         | Some(handler) =>

package/src/EventProcessing.res.mjs

@@ -65,7 +65,8 @@ async function runEventHandlerOrThrow(item, checkpointId, handler, indexerState,
     };
   }
   let handlerDuration = Performance.secondsSince(timeBeforeHandler);
-  return Prometheus.ProcessingHandler.increment(item.onEventRegistration.eventConfig.contractName, item.onEventRegistration.eventConfig.name, handlerDuration);
+  let eventConfig = item.onEventRegistration.eventConfig;
+  return Prometheus.ProcessingHandler.increment(eventConfig.contractName, eventConfig.name, handlerDuration);
 }
 
 async function runHandlerOrThrow(item, checkpointId, indexerState, loadManager, persistence, config, chains) {