envio 3.3.0-alpha.7 → 3.3.0-alpha.8

package/src/EventConfigBuilder.res

@@ -378,20 +378,54 @@ let buildEvmEventConfig = (
   ~eventName: string,
   ~sighash: string,
   ~params: array<paramMeta>,
+  ~blockFields: option<array<Internal.evmBlockField>>=?,
+  ~transactionFields: option<array<Internal.evmTransactionField>>=?,
+  ~globalBlockFieldsSet: Utils.Set.t<Internal.evmBlockField>=Utils.Set.make(),
+  ~globalTransactionFieldsSet: Utils.Set.t<Internal.evmTransactionField>=Utils.Set.make(),
+): Internal.evmEventConfig => {
+  let topicCount = params->Array.reduce(1, (acc, p) => p.indexed ? acc + 1 : acc)
+
+  let (selectedBlockFields, selectedTransactionFields) = resolveFieldSelection(
+    ~blockFields,
+    ~transactionFields,
+    ~globalBlockFieldsSet,
+    ~globalTransactionFieldsSet,
+  )
+
+  {
+    id: sighash ++ "_" ++ topicCount->Int.toString,
+    name: eventName,
+    contractName,
+    paramsRawEventSchema: buildParamsSchema(params),
+    simulateParamsSchema: buildSimulateParamsSchema(params),
+    selectedBlockFields,
+    selectedTransactionFields,
+    transactionFieldMask: Evm.eventTransactionFieldMask(selectedTransactionFields),
+    blockFieldMask: Evm.eventBlockFieldMask(
+      selectedBlockFields->(
+        Utils.magic: Utils.Set.t<Internal.evmBlockField> => Utils.Set.t<string>
+      ),
+    ),
+    sighash,
+    topicCount,
+    paramsMetadata: params,
+  }
+}
+
+// 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`.
+let buildEvmOnEventRegistration = (
+  ~eventConfig: Internal.evmEventConfig,
   ~isWildcard: bool,
   ~handler: option<Internal.handler>,
   ~contractRegister: option<Internal.contractRegister>,
   ~eventFilters: option<JSON.t>,
   ~probeChainId: int,
   ~onEventBlockFilterSchema: S.t<option<unknown>>,
-  ~blockFields: option<array<Internal.evmBlockField>>=?,
-  ~transactionFields: option<array<Internal.evmTransactionField>>=?,
   ~startBlock: option<int>=?,
-  ~globalBlockFieldsSet: Utils.Set.t<Internal.evmBlockField>=Utils.Set.make(),
-  ~globalTransactionFieldsSet: Utils.Set.t<Internal.evmTransactionField>=Utils.Set.make(),
-): Internal.evmEventConfig => {
-  let topicCount = params->Array.reduce(1, (acc, p) => p.indexed ? acc + 1 : acc)
-  let indexedParams = params->Array.filter(p => p.indexed)
+): Internal.evmOnEventRegistration => {
+  let indexedParams = eventConfig.paramsMetadata->Array.filter(p => p.indexed)
 
   let {
     getEventFiltersOrThrow,
@@ -400,9 +434,9 @@ let buildEvmEventConfig = (
     startBlock: whereStartBlock,
   } = LogSelection.parseEventFiltersOrThrow(
     ~eventFilters,
-    ~sighash,
+    ~sighash=eventConfig.sighash,
     ~params=indexedParams->Array.map(p => p.name),
-    ~contractName,
+    ~contractName=eventConfig.contractName,
     ~probeChainId,
     ~onEventBlockFilterSchema,
     ~topic1=?indexedParams->Array.get(0)->Option.map(buildTopicGetter),
@@ -410,46 +444,32 @@ let buildEvmEventConfig = (
     ~topic3=?indexedParams->Array.get(2)->Option.map(buildTopicGetter),
   )
 
-  // `where.block.number._gte` overrides the contract-level startBlock
-  // when present. The user opts into this explicitly in handler code so
-  // it should win over the `config.yaml` contract `start_block`; absent
-  // `where.block`, the caller's contract-level value passes through.
+  // `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 {
   | Some(_) as sb => sb
   | None => startBlock
   }
 
-  let (selectedBlockFields, selectedTransactionFields) = resolveFieldSelection(
-    ~blockFields,
-    ~transactionFields,
-    ~globalBlockFieldsSet,
-    ~globalTransactionFieldsSet,
-  )
-
   {
-    id: sighash ++ "_" ++ topicCount->Int.toString,
-    name: eventName,
-    contractName,
+    eventConfig: (eventConfig :> Internal.eventConfig),
     isWildcard,
     handler,
     contractRegister,
-    paramsRawEventSchema: buildParamsSchema(params),
-    simulateParamsSchema: buildSimulateParamsSchema(params),
     getEventFiltersOrThrow,
     filterByAddresses,
     clientAddressFilter: ?buildAddressFilter(addressFilterParamGroups, ~isWildcard),
-    dependsOnAddresses: !isWildcard || filterByAddresses,
+    dependsOnAddresses: Internal.dependsOnAddresses(~isWildcard, ~filterByAddresses),
     startBlock: resolvedStartBlock,
-    selectedBlockFields,
-    selectedTransactionFields,
-    transactionFieldMask: Evm.eventTransactionFieldMask(selectedTransactionFields),
-    sighash,
-    topicCount,
-    paramsMetadata: params,
   }
 }
 
-// ============== Build Fuel event config ==============
+// ============== Build SVM instruction event config ==============
+
+// Always-included block fields (slot, time, hash) are prepended at runtime so
+// they're always present regardless of config.
+let alwaysIncludedSvmBlockFields: array<Internal.svmBlockField> = [Slot, Time, Hash]
 
 let buildSvmInstructionEventConfig = (
   ~contractName: string,
@@ -459,15 +479,12 @@ let buildSvmInstructionEventConfig = (
   ~discriminatorByteLen: int,
   ~includeLogs: bool,
   ~transactionFields: array<Internal.svmTransactionField>=[],
+  ~blockFields: array<Internal.svmBlockField>=[],
   ~accountFilters: array<Internal.svmAccountFilterGroup>,
   ~isInner: option<bool>,
-  ~isWildcard: bool,
-  ~handler: option<Internal.handler>,
-  ~contractRegister: option<Internal.contractRegister>,
   ~accounts: array<string>=[],
   ~args: JSON.t=JSON.Null,
   ~definedTypes: JSON.t=JSON.Null,
-  ~startBlock: option<int>=?,
 ): Internal.svmInstructionEventConfig => {
   let paramsSchema =
     S.json(~validate=false)
@@ -480,6 +497,12 @@ let buildSvmInstructionEventConfig = (
     Utils.Set.fromArray(transactionFields)->(
       Utils.magic: Utils.Set.t<Internal.svmTransactionField> => Utils.Set.t<string>
     )
+  let selectedBlockFields = Utils.Set.fromArray(
+    Array.concat(alwaysIncludedSvmBlockFields, blockFields),
+  )
+  let blockFieldMask = Svm.eventBlockFieldMask(
+    selectedBlockFields->(Utils.magic: Utils.Set.t<Internal.svmBlockField> => Utils.Set.t<string>),
+  )
   {
     id: switch discriminator {
     | Some(d) => d
@@ -487,21 +510,16 @@ let buildSvmInstructionEventConfig = (
     },
     name: instructionName,
     contractName,
-    isWildcard,
-    handler,
-    contractRegister,
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
-    filterByAddresses: false,
-    dependsOnAddresses: !isWildcard,
-    clientAddressFilter: ?buildAddressFilter([], ~isWildcard, ~srcAddressExpr="event.programId"),
-    startBlock,
     programId,
     discriminator,
     discriminatorByteLen,
     includeLogs,
     selectedTransactionFields,
     transactionFieldMask: Svm.eventTransactionFieldMask(selectedTransactionFields),
+    selectedBlockFields,
+    blockFieldMask,
     accountFilters,
     isInner,
     accounts,
@@ -510,16 +528,33 @@ let buildSvmInstructionEventConfig = (
   }
 }
 
+// Enrich an SVM definition into a registration. SVM has no `where`; only the
+// handler binding + wildcard-derived address gate are registration state.
+let buildSvmOnEventRegistration = (
+  ~eventConfig: Internal.svmInstructionEventConfig,
+  ~isWildcard: bool,
+  ~handler: option<Internal.handler>,
+  ~contractRegister: option<Internal.contractRegister>,
+  ~startBlock: option<int>=?,
+): Internal.svmOnEventRegistration => {
+  eventConfig: (eventConfig :> Internal.eventConfig),
+  handler,
+  contractRegister,
+  isWildcard,
+  filterByAddresses: false,
+  dependsOnAddresses: Internal.dependsOnAddresses(~isWildcard, ~filterByAddresses=false),
+  clientAddressFilter: ?buildAddressFilter([], ~isWildcard, ~srcAddressExpr="event.programId"),
+  startBlock,
+}
+
+// ============== Build Fuel event config ==============
+
 let buildFuelEventConfig = (
   ~contractName: string,
   ~eventName: string,
   ~kind: string,
   ~sighash: string,
   ~rawAbi: JSON.t,
-  ~isWildcard: bool,
-  ~handler: option<Internal.handler>,
-  ~contractRegister: option<Internal.contractRegister>,
-  ~startBlock: option<int>=?,
 ): Internal.fuelEventConfig => {
   let fuelKind = switch kind {
   | "logData" =>
@@ -559,18 +594,32 @@ let buildFuelEventConfig = (
     },
     name: eventName,
     contractName,
-    isWildcard,
-    handler,
-    contractRegister,
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
-    filterByAddresses: false,
-    dependsOnAddresses: !isWildcard,
-    clientAddressFilter: ?buildAddressFilter([], ~isWildcard),
-    startBlock,
-    // Fuel keeps the transaction inline on the payload; nothing to materialise.
+    // Fuel keeps the transaction and block inline on the payload; nothing to
+    // materialise.
     selectedTransactionFields: Utils.Set.make(),
     transactionFieldMask: 0.,
+    blockFieldMask: 0.,
     kind: fuelKind,
   }
 }
+
+// Enrich a Fuel definition into a registration (handler binding +
+// wildcard-derived address gate; Fuel never filters by addresses).
+let buildFuelOnEventRegistration = (
+  ~eventConfig: Internal.fuelEventConfig,
+  ~isWildcard: bool,
+  ~handler: option<Internal.handler>,
+  ~contractRegister: option<Internal.contractRegister>,
+  ~startBlock: option<int>=?,
+): Internal.fuelOnEventRegistration => {
+  eventConfig: (eventConfig :> Internal.eventConfig),
+  handler,
+  contractRegister,
+  isWildcard,
+  filterByAddresses: false,
+  dependsOnAddresses: Internal.dependsOnAddresses(~isWildcard, ~filterByAddresses=false),
+  clientAddressFilter: ?buildAddressFilter([], ~isWildcard),
+  startBlock,
+}

package/src/EventConfigBuilder.res.mjs

@@ -280,7 +280,7 @@ function buildAddressFilter(groups, isWildcard, srcAddressExprOpt) {
   return Stdlib_Option.map(buildAddressFilterBody(groups, isWildcard, srcAddressExpr), compileAddressFilter);
 }
 
-function buildEvmEventConfig(contractName, eventName, sighash, params, isWildcard, handler, contractRegister, eventFilters, probeChainId, onEventBlockFilterSchema, blockFields, transactionFields, startBlock, globalBlockFieldsSetOpt, globalTransactionFieldsSetOpt) {
+function buildEvmEventConfig(contractName, eventName, sighash, params, blockFields, transactionFields, globalBlockFieldsSetOpt, globalTransactionFieldsSetOpt) {
   let globalBlockFieldsSet = globalBlockFieldsSetOpt !== undefined ? Primitive_option.valFromOption(globalBlockFieldsSetOpt) : new Set();
   let globalTransactionFieldsSet = globalTransactionFieldsSetOpt !== undefined ? Primitive_option.valFromOption(globalTransactionFieldsSetOpt) : new Set();
   let topicCount = Stdlib_Array.reduce(params, 1, (acc, p) => {
@@ -290,58 +290,70 @@ function buildEvmEventConfig(contractName, eventName, sighash, params, isWildcar
       return acc;
     }
   });
-  let indexedParams = params.filter(p => p.indexed);
-  let match = LogSelection.parseEventFiltersOrThrow(eventFilters, sighash, indexedParams.map(p => p.name), 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 filterByAddresses = match.filterByAddresses;
-  let resolvedStartBlock = whereStartBlock !== undefined ? whereStartBlock : startBlock;
-  let match$1 = resolveFieldSelection(blockFields, transactionFields, globalBlockFieldsSet, globalTransactionFieldsSet);
-  let selectedTransactionFields = match$1[1];
+  let match = resolveFieldSelection(blockFields, transactionFields, globalBlockFieldsSet, globalTransactionFieldsSet);
+  let selectedTransactionFields = match[1];
+  let selectedBlockFields = match[0];
   return {
     id: sighash + "_" + topicCount.toString(),
     name: eventName,
     contractName: contractName,
-    isWildcard: isWildcard,
-    filterByAddresses: filterByAddresses,
-    dependsOnAddresses: !isWildcard || filterByAddresses,
-    clientAddressFilter: buildAddressFilter(match.addressFilterParamGroups, isWildcard, undefined),
-    handler: handler,
-    contractRegister: contractRegister,
     paramsRawEventSchema: buildParamsSchema(params),
     simulateParamsSchema: buildSimulateParamsSchema(params),
-    startBlock: resolvedStartBlock,
     selectedTransactionFields: selectedTransactionFields,
     transactionFieldMask: Evm.eventTransactionFieldMask(selectedTransactionFields),
-    getEventFiltersOrThrow: match.getEventFiltersOrThrow,
-    selectedBlockFields: match$1[0],
+    blockFieldMask: Evm.eventBlockFieldMask(selectedBlockFields),
+    selectedBlockFields: selectedBlockFields,
     sighash: sighash,
     topicCount: topicCount,
     paramsMetadata: params
   };
 }
 
-function buildSvmInstructionEventConfig(contractName, instructionName, programId, discriminator, discriminatorByteLen, includeLogs, transactionFieldsOpt, accountFilters, isInner, isWildcard, handler, contractRegister, accountsOpt, argsOpt, definedTypesOpt, startBlock) {
+function buildEvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, eventFilters, probeChainId, 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 filterByAddresses = match.filterByAddresses;
+  let resolvedStartBlock = whereStartBlock !== undefined ? whereStartBlock : startBlock;
+  return {
+    eventConfig: eventConfig,
+    handler: handler,
+    contractRegister: contractRegister,
+    isWildcard: isWildcard,
+    filterByAddresses: filterByAddresses,
+    dependsOnAddresses: Internal.dependsOnAddresses(isWildcard, filterByAddresses),
+    clientAddressFilter: buildAddressFilter(match.addressFilterParamGroups, isWildcard, undefined),
+    startBlock: resolvedStartBlock,
+    getEventFiltersOrThrow: match.getEventFiltersOrThrow
+  };
+}
+
+let alwaysIncludedSvmBlockFields = [
+  "slot",
+  "time",
+  "hash"
+];
+
+function buildSvmInstructionEventConfig(contractName, instructionName, programId, discriminator, discriminatorByteLen, includeLogs, transactionFieldsOpt, blockFieldsOpt, accountFilters, isInner, accountsOpt, argsOpt, definedTypesOpt) {
   let transactionFields = transactionFieldsOpt !== undefined ? transactionFieldsOpt : [];
+  let blockFields = blockFieldsOpt !== undefined ? blockFieldsOpt : [];
   let accounts = accountsOpt !== undefined ? accountsOpt : [];
   let args = argsOpt !== undefined ? argsOpt : null;
   let definedTypes = definedTypesOpt !== undefined ? definedTypesOpt : null;
   let paramsSchema = Utils.Schema.coerceToJsonPgType(S$RescriptSchema.json(false));
   let selectedTransactionFields = new Set(transactionFields);
+  let selectedBlockFields = new Set(alwaysIncludedSvmBlockFields.concat(blockFields));
+  let blockFieldMask = Svm.eventBlockFieldMask(selectedBlockFields);
   return {
     id: discriminator !== undefined ? discriminator : "none",
     name: instructionName,
     contractName: contractName,
-    isWildcard: isWildcard,
-    filterByAddresses: false,
-    dependsOnAddresses: !isWildcard,
-    clientAddressFilter: buildAddressFilter([], isWildcard, "event.programId"),
-    handler: handler,
-    contractRegister: contractRegister,
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
-    startBlock: startBlock,
     selectedTransactionFields: selectedTransactionFields,
     transactionFieldMask: Svm.eventTransactionFieldMask(selectedTransactionFields),
+    blockFieldMask: blockFieldMask,
+    selectedBlockFields: selectedBlockFields,
     programId: programId,
     discriminator: discriminator,
     discriminatorByteLen: discriminatorByteLen,
@@ -354,7 +366,20 @@ function buildSvmInstructionEventConfig(contractName, instructionName, programId
   };
 }
 
-function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi, isWildcard, handler, contractRegister, startBlock) {
+function buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, startBlock) {
+  return {
+    eventConfig: eventConfig,
+    handler: handler,
+    contractRegister: contractRegister,
+    isWildcard: isWildcard,
+    filterByAddresses: false,
+    dependsOnAddresses: Internal.dependsOnAddresses(isWildcard, false),
+    clientAddressFilter: buildAddressFilter([], isWildcard, "event.programId"),
+    startBlock: startBlock
+  };
+}
+
+function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi) {
   let fuelKind;
   switch (kind) {
     case "burn" :
@@ -401,21 +426,28 @@ function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi, is
     id: tmp,
     name: eventName,
     contractName: contractName,
-    isWildcard: isWildcard,
-    filterByAddresses: false,
-    dependsOnAddresses: !isWildcard,
-    clientAddressFilter: buildAddressFilter([], isWildcard, undefined),
-    handler: handler,
-    contractRegister: contractRegister,
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
-    startBlock: startBlock,
     selectedTransactionFields: new Set(),
     transactionFieldMask: 0,
+    blockFieldMask: 0,
     kind: fuelKind
   };
 }
 
+function buildFuelOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, startBlock) {
+  return {
+    eventConfig: eventConfig,
+    handler: handler,
+    contractRegister: contractRegister,
+    isWildcard: isWildcard,
+    filterByAddresses: false,
+    dependsOnAddresses: Internal.dependsOnAddresses(isWildcard, false),
+    clientAddressFilter: buildAddressFilter([], isWildcard, undefined),
+    startBlock: startBlock
+  };
+}
+
 export {
   paramMetaSchema,
   normalizeOrThrow,
@@ -435,7 +467,11 @@ export {
   buildAddressFilterBody,
   buildAddressFilter,
   buildEvmEventConfig,
+  buildEvmOnEventRegistration,
+  alwaysIncludedSvmBlockFields,
   buildSvmInstructionEventConfig,
+  buildSvmOnEventRegistration,
   buildFuelEventConfig,
+  buildFuelOnEventRegistration,
 }
 /* paramMetaSchema Not a pure module */

package/src/EventProcessing.res

@@ -74,8 +74,8 @@ let runEventHandlerOrThrow = async (
   }
   let handlerDuration = timeBeforeHandler->Performance.secondsSince
   Prometheus.ProcessingHandler.increment(
-    ~contract=eventItem.eventConfig.contractName,
-    ~event=eventItem.eventConfig.name,
+    ~contract=eventItem.onEventRegistration.eventConfig.contractName,
+    ~event=eventItem.onEventRegistration.eventConfig.name,
     ~duration=handlerDuration,
   )
 }
@@ -90,7 +90,7 @@ let runHandlerOrThrow = async (
   ~chains: Internal.chains,
 ) => {
   switch item {
-  | Block({onBlockConfig: {handler}, blockNumber}) =>
+  | Block({onBlockRegistration: {handler}, blockNumber}) =>
     try {
       let contextParams: UserContext.contextParams = {
         item,
@@ -121,8 +121,8 @@ let runHandlerOrThrow = async (
         }),
       )
     }
-  | Event({eventConfig}) =>
-    switch eventConfig.handler {
+  | Event({onEventRegistration}) =>
+    switch onEventRegistration.handler {
     | Some(handler) =>
       await item->runEventHandlerOrThrow(
         ~handler,
@@ -161,7 +161,7 @@ let preloadBatchOrThrow = async (
     for idx in 0 to checkpointEventsProcessed - 1 {
       let item = batch.items->Array.getUnsafe(itemIdx.contents + idx)
       switch item {
-      | Event({eventConfig: {handler, contractName, name: eventName}}) =>
+      | Event({onEventRegistration: {handler, eventConfig: {contractName, name: eventName}}}) =>
         switch handler {
         | None => ()
         | Some(handler) =>
@@ -200,7 +200,7 @@ let preloadBatchOrThrow = async (
           | _ => ()
           }
         }
-      | Block({onBlockConfig: {handler}, blockNumber}) =>
+      | Block({onBlockRegistration: {handler}, blockNumber}) =>
         try {
           promises->Array.push(
             handler({
@@ -289,15 +289,19 @@ type logPartitionInfo = {
   lastItemBlockNumber?: int,
 }
 
-// Off the hot path: bulk-materialise the selected transaction fields for the
-// batch's store-backed (HyperSync) items and write them onto the payloads, so
-// handlers read plain objects. A batch can span chains, each with its own store
-// and field mask, so group items by chain before materialising.
-let materializeBatchTransactions = async (batch: Batch.t, ~chainStates: dict<ChainState.t>) => {
+// Off the hot path: bulk-materialise the selected transaction and block fields
+// for the batch's store-backed (HyperSync) items and write them onto the
+// payloads, so handlers read plain objects. A batch can span chains, each with
+// its own stores and field masks, so group items by chain before materialising.
+let materializeBatchEvents = async (
+  batch: Batch.t,
+  ~chainStates: dict<ChainState.t>,
+  ~ecosystem,
+) => {
   switch chainStates->Dict.valuesToArray {
   // Single-chain indexers (the common case): every item belongs to the one
   // chain, so skip the per-chain grouping and its allocations.
-  | [cs] => await cs->ChainState.materializeBatchItems(~items=batch.items)
+  | [cs] => await cs->ChainState.materializeBatchItems(~items=batch.items, ~ecosystem)
   | _ =>
     let itemsByChain: dict<array<Internal.item>> = Dict.make()
     batch.items->Array.forEach(item => {
@@ -312,7 +316,7 @@ let materializeBatchTransactions = async (batch: Batch.t, ~chainStates: dict<Cha
     ->Dict.toArray
     ->Array.map(async ((chainId, items)) => {
       let cs = chainStates->Dict.getUnsafe(chainId)
-      await cs->ChainState.materializeBatchItems(~items)
+      await cs->ChainState.materializeBatchItems(~items, ~ecosystem)
     })
     ->Promise.all
   }
@@ -348,7 +352,7 @@ let processEventBatch = async (
     if batch.items->Utils.Array.notEmpty {
       // Materialise store-backed transactions onto payloads before any handler
       // (preload or execute) reads them.
-      await materializeBatchTransactions(batch, ~chainStates)
+      await materializeBatchEvents(batch, ~chainStates, ~ecosystem=config.ecosystem.name)
       await batch->preloadBatchOrThrow(~loadManager, ~persistence, ~indexerState, ~chains, ~config)
     }
 

package/src/EventProcessing.res.mjs

@@ -65,12 +65,12 @@ async function runEventHandlerOrThrow(item, checkpointId, handler, indexerState,
     };
   }
   let handlerDuration = Performance.secondsSince(timeBeforeHandler);
-  return Prometheus.ProcessingHandler.increment(item.eventConfig.contractName, item.eventConfig.name, handlerDuration);
+  return Prometheus.ProcessingHandler.increment(item.onEventRegistration.eventConfig.contractName, item.onEventRegistration.eventConfig.name, handlerDuration);
 }
 
 async function runHandlerOrThrow(item, checkpointId, indexerState, loadManager, persistence, config, chains) {
   if (item.kind === 0) {
-    let handler = item.eventConfig.handler;
+    let handler = item.onEventRegistration.handler;
     if (handler !== undefined) {
       return await runEventHandlerOrThrow(item, checkpointId, handler, indexerState, loadManager, persistence, chains, config);
     } else {
@@ -89,7 +89,7 @@ async function runHandlerOrThrow(item, checkpointId, indexerState, loadManager,
       config: config,
       isResolved: false
     };
-    await item.onBlockConfig.handler(Ecosystem.makeOnBlockArgs(item.blockNumber, config.ecosystem, UserContext.getHandlerContext(contextParams)));
+    await item.onBlockRegistration.handler(Ecosystem.makeOnBlockArgs(item.blockNumber, config.ecosystem, UserContext.getHandlerContext(contextParams)));
     contextParams.isResolved = true;
     return;
   } catch (raw_exn) {
@@ -113,11 +113,12 @@ async function preloadBatchOrThrow(batch, loadManager, persistence, config, inde
     for (let idx = 0; idx < checkpointEventsProcessed; ++idx) {
       let item = batch.items[itemIdx + idx | 0];
       if (item.kind === 0) {
-        let match = item.eventConfig;
+        let match = item.onEventRegistration;
         let handler = match.handler;
         if (handler !== undefined) {
-          let contractName = match.contractName;
-          let eventName = match.name;
+          let match$1 = match.eventConfig;
+          let contractName = match$1.contractName;
+          let eventName = match$1.name;
           try {
             let timerRef = Prometheus.PreloadHandler.startOperation(contractName, eventName);
             promises.push(Utils.$$Promise.silentCatch(handler({
@@ -140,7 +141,7 @@ async function preloadBatchOrThrow(batch, loadManager, persistence, config, inde
         }
       } else {
         try {
-          promises.push(Utils.$$Promise.silentCatch(item.onBlockConfig.handler(Ecosystem.makeOnBlockArgs(item.blockNumber, config.ecosystem, UserContext.getHandlerContext({
+          promises.push(Utils.$$Promise.silentCatch(item.onBlockRegistration.handler(Ecosystem.makeOnBlockArgs(item.blockNumber, config.ecosystem, UserContext.getHandlerContext({
             item: item,
             checkpointId: checkpointId,
             indexerState: indexerState,
@@ -184,7 +185,7 @@ function registerProcessEventBatchMetrics(logger, batch, loadDuration, handlerDu
   Prometheus.ProcessingBatch.registerMetrics(loadDuration, handlerDuration);
 }
 
-async function materializeBatchTransactions(batch, chainStates) {
+async function materializeBatchEvents(batch, chainStates, ecosystem) {
   let match = Object.values(chainStates);
   if (match.length !== 1) {
     let itemsByChain = {};
@@ -199,12 +200,12 @@ async function materializeBatchTransactions(batch, chainStates) {
     });
     await Promise.all(Object.entries(itemsByChain).map(async param => {
       let cs = chainStates[param[0]];
-      return await ChainState.materializeBatchItems(cs, param[1]);
+      return await ChainState.materializeBatchItems(cs, param[1], ecosystem);
     }));
     return;
   }
   let cs = match[0];
-  return await ChainState.materializeBatchItems(cs, batch.items);
+  return await ChainState.materializeBatchItems(cs, batch.items, ecosystem);
 }
 
 async function processEventBatch(batch, indexerState, loadManager, persistence, config, chainStates) {
@@ -219,7 +220,7 @@ async function processEventBatch(batch, indexerState, loadManager, persistence,
     await Writing.awaitCapacity(indexerState);
     let timeRef = Performance.now();
     if (Utils.$$Array.notEmpty(batch.items)) {
-      await materializeBatchTransactions(batch, chainStates);
+      await materializeBatchEvents(batch, chainStates, config.ecosystem.name);
       await preloadBatchOrThrow(batch, loadManager, persistence, config, indexerState, chains);
     }
     let elapsedTimeAfterLoaders = Performance.secondsSince(timeRef);
@@ -264,7 +265,7 @@ export {
   preloadBatchOrThrow,
   runBatchHandlersOrThrow,
   registerProcessEventBatchMetrics,
-  materializeBatchTransactions,
+  materializeBatchEvents,
   processEventBatch,
 }
 /* Utils Not a pure module */