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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.5.0-alpha.3",
+  "version": "3.5.0-rc.0",
   "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.5.0-alpha.3",
-    "envio-linux-x64-musl": "3.5.0-alpha.3",
-    "envio-linux-arm64": "3.5.0-alpha.3",
-    "envio-darwin-x64": "3.5.0-alpha.3",
-    "envio-darwin-arm64": "3.5.0-alpha.3"
+    "envio-linux-x64": "3.5.0-rc.0",
+    "envio-linux-x64-musl": "3.5.0-rc.0",
+    "envio-linux-arm64": "3.5.0-rc.0",
+    "envio-darwin-x64": "3.5.0-rc.0",
+    "envio-darwin-arm64": "3.5.0-rc.0"
   }
 }

package/src/Batch.res

@@ -28,7 +28,7 @@ type t = {
   isInReorgThreshold: bool,
   // Unnest-like checkpoint fields:
   checkpointIds: array<bigint>,
-  checkpointChainIds: array<int>,
+  checkpointChainIds: array<ChainId.t>,
   checkpointBlockNumbers: array<int>,
   checkpointBlockHashes: array<Null.t<string>>,
   checkpointEventsProcessed: array<int>,
@@ -80,14 +80,14 @@ let getProgressedChainsById = {
       let fetchState = chainBeforeBatch.fetchState
 
       let progressBlockNumberAfterBatch = switch progressBlockNumberPerChain->Utils.Dict.dangerouslyGetNonOption(
-        fetchState.chainId->Int.toString,
+        fetchState.chainId->ChainId.toString,
       ) {
       | Some(progressBlockNumber) => progressBlockNumber
       | None => chainBeforeBatch.progressBlockNumber
       }
 
       switch switch batchSizePerChain->Utils.Dict.dangerouslyGetNonOption(
-        fetchState.chainId->Int.toString,
+        fetchState.chainId->ChainId.toString,
       ) {
       | Some(batchSize) =>
         let leftItems = fetchState.buffer->Array.slice(~start=batchSize)
@@ -107,7 +107,7 @@ let getProgressedChainsById = {
         )
       } {
       | Some(progressedChain) =>
-        progressedChainsById->Utils.Dict.setByInt(
+        progressedChainsById->ChainId.Dict.set(
           chainBeforeBatch.fetchState.chainId,
           progressedChain,
         )
@@ -195,7 +195,7 @@ let prepareBatch = (
       )
     let chainBeforeBatch =
       chainsBeforeBatch
-      ->Utils.Dict.dangerouslyGetByIntNonOption(fetchState.chainId)
+      ->ChainId.Dict.dangerouslyGetNonOption(fetchState.chainId)
       ->Option.getUnsafe
 
     let prevBlockNumber = ref(chainBeforeBatch.progressBlockNumber)
@@ -245,7 +245,7 @@ let prepareBatch = (
       }
 
       totalBatchSize := totalBatchSize.contents + chainBatchSize
-      mutBatchSizePerChain->Utils.Dict.setByInt(fetchState.chainId, chainBatchSize)
+      mutBatchSizePerChain->ChainId.Dict.set(fetchState.chainId, chainBatchSize)
     }
 
     let progressBlockNumberAfterBatch =
@@ -265,7 +265,7 @@ let prepareBatch = (
         ~mutCheckpointEventsProcessed=checkpointEventsProcessed,
       )
 
-    mutProgressBlockNumberPerChain->Utils.Dict.setByInt(
+    mutProgressBlockNumberPerChain->ChainId.Dict.set(
       fetchState.chainId,
       progressBlockNumberAfterBatch,
     )
@@ -325,7 +325,7 @@ let findLastEventItem = (batch: t, ~chainId) => {
     switch item {
     | Internal.Event(_) as eventItem => {
         let eventItem = eventItem->Internal.castUnsafeEventItem
-        if eventItem.chain->ChainMap.Chain.toChainId === chainId {
+        if eventItem.chainId === chainId {
           result := Some(eventItem)
         } else {
           idx := idx.contents - 1

package/src/Batch.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
+import * as ChainId from "./ChainId.res.mjs";
 import * as FetchState from "./FetchState.res.mjs";
 import * as ReorgDetection from "./ReorgDetection.res.mjs";
 
@@ -21,9 +22,9 @@ function getProgressedChainsById(chainsBeforeBatch, batchSizePerChain, progressB
   let progressedChainsById = {};
   Object.values(chainsBeforeBatch).forEach(chainBeforeBatch => {
     let fetchState = chainBeforeBatch.fetchState;
-    let progressBlockNumber = progressBlockNumberPerChain[fetchState.chainId.toString()];
+    let progressBlockNumber = progressBlockNumberPerChain[ChainId.toString(fetchState.chainId)];
     let progressBlockNumberAfterBatch = progressBlockNumber !== undefined ? progressBlockNumber : chainBeforeBatch.progressBlockNumber;
-    let batchSize = batchSizePerChain[fetchState.chainId.toString()];
+    let batchSize = batchSizePerChain[ChainId.toString(fetchState.chainId)];
     let progressedChain;
     if (batchSize !== undefined) {
       let leftItems = fetchState.buffer.slice(batchSize);
@@ -188,7 +189,7 @@ function findLastEventItem(batch, chainId) {
   let result;
   while (idx >= 0 && result === undefined) {
     let item = batch.items[idx];
-    if (item.kind === 0 && item.chain === chainId) {
+    if (item.kind === 0 && item.chainId === chainId) {
       result = item;
     } else {
       idx = idx - 1;

package/src/BatchProcessing.res

@@ -101,16 +101,26 @@ and processNextBatch = async (state: IndexerState.t, ~scheduleFetch): unit => {
       scheduleFetch()
     }
 
+    // Nothing progressed, but a backfill that reached the head and died before
+    // finalizing resumes exactly here: it still owes the schema its deferred
+    // indexes, and no batch will ever come along to notice.
+    state->IndexerState.markCaughtUpIfSettled
+    if state->IndexerState.isFinalizingIndexes {
+      await FinalizeBackfill.run(state)
+    }
+
+    // Same realtime handoff the progressed-batch path does below. IndexerLoop
+    // starts fetching before processing, so by now the chain is already parked
+    // on a pre-realtime waiter; without this it stays there, polling the sync
+    // source at the backfill interval, until that source reports a new height.
+    if !isRealtimeBeforeUpdate && state->IndexerState.isRealtime {
+      state->IndexerState.invalidateInflight
+      scheduleFetch()
+    }
+
     // When resuming from persisted state, all events may already be processed.
     if EventProcessing.allChainsEventsProcessedToEndblock(state->IndexerState.chainStates) {
       Logging.info("All chains are caught up to end blocks.")
-      // A run that has nothing left to process still owes the schema its
-      // deferred indexes — otherwise a resume of a backfill that died right
-      // before finalizing would report ready without them.
-      state->IndexerState.markCaughtUp
-      if state->IndexerState.isFinalizingIndexes {
-        await FinalizeBackfill.run(state)
-      }
       if !(state->IndexerState.keepProcessAlive) {
         await ExitOnCaughtUp.run(state)
       }

package/src/BatchProcessing.res.mjs

@@ -37,12 +37,16 @@ async function processNextBatch(state, scheduleFetch) {
     if (shouldEnterReorgThreshold) {
       scheduleFetch();
     }
+    IndexerState.markCaughtUpIfSettled(state);
+    if (IndexerState.isFinalizingIndexes(state)) {
+      await FinalizeBackfill.run(state);
+    }
+    if (!isRealtimeBeforeUpdate && IndexerState.isRealtime(state)) {
+      IndexerState.invalidateInflight(state);
+      scheduleFetch();
+    }
     if (EventProcessing.allChainsEventsProcessedToEndblock(IndexerState.chainStates(state))) {
       Logging.info("All chains are caught up to end blocks.");
-      IndexerState.markCaughtUp(state);
-      if (IndexerState.isFinalizingIndexes(state)) {
-        await FinalizeBackfill.run(state);
-      }
       if (!IndexerState.keepProcessAlive(state)) {
         return await ExitOnCaughtUp.run(state);
       } else {

package/src/ChainFetching.res

@@ -3,7 +3,7 @@
 // (state + transitions) and leaf effect modules.
 
 type partitionQueryResponse = {
-  chain: IndexerState.chain,
+  chainId: ChainId.t,
   response: Source.blockRangeFetchResponse,
   query: FetchState.query,
 }
@@ -106,7 +106,7 @@ let runContractRegistersOrThrow = async (
 
 let rec onQueryResponse = async (
   state: IndexerState.t,
-  {chain, response, query}: partitionQueryResponse,
+  {chainId, response, query}: partitionQueryResponse,
   ~stateId,
   ~scheduleFetch,
   ~scheduleProcessing,
@@ -115,7 +115,7 @@ let rec onQueryResponse = async (
   if state->IndexerState.isStale(~stateId) {
     ()
   } else {
-    let chainState = state->IndexerState.getChainState(~chain)
+    let chainState = state->IndexerState.getChainState(~chainId)
     let {
       parsedQueueItems,
       transactionStore,
@@ -142,7 +142,7 @@ let rec onQueryResponse = async (
     if numContractRegisterEvents === 0 {
       Logging.trace({
         "msg": "Finished querying",
-        "chainId": chain->ChainMap.Chain.toChainId,
+        "chainId": chainId,
         "partitionId": query.partitionId,
         "fromBlock": fromBlockQueried,
         "toBlock": latestFetchedBlockNumber,
@@ -151,7 +151,7 @@ let rec onQueryResponse = async (
     } else {
       Logging.trace({
         "msg": "Finished querying",
-        "chainId": chain->ChainMap.Chain.toChainId,
+        "chainId": chainId,
         "partitionId": query.partitionId,
         "fromBlock": fromBlockQueried,
         "toBlock": latestFetchedBlockNumber,
@@ -199,20 +199,21 @@ let rec onQueryResponse = async (
         cs->ChainState.prepareReorg(
           ~eventsProcessedDiff=switch eventsProcessedDiffByChain {
           | Some(byChain) =>
-            byChain->Utils.Dict.dangerouslyGetByIntNonOption((cs->ChainState.chainConfig).id)
+            byChain->ChainId.Dict.dangerouslyGetNonOption((cs->ChainState.chainConfig).id)
           | None => None
           },
         )
       )
-      state->IndexerState.beginReorg(~chain, ~blockNumber=reorgDetectedBlockNumber)
+      state->IndexerState.beginReorg(~chainId, ~blockNumber=reorgDetectedBlockNumber)
       // Advances synchronously to FindingReorgDepth, so a concurrent rollback
       // kick (eg from the processing loop quiescing) collapses into this one.
       scheduleRollback()
     | None =>
       // Over-fetched events (a merged partition returning an address before its
-      // effectiveStartBlock, or a wildcard param referencing an address
-      // registered after the log's block) are already dropped by the source's
-      // native address gate, so everything here is indexable.
+      // effectiveStartBlock, a wildcard param referencing an address registered
+      // after the log's block, or a registration whose own start block is later
+      // than its contract's) are already dropped by the source's native gates,
+      // so everything here is indexable.
       let newItems = parsedQueueItems
       let itemsWithContractRegister = []
       for idx in 0 to newItems->Array.length - 1 {
@@ -229,7 +230,7 @@ let rec onQueryResponse = async (
         if !(state->IndexerState.isStale(~stateId)) {
           applyQueryResponse(
             state,
-            ~chain,
+            ~chainId,
             ~newItems,
             ~newItemsWithDcs,
             ~knownHeight,
@@ -264,7 +265,7 @@ let rec onQueryResponse = async (
 
 and applyQueryResponse = (
   state: IndexerState.t,
-  ~chain,
+  ~chainId,
   ~newItems,
   ~newItemsWithDcs,
   ~knownHeight,
@@ -273,7 +274,7 @@ and applyQueryResponse = (
   ~transactionStore,
   ~blockStore,
 ) => {
-  let chainState = state->IndexerState.getChainState(~chain)
+  let chainState = state->IndexerState.getChainState(~chainId)
   let wasFetchingAtHead = chainState->ChainState.isFetchingAtHead
 
   chainState->ChainState.handleQueryResult(
@@ -307,7 +308,7 @@ and applyQueryResponse = (
 
 let finishWaitingForNewBlock = (
   state: IndexerState.t,
-  ~chain,
+  ~chainId,
   ~knownHeight,
   ~stateId,
   ~scheduleFetch,
@@ -316,7 +317,7 @@ let finishWaitingForNewBlock = (
   if state->IndexerState.isStale(~stateId) {
     ()
   } else {
-    let chainState = state->IndexerState.getChainState(~chain)
+    let chainState = state->IndexerState.getChainState(~chainId)
     chainState->ChainState.updateKnownHeight(~knownHeight)
 
     // No reorg-threshold check here: scheduleProcessing always runs at least one
@@ -327,14 +328,14 @@ let finishWaitingForNewBlock = (
 
 let fetchChain = async (
   state: IndexerState.t,
-  chain,
+  chainId,
   ~action,
   ~stateId,
   ~scheduleFetch,
   ~scheduleProcessing,
   ~scheduleRollback,
 ) => {
-  let chainState = state->IndexerState.getChainState(~chain)
+  let chainState = state->IndexerState.getChainState(~chainId)
   if !(state->IndexerState.isResolvingReorg) && !(state->IndexerState.isStopped) {
     let isRealtime = state->IndexerState.isRealtime
     let sourceManager = chainState->ChainState.sourceManager
@@ -352,7 +353,7 @@ let fetchChain = async (
         ~onNewBlock=(~knownHeight) =>
           finishWaitingForNewBlock(
             state,
-            ~chain,
+            ~chainId,
             ~knownHeight,
             ~stateId,
             ~scheduleFetch,
@@ -370,7 +371,7 @@ let fetchChain = async (
             )
             await onQueryResponse(
               state,
-              {chain, response, query},
+              {chainId, response, query},
               ~stateId,
               ~scheduleFetch,
               ~scheduleProcessing,

package/src/ChainFetching.res.mjs

@@ -71,8 +71,8 @@ async function runContractRegistersOrThrow(itemsWithContractRegister, config, tr
   return itemsWithDcs;
 }
 
-function applyQueryResponse(state, chain, newItems, newItemsWithDcs, knownHeight, latestFetchedBlock, query, transactionStore, blockStore) {
-  let chainState = IndexerState.getChainState(state, chain);
+function applyQueryResponse(state, chainId, newItems, newItemsWithDcs, knownHeight, latestFetchedBlock, query, transactionStore, blockStore) {
+  let chainState = IndexerState.getChainState(state, chainId);
   let wasFetchingAtHead = ChainState.isFetchingAtHead(chainState);
   ChainState.handleQueryResult(chainState, query, newItems, newItemsWithDcs, latestFetchedBlock, knownHeight, transactionStore, blockStore);
   if (IndexerState.exitAfterFirstEventBlock(state) && newItems.length !== 0) {
@@ -86,11 +86,11 @@ function applyQueryResponse(state, chain, newItems, newItemsWithDcs, knownHeight
 async function onQueryResponse(state, param, stateId, scheduleFetch, scheduleProcessing, scheduleRollback) {
   let query = param.query;
   let response = param.response;
-  let chain = param.chain;
+  let chainId = param.chainId;
   if (IndexerState.isStale(state, stateId)) {
     return;
   }
-  let chainState = IndexerState.getChainState(state, chain);
+  let chainState = IndexerState.getChainState(state, chainId);
   let stats = response.stats;
   let latestFetchedBlockTimestamp = response.latestFetchedBlockTimestamp;
   let latestFetchedBlockNumber = response.latestFetchedBlockNumber;
@@ -110,7 +110,7 @@ async function onQueryResponse(state, param, stateId, scheduleFetch, schedulePro
   if (numContractRegisterEvents === 0) {
     Logging.trace({
       msg: "Finished querying",
-      chainId: chain,
+      chainId: chainId,
       partitionId: query.partitionId,
       fromBlock: fromBlockQueried,
       toBlock: latestFetchedBlockNumber,
@@ -119,7 +119,7 @@ async function onQueryResponse(state, param, stateId, scheduleFetch, schedulePro
   } else {
     Logging.trace({
       msg: "Finished querying",
-      chainId: chain,
+      chainId: chainId,
       partitionId: query.partitionId,
       fromBlock: fromBlockQueried,
       toBlock: latestFetchedBlockNumber,
@@ -142,7 +142,7 @@ async function onQueryResponse(state, param, stateId, scheduleFetch, schedulePro
     let eventsProcessedDiffByChain;
     eventsProcessedDiffByChain = typeof match !== "object" || match.TAG !== "RollbackReady" ? undefined : match.eventsProcessedDiffByChain;
     Utils.Dict.forEach(IndexerState.chainStates(state), cs => ChainState.prepareReorg(cs, eventsProcessedDiffByChain !== undefined ? eventsProcessedDiffByChain[ChainState.chainConfig(cs).id] : undefined));
-    IndexerState.beginReorg(state, chain, rollbackWithReorgDetectedBlockNumber);
+    IndexerState.beginReorg(state, chainId, rollbackWithReorgDetectedBlockNumber);
     return scheduleRollback();
   }
   let itemsWithContractRegister = [];
@@ -154,7 +154,7 @@ async function onQueryResponse(state, param, stateId, scheduleFetch, schedulePro
   }
   let proceed = newItemsWithDcs => {
     if (!IndexerState.isStale(state, stateId)) {
-      applyQueryResponse(state, chain, parsedQueueItems, newItemsWithDcs, knownHeight, {
+      applyQueryResponse(state, chainId, parsedQueueItems, newItemsWithDcs, knownHeight, {
         blockNumber: latestFetchedBlockNumber,
         blockTimestamp: latestFetchedBlockTimestamp
       }, query, transactionStore, blockStore);
@@ -176,18 +176,18 @@ async function onQueryResponse(state, param, stateId, scheduleFetch, schedulePro
   return proceed(newItemsWithDcs);
 }
 
-function finishWaitingForNewBlock(state, chain, knownHeight, stateId, scheduleFetch, scheduleProcessing) {
+function finishWaitingForNewBlock(state, chainId, knownHeight, stateId, scheduleFetch, scheduleProcessing) {
   if (IndexerState.isStale(state, stateId)) {
     return;
   }
-  let chainState = IndexerState.getChainState(state, chain);
+  let chainState = IndexerState.getChainState(state, chainId);
   ChainState.updateKnownHeight(chainState, knownHeight);
   scheduleFetch();
   scheduleProcessing();
 }
 
-async function fetchChain(state, chain, action, stateId, scheduleFetch, scheduleProcessing, scheduleRollback) {
-  let chainState = IndexerState.getChainState(state, chain);
+async function fetchChain(state, chainId, action, stateId, scheduleFetch, scheduleProcessing, scheduleRollback) {
+  let chainState = IndexerState.getChainState(state, chainId);
   if (IndexerState.isResolvingReorg(state) || IndexerState.isStopped(state)) {
     return;
   }
@@ -199,7 +199,7 @@ async function fetchChain(state, chain, action, stateId, scheduleFetch, schedule
       try {
         let response = await SourceManager.executeQuery(sourceManager, query, ChainState.knownHeight(chainState), isRealtime);
         return await onQueryResponse(state, {
-          chain: chain,
+          chainId: chainId,
           response: response,
           query: query
         }, stateId, scheduleFetch, scheduleProcessing, scheduleRollback);
@@ -207,7 +207,7 @@ async function fetchChain(state, chain, action, stateId, scheduleFetch, schedule
         let exn = Primitive_exceptions.internalToException(raw_exn);
         return IndexerState.errorExit(state, ErrorHandling.make(exn, undefined, undefined));
       }
-    }, knownHeight => SourceManager.waitForNewBlock(sourceManager, knownHeight, isRealtime, reducedPolling), knownHeight => finishWaitingForNewBlock(state, chain, knownHeight, stateId, scheduleFetch, scheduleProcessing), action, stateId);
+    }, knownHeight => SourceManager.waitForNewBlock(sourceManager, knownHeight, isRealtime, reducedPolling), knownHeight => finishWaitingForNewBlock(state, chainId, knownHeight, stateId, scheduleFetch, scheduleProcessing), action, stateId);
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     return IndexerState.errorExit(state, ErrorHandling.make(exn, undefined, IndexerState.unexpectedErrorMsg));

package/src/ChainId.res

@@ -0,0 +1,58 @@
+// Chain ids are identifiers, never arithmetic operands, so the runtime
+// representation is a plain JS number. ReScript's `int` would cap them at
+// 2^31-1, which networks like Tron Shasta (2494104990) already exceed.
+type t = float
+
+// Widest scalar the internal chain-id columns need. Resolved by the CLI from
+// the maximum active chain id and carried through the public config, so a
+// resume against a schema built for the other mode is rejected instead of
+// silently truncating ids.
+type mode = | @as("int32") Int32 | @as("int64") Int64
+
+let modeSchema = S.enum([Int32, Int64])
+
+// Number.MAX_SAFE_INTEGER — above this a chain id can't round-trip through
+// JSON or a JS number at all.
+let maxSafe = 9007199254740991.
+
+@scope("Number") @val external isSafeInteger: float => bool = "isSafeInteger"
+
+// Escapes for the boundaries that stay `int`: the handler-facing
+// `context.chain.id` / `Envio.effectChain.id`, and int literals in configs and
+// tests. Both are the identity at runtime — an `int` is already a JS number.
+external fromInt: int => t = "%identity"
+external toInt: t => int = "%identity"
+
+let toString = (chainId: t) => chainId->Float.toString
+let compare = (a: t, b: t) => a < b ? -1 : a > b ? 1 : 0
+
+// PostgreSQL BIGINT and ClickHouse UInt64 columns come back as strings (a
+// JS number can't hold their full range), so the parser accepts both and
+// range-checks the result rather than trusting the driver.
+let schema: S.t<t> = S.float->S.preprocess(s => {
+  parser: value => {
+    let number = switch value->typeof {
+    | #string => value->(Utils.magic: unknown => string)->Float.parseFloat
+    | _ => value->(Utils.magic: unknown => float)
+    }
+    if !isSafeInteger(number) || number < 0. {
+      s.fail(
+        `Expected a chain id between 0 and ${maxSafe->Float.toString}, received ${value->(
+            Utils.magic: unknown => string
+          )}`,
+      )
+    }
+    number
+  },
+})
+
+// Dicts keyed by chain id. JS coerces the number key to its decimal string,
+// which is exactly what `toString` produces, so the two key forms interoperate.
+module Dict = {
+  @get_index external dangerouslyGetNonOption: (dict<'a>, t) => option<'a> = ""
+  @set_index external set: (dict<'a>, t, 'a) => unit = ""
+}
+
+// Postgres returns BIGINT columns as strings, so raw (schema-less) reads of a
+// chain-id column go through this instead of trusting the driver's type.
+let normalizeOrThrow = (value: 'a): t => value->S.parseOrThrow(schema)

package/src/ChainId.res.mjs

@@ -0,0 +1,49 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+let modeSchema = S$RescriptSchema.$$enum([
+  "int32",
+  "int64"
+]);
+
+function toString(chainId) {
+  return chainId.toString();
+}
+
+function compare(a, b) {
+  if (a < b) {
+    return -1;
+  } else if (a > b) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+let schema = S$RescriptSchema.preprocess(S$RescriptSchema.float, s => ({
+  p: value => {
+    let match = typeof value;
+    let number = match === "string" ? parseFloat(value) : value;
+    if (!Number.isSafeInteger(number) || number < 0) {
+      s.fail(`Expected a chain id between 0 and ` + (9007199254740991).toString() + `, received ` + value, undefined);
+    }
+    return number;
+  }
+}));
+
+let Dict = {};
+
+function normalizeOrThrow(value) {
+  return S$RescriptSchema.parseOrThrow(value, schema);
+}
+
+export {
+  modeSchema,
+  toString,
+  compare,
+  schema,
+  Dict,
+  normalizeOrThrow,
+}
+/* modeSchema Not a pure module */

package/src/ChainId.resi

@@ -0,0 +1,27 @@
+type t
+
+type mode = | @as("int32") Int32 | @as("int64") Int64
+
+let modeSchema: S.t<mode>
+
+// Escapes for the boundaries that stay `int`: the handler-facing
+// `context.chain.id` / `Envio.effectChain.id`, and int literals in configs and
+// tests. Both are the identity at runtime — an `int` is already a JS number.
+external fromInt: int => t = "%identity"
+external toInt: t => int = "%identity"
+
+let toString: t => string
+let compare: (t, t) => int
+
+let schema: S.t<t>
+
+// Dicts keyed by chain id. JS coerces the number key to its decimal string,
+// which is exactly what `toString` produces, so the two key forms interoperate.
+module Dict: {
+  @get_index external dangerouslyGetNonOption: (dict<'a>, t) => option<'a> = ""
+  @set_index external set: (dict<'a>, t, 'a) => unit = ""
+}
+
+// Postgres returns BIGINT columns as strings, so raw (schema-less) reads of a
+// chain-id column go through this instead of trusting the driver's type.
+let normalizeOrThrow: 'a => t

package/src/ChainMap.res

@@ -1,40 +1,26 @@
-module Chain = {
-  type t = int
-
-  external toChainId: t => int = "%identity"
-
-  let toString = chainId => chainId->Int.toString
-
-  let makeUnsafe = (~chainId) => chainId
-}
-
 module ChainIdCmp = Belt.Id.MakeComparable({
-  type t = Chain.t
-  let cmp = (a, b) => Int.compare(a->Chain.toChainId, b->Chain.toChainId)->Int.fromFloat
+  type t = ChainId.t
+  let cmp = ChainId.compare
 })
 
 type t<'a> = Belt.Map.t<ChainIdCmp.t, 'a, ChainIdCmp.identity>
 
-let fromArrayUnsafe: array<(Chain.t, 'a)> => t<'a> = arr => {
+let fromArrayUnsafe: array<(ChainId.t, 'a)> => t<'a> = arr => {
   arr->Belt.Map.fromArray(~id=module(ChainIdCmp))
 }
 
-let get: (t<'a>, Chain.t) => 'a = (self, chain) =>
-  switch Belt.Map.get(self, chain) {
+let get: (t<'a>, ChainId.t) => 'a = (self, chainId) =>
+  switch Belt.Map.get(self, chainId) {
   | Some(v) => v
   | None =>
-    // Should be unreachable, since we validate on Chain.t creation
+    // Should be unreachable, since we validate chain ids when parsing the config.
     // Still throw just in case something went wrong
-    JsError.throwWithMessage("No chain with id " ++ chain->Chain.toString ++ " found in chain map")
+    JsError.throwWithMessage(
+      "No chain with id " ++ chainId->ChainId.toString ++ " found in chain map",
+    )
   }
 
-let set: (t<'a>, Chain.t, 'a) => t<'a> = (map, chain, v) => Belt.Map.set(map, chain, v)
 let values: t<'a> => array<'a> = map => Belt.Map.valuesToArray(map)
-let keys: t<'a> => array<Chain.t> = map => Belt.Map.keysToArray(map)
-let entries: t<'a> => array<(Chain.t, 'a)> = map => Belt.Map.toArray(map)
-let has: (t<'a>, Chain.t) => bool = (map, chain) => Belt.Map.has(map, chain)
-let map: (t<'a>, 'a => 'b) => t<'b> = (map, fn) => Belt.Map.map(map, fn)
-let mapWithKey: (t<'a>, (Chain.t, 'a) => 'b) => t<'b> = (map, fn) => Belt.Map.mapWithKey(map, fn)
-let size: t<'a> => int = map => Belt.Map.size(map)
-let update: (t<'a>, Chain.t, 'a => 'a) => t<'a> = (map, chain, updateFn) =>
-  Belt.Map.update(map, chain, opt => opt->Option.map(updateFn))
+let keys: t<'a> => array<ChainId.t> = map => Belt.Map.keysToArray(map)
+let has: (t<'a>, ChainId.t) => bool = (map, chainId) => Belt.Map.has(map, chainId)
+let mapWithKey: (t<'a>, (ChainId.t, 'a) => 'b) => t<'b> = (map, fn) => Belt.Map.mapWithKey(map, fn)