envio 3.6.1 → 3.7.0

package/src/EventConfigBuilder.res

@@ -236,8 +236,8 @@ let buildSimulateParamsSchema = (params: array<paramMeta>): S.t<Internal.eventPa
 
 // ============== Build topic filter getters ==============
 
-let getTopicEncoder = (abiType: string): (unknown => EvmTypes.Hex.t) => value =>
-  Core.getAddon().encodeIndexedTopic(~abiType, ~value)
+let getTopicEncoder = (abiType: string): (unknown => EvmTypes.Hex.t) =>
+  value => Core.getAddon().encodeIndexedTopic(~abiType, ~value)
 
 let buildTopicGetter = (p: paramMeta) => {
   let encoder = getTopicEncoder(p.abiType)
@@ -247,6 +247,7 @@ let buildTopicGetter = (p: paramMeta) => {
     ->Utils.Dict.dangerouslyGetNonOption(p.name)
     ->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
@@ -282,13 +283,128 @@ let resolveFieldSelection = (
   | Some(fields) => Utils.Set.fromArray(fields)
   | None => globalTransactionFieldsSet
   }
-  // The base eventConfig stores these as a string set (field names match the
-  // typed variants at runtime).
-  (
-    selectedBlockFields,
-    selectedTransactionFields->(
+  Internal.makeFieldSelection(
+    ~blockFields=selectedBlockFields->(
+      Utils.magic: Utils.Set.t<Internal.evmBlockField> => Utils.Set.t<string>
+    ),
+    ~transactionFields=selectedTransactionFields->(
       Utils.magic: Utils.Set.t<Internal.evmTransactionField> => Utils.Set.t<string>
     ),
+    ~blockMaskFn=Evm.eventBlockFieldMask,
+    ~transactionMaskFn=Evm.eventTransactionFieldMask,
+  )
+}
+
+// `block.number` is the item's own key, so an inline selection carries it
+// whether or not the handler listed it. Nothing else is added: dropping
+// `timestamp`/`hash` is the point of naming fields inline, and the two things
+// that read them off the payload cope — the progress-latency metric
+// (`ChainState.applyBatchProgress`) skips a batch whose last block has no
+// timestamp, and `raw_events` selects them back below.
+let internalBlockFields = ["number"]
+
+// `toRawEvent` reads `block.hash`/`block.timestamp` for the `raw_events` row's
+// own columns, which are not nullable. They stay out of the row's stored
+// `block_fields` (`Evm.cleanUpRawEventFieldsInPlace` strips number/timestamp/
+// hash from it), so the column still holds exactly what the registration
+// selected.
+let rawEventBlockFields = ["hash", "timestamp"]
+
+let selectionKinds = ["block", "transaction"]
+
+// A handler written in plain JS gets no type error for a `blocks`/`transactions`
+// typo, and an unrecognised key would read as an empty selection — silently
+// dropping every field `config.yaml` selected. Rejected here so the option is
+// held to the same shape whether or not the project type-checks it.
+let validateFieldsShapeOrThrow = (fields: Internal.evmFieldsSelection, ~registration: string) => {
+  let raw = fields->(Utils.magic: Internal.evmFieldsSelection => unknown)
+  if typeof(raw) !== #object || raw === %raw(`null`) || Array.isArray(raw) {
+    JsError.throwWithMessage(
+      `The fields option of ${registration} must be an object of block and transaction field names.`,
+    )
+  }
+  raw
+  ->(Utils.magic: unknown => dict<unknown>)
+  ->Dict.keysToArray
+  ->Array.forEach(key =>
+    if !(selectionKinds->Array.includes(key)) {
+      JsError.throwWithMessage(
+        `Invalid "${key}" key in the fields option of ${registration}. Valid keys: ${selectionKinds->Array.joinUnsafe(
+            ", ",
+          )}.`,
+      )
+    }
+  )
+}
+
+let validBlockFields = Utils.Set.fromArray(Evm.blockFields)
+let validTransactionFields = Utils.Set.fromArray(Evm.transactionFields)
+
+let parseFieldsOrThrow = (
+  fields: option<array<string>>,
+  ~valid: Utils.Set.t<string>,
+  ~kind: string,
+  ~registration: string,
+) => {
+  let seen = Utils.Set.make()
+  let fields = switch fields {
+  | None => []
+  | Some(fields) if !Array.isArray(fields) =>
+    JsError.throwWithMessage(
+      `The fields.${kind} option of ${registration} must be an array of field names.`,
+    )
+  | Some(fields) => fields
+  }
+  fields->Array.forEach(name => {
+    if !(valid->Utils.Set.has(name)) {
+      JsError.throwWithMessage(
+        `Invalid "${name}" field in the fields.${kind} option of ${registration}. Valid ${kind} fields: ${valid
+          ->Utils.Set.toArray
+          ->Array.joinUnsafe(", ")}.`,
+      )
+    }
+    if seen->Utils.Set.has(name) {
+      JsError.throwWithMessage(
+        `Duplicate "${name}" field in the fields.${kind} option of ${registration}.`,
+      )
+    }
+    seen->Utils.Set.add(name)->ignore
+  })
+  seen
+}
+
+// Resolve an inline `fields` option into a selection. Depends only on the
+// option itself (the names are for error messages), never on the chain, so one
+// `onEvent` call resolves once and shares the result across every chain.
+let resolveInlineFieldSelection = (
+  fields: Internal.evmFieldsSelection,
+  ~contractName: string,
+  ~eventName: string,
+  ~enableRawEvents: bool,
+): Internal.fieldSelection => {
+  let registration = `the "${eventName}" event registration on contract "${contractName}"`
+  validateFieldsShapeOrThrow(fields, ~registration)
+  let blockFields = parseFieldsOrThrow(
+    fields.block,
+    ~valid=validBlockFields,
+    ~kind="block",
+    ~registration,
+  )
+  let transactionFields = parseFieldsOrThrow(
+    fields.transaction,
+    ~valid=validTransactionFields,
+    ~kind="transaction",
+    ~registration,
+  )
+  blockFields->Utils.Set.addMany(internalBlockFields)
+  if enableRawEvents {
+    blockFields->Utils.Set.addMany(rawEventBlockFields)
+  }
+  Internal.makeFieldSelection(
+    ~blockFields,
+    ~transactionFields,
+    ~blockMaskFn=Evm.eventBlockFieldMask,
+    ~transactionMaskFn=Evm.eventTransactionFieldMask,
   )
 }
 
@@ -306,26 +422,17 @@ let buildEvmEventConfig = (
 ): 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>
-      ),
+    fieldSelection: resolveFieldSelection(
+      ~blockFields,
+      ~transactionFields,
+      ~globalBlockFieldsSet,
+      ~globalTransactionFieldsSet,
     ),
     sighash,
     topicCount,
@@ -344,6 +451,9 @@ let buildEvmOnEventRegistration = (
   ~where: option<JSON.t>,
   ~chainId: ChainId.t,
   ~onEventBlockFilterSchema: S.t<option<unknown>>,
+  // The registration's inline selection, already resolved; absent when it named
+  // no fields and takes the event config's.
+  ~fieldSelection: option<Internal.fieldSelection>=?,
   ~startBlock: option<int>=?,
 ): Internal.evmOnEventRegistration => {
   let indexedParams = eventConfig.paramsMetadata->Array.filter(p => p.indexed)
@@ -379,6 +489,10 @@ let buildEvmOnEventRegistration = (
     addressFilterParamGroups,
     dependsOnAddresses: Internal.dependsOnAddresses(~isWildcard, ~filterByAddresses),
     startBlock: resolvedStartBlock,
+    fieldSelection: switch fieldSelection {
+    | Some(fieldSelection) => fieldSelection
+    | None => eventConfig.fieldSelection
+    },
   }
 }
 
@@ -408,17 +522,15 @@ let buildSvmInstructionEventConfig = (
     ->Utils.Schema.coerceToJsonPgType
     ->(Utils.magic: S.t<JSON.t> => S.t<Internal.eventParams>)
 
-  // The base eventConfig stores these as a string set (field names match the
-  // typed variants at runtime).
-  let selectedTransactionFields =
-    Utils.Set.fromArray(transactionFields)->(
+  let fieldSelection = Internal.makeFieldSelection(
+    ~blockFields=Utils.Set.fromArray(Array.concat(alwaysIncludedSvmBlockFields, blockFields))->(
+      Utils.magic: Utils.Set.t<Internal.svmBlockField> => Utils.Set.t<string>
+    ),
+    ~transactionFields=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>),
+    ),
+    ~blockMaskFn=Svm.eventBlockFieldMask,
+    ~transactionMaskFn=Svm.eventTransactionFieldMask,
   )
   {
     id: switch discriminator {
@@ -433,10 +545,7 @@ let buildSvmInstructionEventConfig = (
     discriminator,
     discriminatorByteLen,
     includeLogs,
-    selectedTransactionFields,
-    transactionFieldMask: Svm.eventTransactionFieldMask(selectedTransactionFields),
-    selectedBlockFields,
-    blockFieldMask,
+    fieldSelection,
     accountFilters,
     isInner,
     accounts,
@@ -462,6 +571,7 @@ let buildSvmOnEventRegistration = (
   filterByAddresses: false,
   dependsOnAddresses: Internal.dependsOnAddresses(~isWildcard, ~filterByAddresses=false),
   startBlock,
+  fieldSelection: eventConfig.fieldSelection,
 }
 
 // ============== Build Fuel event config ==============
@@ -513,11 +623,15 @@ let buildFuelEventConfig = (
     contractName,
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
-    // Fuel keeps the transaction and block inline on the payload; nothing to
-    // materialise.
-    selectedTransactionFields: Utils.Set.make(),
-    transactionFieldMask: 0.,
-    blockFieldMask: 0.,
+    // Fuel keeps the transaction inline on the payload, so nothing is selected
+    // for it; the block is materialised from the store with the full
+    // always-queried trio.
+    fieldSelection: Internal.makeFieldSelection(
+      ~blockFields=Utils.Set.fromArray(Fuel.blockFields),
+      ~transactionFields=Utils.Set.fromArray(Fuel.transactionFields),
+      ~blockMaskFn=Fuel.eventBlockFieldMask,
+      ~transactionMaskFn=Fuel.eventTransactionFieldMask,
+    ),
     kind: fuelKind,
   }
 }
@@ -539,4 +653,5 @@ let buildFuelOnEventRegistration = (
   filterByAddresses: false,
   dependsOnAddresses: Internal.dependsOnAddresses(~isWildcard, ~filterByAddresses=false),
   startBlock,
+  fieldSelection: eventConfig.fieldSelection,
 }

package/src/EventConfigBuilder.res.mjs

@@ -3,6 +3,7 @@
 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 Fuel from "./sources/Fuel.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Address from "./Address.res.mjs";
 import * as FuelSDK from "./sources/FuelSDK.res.mjs";
@@ -237,10 +238,63 @@ let alwaysIncludedBlockFields = [
 function resolveFieldSelection(blockFields, transactionFields, globalBlockFieldsSet, globalTransactionFieldsSet) {
   let selectedBlockFields = blockFields !== undefined ? new Set(alwaysIncludedBlockFields.concat(blockFields)) : globalBlockFieldsSet;
   let selectedTransactionFields = transactionFields !== undefined ? new Set(transactionFields) : globalTransactionFieldsSet;
-  return [
-    selectedBlockFields,
-    selectedTransactionFields
-  ];
+  return Internal.makeFieldSelection(selectedBlockFields, selectedTransactionFields, Evm.eventBlockFieldMask, Evm.eventTransactionFieldMask);
+}
+
+let internalBlockFields = ["number"];
+
+let rawEventBlockFields = [
+  "hash",
+  "timestamp"
+];
+
+let selectionKinds = [
+  "block",
+  "transaction"
+];
+
+function validateFieldsShapeOrThrow(fields, registration) {
+  if (typeof fields !== "object" || fields === null || Array.isArray(fields)) {
+    Stdlib_JsError.throwWithMessage(`The fields option of ` + registration + ` must be an object of block and transaction field names.`);
+  }
+  Object.keys(fields).forEach(key => {
+    if (!selectionKinds.includes(key)) {
+      return Stdlib_JsError.throwWithMessage(`Invalid "` + key + `" key in the fields option of ` + registration + `. Valid keys: ` + selectionKinds.join(", ") + `.`);
+    }
+  });
+}
+
+let validBlockFields = new Set(Evm.blockFields);
+
+let validTransactionFields = new Set(Evm.transactionFields);
+
+function parseFieldsOrThrow(fields, valid, kind, registration) {
+  let seen = new Set();
+  let fields$1 = fields !== undefined ? (
+      Array.isArray(fields) ? fields : Stdlib_JsError.throwWithMessage(`The fields.` + kind + ` option of ` + registration + ` must be an array of field names.`)
+    ) : [];
+  fields$1.forEach(name => {
+    if (!valid.has(name)) {
+      Stdlib_JsError.throwWithMessage(`Invalid "` + name + `" field in the fields.` + kind + ` option of ` + registration + `. Valid ` + kind + ` fields: ` + Array.from(valid).join(", ") + `.`);
+    }
+    if (seen.has(name)) {
+      Stdlib_JsError.throwWithMessage(`Duplicate "` + name + `" field in the fields.` + kind + ` option of ` + registration + `.`);
+    }
+    seen.add(name);
+  });
+  return seen;
+}
+
+function resolveInlineFieldSelection(fields, contractName, eventName, enableRawEvents) {
+  let registration = `the "` + eventName + `" event registration on contract "` + contractName + `"`;
+  validateFieldsShapeOrThrow(fields, registration);
+  let blockFields = parseFieldsOrThrow(fields.block, validBlockFields, "block", registration);
+  let transactionFields = parseFieldsOrThrow(fields.transaction, validTransactionFields, "transaction", registration);
+  Utils.$$Set.addMany(blockFields, internalBlockFields);
+  if (enableRawEvents) {
+    Utils.$$Set.addMany(blockFields, rawEventBlockFields);
+  }
+  return Internal.makeFieldSelection(blockFields, transactionFields, Evm.eventBlockFieldMask, Evm.eventTransactionFieldMask);
 }
 
 function buildEvmEventConfig(contractName, eventName, sighash, params, blockFields, transactionFields, globalBlockFieldsSetOpt, globalTransactionFieldsSetOpt) {
@@ -253,26 +307,20 @@ function buildEvmEventConfig(contractName, eventName, sighash, params, blockFiel
       return acc;
     }
   });
-  let match = resolveFieldSelection(blockFields, transactionFields, globalBlockFieldsSet, globalTransactionFieldsSet);
-  let selectedTransactionFields = match[1];
-  let selectedBlockFields = match[0];
   return {
     id: sighash + "_" + topicCount.toString(),
     name: eventName,
     contractName: contractName,
     paramsRawEventSchema: buildParamsSchema(params),
     simulateParamsSchema: buildSimulateParamsSchema(params),
-    selectedTransactionFields: selectedTransactionFields,
-    transactionFieldMask: Evm.eventTransactionFieldMask(selectedTransactionFields),
-    blockFieldMask: Evm.eventBlockFieldMask(selectedBlockFields),
-    selectedBlockFields: selectedBlockFields,
+    fieldSelection: resolveFieldSelection(blockFields, transactionFields, globalBlockFieldsSet, globalTransactionFieldsSet),
     sighash: sighash,
     topicCount: topicCount,
     paramsMetadata: params
   };
 }
 
-function buildEvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, where, chainId, onEventBlockFilterSchema, startBlock) {
+function buildEvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, where, chainId, onEventBlockFilterSchema, fieldSelection, startBlock) {
   let indexedParams = eventConfig.paramsMetadata.filter(p => p.indexed);
   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;
@@ -289,6 +337,7 @@ function buildEvmOnEventRegistration(eventConfig, isWildcard, handler, contractR
     dependsOnAddresses: Internal.dependsOnAddresses(isWildcard, filterByAddresses),
     addressFilterParamGroups: match.addressFilterParamGroups,
     startBlock: resolvedStartBlock,
+    fieldSelection: fieldSelection !== undefined ? fieldSelection : eventConfig.fieldSelection,
     resolvedWhere: resolvedWhere
   };
 }
@@ -306,19 +355,14 @@ function buildSvmInstructionEventConfig(contractName, instructionName, programId
   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);
+  let fieldSelection = Internal.makeFieldSelection(new Set(alwaysIncludedSvmBlockFields.concat(blockFields)), new Set(transactionFields), Svm.eventBlockFieldMask, Svm.eventTransactionFieldMask);
   return {
     id: discriminator !== undefined ? discriminator : "none",
     name: instructionName,
     contractName: contractName,
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
-    selectedTransactionFields: selectedTransactionFields,
-    transactionFieldMask: Svm.eventTransactionFieldMask(selectedTransactionFields),
-    blockFieldMask: blockFieldMask,
-    selectedBlockFields: selectedBlockFields,
+    fieldSelection: fieldSelection,
     programId: programId,
     discriminator: discriminator,
     discriminatorByteLen: discriminatorByteLen,
@@ -340,7 +384,8 @@ function buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractR
     isWildcard: isWildcard,
     filterByAddresses: false,
     dependsOnAddresses: Internal.dependsOnAddresses(isWildcard, false),
-    startBlock: startBlock
+    startBlock: startBlock,
+    fieldSelection: eventConfig.fieldSelection
   };
 }
 
@@ -393,9 +438,7 @@ function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi) {
     contractName: contractName,
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
-    selectedTransactionFields: new Set(),
-    transactionFieldMask: 0,
-    blockFieldMask: 0,
+    fieldSelection: Internal.makeFieldSelection(new Set(Fuel.blockFields), new Set(Fuel.transactionFields), Fuel.eventBlockFieldMask, Fuel.eventTransactionFieldMask),
     kind: fuelKind
   };
 }
@@ -409,7 +452,8 @@ function buildFuelOnEventRegistration(eventConfig, isWildcard, handler, contract
     isWildcard: isWildcard,
     filterByAddresses: false,
     dependsOnAddresses: Internal.dependsOnAddresses(isWildcard, false),
-    startBlock: startBlock
+    startBlock: startBlock,
+    fieldSelection: eventConfig.fieldSelection
   };
 }
 
@@ -428,6 +472,14 @@ export {
   buildTopicGetter,
   alwaysIncludedBlockFields,
   resolveFieldSelection,
+  internalBlockFields,
+  rawEventBlockFields,
+  selectionKinds,
+  validateFieldsShapeOrThrow,
+  validBlockFields,
+  validTransactionFields,
+  parseFieldsOrThrow,
+  resolveInlineFieldSelection,
   buildEvmEventConfig,
   buildEvmOnEventRegistration,
   alwaysIncludedSvmBlockFields,

package/src/EventProcessing.res

@@ -300,15 +300,11 @@ type logPartitionInfo = {
 // 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,
-) => {
+let materializeBatchEvents = async (batch: Batch.t, ~chainStates: dict<ChainState.t>) => {
   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, ~ecosystem)
+  | [cs] => await cs->ChainState.materializeBatchItems(~items=batch.items)
   | _ =>
     let itemsByChain: dict<array<Internal.item>> = Dict.make()
     batch.items->Array.forEach(item => {
@@ -323,7 +319,7 @@ let materializeBatchEvents = async (
     ->Dict.toArray
     ->Array.map(async ((chainId, items)) => {
       let cs = chainStates->Dict.getUnsafe(chainId)
-      await cs->ChainState.materializeBatchItems(~items, ~ecosystem)
+      await cs->ChainState.materializeBatchItems(~items)
     })
     ->Promise.all
   }
@@ -359,7 +355,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 materializeBatchEvents(batch, ~chainStates, ~ecosystem=config.ecosystem.name)
+      await materializeBatchEvents(batch, ~chainStates)
       await batch->preloadBatchOrThrow(~loadManager, ~persistence, ~indexerState, ~chains, ~config)
     }
 

package/src/EventProcessing.res.mjs

@@ -186,7 +186,7 @@ function registerProcessEventBatchMetrics(logger, batch, indexerState, loadDurat
   IndexerState.recordBatchDurations(indexerState, loadDuration, handlerDuration);
 }
 
-async function materializeBatchEvents(batch, chainStates, ecosystem) {
+async function materializeBatchEvents(batch, chainStates) {
   let match = Object.values(chainStates);
   if (match.length !== 1) {
     let itemsByChain = {};
@@ -201,12 +201,12 @@ async function materializeBatchEvents(batch, chainStates, ecosystem) {
     });
     await Promise.all(Object.entries(itemsByChain).map(async param => {
       let cs = chainStates[param[0]];
-      return await ChainState.materializeBatchItems(cs, param[1], ecosystem);
+      return await ChainState.materializeBatchItems(cs, param[1]);
     }));
     return;
   }
   let cs = match[0];
-  return await ChainState.materializeBatchItems(cs, batch.items, ecosystem);
+  return await ChainState.materializeBatchItems(cs, batch.items);
 }
 
 async function processEventBatch(batch, indexerState, loadManager, persistence, config, chainStates) {
@@ -221,7 +221,7 @@ async function processEventBatch(batch, indexerState, loadManager, persistence,
     await Writing.awaitCapacity(indexerState);
     let timeRef = Performance.now();
     if (Utils.$$Array.notEmpty(batch.items)) {
-      await materializeBatchEvents(batch, chainStates, config.ecosystem.name);
+      await materializeBatchEvents(batch, chainStates);
       await preloadBatchOrThrow(batch, loadManager, persistence, config, indexerState, chains);
     }
     let elapsedTimeAfterLoaders = Performance.secondsSince(timeRef);

package/src/EventUtils.res

@@ -1,11 +1,6 @@
-// type eventIndex = {
-//   blockNumber: int,
-//   logIndex: int,
-// }
-//
-
-// takes blockNumber, logIndex and packs them into a number with
-//32 bits, 16 bits and 16 bits respectively
+// Packs blockNumber and logIndex into one number: 32 bits and 16 bits
+// respectively. EVM only — it is the `raw_events.event_id` primary value, and
+// no other ecosystem writes that table.
 let packEventIndex = (~blockNumber, ~logIndex) => {
   let blockNumber = blockNumber->BigInt.fromInt
   let logIndex = logIndex->BigInt.fromInt
@@ -13,42 +8,3 @@ let packEventIndex = (~blockNumber, ~logIndex) => {
 
   blockNumber->BigInt.bitwiseOr(logIndex)
 }
-
-// //Currently not used but keeping in utils
-// //using @live flag for dead code analyser
-// @live
-// let packMultiChainEventIndex = (~timestamp, ~chainId, ~blockNumber, ~logIndex) => {
-//   let timestamp = timestamp->BigInt.fromInt
-//   let chainId = chainId->BigInt.fromInt
-//   let blockNumber = blockNumber->BigInt.fromInt
-//   let logIndex = logIndex->BigInt.fromInt
-
-//   let timestamp = BigInt.shiftLeft(timestamp, 48->BigInt.fromInt)
-//   let chainId = BigInt.shiftLeft(chainId, 16->BigInt.fromInt)
-//   let blockNumber = BigInt.shiftLeft(blockNumber, 16->BigInt.fromInt)
-
-//   timestamp
-//   ->BigInt.bitwiseOr(chainId)
-//   ->BigInt.bitwiseOr(blockNumber)
-//   ->BigInt.bitwiseOr(logIndex)
-// }
-
-// //Currently not used but keeping in utils
-// //using @live flag for dead code analyser
-// @live
-// let unpackEventIndex = (packedEventIndex: bigint) => {
-//   let blockNumber = packedEventIndex->BigInt.shiftRight(16->BigInt.fromInt)
-//   let logIndexMask = 65535->BigInt.fromInt
-//   let logIndex = packedEventIndex->BigInt.bitwiseAnd(logIndexMask)
-//   {
-//     blockNumber: blockNumber->BigInt.toString->Int.fromString->Option.getUnsafe,
-//     logIndex: logIndex->BigInt.toString->Int.fromString->Option.getUnsafe,
-//   }
-// }
-
-// //takes an eventIndex record and returnts a packed event index
-// //used in TS tests
-// @live
-// let packEventIndexFromRecord = (eventIndex: eventIndex) => {
-//   packEventIndex(~blockNumber=eventIndex.blockNumber, ~logIndex=eventIndex.logIndex)
-// }