envio 3.3.0-alpha.2 → 3.3.0-alpha.3

package/index.d.ts

@@ -997,24 +997,6 @@ export type SvmTokenBalance = {
   readonly postAmount?: string;
 };
 
-/** Parent transaction surfaced when an instruction's
- * `include_transaction` flag is `true`. */
-export type SvmTransaction = {
-  readonly signatures: readonly string[];
-  readonly feePayer?: string;
-  readonly success?: boolean;
-  readonly err?: string;
-  /** Lamports. */
-  readonly fee?: bigint;
-  readonly computeUnitsConsumed?: bigint;
-  readonly accountKeys: readonly string[];
-  readonly recentBlockhash?: string;
-  readonly version?: string;
-  /** SPL Token / Token-2022 balance snapshots for this transaction.
-   * Present when `include_token_balances` is `true`. */
-  readonly tokenBalances?: readonly SvmTokenBalance[];
-};
-
 export type SvmLog = {
   readonly kind: string;
   readonly message: string;
@@ -1033,6 +1015,7 @@ export type SvmLog = {
  * are base58 strings. */
 export type SvmInstruction<
   Params extends SvmInstructionParams = SvmInstructionParams,
+  Tx = SvmTransaction,
 > = {
   /** Program name as declared under `programs[].name` in `config.yaml`. */
   readonly programName: string;
@@ -1050,8 +1033,11 @@ export type SvmInstruction<
   readonly d8?: string;
   /** Borsh-decoded params. Present when a schema is configured and matched. */
   readonly params?: Params;
-  /** Present when the instruction's `include_transaction` is `true`. */
-  readonly transaction?: SvmTransaction;
+  /** Parent transaction. Carries only the fields selected via this
+   * instruction's `field_selection`; unselected fields are typed as
+   * `FieldNotSelected<...>` so reading them is a compile error. Always present
+   * (`{}` when no fields are selected). */
+  readonly transaction: Tx;
   /** Present when the instruction's `include_logs` is `true`; only logs
    * scoped to this exact instruction (matching `instruction_address`). */
   readonly logs?: readonly SvmLog[];
@@ -1327,7 +1313,10 @@ type SvmEcosystem<Config extends IndexerConfigTypes = GlobalConfig> =
                   handler: (
                     args: SvmOnInstructionHandlerArgs<
                       Config,
-                      SvmInstruction<SvmParamsFromProgramTable<Programs[P][I]>>
+                      SvmInstruction<
+                        SvmParamsFromProgramTable<Programs[P][I]>,
+                        Programs[P][I]["transaction"]
+                      >
                     >,
                   ) => Promise<void>,
                 ) => void;
@@ -1695,6 +1684,7 @@ type EvmContractsT  = GlobalConfig extends { evm:  { contracts: infer X extends
 type FuelChainsT    = GlobalConfig extends { fuel: { chains:    infer X extends Record<string, { id: number }> } } ? X : {};
 type FuelContractsT = GlobalConfig extends { fuel: { contracts: infer X extends Record<string, Record<string, any>> } } ? X : {};
 type SvmChainsT     = GlobalConfig extends { svm:  { chains:    infer X extends Record<string, { id: number }> } } ? X : {};
+type SvmProgramsT   = GlobalConfig extends { svm:  { programs:  infer X extends Record<string, Record<string, any>> } } ? X : {};
 type EntitiesT      = GlobalConfig extends { entities: infer X extends Record<string, object> } ? X : {};
 type EnumsT         = GlobalConfig extends { enums: infer X extends Record<string, any> } ? X : {};
 
@@ -1716,6 +1706,18 @@ export type FuelChainId = IsEmptyObject<FuelChainsT> extends true ? NotConfigure
 /** Union of all configured SVM chain IDs. */
 export type SvmChainId  = IsEmptyObject<SvmChainsT>  extends true ? NotConfigured<"SvmChainId",  "Configure SVM chains">  : SvmChainsT [keyof SvmChainsT ]["id"];
 
+/** The SVM parent-transaction type generated from this project's
+ *  `field_selection`: the union of every instruction's `transaction` shape,
+ *  with unselected fields typed as `FieldNotSelected<...>`. Resolves to a
+ *  `NotConfigured` hint until `envio codegen` augments {@link Global}. */
+export type SvmTransaction = IsEmptyObject<SvmProgramsT> extends true
+  ? NotConfigured<"SvmTransaction", "Configure SVM programs">
+  : {
+      [P in keyof SvmProgramsT]: {
+        [I in keyof SvmProgramsT[P]]: SvmProgramsT[P][I]["transaction"];
+      }[keyof SvmProgramsT[P]];
+    }[keyof SvmProgramsT];
+
 /** Lookup an EVM event type by contract and event name. Without generics,
  *  resolves to the discriminated union of every EVM event in the project. */
 export type EvmEvent<

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.3.0-alpha.2",
+  "version": "3.3.0-alpha.3",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -69,10 +69,10 @@
     "tsx": "4.21.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.3.0-alpha.2",
-    "envio-linux-x64-musl": "3.3.0-alpha.2",
-    "envio-linux-arm64": "3.3.0-alpha.2",
-    "envio-darwin-x64": "3.3.0-alpha.2",
-    "envio-darwin-arm64": "3.3.0-alpha.2"
+    "envio-linux-x64": "3.3.0-alpha.3",
+    "envio-linux-x64-musl": "3.3.0-alpha.3",
+    "envio-linux-arm64": "3.3.0-alpha.3",
+    "envio-darwin-x64": "3.3.0-alpha.3",
+    "envio-darwin-arm64": "3.3.0-alpha.3"
   }
 }

package/src/ChainFetching.res

@@ -336,6 +336,15 @@ let fetchChain = async (
     // there's nothing to fetch. During backfill any such chain is idle.
     let reducedPolling = !isRealtime
 
+    // Accumulated across all queries dispatched in this tick so their per-query
+    // results collapse into a single completion log instead of one per query.
+    let dispatchedCount = switch action {
+    | FetchState.Ready(queries) => queries->Array.length
+    | WaitingForNewBlock | NothingToQuery => 0
+    }
+    let fetchedByPartition = Dict.make()
+    let fetchedCount = ref(0)
+
     // Owns its error boundary: launch doesn't catch, so any failure here (the
     // query, response handling, or dispatch itself) must stop the indexer.
     try {
@@ -361,6 +370,22 @@ let fetchChain = async (
               ~knownHeight=chainState->ChainState.knownHeight,
               ~isRealtime,
             )
+            fetchedCount := fetchedCount.contents + 1
+            fetchedByPartition->Dict.set(
+              query.partitionId,
+              {
+                "fromBlock": response.fromBlockQueried,
+                "toBlock": response.latestFetchedBlockNumber,
+                "numEvents": response.parsedQueueItems->Array.length,
+              },
+            )
+            if dispatchedCount > 0 && fetchedCount.contents === dispatchedCount {
+              Logging.trace({
+                "msg": "Finished querying",
+                "chainId": chain->ChainMap.Chain.toChainId,
+                "partitions": fetchedByPartition,
+              })
+            }
             await onQueryResponse(
               state,
               {chain, response, query},

package/src/ChainFetching.res.mjs

@@ -176,10 +176,29 @@ async function fetchChain(state, chain, action, stateId, scheduleFetch, schedule
   let isRealtime = IndexerState.isRealtime(state);
   let sourceManager = ChainState.sourceManager(chainState);
   let reducedPolling = !isRealtime;
+  let dispatchedCount;
+  dispatchedCount = typeof action !== "object" ? 0 : action._0.length;
+  let fetchedByPartition = {};
+  let fetchedCount = {
+    contents: 0
+  };
   try {
     return await ChainState.dispatch(chainState, async query => {
       try {
         let response = await SourceManager.executeQuery(sourceManager, query, ChainState.knownHeight(chainState), isRealtime);
+        fetchedCount.contents = fetchedCount.contents + 1 | 0;
+        fetchedByPartition[query.partitionId] = {
+          fromBlock: response.fromBlockQueried,
+          toBlock: response.latestFetchedBlockNumber,
+          numEvents: response.parsedQueueItems.length
+        };
+        if (dispatchedCount > 0 && fetchedCount.contents === dispatchedCount) {
+          Logging.trace({
+            msg: "Finished querying",
+            chainId: chain,
+            partitions: fetchedByPartition
+          });
+        }
         return await onQueryResponse(state, {
           chain: chain,
           response: response,

package/src/CrossChainState.res

@@ -254,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

@@ -170,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,

package/src/EventConfigBuilder.res

@@ -326,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 ==============
 
@@ -415,7 +437,7 @@ let buildEvmEventConfig = (
     simulateParamsSchema: buildSimulateParamsSchema(params),
     getEventFiltersOrThrow,
     filterByAddresses,
-    clientAddressFilter: ?buildAddressFilter(addressFilterParamGroups),
+    clientAddressFilter: ?buildAddressFilter(addressFilterParamGroups, ~isWildcard),
     dependsOnAddresses: !isWildcard || filterByAddresses,
     startBlock: resolvedStartBlock,
     selectedBlockFields,
@@ -471,6 +493,7 @@ let buildSvmInstructionEventConfig = (
     simulateParamsSchema: paramsSchema,
     filterByAddresses: false,
     dependsOnAddresses: !isWildcard,
+    clientAddressFilter: ?buildAddressFilter([], ~isWildcard, ~srcAddressExpr="event.programId"),
     startBlock,
     programId,
     discriminator,
@@ -541,6 +564,7 @@ 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(),

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,7 +301,7 @@ 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),
@@ -320,6 +330,7 @@ function buildSvmInstructionEventConfig(contractName, instructionName, programId
     isWildcard: isWildcard,
     filterByAddresses: false,
     dependsOnAddresses: !isWildcard,
+    clientAddressFilter: buildAddressFilter([], isWildcard, "event.programId"),
     handler: handler,
     contractRegister: contractRegister,
     paramsRawEventSchema: paramsSchema,
@@ -388,6 +399,7 @@ function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi, is
     isWildcard: isWildcard,
     filterByAddresses: false,
     dependsOnAddresses: !isWildcard,
+    clientAddressFilter: buildAddressFilter([], isWildcard, undefined),
     handler: handler,
     contractRegister: contractRegister,
     paramsRawEventSchema: paramsSchema,

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)
@@ -286,22 +294,28 @@ type logPartitionInfo = {
 // 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>) => {
-  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
+  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 (
@@ -312,27 +326,24 @@ 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
@@ -341,7 +352,7 @@ let processEventBatch = async (
       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(
@@ -353,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}) =>