envio 3.3.0-alpha.1 → 3.3.0-alpha.3

package/src/CrossChainState.res

@@ -57,7 +57,7 @@ let totalReadyCount = (crossChainState: t) => {
   let total = ref(0)
   for i in 0 to crossChainState.chainIds->Array.length - 1 {
     let cs = crossChainState->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
-    total := total.contents + cs->ChainState.fetchState->FetchState.bufferReadyCount
+    total := total.contents + cs->ChainState.bufferReadyCount
   }
   total.contents
 }
@@ -65,9 +65,7 @@ let totalReadyCount = (crossChainState: t) => {
 // --- Derived (pure). ---
 
 let nextItemIsNone = (crossChainState: t): bool =>
-  !Batch.hasReadyItem(
-    crossChainState.chainStates->Dict.valuesToArray->Array.map(ChainState.fetchState),
-  )
+  !(crossChainState.chainStates->Dict.valuesToArray->Array.some(ChainState.hasReadyItem))
 
 let getSafeCheckpointId = (crossChainState: t) => {
   let result: ref<option<bigint>> = ref(None)
@@ -79,7 +77,7 @@ let getSafeCheckpointId = (crossChainState: t) => {
     | Some(safeCheckpointTracking) =>
       let safeCheckpointId =
         safeCheckpointTracking->SafeCheckpointTracking.getSafeCheckpointId(
-          ~sourceBlockNumber=(cs->ChainState.fetchState).knownHeight,
+          ~sourceBlockNumber=cs->ChainState.knownHeight,
         )
       switch result.contents {
       | None => result := Some(safeCheckpointId)
@@ -111,16 +109,9 @@ let createBatch = (
       // in an append-only ClickHouse insert.
       isRollback ? 1n : 0n,
     ),
-    ~chainsBeforeBatch=crossChainState.chainStates->Utils.Dict.mapValues((
-      cs
-    ): Batch.chainBeforeBatch => {
-      fetchState: cs->ChainState.fetchState,
-      progressBlockNumber: cs->ChainState.committedProgressBlockNumber,
-      totalEventsProcessed: cs->ChainState.numEventsProcessed,
-      sourceBlockNumber: (cs->ChainState.fetchState).knownHeight,
-      reorgDetection: cs->ChainState.reorgDetection,
-      chainConfig: cs->ChainState.chainConfig,
-    }),
+    ~chainsBeforeBatch=crossChainState.chainStates->Utils.Dict.mapValues(
+      ChainState.toChainBeforeBatch,
+    ),
     ~batchSizeTarget,
   )
 }
@@ -184,10 +175,7 @@ let priorityOrder = (crossChainState: t) =>
   crossChainState.chainStates
   ->Dict.valuesToArray
   ->Array.toSorted((a, b) =>
-    Float.compare(
-      a->ChainState.fetchState->FetchState.getProgressPercentage,
-      b->ChainState.fetchState->FetchState.getProgressPercentage,
-    )
+    Float.compare(a->ChainState.getProgressPercentage, b->ChainState.getProgressPercentage)
   )
 
 // In-flight estimated items across every chain — the live draw against
@@ -235,11 +223,7 @@ let checkAndFetch = async (
   for i in 0 to chainIds->Array.length - 1 {
     let chainId = chainIds->Array.getUnsafe(i)
     let cs = crossChainState->getChainState(chainId)
-    let fetchState = cs->ChainState.fetchState
-    switch fetchState->FetchState.getNextQuery(
-      ~budget=remaining,
-      ~chainPendingBudget=cs->ChainState.pendingBudget,
-    ) {
+    switch cs->ChainState.getNextQuery(~budget=remaining) {
     | (WaitingForNewBlock | NothingToQuery) as action =>
       actionByChain->Utils.Dict.setByInt(chainId, action)
     | Ready(queries) =>
@@ -247,8 +231,7 @@ let checkAndFetch = async (
       actionByChain->Utils.Dict.setByInt(chainId, FetchState.NothingToQuery)
       queries->Array.forEach(query => {
         query.chainId = chainId
-        query.progress =
-          fetchState->FetchState.getProgressPercentageAt(~blockNumber=query.fromBlock)
+        query.progress = cs->ChainState.getProgressPercentageAt(~blockNumber=query.fromBlock)
         candidates->Array.push(query)
       })
     }
@@ -271,6 +254,21 @@ let checkAndFetch = async (
     idx := idx.contents + 1
   }
   admittedByChain->Dict.forEachWithKey((queries, chainId) => {
+    let partitions = Dict.make()
+    queries->Array.forEach((query: FetchState.query) =>
+      partitions->Dict.set(
+        query.partitionId,
+        {
+          "fromBlock": query.fromBlock,
+          "targetBlock": query.toBlock,
+        },
+      )
+    )
+    Logging.trace({
+      "msg": "Started querying",
+      "chainId": chainId->Int.fromString->Option.getUnsafe,
+      "partitions": partitions,
+    })
     actionByChain->Dict.set(chainId, FetchState.Ready(queries))
     // Mark the admitted queries in flight and reserve their size against the
     // shared budget; released as each response lands in handleQueryResult.

package/src/CrossChainState.res.mjs

@@ -6,7 +6,6 @@ import * as Utils from "./Utils.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
-import * as FetchState from "./FetchState.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
@@ -53,13 +52,13 @@ function totalReadyCount(crossChainState) {
   let total = 0;
   for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
     let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
-    total = total + FetchState.bufferReadyCount(ChainState.fetchState(cs)) | 0;
+    total = total + ChainState.bufferReadyCount(cs) | 0;
   }
   return total;
 }
 
 function nextItemIsNone(crossChainState) {
-  return !Batch.hasReadyItem(Object.values(crossChainState.chainStates).map(ChainState.fetchState));
+  return !Object.values(crossChainState.chainStates).some(ChainState.hasReadyItem);
 }
 
 function getSafeCheckpointId(crossChainState) {
@@ -68,7 +67,7 @@ function getSafeCheckpointId(crossChainState) {
     let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
     let safeCheckpointTracking = ChainState.safeCheckpointTracking(cs);
     if (safeCheckpointTracking !== undefined) {
-      let safeCheckpointId = SafeCheckpointTracking.getSafeCheckpointId(safeCheckpointTracking, ChainState.fetchState(cs).knownHeight);
+      let safeCheckpointId = SafeCheckpointTracking.getSafeCheckpointId(safeCheckpointTracking, ChainState.knownHeight(cs));
       let current = result;
       if (!(current !== undefined && safeCheckpointId >= current)) {
         result = safeCheckpointId;
@@ -84,14 +83,7 @@ function getSafeCheckpointId(crossChainState) {
 function createBatch(crossChainState, processedCheckpointId, batchSizeTarget, isRollback) {
   return Batch.make(processedCheckpointId + (
     isRollback ? 1n : 0n
-  ), Utils.Dict.mapValues(crossChainState.chainStates, cs => ({
-    fetchState: ChainState.fetchState(cs),
-    reorgDetection: ChainState.reorgDetection(cs),
-    progressBlockNumber: ChainState.committedProgressBlockNumber(cs),
-    sourceBlockNumber: ChainState.fetchState(cs).knownHeight,
-    totalEventsProcessed: ChainState.numEventsProcessed(cs),
-    chainConfig: ChainState.chainConfig(cs)
-  })), batchSizeTarget, crossChainState.isInReorgThreshold);
+  ), Utils.Dict.mapValues(crossChainState.chainStates, ChainState.toChainBeforeBatch), batchSizeTarget, crossChainState.isInReorgThreshold);
 }
 
 function enterReorgThreshold(crossChainState) {
@@ -131,7 +123,7 @@ function applyBatchProgress(crossChainState, batch) {
 }
 
 function priorityOrder(crossChainState) {
-  return Object.values(crossChainState.chainStates).toSorted((a, b) => Primitive_float.compare(FetchState.getProgressPercentage(ChainState.fetchState(a)), FetchState.getProgressPercentage(ChainState.fetchState(b))));
+  return Object.values(crossChainState.chainStates).toSorted((a, b) => Primitive_float.compare(ChainState.getProgressPercentage(a), ChainState.getProgressPercentage(b)));
 }
 
 function totalReservedSize(crossChainState) {
@@ -155,15 +147,14 @@ async function checkAndFetch(crossChainState, dispatchChain) {
   for (let i = 0, i_finish = chainIds.length; i < i_finish; ++i) {
     let chainId = chainIds[i];
     let cs = crossChainState.chainStates[chainId];
-    let fetchState = ChainState.fetchState(cs);
-    let action = FetchState.getNextQuery(fetchState, remaining, ChainState.pendingBudget(cs));
+    let action = ChainState.getNextQuery(cs, remaining);
     if (typeof action !== "object") {
       actionByChain[chainId] = action;
     } else {
       actionByChain[chainId] = "NothingToQuery";
       action._0.forEach(query => {
         query.chainId = chainId;
-        query.progress = FetchState.getProgressPercentageAt(fetchState, query.fromBlock);
+        query.progress = ChainState.getProgressPercentageAt(cs, query.fromBlock);
         candidates.push(query);
       });
     }
@@ -179,6 +170,18 @@ async function checkAndFetch(crossChainState, dispatchChain) {
     idx = idx + 1 | 0;
   };
   Stdlib_Dict.forEachWithKey(admittedByChain, (queries, chainId) => {
+    let partitions = {};
+    queries.forEach(query => {
+      partitions[query.partitionId] = {
+        fromBlock: query.fromBlock,
+        targetBlock: query.toBlock
+      };
+    });
+    Logging.trace({
+      msg: "Started querying",
+      chainId: Stdlib_Int.fromString(chainId, undefined),
+      partitions: partitions
+    });
     actionByChain[chainId] = {
       TAG: "Ready",
       _0: queries

package/src/Ecosystem.res

@@ -2,8 +2,6 @@ type name = | @as("evm") Evm | @as("fuel") Fuel | @as("svm") Svm
 
 type t = {
   name: name,
-  blockFields: array<string>,
-  transactionFields: array<string>,
   blockNumberName: string,
   blockTimestampName: string,
   blockHashName: string,
@@ -33,8 +31,13 @@ type t = {
       loggers (see `getItemLogger`). */
   logger: Pino.t,
   /** Materialise the user-facing event handed to handlers and contract
-      registration from an item's opaque payload. */
+      registration from an item's opaque payload. `event.transaction` is written
+      onto the payload at batch prep (HyperSync) or inline (RPC/simulate). */
   toEvent: Internal.eventItem => Internal.event,
+  /** Bitmask (as a float) of the transaction fields selected across the chain's
+      events — the set the store materialises at batch prep. `0.` when the
+      ecosystem carries transactions inline. */
+  transactionFieldMask: array<Internal.eventConfig> => float,
   /** Build the per-item child logger for an event item, with
       ecosystem-specific log fields (EVM/Fuel: contract/event/address; SVM:
       program/instruction/programId). Closes over the injected logger. */

package/src/Envio.res

@@ -48,6 +48,7 @@ type svmTokenBalance = {
 }
 
 type svmTransaction = {
+  transactionIndex?: int,
   signatures: array<string>,
   feePayer?: SvmTypes.Pubkey.t,
   success?: bool,
@@ -104,8 +105,8 @@ type svmInstruction = {
   d8?: string,
   /** Borsh-decoded params view. See [[svmInstructionParams]]. */
   params?: svmInstructionParams,
-  /** Parent transaction. Absent when the per-instruction
-   `include_transaction` flag is `false`. */
+  /** Parent transaction. Carries only the fields selected via
+   `field_selection.transaction_fields`; absent when none are selected. */
   transaction?: svmTransaction,
   /** Program log entries scoped to this instruction. Absent when the
    per-instruction `include_logs` flag is `false`. */

package/src/EventConfigBuilder.res

@@ -306,7 +306,14 @@ let resolveFieldSelection = (
   | Some(fields) => Utils.Set.fromArray(fields)
   | None => globalTransactionFieldsSet
   }
-  (selectedBlockFields, selectedTransactionFields)
+  // The base eventConfig stores these as a string set (field names match the
+  // typed variants at runtime).
+  (
+    selectedBlockFields,
+    selectedTransactionFields->(
+      Utils.magic: Utils.Set.t<Internal.evmTransactionField> => Utils.Set.t<string>
+    ),
+  )
 }
 
 // ============== Client-side address filter ==============
@@ -319,28 +326,50 @@ let compileAddressFilter: string => (
   return new Function("event", "blockNumber", "indexingAddresses", body);
 }`)
 
-// Body of the client-side address filter for a DNF of address-filtered param
-// names (OR of AND-groups): keep the event only if some group's params are all
-// registered at or before the log's block. The DNF is fixed here, so it's
-// unrolled into one boolean expression — no per-event closure, loop, or array.
-// `None` when there's no address-param filter. Exposed for snapshotting.
-let buildAddressFilterBody = (groups: array<array<string>>): option<string> => {
-  switch groups {
+// Body of the client-side address filter. Two analogous registered-at-or-before
+// checks, ANDed: (1) for non-wildcard events, the log's srcAddress must itself be
+// registered (ownership is resolved structurally by partition, but the temporal
+// `effectiveStartBlock` gate lives here now); (2) a DNF of address-filtered param
+// names (OR of AND-groups) for events that filter an indexed address param. The
+// DNF is fixed here, so it's unrolled into one boolean expression — no per-event
+// closure, loop, or array. `None` only for wildcard events without a param
+// filter. Exposed for snapshotting.
+// `srcAddressExpr` is the JS expression for the event's owning address: EVM and
+// Fuel events expose `event.srcAddress`; SVM instructions expose `event.programId`.
+let buildAddressFilterBody = (
+  groups: array<array<string>>,
+  ~isWildcard: bool,
+  ~srcAddressExpr: string="event.srcAddress",
+): option<string> => {
+  let paramLeaf = name =>
+    `(ic = indexingAddresses[p[${JSON.stringify(
+        JSON.String(name),
+      )}]]) !== undefined && ic.effectiveStartBlock <= blockNumber`
+  let paramDnf = switch groups {
   | [] => None
   | _ =>
-    let leaf = name =>
-      `(ic = indexingAddresses[p[${JSON.stringify(
-          JSON.String(name),
-        )}]]) !== undefined && ic.effectiveStartBlock <= blockNumber`
-    let groupExprs =
-      groups->Array.map(group => "(" ++ group->Array.map(leaf)->Array.join(" && ") ++ ")")
-    Some("var p = event.params, ic; return " ++ groupExprs->Array.join(" || ") ++ ";")
+    Some(
+      groups
+      ->Array.map(group => "(" ++ group->Array.map(paramLeaf)->Array.join(" && ") ++ ")")
+      ->Array.join(" || "),
+    )
+  }
+  let srcLeaf = `(ic = indexingAddresses[${srcAddressExpr}]) !== undefined && ic.effectiveStartBlock <= blockNumber`
+  switch (isWildcard, paramDnf) {
+  | (true, None) => None
+  | (true, Some(dnf)) => Some("var p = event.params, ic; return " ++ dnf ++ ";")
+  | (false, None) => Some("var ic; return " ++ srcLeaf ++ ";")
+  | (false, Some(dnf)) =>
+    Some("var p = event.params, ic; return " ++ srcLeaf ++ " && (" ++ dnf ++ ");")
   }
 }
 
-let buildAddressFilter = (groups: array<array<string>>): option<
-  (Internal.eventPayload, int, dict<Internal.indexingContract>) => bool,
-> => buildAddressFilterBody(groups)->Option.map(compileAddressFilter)
+let buildAddressFilter = (
+  groups: array<array<string>>,
+  ~isWildcard: bool,
+  ~srcAddressExpr: string="event.srcAddress",
+): option<(Internal.eventPayload, int, dict<Internal.indexingContract>) => bool> =>
+  buildAddressFilterBody(groups, ~isWildcard, ~srcAddressExpr)->Option.map(compileAddressFilter)
 
 // ============== Build complete EVM event config ==============
 
@@ -408,7 +437,7 @@ let buildEvmEventConfig = (
     simulateParamsSchema: buildSimulateParamsSchema(params),
     getEventFiltersOrThrow,
     filterByAddresses,
-    clientAddressFilter: ?buildAddressFilter(addressFilterParamGroups),
+    clientAddressFilter: ?buildAddressFilter(addressFilterParamGroups, ~isWildcard),
     dependsOnAddresses: !isWildcard || filterByAddresses,
     startBlock: resolvedStartBlock,
     selectedBlockFields,
@@ -427,9 +456,8 @@ let buildSvmInstructionEventConfig = (
   ~programId: SvmTypes.Pubkey.t,
   ~discriminator: option<string>,
   ~discriminatorByteLen: int,
-  ~includeTransaction: bool,
   ~includeLogs: bool,
-  ~includeTokenBalances: bool,
+  ~transactionFields: array<Internal.svmTransactionField>=[],
   ~accountFilters: array<Internal.svmAccountFilterGroup>,
   ~isInner: option<bool>,
   ~isWildcard: bool,
@@ -444,6 +472,13 @@ let buildSvmInstructionEventConfig = (
     S.json(~validate=false)
     ->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)->(
+      Utils.magic: Utils.Set.t<Internal.svmTransactionField> => Utils.Set.t<string>
+    )
   {
     id: switch discriminator {
     | Some(d) => d
@@ -458,13 +493,13 @@ let buildSvmInstructionEventConfig = (
     simulateParamsSchema: paramsSchema,
     filterByAddresses: false,
     dependsOnAddresses: !isWildcard,
+    clientAddressFilter: ?buildAddressFilter([], ~isWildcard, ~srcAddressExpr="event.programId"),
     startBlock,
     programId,
     discriminator,
     discriminatorByteLen,
-    includeTransaction,
     includeLogs,
-    includeTokenBalances,
+    selectedTransactionFields,
     accountFilters,
     isInner,
     accounts,
@@ -529,7 +564,10 @@ let buildFuelEventConfig = (
     simulateParamsSchema: paramsSchema,
     filterByAddresses: false,
     dependsOnAddresses: !isWildcard,
+    clientAddressFilter: ?buildAddressFilter([], ~isWildcard),
     startBlock,
+    // Fuel keeps the transaction inline on the payload; nothing to materialise.
+    selectedTransactionFields: Utils.Set.make(),
     kind: fuelKind,
   }
 }

package/src/EventConfigBuilder.res.mjs

@@ -255,17 +255,27 @@ let compileAddressFilter = (function (body) {
   return new Function("event", "blockNumber", "indexingAddresses", body);
 });
 
-function buildAddressFilterBody(groups) {
-  if (groups.length === 0) {
-    return;
+function buildAddressFilterBody(groups, isWildcard, srcAddressExprOpt) {
+  let srcAddressExpr = srcAddressExprOpt !== undefined ? srcAddressExprOpt : "event.srcAddress";
+  let paramLeaf = name => `(ic = indexingAddresses[p[` + JSON.stringify(name) + `]]) !== undefined && ic.effectiveStartBlock <= blockNumber`;
+  let paramDnf = groups.length !== 0 ? groups.map(group => "(" + group.map(paramLeaf).join(" && ") + ")").join(" || ") : undefined;
+  let srcLeaf = `(ic = indexingAddresses[` + srcAddressExpr + `]) !== undefined && ic.effectiveStartBlock <= blockNumber`;
+  if (isWildcard) {
+    if (paramDnf !== undefined) {
+      return "var p = event.params, ic; return " + paramDnf + ";";
+    } else {
+      return;
+    }
+  } else if (paramDnf !== undefined) {
+    return "var p = event.params, ic; return " + srcLeaf + " && (" + paramDnf + ");";
+  } else {
+    return "var ic; return " + srcLeaf + ";";
   }
-  let leaf = name => `(ic = indexingAddresses[p[` + JSON.stringify(name) + `]]) !== undefined && ic.effectiveStartBlock <= blockNumber`;
-  let groupExprs = groups.map(group => "(" + group.map(leaf).join(" && ") + ")");
-  return "var p = event.params, ic; return " + groupExprs.join(" || ") + ";";
 }
 
-function buildAddressFilter(groups) {
-  return Stdlib_Option.map(buildAddressFilterBody(groups), compileAddressFilter);
+function buildAddressFilter(groups, isWildcard, srcAddressExprOpt) {
+  let srcAddressExpr = srcAddressExprOpt !== undefined ? srcAddressExprOpt : "event.srcAddress";
+  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) {
@@ -291,26 +301,28 @@ function buildEvmEventConfig(contractName, eventName, sighash, params, isWildcar
     isWildcard: isWildcard,
     filterByAddresses: filterByAddresses,
     dependsOnAddresses: !isWildcard || filterByAddresses,
-    clientAddressFilter: Stdlib_Option.map(buildAddressFilterBody(match.addressFilterParamGroups), compileAddressFilter),
+    clientAddressFilter: buildAddressFilter(match.addressFilterParamGroups, isWildcard, undefined),
     handler: handler,
     contractRegister: contractRegister,
     paramsRawEventSchema: buildParamsSchema(params),
     simulateParamsSchema: buildSimulateParamsSchema(params),
     startBlock: resolvedStartBlock,
+    selectedTransactionFields: match$1[1],
     getEventFiltersOrThrow: match.getEventFiltersOrThrow,
     selectedBlockFields: match$1[0],
-    selectedTransactionFields: match$1[1],
     sighash: sighash,
     topicCount: topicCount,
     paramsMetadata: params
   };
 }
 
-function buildSvmInstructionEventConfig(contractName, instructionName, programId, discriminator, discriminatorByteLen, includeTransaction, includeLogs, includeTokenBalances, accountFilters, isInner, isWildcard, handler, contractRegister, accountsOpt, argsOpt, definedTypesOpt, startBlock) {
+function buildSvmInstructionEventConfig(contractName, instructionName, programId, discriminator, discriminatorByteLen, includeLogs, transactionFieldsOpt, accountFilters, isInner, isWildcard, handler, contractRegister, accountsOpt, argsOpt, definedTypesOpt, startBlock) {
+  let transactionFields = transactionFieldsOpt !== undefined ? transactionFieldsOpt : [];
   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);
   return {
     id: discriminator !== undefined ? discriminator : "none",
     name: instructionName,
@@ -318,17 +330,17 @@ function buildSvmInstructionEventConfig(contractName, instructionName, programId
     isWildcard: isWildcard,
     filterByAddresses: false,
     dependsOnAddresses: !isWildcard,
+    clientAddressFilter: buildAddressFilter([], isWildcard, "event.programId"),
     handler: handler,
     contractRegister: contractRegister,
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
     startBlock: startBlock,
+    selectedTransactionFields: selectedTransactionFields,
     programId: programId,
     discriminator: discriminator,
     discriminatorByteLen: discriminatorByteLen,
-    includeTransaction: includeTransaction,
     includeLogs: includeLogs,
-    includeTokenBalances: includeTokenBalances,
     accountFilters: accountFilters,
     isInner: isInner,
     accounts: accounts,
@@ -387,11 +399,13 @@ function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi, is
     isWildcard: isWildcard,
     filterByAddresses: false,
     dependsOnAddresses: !isWildcard,
+    clientAddressFilter: buildAddressFilter([], isWildcard, undefined),
     handler: handler,
     contractRegister: contractRegister,
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
     startBlock: startBlock,
+    selectedTransactionFields: new Set(),
     kind: fuelKind
   };
 }

package/src/EventProcessing.res

@@ -39,7 +39,7 @@ let runEventHandlerOrThrow = async (
   let eventItem = item->Internal.castUnsafeEventItem
 
   //Include the load in time before handler
-  let timeBeforeHandler = Hrtime.makeTimer()
+  let timeBeforeHandler = Performance.now()
 
   try {
     let contextParams: UserContext.contextParams = {
@@ -72,7 +72,7 @@ let runEventHandlerOrThrow = async (
       }),
     )
   }
-  let handlerDuration = timeBeforeHandler->Hrtime.timeSince->Hrtime.toSecondsFloat
+  let handlerDuration = timeBeforeHandler->Performance.secondsSince
   Prometheus.ProcessingHandler.increment(
     ~contract=eventItem.eventConfig.contractName,
     ~event=eventItem.eventConfig.name,
@@ -264,11 +264,19 @@ let runBatchHandlersOrThrow = async (
   }
 }
 
-let registerProcessEventBatchMetrics = (~logger, ~loadDuration, ~handlerDuration) => {
-  logger->Logging.childTrace({
-    "msg": "Finished processing batch",
-    "loader_time_elapsed": loadDuration,
-    "handlers_time_elapsed": handlerDuration,
+let registerProcessEventBatchMetrics = (
+  ~logger,
+  ~batch: Batch.t,
+  ~loadDuration,
+  ~handlerDuration,
+) => {
+  batch.progressedChainsById->Dict.forEachWithKey((chainAfterBatch, chainId) => {
+    logger->Logging.childTrace({
+      "msg": "Finished processing",
+      "chainId": chainId->Int.fromString->Option.getUnsafe,
+      "batchSize": chainAfterBatch.batchSize,
+      "progress": chainAfterBatch.progressBlockNumber,
+    })
   })
 
   Prometheus.ProcessingBatch.registerMetrics(~loadDuration, ~handlerDuration)
@@ -281,6 +289,35 @@ 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>) => {
+  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)
+  | _ =>
+    let itemsByChain: dict<array<Internal.item>> = Dict.make()
+    batch.items->Array.forEach(item => {
+      let chainId = item->Internal.getItemChainId->Int.toString
+      switch itemsByChain->Utils.Dict.dangerouslyGetNonOption(chainId) {
+      | Some(items) => items->Array.push(item)
+      | None => itemsByChain->Dict.set(chainId, [item])
+      }
+    })
+
+    let _ = await itemsByChain
+    ->Dict.toArray
+    ->Array.map(async ((chainId, items)) => {
+      let cs = chainStates->Dict.getUnsafe(chainId)
+      await cs->ChainState.materializeBatchItems(~items)
+    })
+    ->Promise.all
+  }
+}
+
 let processEventBatch = async (
   ~batch: Batch.t,
   ~indexerState: IndexerState.t,
@@ -289,33 +326,33 @@ let processEventBatch = async (
   ~config: Config.t,
   ~chainStates: dict<ChainState.t>,
 ) => {
-  let totalBatchSize = batch.totalBatchSize
   // Compute chains state for this batch
   let chains: Internal.chains = chainStates->computeChainsState
 
   let logger = Logging.getLogger()
-  logger->Logging.childTrace({
-    "msg": "Started processing batch",
-    "totalBatchSize": totalBatchSize,
-    "chains": batch.progressedChainsById->Utils.Dict.mapValues(chainAfterBatch => {
-      {
-        "batchSize": chainAfterBatch.batchSize,
-        "progress": chainAfterBatch.progressBlockNumber,
-      }
-    }),
+
+  batch.progressedChainsById->Dict.forEachWithKey((chainAfterBatch, chainId) => {
+    logger->Logging.childTrace({
+      "msg": "Started processing",
+      "chainId": chainId->Int.fromString->Option.getUnsafe,
+      "batchSize": chainAfterBatch.batchSize,
+    })
   })
 
   try {
     // Backpressure: keep processing within keepLatestChangesLimit of the cycle.
     await indexerState->Writing.awaitCapacity
 
-    let timeRef = Hrtime.makeTimer()
+    let timeRef = Performance.now()
 
     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 batch->preloadBatchOrThrow(~loadManager, ~persistence, ~indexerState, ~chains, ~config)
     }
 
-    let elapsedTimeAfterLoaders = timeRef->Hrtime.timeSince->Hrtime.toSecondsFloat
+    let elapsedTimeAfterLoaders = timeRef->Performance.secondsSince
 
     if batch.items->Utils.Array.notEmpty {
       await batch->runBatchHandlersOrThrow(
@@ -327,13 +364,18 @@ let processEventBatch = async (
       )
     }
 
-    let elapsedTimeAfterProcessing = timeRef->Hrtime.timeSince->Hrtime.toSecondsFloat
+    let elapsedTimeAfterProcessing = timeRef->Performance.secondsSince
 
     indexerState->Writing.commitBatch(~batch)
 
     let loaderDuration = elapsedTimeAfterLoaders
     let handlerDuration = elapsedTimeAfterProcessing -. loaderDuration
-    registerProcessEventBatchMetrics(~logger, ~loadDuration=loaderDuration, ~handlerDuration)
+    registerProcessEventBatchMetrics(
+      ~logger,
+      ~batch,
+      ~loadDuration=loaderDuration,
+      ~handlerDuration,
+    )
     Ok()
   } catch {
   | Persistence.StorageError({message, reason}) =>