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

package/src/RawEvent.res.mjs

@@ -29,7 +29,7 @@ function make(eventItem, block, transaction, params, srcAddress, blockHash, bloc
   let params$1 = S$RescriptSchema.reverseConvertOrThrow(params, eventConfig.paramsRawEventSchema);
   let params$2 = params$1 === null ? "null" : params$1;
   return {
-    chain_id: eventItem.chain,
+    chain_id: eventItem.chainId,
     event_id: eventId,
     event_name: eventConfig.name,
     contract_name: eventConfig.contractName,

package/src/Rollback.res

@@ -50,8 +50,8 @@ let rec rollback = async (
     switch state->IndexerState.rollbackState {
     | NoRollback | RollbackReady(_) =>
       JsError.throwWithMessage("Internal error: Rollback initiated with invalid state")
-    | ReorgDetected({chain, blockNumber: reorgBlockNumber}) =>
-      let chainState = state->IndexerState.getChainState(~chain)
+    | ReorgDetected({chainId, blockNumber: reorgBlockNumber}) =>
+      let chainState = state->IndexerState.getChainState(~chainId)
 
       state->IndexerState.enterFindingReorgDepth
       let rollbackTargetBlockNumber = await chainState->getLastKnownValidBlock(
@@ -63,7 +63,7 @@ let rec rollback = async (
       ->ChainState.sourceManager
       ->SourceManager.onReorg(~rollbackTargetBlock=rollbackTargetBlockNumber)
 
-      state->IndexerState.foundReorgDepth(~chain, ~rollbackTargetBlockNumber)
+      state->IndexerState.foundReorgDepth(~chainId, ~rollbackTargetBlockNumber)
       // Rendezvous with the processing loop: whichever of {depth found, loop
       // idle} happens last triggers the rollback; the earlier one finds the
       // other condition unmet and bails here.
@@ -73,7 +73,7 @@ let rec rollback = async (
     | FindingReorgDepth => ()
     | FoundReorgDepth(_) if state->IndexerState.isProcessing =>
       Logging.trace("Waiting for batch to finish processing before executing rollback")
-    | FoundReorgDepth({chain: reorgChain, rollbackTargetBlockNumber}) =>
+    | FoundReorgDepth({chainId: reorgChain, rollbackTargetBlockNumber}) =>
       await executeRollback(
         state,
         ~reorgChain,
@@ -108,11 +108,9 @@ and executeRollback = async (
   )
   logger->Logging.childInfo("Started rollback on reorg")
   state
-  ->IndexerState.getChainState(~chain=reorgChain)
+  ->IndexerState.getChainState(~chainId=reorgChain)
   ->ChainState.setRollbackTargetBlock(~blockNumber=rollbackTargetBlockNumber)
 
-  let reorgChainId = reorgChain->ChainMap.Chain.toChainId
-
   // Finish pending batch writes first: the target checkpoint, the progress
   // diff and the rollback diff below must all be computed from the same db
   // state. Otherwise an in-flight batch lands after the progress reads and
@@ -122,7 +120,7 @@ and executeRollback = async (
 
   let rollbackTargetCheckpointId = {
     switch await (state->IndexerState.persistence).storage.getRollbackTargetCheckpoint(
-      ~reorgChainId,
+      ~reorgChainId=reorgChain,
       ~lastKnownValidBlockNumber=rollbackTargetBlockNumber,
     ) {
     | Some(checkpointId) => checkpointId
@@ -140,7 +138,7 @@ and executeRollback = async (
     ).storage.getRollbackProgressDiff(~rollbackTargetCheckpointId)
     for idx in 0 to rollbackProgressDiff->Array.length - 1 {
       let diff = rollbackProgressDiff->Array.getUnsafe(idx)
-      eventsProcessedDiffByChain->Utils.Dict.setByInt(
+      eventsProcessedDiffByChain->ChainId.Dict.set(
         diff["chain_id"],
         {
           let eventsProcessedDiff =
@@ -149,9 +147,9 @@ and executeRollback = async (
           eventsProcessedDiff
         },
       )
-      newProgressBlockNumberPerChain->Utils.Dict.setByInt(
+      newProgressBlockNumberPerChain->ChainId.Dict.set(
         diff["chain_id"],
-        if rollbackTargetCheckpointId === 0n && diff["chain_id"] === reorgChainId {
+        if rollbackTargetCheckpointId === 0n && diff["chain_id"] === reorgChain {
           Pervasives.min(diff["new_progress_block_number"], rollbackTargetBlockNumber)
         } else {
           diff["new_progress_block_number"]
@@ -167,14 +165,14 @@ and executeRollback = async (
     let chainId = (cs->ChainState.chainConfig).id
     let fromBlock = cs->ChainState.committedProgressBlockNumber
     cs->ChainState.rollback(
-      ~newProgressBlockNumber=newProgressBlockNumberPerChain->Utils.Dict.dangerouslyGetByIntNonOption(
+      ~newProgressBlockNumber=newProgressBlockNumberPerChain->ChainId.Dict.dangerouslyGetNonOption(
         chainId,
       ),
-      ~eventsProcessedDiff=eventsProcessedDiffByChain->Utils.Dict.dangerouslyGetByIntNonOption(
+      ~eventsProcessedDiff=eventsProcessedDiffByChain->ChainId.Dict.dangerouslyGetNonOption(
         chainId,
       ),
       ~rollbackTargetBlockNumber,
-      ~isReorgChain=chainId === reorgChainId,
+      ~isReorgChain=chainId === reorgChain,
     )
     let toBlock = cs->ChainState.committedProgressBlockNumber
     if fromBlock !== toBlock {
@@ -184,7 +182,7 @@ and executeRollback = async (
         "fromBlock": fromBlock,
         "toBlock": toBlock,
         "rollbackedEvents": eventsProcessedDiffByChain
-        ->Utils.Dict.dangerouslyGetByIntNonOption(chainId)
+        ->ChainId.Dict.dangerouslyGetNonOption(chainId)
         ->Option.getOr(0.),
       })
       ->ignore
@@ -197,13 +195,13 @@ and executeRollback = async (
     ~progressBlockNumberByChainId=newProgressBlockNumberPerChain,
   )
 
-  rolledBackChains->Array.forEach(chain => {
+  rolledBackChains->Array.forEach(rolledBack => {
     logger->Logging.childInfo({
       "msg": "Rollbacked",
-      "chainId": chain["chainId"],
-      "fromBlock": chain["fromBlock"],
-      "toBlock": chain["toBlock"],
-      "rollbackedEvents": chain["rollbackedEvents"],
+      "chainId": rolledBack["chainId"],
+      "fromBlock": rolledBack["fromBlock"],
+      "toBlock": rolledBack["toBlock"],
+      "rollbackedEvents": rolledBack["rollbackedEvents"],
     })
   })
   logger->Logging.childTrace({

package/src/Rollback.res.mjs

@@ -70,12 +70,12 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
     }
   });
   let diff$1 = await InMemoryStore.prepareRollbackDiff(state, rollbackTargetCheckpointId, IndexerState.committedCheckpointId(state) + 1n, newProgressBlockNumberPerChain);
-  rolledBackChains.forEach(chain => Logging.childInfo(logger, {
+  rolledBackChains.forEach(rolledBack => Logging.childInfo(logger, {
     msg: "Rollbacked",
-    chainId: chain.chainId,
-    fromBlock: chain.fromBlock,
-    toBlock: chain.toBlock,
-    rollbackedEvents: chain.rollbackedEvents
+    chainId: rolledBack.chainId,
+    fromBlock: rolledBack.fromBlock,
+    toBlock: rolledBack.toBlock,
+    rollbackedEvents: rolledBack.rollbackedEvents
   }));
   Logging.childTrace(logger, {
     msg: "Rollback entity changes",
@@ -100,18 +100,18 @@ async function rollback(state, scheduleFetch, scheduleProcessing, scheduleRollba
     }
     switch (match.TAG) {
       case "ReorgDetected" :
-        let chain = match.chain;
-        let chainState = IndexerState.getChainState(state, chain);
+        let chainId = match.chainId;
+        let chainState = IndexerState.getChainState(state, chainId);
         IndexerState.enterFindingReorgDepth(state);
         let rollbackTargetBlockNumber = await getLastKnownValidBlock(chainState, match.blockNumber, IndexerState.isRealtime(state));
         SourceManager.onReorg(ChainState.sourceManager(chainState), rollbackTargetBlockNumber);
-        IndexerState.foundReorgDepth(state, chain, rollbackTargetBlockNumber);
+        IndexerState.foundReorgDepth(state, chainId, rollbackTargetBlockNumber);
         return scheduleRollback();
       case "FoundReorgDepth" :
         if (IndexerState.isProcessing(state)) {
           return Logging.trace("Waiting for batch to finish processing before executing rollback");
         } else {
-          return await executeRollback(state, match.chain, match.rollbackTargetBlockNumber, scheduleFetch, scheduleProcessing);
+          return await executeRollback(state, match.chainId, match.rollbackTargetBlockNumber, scheduleFetch, scheduleProcessing);
         }
       case "RollbackReady" :
         return Stdlib_JsError.throwWithMessage("Internal error: Rollback initiated with invalid state");

package/src/RollbackCommit.res

@@ -3,7 +3,7 @@
 // feature lives here plus two call sites: registration in `Main.res` and the
 // fire on a successful rollback write in `InMemoryStore.res`. Delete those
 // together with this module.
-type args = {chainId: int, rollbackToBlock: int}
+type args = {chainId: ChainId.t, rollbackToBlock: int}
 type callback = args => promise<unit>
 
 // Lives in the process-wide `EnvioGlobal` record so callbacks registered
@@ -28,7 +28,7 @@ let fire = async (~progressBlockNumberByChainId: dict<int>) => {
   let _ = await progressBlockNumberByChainId
   ->Dict.toArray
   ->Array.flatMap(((chainIdKey, rollbackToBlock)) => {
-    let args = {chainId: chainIdKey->Int.fromString->Option.getUnsafe, rollbackToBlock}
+    let args = {chainId: chainIdKey->ChainId.normalizeOrThrow, rollbackToBlock}
     callbacks->Array.map(callback => callback(args))
   })
   ->Promise.all

package/src/RollbackCommit.res.mjs

@@ -1,6 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as ChainId from "./ChainId.res.mjs";
 import * as EnvioGlobal from "./EnvioGlobal.res.mjs";
 
 let callbacks = EnvioGlobal.value.rollbackCommitCallbacks;
@@ -18,7 +18,7 @@ function register(callback) {
 
 async function fire(progressBlockNumberByChainId) {
   await Promise.all(Object.entries(progressBlockNumberByChainId).flatMap(param => {
-    let args_chainId = Stdlib_Int.fromString(param[0], undefined);
+    let args_chainId = ChainId.normalizeOrThrow(param[0]);
     let args_rollbackToBlock = param[1];
     let args = {
       chainId: args_chainId,
@@ -33,4 +33,4 @@ export {
   register,
   fire,
 }
-/* EnvioGlobal Not a pure module */
+/* ChainId Not a pure module */

package/src/SafeCheckpointTracking.res

@@ -70,10 +70,10 @@ let getSafeCheckpointId = (safeCheckpointTracking: t, ~sourceBlockNumber: int) =
 let updateOnNewBatch = (
   safeCheckpointTracking: t,
   ~sourceBlockNumber: int,
-  ~chainId: int,
+  ~chainId: ChainId.t,
   ~batchCheckpointIds: array<bigint>,
   ~batchCheckpointBlockNumbers: array<int>,
-  ~batchCheckpointChainIds: array<int>,
+  ~batchCheckpointChainIds: array<ChainId.t>,
 ) => {
   let safeCheckpointId = getSafeCheckpointId(safeCheckpointTracking, ~sourceBlockNumber)
 

package/src/SimulateDeadInputTracker.res

@@ -6,16 +6,15 @@
 // transform of the item between the source and the batch.
 let itemKey = (item: Internal.item): string =>
   switch item {
-  | Internal.Event({chain, blockNumber, logIndex}) =>
-    `${chain
-      ->ChainMap.Chain.toChainId
-      ->Int.toString}:${blockNumber->Int.toString}:${logIndex->Int.toString}`
+  | Internal.Event({chainId, blockNumber, logIndex}) =>
+    `${chainId
+      ->ChainId.toString}:${blockNumber->Int.toString}:${logIndex->Int.toString}`
   | Internal.Block(_) => ""
   }
 
 // `index` is the item's position in its chain's `simulate` array, reported back
 // so a user finds it without echoing its fields.
-type entry = {chainId: int, index: int, key: string}
+type entry = {chainId: ChainId.t, index: int, key: string}
 
 type t = {mutable unprocessed: array<entry>}
 
@@ -25,18 +24,12 @@ let makeFromConfig = (config: Config.t): option<t> => {
     ->ChainMap.values
     ->Array.flatMap(chainConfig =>
       switch chainConfig.sourceConfig {
-      | Config.CustomSources(sources) =>
-        sources->Array.flatMap(source =>
-          source.simulateItems
-          ->Option.getOr([])
-          ->Array.mapWithIndex(
-            (item, index) => {
-              chainId: chainConfig.id,
-              index,
-              key: itemKey(item),
-            },
-          )
-        )
+      | Config.SimulateSourceConfig({items}) =>
+        items->Array.mapWithIndex((item, index) => {
+          chainId: chainConfig.id,
+          index,
+          key: itemKey(item),
+        })
       | _ => []
       }
     )
@@ -52,17 +45,20 @@ let recordProcessed = (t: t, ~batch: Batch.t) => {
 }
 
 // Unrouted item indices grouped by chain, in the order chains were first seen.
-let unroutedByChain = (t: t): array<(int, array<int>)> => {
+let unroutedByChain = (t: t): array<(ChainId.t, array<int>)> => {
   let indicesByChain = Dict.make()
   let chainOrder = []
   t.unprocessed->Array.forEach(entry => {
-    let key = entry.chainId->Int.toString
+    let key = entry.chainId->ChainId.toString
     if indicesByChain->Dict.get(key)->Option.isNone {
       chainOrder->Array.push(entry.chainId)->ignore
     }
     indicesByChain->Utils.Dict.push(key, entry.index)
   })
-  chainOrder->Array.map(chainId => (chainId, indicesByChain->Dict.getUnsafe(chainId->Int.toString)))
+  chainOrder->Array.map(chainId => (
+    chainId,
+    indicesByChain->Dict.getUnsafe(chainId->ChainId.toString),
+  ))
 }
 
 let failureMessage = (t: t): option<string> =>
@@ -74,7 +70,7 @@ let failureMessage = (t: t): option<string> =>
     let lines =
       byChain
       ->Array.map(((chainId, indices)) =>
-        `  - chain ${chainId->Int.toString}: ${indices
+        `  - chain ${chainId->ChainId.toString}: ${indices
           ->Array.map(index => index->Int.toString)
           ->Array.join(", ")}`
       )

package/src/SimulateDeadInputTracker.res.mjs

@@ -1,13 +1,14 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
+import * as ChainId from "./ChainId.res.mjs";
 import * as ChainMap from "./ChainMap.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";
 
 function itemKey(item) {
   if (item.kind === 0) {
-    return item.chain.toString() + `:` + item.blockNumber.toString() + `:` + item.logIndex.toString();
+    return ChainId.toString(item.chainId) + `:` + item.blockNumber.toString() + `:` + item.logIndex.toString();
   } else {
     return "";
   }
@@ -15,13 +16,13 @@ function itemKey(item) {
 
 function makeFromConfig(config) {
   let entries = ChainMap.values(config.chainMap).flatMap(chainConfig => {
-    let sources = chainConfig.sourceConfig;
-    if (sources.TAG === "CustomSources") {
-      return sources._0.flatMap(source => Stdlib_Option.getOr(source.simulateItems, []).map((item, index) => ({
+    let match = chainConfig.sourceConfig;
+    if (match.TAG === "SimulateSourceConfig") {
+      return match.items.map((item, index) => ({
         chainId: chainConfig.id,
         index: index,
         key: itemKey(item)
-      })));
+      }));
     } else {
       return [];
     }
@@ -42,7 +43,7 @@ function unroutedByChain(t) {
   let indicesByChain = {};
   let chainOrder = [];
   t.unprocessed.forEach(entry => {
-    let key = entry.chainId.toString();
+    let key = ChainId.toString(entry.chainId);
     if (Stdlib_Option.isNone(indicesByChain[key])) {
       chainOrder.push(entry.chainId);
     }
@@ -50,7 +51,7 @@ function unroutedByChain(t) {
   });
   return chainOrder.map(chainId => [
     chainId,
-    indicesByChain[chainId.toString()]
+    indicesByChain[ChainId.toString(chainId)]
   ]);
 }
 
@@ -61,7 +62,7 @@ function failureMessage(t) {
   }
   let count = Stdlib_Array.reduce(byChain, 0, (acc, param) => acc + param[1].length | 0);
   let itemWord = count === 1 ? "item" : "items";
-  let lines = byChain.map(param => `  - chain ` + param[0].toString() + `: ` + param[1].map(index => index.toString()).join(", ")).join("\n");
+  let lines = byChain.map(param => `  - chain ` + ChainId.toString(param[0]) + `: ` + param[1].map(index => index.toString()).join(", ")).join("\n");
   return `simulate: ` + count.toString() + ` ` + itemWord + ` you passed to simulate never reached a handler, so nothing ran for them. Each was filtered out before the handler — usually a non-wildcard srcAddress that isn't indexed for the contract, or a where/block filter that excluded the event. Unrouted items, by index in each chain's simulate array:\n` + lines;
 }
 

package/src/SimulateItems.res

@@ -246,7 +246,6 @@ let parse = (
   ~chainConfig: Config.chain,
   ~onEventRegistrations: array<Internal.onEventRegistration>,
 ): array<Internal.item> => {
-  let chain = ChainMap.Chain.makeUnsafe(~chainId=chainConfig.id)
   let chainId = chainConfig.id
   let startBlock = chainConfig.startBlock
   let currentBlock = ref(startBlock)
@@ -334,7 +333,7 @@ let parse = (
       switch seenCoordinates->Dict.get(coordinate) {
       | Some(firstIndex) =>
         JsError.throwWithMessage(
-          `simulate: items at index ${firstIndex->Int.toString} and ${itemIndex->Int.toString} on chain ${chainId->Int.toString} both resolve to block ${blockNumber->Int.toString}, logIndex ${logIndex->Int.toString}. Give each item a distinct logIndex (or omit logIndex so they auto-increment).`,
+          `simulate: items at index ${firstIndex->Int.toString} and ${itemIndex->Int.toString} on chain ${chainId->ChainId.toString} both resolve to block ${blockNumber->Int.toString}, logIndex ${logIndex->Int.toString}. Give each item a distinct logIndex (or omit logIndex so they auto-increment).`,
         )
       | None => seenCoordinates->Dict.set(coordinate, itemIndex)
       }
@@ -351,7 +350,7 @@ let parse = (
       let liveRegistrations =
         HandlerRegister.getSimulateOnEventRegistrations(
           ~config,
-          ~chainId,
+          ~chainId=chainId,
           ~eventConfig,
         )->Array.filter(reg =>
           (reg.handler->Option.isSome || reg.contractRegister->Option.isSome) &&
@@ -363,7 +362,7 @@ let parse = (
             ->ChainMap.values
             ->Array.length {
             | 1 => ""
-            | _ => ` on chain ${chainId->Int.toString}`
+            | _ => ` on chain ${chainId->ChainId.toString}`
             }}. Register a handler with indexer.onEvent (and check any \`where\` filter isn't excluding this chain) before simulating it.`,
         )
       }
@@ -378,7 +377,7 @@ let parse = (
         ->Array.push(
           Internal.Event({
             onEventRegistration,
-            chain,
+            chainId,
             blockNumber,
             logIndex,
             // Simulate keeps the transaction inline on the payload, so the store
@@ -389,7 +388,7 @@ let parse = (
                 contractName: eventConfig.contractName,
                 eventName: eventConfig.name,
                 params,
-                chainId,
+                chainId: chainId,
                 srcAddress,
                 logIndex,
                 transaction,
@@ -420,8 +419,8 @@ let patchConfig = (
     (processConfig->(Utils.magic: JSON.t => {..}))["chains"]->Nullable.toOption
   switch processChains {
   | Some(chainsDict) =>
-    let newChainMap = config.chainMap->ChainMap.mapWithKey((chain, chainConfig) => {
-      let chainIdStr = chain->ChainMap.Chain.toChainId->Int.toString
+    let newChainMap = config.chainMap->ChainMap.mapWithKey((chainId, chainConfig) => {
+      let chainIdStr = chainId->ChainId.toString
       switch chainsDict->Dict.get(chainIdStr) {
       | Some(processChainJson) =>
         let raw = processChainJson->(Utils.magic: JSON.t => {..})
@@ -451,8 +450,7 @@ let patchConfig = (
             ~chainConfig,
             ~onEventRegistrations=chainRegistrations.onEventRegistrations,
           )
-          let source = SimulateSource.make(~items, ~endBlock, ~chain)
-          {...chainConfig, sourceConfig: Config.CustomSources([source])}
+          {...chainConfig, sourceConfig: Config.SimulateSourceConfig({items, endBlock})}
         | None => chainConfig
         }
       | None => chainConfig

package/src/SimulateItems.res.mjs

@@ -3,9 +3,9 @@
 import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as Address from "./Address.res.mjs";
+import * as ChainId from "./ChainId.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-import * as SimulateSource from "./sources/SimulateSource.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as HandlerRegister from "./HandlerRegister.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
@@ -169,7 +169,6 @@ function deriveSrcAddress(providedSrcAddress, eventConfig, chainConfig, config)
 }
 
 function parse(simulateItems, config, chainConfig, onEventRegistrations) {
-  let chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
   let chainId = chainConfig.id;
   let startBlock = chainConfig.startBlock;
   let currentBlock = {
@@ -251,7 +250,7 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
     let coordinate = blockNumber.toString() + `:` + logIndex.toString();
     let firstIndex = seenCoordinates[coordinate];
     if (firstIndex !== undefined) {
-      Stdlib_JsError.throwWithMessage(`simulate: items at index ` + firstIndex.toString() + ` and ` + itemIndex.toString() + ` on chain ` + chainId.toString() + ` both resolve to block ` + blockNumber.toString() + `, logIndex ` + logIndex.toString() + `. Give each item a distinct logIndex (or omit logIndex so they auto-increment).`);
+      Stdlib_JsError.throwWithMessage(`simulate: items at index ` + firstIndex.toString() + ` and ` + itemIndex.toString() + ` on chain ` + ChainId.toString(chainId) + ` both resolve to block ` + blockNumber.toString() + `, logIndex ` + logIndex.toString() + `. Give each item a distinct logIndex (or omit logIndex so they auto-increment).`);
     } else {
       seenCoordinates[coordinate] = itemIndex;
     }
@@ -265,7 +264,7 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
     if (Utils.$$Array.isEmpty(liveRegistrations)) {
       let match$5 = ChainMap.values(config.chainMap).length;
       Stdlib_JsError.throwWithMessage(`simulate: no handler runs for event "` + match$1 + `" on contract "` + match + `"` + (
-        match$5 !== 1 ? ` on chain ` + chainId.toString() : ""
+        match$5 !== 1 ? ` on chain ` + ChainId.toString(chainId) : ""
       ) + `. Register a handler with indexer.onEvent (and check any \`where\` filter isn't excluding this chain) before simulating it.`);
     }
     liveRegistrations.forEach(reg => {
@@ -276,7 +275,7 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
       items.push({
         kind: 0,
         onEventRegistration: newrecord,
-        chain: chain,
+        chainId: chainId,
         blockNumber: blockNumber,
         logIndex: logIndex,
         transactionIndex: 0,
@@ -301,8 +300,8 @@ function patchConfig(config, processConfig, registrationsByChainId) {
   if (processChains == null) {
     return config;
   }
-  let newChainMap = ChainMap.mapWithKey(config.chainMap, (chain, chainConfig) => {
-    let chainIdStr = chain.toString();
+  let newChainMap = ChainMap.mapWithKey(config.chainMap, (chainId, chainConfig) => {
+    let chainIdStr = ChainId.toString(chainId);
     let processChainJson = processChains[chainIdStr];
     if (processChainJson === undefined) {
       return chainConfig;
@@ -331,11 +330,11 @@ function patchConfig(config, processConfig, registrationsByChainId) {
     newrecord.endBlock = endBlock;
     newrecord.startBlock = startBlock;
     let items = parse(simulateRaw, config, newrecord, chainRegistrations.onEventRegistrations);
-    let source = SimulateSource.make(items, endBlock, chain);
     let newrecord$1 = {...newrecord};
     newrecord$1.sourceConfig = {
-      TAG: "CustomSources",
-      _0: [source]
+      TAG: "SimulateSourceConfig",
+      items: items,
+      endBlock: endBlock
     };
     return newrecord$1;
   });

package/src/Sink.res

@@ -12,7 +12,7 @@ type t = {
   ) => promise<unit>,
 }
 
-let makeClickHouse = (~host, ~database, ~username, ~password): t => {
+let makeClickHouse = (~host, ~database, ~username, ~password, ~chainIdMode: ChainId.mode=Int32): t => {
   let client = ClickHouse.createClient({
     url: host,
     username,
@@ -27,7 +27,7 @@ let makeClickHouse = (~host, ~database, ~username, ~password): t => {
   {
     name: "clickhouse",
     initialize: (~chainConfigs as _=[], ~entities=[], ~enums=[]) => {
-      ClickHouse.initialize(client, ~database, ~entities, ~enums)
+      ClickHouse.initialize(client, ~database, ~entities, ~enums, ~chainIdMode)
     },
     resume: (~checkpointId) => {
       ClickHouse.resume(client, ~database, ~checkpointId)

package/src/Sink.res.mjs

@@ -3,7 +3,8 @@
 import * as ClickHouse from "./bindings/ClickHouse.res.mjs";
 import * as Client from "@clickhouse/client";
 
-function makeClickHouse(host, database, username, password) {
+function makeClickHouse(host, database, username, password, chainIdModeOpt) {
+  let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
   let client = Client.createClient({
     url: host,
     username: username,
@@ -16,7 +17,7 @@ function makeClickHouse(host, database, username, password) {
       $staropt$star !== undefined;
       let entities = $staropt$star$1 !== undefined ? $staropt$star$1 : [];
       let enums = $staropt$star$2 !== undefined ? $staropt$star$2 : [];
-      return ClickHouse.initialize(client, database, entities, enums);
+      return ClickHouse.initialize(client, database, entities, enums, chainIdMode);
     },
     resume: checkpointId => ClickHouse.resume(client, database, checkpointId),
     writeBatch: async (batch, updatedEntities) => {

package/src/TestIndexer.res

@@ -55,7 +55,7 @@ let getIndexingAddressesByChain = (state: testIndexerState): dict<
     ->Dict.valuesToArray
     ->Array.forEach(entity => {
       let dc = entity->castToEnvioAddresses
-      let chainIdStr = dc.chainId->Int.toString
+      let chainIdStr = dc.chainId->ChainId.toString
       let contracts = switch byChain->Dict.get(chainIdStr) {
       | Some(arr) => arr
       | None =>
@@ -96,7 +96,7 @@ let handleWriteBatch = (
   state: testIndexerState,
   ~updatedEntities: array<Persistence.updatedEntity>,
   ~checkpointIds: array<bigint>,
-  ~checkpointChainIds: array<int>,
+  ~checkpointChainIds: array<ChainId.t>,
   ~checkpointBlockNumbers: array<int>,
   ~checkpointEventsProcessed: array<int>,
 ): unit => {
@@ -158,7 +158,7 @@ let handleWriteBatch = (
 
     // Update progress tracking from checkpoint data
     state.progressBlockByChain->Dict.set(
-      checkpointChainIds->Array.getUnsafe(i)->Int.toString,
+      checkpointChainIds->Array.getUnsafe(i)->ChainId.toString,
       checkpointBlockNumbers->Array.getUnsafe(i),
     )
 
@@ -223,8 +223,7 @@ let makeInitialState = (
 ): Persistence.initialState => {
   let chainKeys = processConfigChains->Dict.keysToArray
   let chains = chainKeys->Array.map(chainIdStr => {
-    let chainId = chainIdStr->Int.fromString->Option.getOr(0)
-    let chain = ChainMap.Chain.makeUnsafe(~chainId)
+    let chain = chainIdStr->ChainId.normalizeOrThrow
 
     if !(config.chainMap->ChainMap.has(chain)) {
       JsError.throwWithMessage(`Chain ${chainIdStr} is not configured in config.yaml`)
@@ -233,7 +232,7 @@ let makeInitialState = (
     let processChainConfig = processConfigChains->Dict.getUnsafe(chainIdStr)
     let indexingAddresses = indexingAddressesByChain->Dict.get(chainIdStr)->Option.getOr([])
     {
-      Persistence.id: chainId,
+      Persistence.id: chain,
       startBlock: processChainConfig.startBlock,
       endBlock: processChainConfig.endBlock,
       sourceBlockNumber: processChainConfig.endBlock->Option.getOr(0),
@@ -310,12 +309,9 @@ let parseBlockRange = (
   ~rawChainConfig: rawChainConfig,
   ~progressBlock: option<int>,
 ): chainConfig => {
-  let chainId = switch chainIdStr->Int.fromString {
-  | Some(id) => id
-  | None =>
-    JsError.throwWithMessage(`Invalid chain ID "${chainIdStr}": expected a numeric chain ID`)
+  let chain = try chainIdStr->ChainId.normalizeOrThrow catch {
+  | _ => JsError.throwWithMessage(`Invalid chain ID "${chainIdStr}": expected a numeric chain ID`)
   }
-  let chain = ChainMap.Chain.makeUnsafe(~chainId)
   if !(config.chainMap->ChainMap.has(chain)) {
     JsError.throwWithMessage(`Chain ${chainIdStr} is not configured in config.yaml`)
   }
@@ -485,6 +481,10 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
     state
     ->handleLoad(~tableName=table.tableName, ~filter)
     ->(Utils.magic: array<Internal.entity> => array<unknown>),
+  // The in-memory storage has no indexes to build, and it's always ready.
+  ensureQueryIndexes: async (~table as _, ~filters as _) => (),
+  ensureSchemaIndexes: async (~entities as _) => (),
+  finalizeBackfill: async (~entities as _, ~chainIds as _, ~readyAt as _) => (),
   writeBatch: async (
     ~batch,
     ~rollback as _,
@@ -638,7 +638,7 @@ let createTestIndexer = (): t<'processConfig> => {
   config.chainMap
   ->ChainMap.values
   ->Array.forEach(chainConfig => {
-    let chainIdStr = chainConfig.id->Int.toString
+    let chainIdStr = chainConfig.id->ChainId.toString
     chainIds->Array.push(chainConfig.id)->ignore
 
     let chainObj = Utils.Object.createNullObject()
@@ -673,7 +673,7 @@ let createTestIndexer = (): t<'processConfig> => {
               )
             }
             getIndexingAddressesByChain(state)
-            ->Dict.get(chainConfig.id->Int.toString)
+            ->Dict.get(chainConfig.id->ChainId.toString)
             ->Option.getOr([])
             ->Array.filterMap(ia => ia.contractName === contract.name ? Some(ia.address) : None)
           },
@@ -699,7 +699,7 @@ let createTestIndexer = (): t<'processConfig> => {
 
   // Build the result object with process + entity operations + chain info
   let result: dict<unknown> = Dict.make()
-  result->Dict.set("chainIds", chainIds->(Utils.magic: array<int> => unknown))
+  result->Dict.set("chainIds", chainIds->(Utils.magic: array<ChainId.t> => unknown))
   result->Dict.set("chains", chains->(Utils.magic: {..} => unknown))
   entityOpsDict
   ->Dict.toArray