envio 3.5.0-alpha.3 → 3.5.0-rc.0

package/src/Config.res.mjs

@@ -8,6 +8,7 @@ import * as Fuel from "./sources/Fuel.res.mjs";
 import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Address from "./Address.res.mjs";
+import * as ChainId from "./ChainId.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as Internal from "./Internal.res.mjs";
@@ -24,7 +25,7 @@ import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_excep
 let name = "envio_addresses";
 
 function makeId(chainId, address) {
-  return chainId.toString() + "-" + address;
+  return ChainId.toString(chainId) + "-" + address;
 }
 
 function getAddress(entity) {
@@ -34,7 +35,7 @@ function getAddress(entity) {
 
 let schema = S$RescriptSchema.schema(s => ({
   id: s.m(S$RescriptSchema.string),
-  chain_id: s.m(S$RescriptSchema.int),
+  chain_id: s.m(ChainId.schema),
   registration_block: s.m(S$RescriptSchema.int),
   registration_log_index: s.m(S$RescriptSchema.int),
   contract_name: s.m(S$RescriptSchema.string)
@@ -42,7 +43,7 @@ let schema = S$RescriptSchema.schema(s => ({
 
 let table = Table.mkTable(name, undefined, [
   Table.mkField("id", "String", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined, undefined, undefined, undefined),
-  Table.mkField("chain_id", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
+  Table.mkField("chain_id", "ChainId", ChainId.schema, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
   Table.mkField("registration_block", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
   Table.mkField("registration_log_index", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
   Table.mkField("contract_name", "String", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined)
@@ -98,7 +99,7 @@ let chainContractSchema = S$RescriptSchema.schema(s => ({
 }));
 
 let publicConfigChainSchema = S$RescriptSchema.schema(s => ({
-  id: s.m(S$RescriptSchema.int),
+  id: s.m(ChainId.schema),
   startBlock: s.m(S$RescriptSchema.int),
   endBlock: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
   maxReorgDepth: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
@@ -400,6 +401,7 @@ let publicConfigSchema = S$RescriptSchema.schema(s => ({
   rollbackOnReorg: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   saveFullHistory: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   rawEvents: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
+  chainIdMode: s.m(S$RescriptSchema.option(ChainId.modeSchema)),
   storage: s.m(publicConfigStorageSchema),
   evm: s.m(S$RescriptSchema.option(publicConfigEvmSchema)),
   fuel: s.m(S$RescriptSchema.option(publicConfigEcosystemSchema)),
@@ -528,7 +530,7 @@ function fromPublic(publicConfigJson) {
           case "svm" :
             let len = addresses.length;
             let programId = len !== 1 ? (
-                len !== 0 ? Stdlib_JsError.throwWithMessage(`SVM program ` + contractName + ` on chain ` + chainId.toString() + ` has multiple addresses; a program is uniquely identified by a single program_id`) : Stdlib_JsError.throwWithMessage(`SVM program ` + contractName + ` on chain ` + chainId.toString() + ` is missing a program_id`)
+                len !== 0 ? Stdlib_JsError.throwWithMessage(`SVM program ` + contractName + ` on chain ` + ChainId.toString(chainId) + ` has multiple addresses; a program is uniquely identified by a single program_id`) : Stdlib_JsError.throwWithMessage(`SVM program ` + contractName + ` on chain ` + ChainId.toString(chainId) + ` is missing a program_id`)
               ) : addresses[0];
             let s = eventItem.svm;
             let svm = s !== undefined ? Primitive_option.valFromOption(s) : Stdlib_JsError.throwWithMessage(`SVM instruction ` + contractName + `.` + eventName + ` is missing the "svm" descriptor in internal config`);
@@ -591,7 +593,7 @@ function fromPublic(publicConfigJson) {
       contract.addresses.forEach(address => {
         let existingContractName = contractNameByAddress[address];
         if (existingContractName !== undefined) {
-          return Stdlib_JsError.throwWithMessage(existingContractName === contract.name ? `Address ` + address + ` is listed multiple times for the contract ` + contract.name + ` on chain ` + chainId.toString() + `. Please remove the duplicate from your config.` : `Address ` + address + ` on chain ` + chainId.toString() + ` is configured for multiple contracts: ` + existingContractName + ` and ` + contract.name + `. Indexing the same address with multiple contract definitions is not supported. Please define the events on a single contract definition instead.`);
+          return Stdlib_JsError.throwWithMessage(existingContractName === contract.name ? `Address ` + address + ` is listed multiple times for the contract ` + contract.name + ` on chain ` + ChainId.toString(chainId) + `. Please remove the duplicate from your config.` : `Address ` + address + ` on chain ` + ChainId.toString(chainId) + ` is configured for multiple contracts: ` + existingContractName + ` and ` + contract.name + `. Indexing the same address with multiple contract definitions is not supported. Please define the events on a single contract definition instead.`);
         } else {
           contractNameByAddress[address] = contract.name;
           return;
@@ -677,7 +679,7 @@ function fromPublic(publicConfigJson) {
     };
   });
   let chainMap = ChainMap.fromArrayUnsafe(chains.map(chain => [
-    ChainMap.Chain.makeUnsafe(chain.id),
+    chain.id,
     chain
   ]));
   let allEnums = parseEnumsFromJson(Stdlib_Option.getOr(publicConfig.enums, {}));
@@ -709,6 +711,7 @@ function fromPublic(publicConfigJson) {
     shouldRollbackOnReorg: Stdlib_Option.getOr(publicConfig.rollbackOnReorg, true),
     shouldSaveFullHistory: Stdlib_Option.getOr(publicConfig.saveFullHistory, false),
     storage: globalStorage,
+    chainIdMode: Stdlib_Option.getOr(publicConfig.chainIdMode, "int32"),
     chainMap: chainMap,
     defaultChain: chains[0],
     ecosystem: ecosystem,
@@ -765,14 +768,14 @@ function normalizeSimulateAddress(config, address) {
 function getEventConfig(config, contractName, eventName, chainId) {
   let chains;
   if (chainId !== undefined) {
-    let chain = ChainMap.Chain.makeUnsafe(chainId);
+    let chainId$1 = Primitive_option.valFromOption(chainId);
     let exit = 0;
     let chainConfig;
     try {
-      chainConfig = ChainMap.get(config.chainMap, chain);
+      chainConfig = ChainMap.get(config.chainMap, chainId$1);
       exit = 1;
     } catch (exn) {
-      chains = Stdlib_JsError.throwWithMessage(`Chain ` + chainId.toString() + ` is not configured. Add it to config.yaml or pass a configured chain.`);
+      chains = Stdlib_JsError.throwWithMessage(`Chain ` + ChainId.toString(chainId$1) + ` is not configured. Add it to config.yaml or pass a configured chain.`);
     }
     if (exit === 1) {
       chains = [chainConfig];
@@ -808,11 +811,10 @@ function shouldPruneHistory(config, isInReorgThreshold) {
 }
 
 function getChain(config, chainId) {
-  let chain = ChainMap.Chain.makeUnsafe(chainId);
-  if (ChainMap.has(config.chainMap, chain)) {
-    return chain;
+  if (ChainMap.has(config.chainMap, chainId)) {
+    return chainId;
   } else {
-    return Stdlib_JsError.throwWithMessage("No chain with id " + ChainMap.Chain.toString(chain) + " found in config.yaml");
+    return Stdlib_JsError.throwWithMessage("No chain with id " + ChainId.toString(chainId) + " found in config.yaml");
   }
 }
 
@@ -983,6 +985,7 @@ function diffPaths(stored, current) {
   if (typeof stored === "object" && stored !== null && !Array.isArray(stored) && typeof current === "object" && current !== null && !Array.isArray(current)) {
     let tiers = [
       ["version"],
+      ["chainIdMode"],
       ["name"],
       ["storage"],
       [

package/src/ContractRegisterContext.res

@@ -36,7 +36,7 @@ let contractRegisterChainTraps: Utils.Proxy.traps<contractRegisterParams> = {
     switch prop {
     | "id" =>
       let eventItem = params.item->Internal.castUnsafeEventItem
-      eventItem.chain->ChainMap.Chain.toChainId->(Utils.magic: int => unknown)
+      eventItem.chainId->(Utils.magic: ChainId.t => unknown)
     | _ =>
       // Look up the contract name directly in config contracts across all chains.
       let contractName = prop

package/src/ContractRegisterContext.res.mjs

@@ -19,7 +19,7 @@ function makeAddFunction(params, contractName) {
 
 let contractRegisterChainTraps_get = (params, prop) => {
   if (prop === "id") {
-    return params.item.chain;
+    return params.item.chainId;
   }
   let isValidContract = ChainMap.values(params.config.chainMap).some(chain => chain.contracts.some(c => c.name === prop));
   if (isValidContract) {

package/src/Core.res

@@ -21,6 +21,7 @@ type fromUserApiOptions = {
 type fromUserApiResult = {
   config: string,
   indexerTypes: Null.t<string>,
+  indexerCode: Null.t<string>,
 }
 
 type addon = {

package/src/CrossChainState.res

@@ -7,7 +7,7 @@ type t = {
   chainStates: dict<ChainState.t>,
   // Chain ids in a stable order, so the cross-chain loops iterate the chains
   // without allocating a values array on every tick.
-  chainIds: array<int>,
+  chainIds: array<ChainId.t>,
   // True once every chain has caught up to head/endBlock. Monotonic during a run.
   mutable isRealtime: bool,
   // True once every chain has caught up and there's nothing left to process,
@@ -45,7 +45,7 @@ let make = (
 // Resolve a chain's state by id. The id always comes from `chainIds`, which is
 // derived from `chainStates`, so the entry is guaranteed present.
 let getChainState = (crossChainState: t, chainId) =>
-  crossChainState.chainStates->Utils.Dict.dangerouslyGetByIntNonOption(chainId)->Option.getUnsafe
+  crossChainState.chainStates->ChainId.Dict.dangerouslyGetNonOption(chainId)->Option.getUnsafe
 
 // --- Accessors. ---
 
@@ -167,10 +167,57 @@ let applyBatchProgress = (crossChainState: t, ~batch: Batch.t, ~blockTimestampNa
   crossChainState.isRealtime = crossChainState.isRealtime || allChainsReady.contents
 }
 
-// Enter the FinalizingIndexes phase without a batch. Used when the loop finds
-// every chain already processed to its endblock — a resume that has nothing
-// left to do still owes the schema its deferred indexes before it reports ready.
-let markCaughtUp = (crossChainState: t) => crossChainState.isCaughtUp = true
+// Every chain has buffered up to its head (or endblock) with nothing
+// processable left. Derived from current state rather than from the flag a
+// progressed batch sets, because a run that reached the head and died before
+// finalizing resumes with no batch to process — nothing would ever set it.
+let isSettledAtHead = (crossChainState: t) => {
+  let settled = ref(crossChainState->nextItemIsNone)
+  for i in 0 to crossChainState.chainIds->Array.length - 1 {
+    if (
+      !(
+        crossChainState
+        ->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
+        ->ChainState.isFetchingAtHead
+      )
+    ) {
+      settled := false
+    }
+  }
+  settled.contents
+}
+
+// Enter the FinalizingIndexes phase without a batch, for the resume above.
+let markCaughtUpIfSettled = (crossChainState: t) =>
+  if crossChainState->isSettledAtHead {
+    crossChainState.isCaughtUp = true
+  }
+
+// The same resume, decided from persisted values at construction instead of from
+// the fetch frontier. A run that reached the head and died before finalizing has
+// no batch to process on resume, and by the time the first height lands the head
+// may have moved on — at which point no chain looks at head any more and the
+// indexes it still owes would wait out another whole backfill. Deciding here,
+// before any source request, keeps that debt tied to the progress that was
+// actually committed. Skipped once every chain carries `ready_at`: those indexes
+// were committed together with the stamps.
+let markCaughtUpOnResume = (crossChainState: t) => {
+  let everyChainCaughtUp = ref(crossChainState.chainIds->Array.length > 0)
+  let everyChainReady = ref(true)
+  for i in 0 to crossChainState.chainIds->Array.length - 1 {
+    let cs = crossChainState->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
+    if !(cs->ChainState.isDurablyCaughtUp) {
+      everyChainCaughtUp := false
+    }
+    if !(cs->ChainState.isReady) {
+      everyChainReady := false
+    }
+  }
+
+  if everyChainCaughtUp.contents && !everyChainReady.contents && crossChainState->nextItemIsNone {
+    crossChainState.isCaughtUp = true
+  }
+}
 
 // Concludes the FinalizingIndexes phase: stamps every chain with the `ready_at`
 // already committed alongside the deferred schema indexes and switches the
@@ -249,7 +296,7 @@ let idleOrWaitAction = (cs: ChainState.t) =>
 // dropped — chains at head only trail each other by real-time block production.
 let checkAndFetch = async (
   crossChainState: t,
-  ~dispatchChain: (~chain: ChainMap.Chain.t, ~action: FetchState.nextQuery) => promise<unit>,
+  ~dispatchChain: (~chainId: ChainId.t, ~action: FetchState.nextQuery) => promise<unit>,
 ) => {
   let targetBudget = crossChainState.targetBufferSize->Int.toFloat
   let remaining = ref(
@@ -297,14 +344,14 @@ let checkAndFetch = async (
       // hold the whole pool. (The general can't-fetch-yet rule, including
       // blockLag, lives in FetchState.getNextQuery — this branch only
       // short-circuits the unambiguous no-height case.)
-      actionByChain->Utils.Dict.setByInt(chainId, FetchState.WaitingForNewBlock)
+      actionByChain->ChainId.Dict.set(chainId, FetchState.WaitingForNewBlock)
     } else if remaining.contents < minimumAdmissionBudget {
       // More than 90% of the target pool is ready or reserved. Don't admit new
       // queries until a full admission unit becomes free. No wake-up poll is
       // needed: a saturated pool means some chain holds ready items or
       // in-flight reservations, so a batch completion or landing response is
       // guaranteed to schedule another tick that revisits this chain.
-      actionByChain->Utils.Dict.setByInt(chainId, FetchState.NothingToQuery)
+      actionByChain->ChainId.Dict.set(chainId, FetchState.NothingToQuery)
     } else {
       let isCold = cs->ChainState.effectiveDensity === None
       let chainTargetItems =
@@ -319,12 +366,12 @@ let checkAndFetch = async (
       | _ => None
       }
       switch cs->ChainState.getNextQuery(~chainTargetItems, ~maxTargetBlock?) {
-      | WaitingForNewBlock as action => actionByChain->Utils.Dict.setByInt(chainId, action)
+      | WaitingForNewBlock as action => actionByChain->ChainId.Dict.set(chainId, action)
       | NothingToQuery =>
         // A chain below its head can emit no query when its budget went to
         // more-behind chains or the cross-chain alignment clamped its range to
         // nothing — idleOrWaitAction keeps it polling for new blocks.
-        actionByChain->Utils.Dict.setByInt(chainId, idleOrWaitAction(cs))
+        actionByChain->ChainId.Dict.set(chainId, idleOrWaitAction(cs))
       | Ready(queries) => {
           let consumed =
             queries->Array.reduce(0., (acc, query: FetchState.query) =>
@@ -348,7 +395,7 @@ let checkAndFetch = async (
             "partitions": partitions,
           })
 
-          actionByChain->Utils.Dict.setByInt(chainId, FetchState.Ready(queries))
+          actionByChain->ChainId.Dict.set(chainId, FetchState.Ready(queries))
           // Mark the queries in flight and reserve their size against the
           // shared budget; released as each response lands in
           // handleQueryResult.
@@ -362,12 +409,10 @@ let checkAndFetch = async (
   let promises = []
   for i in 0 to crossChainState.chainIds->Array.length - 1 {
     let chainId = crossChainState.chainIds->Array.getUnsafe(i)
-    switch actionByChain->Utils.Dict.dangerouslyGetByIntNonOption(chainId) {
+    switch actionByChain->ChainId.Dict.dangerouslyGetNonOption(chainId) {
     | Some(NothingToQuery)
     | None => ()
-    | Some(action) =>
-      let chain = ChainMap.Chain.makeUnsafe(~chainId)
-      promises->Array.push(dispatchChain(~chain, ~action))
+    | Some(action) => promises->Array.push(dispatchChain(~chainId=chainId, ~action))
     }
   }
   let _ = await promises->Promise.all

package/src/CrossChainState.res.mjs

@@ -4,7 +4,6 @@ import * as Env from "./Env.res.mjs";
 import * as Batch from "./Batch.res.mjs";
 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 Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
@@ -119,8 +118,39 @@ function applyBatchProgress(crossChainState, batch, blockTimestampName) {
   crossChainState.isRealtime = crossChainState.isRealtime || allChainsReady;
 }
 
-function markCaughtUp(crossChainState) {
-  crossChainState.isCaughtUp = true;
+function isSettledAtHead(crossChainState) {
+  let settled = nextItemIsNone(crossChainState);
+  for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
+    if (!ChainState.isFetchingAtHead(crossChainState.chainStates[crossChainState.chainIds[i]])) {
+      settled = false;
+    }
+  }
+  return settled;
+}
+
+function markCaughtUpIfSettled(crossChainState) {
+  if (isSettledAtHead(crossChainState)) {
+    crossChainState.isCaughtUp = true;
+    return;
+  }
+}
+
+function markCaughtUpOnResume(crossChainState) {
+  let everyChainCaughtUp = crossChainState.chainIds.length !== 0;
+  let everyChainReady = true;
+  for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
+    let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
+    if (!ChainState.isDurablyCaughtUp(cs)) {
+      everyChainCaughtUp = false;
+    }
+    if (!ChainState.isReady(cs)) {
+      everyChainReady = false;
+    }
+  }
+  if (everyChainCaughtUp && !everyChainReady && nextItemIsNone(crossChainState)) {
+    crossChainState.isCaughtUp = true;
+    return;
+  }
 }
 
 function markReady(crossChainState, readyAt) {
@@ -215,15 +245,8 @@ async function checkAndFetch(crossChainState, dispatchChain) {
   for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
     let chainId = crossChainState.chainIds[i];
     let action = actionByChain[chainId];
-    if (action !== undefined) {
-      let exit = 0;
-      if (typeof action === "object" || action === "WaitingForNewBlock") {
-        exit = 1;
-      }
-      if (exit === 1) {
-        let chain = ChainMap.Chain.makeUnsafe(chainId);
-        promises.push(dispatchChain(chain, action));
-      }
+    if (action !== undefined && (typeof action === "object" || action === "WaitingForNewBlock")) {
+      promises.push(dispatchChain(chainId, action));
     }
   }
   await Promise.all(promises);
@@ -242,7 +265,8 @@ export {
   createBatch,
   enterReorgThreshold,
   applyBatchProgress,
-  markCaughtUp,
+  markCaughtUpIfSettled,
+  markCaughtUpOnResume,
   markReady,
   priorityOrder,
   checkAndFetch,

package/src/CrossChainState.resi

@@ -32,12 +32,13 @@ let createBatch: (
 ) => Batch.t
 let enterReorgThreshold: t => unit
 let applyBatchProgress: (t, ~batch: Batch.t, ~blockTimestampName: string) => unit
-let markCaughtUp: t => unit
+let markCaughtUpIfSettled: t => unit
+let markCaughtUpOnResume: t => unit
 let markReady: (t, ~readyAt: Date.t) => unit
 
 // Fetch control.
 let priorityOrder: t => array<ChainState.t>
 let checkAndFetch: (
   t,
-  ~dispatchChain: (~chain: ChainMap.Chain.t, ~action: FetchState.nextQuery) => promise<unit>,
+  ~dispatchChain: (~chainId: ChainId.t, ~action: FetchState.nextQuery) => promise<unit>,
 ) => promise<unit>

package/src/Env.res

@@ -3,9 +3,6 @@
 
 %%private(let envSafe = EnvSafe.make())
 
-// resets the timestampCaughtUpToHeadOrEndblock after a restart when true
-let updateSyncTimeOnRestart =
-  envSafe->EnvSafe.get("UPDATE_SYNC_TIME_ON_RESTART", S.bool, ~fallback=true)
 let targetBufferSize = envSafe->EnvSafe.get("ENVIO_INDEXING_MAX_BUFFER_SIZE", S.option(S.int))
 let maxAddrInPartition = envSafe->EnvSafe.get("MAX_PARTITION_SIZE", S.int, ~fallback=5_000)
 

package/src/Env.res.mjs

@@ -13,8 +13,6 @@ import 'dotenv/config'
 
 let envSafe = EnvSafe.make(undefined);
 
-let updateSyncTimeOnRestart = EnvSafe.get(envSafe, "UPDATE_SYNC_TIME_ON_RESTART", S$RescriptSchema.bool, undefined, true, undefined, undefined);
-
 let targetBufferSize = EnvSafe.get(envSafe, "ENVIO_INDEXING_MAX_BUFFER_SIZE", S$RescriptSchema.option(S$RescriptSchema.int), undefined, undefined, undefined, undefined);
 
 let maxAddrInPartition = EnvSafe.get(envSafe, "MAX_PARTITION_SIZE", S$RescriptSchema.int, undefined, 5000, undefined, undefined);
@@ -221,7 +219,6 @@ EnvSafe.close(envSafe);
 let maxChainConcurrency = 100;
 
 export {
-  updateSyncTimeOnRestart,
   targetBufferSize,
   maxAddrInPartition,
   maxChainConcurrency,

package/src/EventConfigBuilder.res

@@ -342,7 +342,7 @@ let buildEvmOnEventRegistration = (
   ~handler: option<Internal.handler>,
   ~contractRegister: option<Internal.contractRegister>,
   ~where: option<JSON.t>,
-  ~chainId: int,
+  ~chainId: ChainId.t,
   ~onEventBlockFilterSchema: S.t<option<unknown>>,
   ~startBlock: option<int>=?,
 ): Internal.evmOnEventRegistration => {

package/src/EventProcessing.res

@@ -13,7 +13,7 @@ let computeChainsState = (chainStates: dict<ChainState.t>): Internal.chains => {
   values->Array.forEach(cs => {
     let chainId = (cs->ChainState.chainConfig).id
     chains->Dict.set(
-      chainId->Int.toString,
+      chainId->ChainId.toString,
       {
         Internal.id: chainId,
         isRealtime,
@@ -280,7 +280,7 @@ let registerProcessEventBatchMetrics = (
   batch.progressedChainsById->Dict.forEachWithKey((chainAfterBatch, chainId) => {
     logger->Logging.childTrace({
       "msg": "Finished processing",
-      "chainId": chainId->Int.fromString->Option.getUnsafe,
+      "chainId": chainId,
       "batchSize": chainAfterBatch.batchSize,
       "progress": chainAfterBatch.progressBlockNumber,
     })
@@ -312,7 +312,7 @@ let materializeBatchEvents = async (
   | _ =>
     let itemsByChain: dict<array<Internal.item>> = Dict.make()
     batch.items->Array.forEach(item => {
-      let chainId = item->Internal.getItemChainId->Int.toString
+      let chainId = item->Internal.getItemChainId->ChainId.toString
       switch itemsByChain->Utils.Dict.dangerouslyGetNonOption(chainId) {
       | Some(items) => items->Array.push(item)
       | None => itemsByChain->Dict.set(chainId, [item])
@@ -345,7 +345,7 @@ let processEventBatch = async (
   batch.progressedChainsById->Dict.forEachWithKey((chainAfterBatch, chainId) => {
     logger->Logging.childTrace({
       "msg": "Started processing",
-      "chainId": chainId->Int.fromString->Option.getUnsafe,
+      "chainId": chainId,
       "batchSize": chainAfterBatch.batchSize,
     })
   })

package/src/EventProcessing.res.mjs

@@ -1,12 +1,12 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
+import * as ChainId from "./ChainId.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Writing from "./Writing.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import * as Ecosystem from "./Ecosystem.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
-import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as Performance from "./bindings/Performance.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
@@ -25,7 +25,7 @@ function computeChainsState(chainStates) {
   let isRealtime = values.every(ChainState.isReady);
   values.forEach(cs => {
     let chainId = ChainState.chainConfig(cs).id;
-    chains[chainId.toString()] = {
+    chains[ChainId.toString(chainId)] = {
       id: chainId,
       isRealtime: isRealtime
     };
@@ -179,7 +179,7 @@ async function runBatchHandlersOrThrow(batch, indexerState, loadManager, persist
 function registerProcessEventBatchMetrics(logger, batch, indexerState, loadDuration, handlerDuration) {
   Stdlib_Dict.forEachWithKey(batch.progressedChainsById, (chainAfterBatch, chainId) => Logging.childTrace(logger, {
     msg: "Finished processing",
-    chainId: Stdlib_Int.fromString(chainId, undefined),
+    chainId: chainId,
     batchSize: chainAfterBatch.batchSize,
     progress: chainAfterBatch.progressBlockNumber
   }));
@@ -191,7 +191,7 @@ async function materializeBatchEvents(batch, chainStates, ecosystem) {
   if (match.length !== 1) {
     let itemsByChain = {};
     batch.items.forEach(item => {
-      let chainId = Internal.getItemChainId(item).toString();
+      let chainId = ChainId.toString(Internal.getItemChainId(item));
       let items = itemsByChain[chainId];
       if (items !== undefined) {
         items.push(item);
@@ -214,7 +214,7 @@ async function processEventBatch(batch, indexerState, loadManager, persistence,
   let logger = Logging.getLogger();
   Stdlib_Dict.forEachWithKey(batch.progressedChainsById, (chainAfterBatch, chainId) => Logging.childTrace(logger, {
     msg: "Started processing",
-    chainId: Stdlib_Int.fromString(chainId, undefined),
+    chainId: chainId,
     batchSize: chainAfterBatch.batchSize
   }));
   try {