envio 3.12.0 → 3.13.0-alpha.0

package/package.json

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

package/src/BatchProcessing.res

@@ -76,11 +76,7 @@ and processNextBatch = async (state: IndexerState.t, ~scheduleFetch): unit => {
   let isBelowReorgThreshold =
     !isInReorgThresholdBeforeUpdate && (state->IndexerState.config).shouldRollbackOnReorg
   let shouldEnterReorgThreshold =
-    isBelowReorgThreshold &&
-    state
-    ->IndexerState.chainStates
-    ->Dict.valuesToArray
-    ->Array.every(cs => cs->ChainState.isReadyToEnterReorgThresholdAfterBatch(~batch))
+    isBelowReorgThreshold && state->IndexerState.isReadyToEnterReorgThreshold(~batch)
 
   if shouldEnterReorgThreshold {
     IndexerState.enterReorgThreshold(state)
@@ -95,7 +91,7 @@ and processNextBatch = async (state: IndexerState.t, ~scheduleFetch): unit => {
     // 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 {
+    if state->IndexerState.shouldFinalizeIndexes {
       await FinalizeBackfill.run(state)
     }
 
@@ -111,7 +107,7 @@ and processNextBatch = async (state: IndexerState.t, ~scheduleFetch): unit => {
     // 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.")
-      if !(state->IndexerState.keepProcessAlive) {
+      if !(state->IndexerState.keepProcessAlive) && !(state->IndexerState.isHoldingRealtime) {
         await ExitOnCaughtUp.run(state)
       }
     }
@@ -166,7 +162,7 @@ and processNextBatch = async (state: IndexerState.t, ~scheduleFetch): unit => {
         // Backfilling → FinalizingIndexes → Ready. Awaiting here holds the
         // processing loop for the whole finalize, which is what pauses
         // processing while the indexes are built.
-        if state->IndexerState.isFinalizingIndexes {
+        if state->IndexerState.shouldFinalizeIndexes {
           await FinalizeBackfill.run(state)
         }
 
@@ -186,7 +182,11 @@ and processNextBatch = async (state: IndexerState.t, ~scheduleFetch): unit => {
           Logging.info("All chains are caught up to end blocks.")
         }
 
-        if allCaughtUp && !(state->IndexerState.keepProcessAlive) {
+        if (
+          allCaughtUp &&
+          !(state->IndexerState.keepProcessAlive) &&
+          !(state->IndexerState.isHoldingRealtime)
+        ) {
           await ExitOnCaughtUp.run(state)
         } else if (
           // In auto-exit mode, error if all chains reached head with no events found

package/src/BatchProcessing.res.mjs

@@ -26,7 +26,7 @@ async function processNextBatch(state, scheduleFetch) {
   let batch = IndexerState.createBatch(state, IndexerState.config(state).batchSize);
   let progressedChainsById = batch.progressedChainsById;
   let isBelowReorgThreshold = !isInReorgThresholdBeforeUpdate && IndexerState.config(state).shouldRollbackOnReorg;
-  let shouldEnterReorgThreshold = isBelowReorgThreshold && Object.values(IndexerState.chainStates(state)).every(cs => ChainState.isReadyToEnterReorgThresholdAfterBatch(cs, batch));
+  let shouldEnterReorgThreshold = isBelowReorgThreshold && IndexerState.isReadyToEnterReorgThreshold(state, batch);
   if (shouldEnterReorgThreshold) {
     IndexerState.enterReorgThreshold(state);
   }
@@ -35,7 +35,7 @@ async function processNextBatch(state, scheduleFetch) {
       scheduleFetch();
     }
     IndexerState.markCaughtUpIfSettled(state);
-    if (IndexerState.isFinalizingIndexes(state)) {
+    if (IndexerState.shouldFinalizeIndexes(state)) {
       await FinalizeBackfill.run(state);
     }
     if (!isRealtimeBeforeUpdate && IndexerState.isRealtime(state)) {
@@ -44,7 +44,7 @@ async function processNextBatch(state, scheduleFetch) {
     }
     if (EventProcessing.allChainsEventsProcessedToEndblock(IndexerState.chainStates(state))) {
       Logging.info("All chains are caught up to end blocks.");
-      if (!IndexerState.keepProcessAlive(state)) {
+      if (!IndexerState.keepProcessAlive(state) && !IndexerState.isHoldingRealtime(state)) {
         return await ExitOnCaughtUp.run(state);
       } else {
         return;
@@ -70,7 +70,7 @@ async function processNextBatch(state, scheduleFetch) {
   }
   IndexerState.clearRollback(state);
   IndexerState.applyBatchProgress(state, batch);
-  if (IndexerState.isFinalizingIndexes(state)) {
+  if (IndexerState.shouldFinalizeIndexes(state)) {
     await FinalizeBackfill.run(state);
   }
   if (!isRealtimeBeforeUpdate && IndexerState.isRealtime(state)) {
@@ -81,7 +81,7 @@ async function processNextBatch(state, scheduleFetch) {
   if (allCaughtUp) {
     Logging.info("All chains are caught up to end blocks.");
   }
-  if (allCaughtUp && !IndexerState.keepProcessAlive(state)) {
+  if (allCaughtUp && !IndexerState.keepProcessAlive(state) && !IndexerState.isHoldingRealtime(state)) {
     return await ExitOnCaughtUp.run(state);
   } else if (!allCaughtUp && IndexerState.exitAfterFirstEventBlock(state) && Object.values(IndexerState.chainStates(state)).every(ChainState.isAtHeadWithoutEndBlock)) {
     return IndexerState.errorExit(state, ErrorHandling.make(new Error("No events found between startBlock and chain head. Cannot auto-detect endBlock."), undefined, undefined));

package/src/Bin.res

@@ -51,23 +51,30 @@ let applyEnv = (env: dict<JSON.t>) =>
 
 let run = async args => {
   try {
-    switch (await Core.runCli(args))->Null.toOption {
-    // Rust-only command (codegen / init / stop / docker / metrics / help /
-    // version / scripts) — nothing for JS to do, exit cleanly.
-    | None => ()
-    | Some(json) =>
-      switch decodeCommand(json->JSON.parseOrThrow) {
-      | Start({reset, cwd, env, config}) =>
-        Config.prime(config)
-        processChdir(cwd)
-        applyEnv(env)
-        await Main.start(~reset)
-      | Migrate({reset, config}) =>
-        Config.prime(config)
-        await Main.migrate(~reset)
-      | DropSchema({config}) =>
-        Config.prime(config)
-        await Main.dropSchema()
+    if Worker.isEnabled {
+      Worker.bindToSupervisor()
+      // Its working directory, its environment and the chains it drives all came
+      // with the fork, so a worker starts the same way every other process does.
+      await Main.start()
+    } else {
+      switch (await Core.runCli(args))->Null.toOption {
+      // Rust-only command (codegen / init / stop / docker / metrics / help /
+      // version / scripts) — nothing for JS to do, exit cleanly.
+      | None => ()
+      | Some(json) =>
+        switch decodeCommand(json->JSON.parseOrThrow) {
+        | Start({reset, cwd, env, config}) =>
+          Config.prime(config)
+          processChdir(cwd)
+          applyEnv(env)
+          await Main.start(~reset)
+        | Migrate({reset, config}) =>
+          Config.prime(config)
+          await Main.migrate(~reset)
+        | DropSchema({config}) =>
+          Config.prime(config)
+          await Main.dropSchema()
+        }
       }
     }
   } catch {

package/src/Bin.res.mjs

@@ -4,6 +4,7 @@ import * as Core from "./Core.res.mjs";
 import * as Main from "./Main.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
+import * as Worker from "./Worker.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Process from "process";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
@@ -57,6 +58,10 @@ function applyEnv(env) {
 
 async function run(args) {
   try {
+    if (Worker.isEnabled) {
+      Worker.bindToSupervisor();
+      return await Main.start(undefined, undefined, undefined, undefined, undefined);
+    }
     let json = await Core.runCli(args);
     if (json === null) {
       return;

package/src/ChainFetching.res

@@ -262,7 +262,6 @@ and applyQueryResponse = (
   ~transactionStore,
 ) => {
   let chainState = state->IndexerState.getChainState(~chainId)
-  let wasFetchingAtHead = chainState->ChainState.isFetchingAtHead
 
   chainState->ChainState.handleQueryResult(
     ~query,
@@ -280,15 +279,30 @@ and applyQueryResponse = (
     )
   }
 
-  // Log the backfill→head transition once: this response brought the fetch
-  // frontier to the head. Gated on !isReady so realtime re-catch-ups (a new
-  // block arrives, gets fetched) don't spam the log after the chain is synced.
-  if (
-    !wasFetchingAtHead &&
-    !(chainState->ChainState.isReady) &&
-    chainState->ChainState.isFetchingAtHead
-  ) {
-    chainState->ChainState.logger->Logging.childInfo("All events have been fetched")
+  // Report the milestone this response brought the fetch frontier to, once.
+  // The chain reaches it again every time the head moves and it catches up, so
+  // what keeps the line off the log is the chain having already reported it,
+  // not the transition — which re-arms on every advance.
+  switch chainState->ChainState.isFetchingAtHead
+    ? chainState->ChainState.takeFetchedTo
+    : None {
+  | None => ()
+  | Some((target, block)) =>
+    // What the chain is waiting on, which is not itself. A held process is
+    // waiting on chains it doesn't drive, so it says so even when it drives
+    // only one — how the run is split is not the reader's problem.
+    let waitingOn = if (
+      state->IndexerState.isHoldingRealtime ||
+        state->IndexerState.chainStates->Dict.keysToArray->Array.length > 1
+    ) {
+      " Waiting for other chains."
+    } else {
+      ""
+    }
+    chainState->ChainState.logger->Logging.childInfo({
+      "msg": `Fetched to ${target}.${waitingOn}`,
+      "block": block,
+    })
   }
 }
 
@@ -326,9 +340,13 @@ let fetchChain = async (
     let isRealtime = state->IndexerState.isRealtime
     let sourceManager = chainState->ChainState.sourceManager
 
-    // Only affects the WaitingForNewBlock branch of dispatch, where
-    // there's nothing to fetch. During backfill any such chain is idle.
-    let reducedPolling = !isRealtime
+    // Only affects the WaitingForNewBlock branch of dispatch, where there's
+    // nothing to fetch. The line is whether any height is known at all, not
+    // whether the head is fetchable yet: a chain held back by its lag is still
+    // tracking a head it has, and asking faster would buy nothing. A chain with
+    // no height has nothing to show for itself until the first one lands, so it
+    // polls at the source's own cadence and earns the normal stall window.
+    let reducedPolling = !isRealtime && chainState->ChainState.knownHeight > 0
 
     // Owns its error boundary: launch doesn't catch, so any failure here (the
     // query, response handling, or dispatch itself) must stop the indexer.

package/src/ChainFetching.res.mjs

@@ -65,14 +65,19 @@ async function runContractRegistersOrThrow(itemsWithContractRegister, config, ch
 
 function applyQueryResponse(state, chainId, newItems, newRegistrations, knownHeight, latestFetchedBlock, query, transactionStore) {
   let chainState = IndexerState.getChainState(state, chainId);
-  let wasFetchingAtHead = ChainState.isFetchingAtHead(chainState);
   ChainState.handleQueryResult(chainState, query, newItems, newRegistrations, latestFetchedBlock, knownHeight, transactionStore);
   if (IndexerState.exitAfterFirstEventBlock(state) && newItems.length !== 0) {
     ChainState.setEndBlockToFirstEvent(chainState, newItems[0].blockNumber);
   }
-  if (!wasFetchingAtHead && !ChainState.isReady(chainState) && ChainState.isFetchingAtHead(chainState)) {
-    return Logging.childInfo(ChainState.logger(chainState), "All events have been fetched");
+  let match = ChainState.isFetchingAtHead(chainState) ? ChainState.takeFetchedTo(chainState) : undefined;
+  if (match === undefined) {
+    return;
   }
+  let waitingOn = IndexerState.isHoldingRealtime(state) || Object.keys(IndexerState.chainStates(state)).length > 1 ? " Waiting for other chains." : "";
+  Logging.childInfo(ChainState.logger(chainState), {
+    msg: `Fetched to ` + match[0] + `.` + waitingOn,
+    block: match[1]
+  });
 }
 
 async function onQueryResponse(state, param, stateId, scheduleFetch, scheduleProcessing, scheduleRollback) {
@@ -180,7 +185,7 @@ async function fetchChain(state, chainId, action, stateId, scheduleFetch, schedu
   }
   let isRealtime = IndexerState.isRealtime(state);
   let sourceManager = ChainState.sourceManager(chainState);
-  let reducedPolling = !isRealtime;
+  let reducedPolling = !isRealtime && ChainState.knownHeight(chainState) > 0;
   try {
     return await ChainState.dispatch(chainState, async query => {
       try {

package/src/ChainState.res

@@ -58,6 +58,9 @@ type t = {
   mutable blockRangeFetchCount: float,
   mutable blockRangeFetchedEvents: float,
   mutable blockRangeFetchedBlocks: float,
+  // What this chain last reported reaching. The head moves, so a chain reaches
+  // it again on every catch-up; only a new milestone is worth a line.
+  mutable reportedFetchedTo: option<string>,
   mutable reorgCount: int,
   mutable reorgDetectedBlock: option<int>,
   mutable rollbackTargetBlock: option<int>,
@@ -171,6 +174,7 @@ let make = (
     blockRangeFetchCount: 0.,
     blockRangeFetchedEvents: 0.,
     blockRangeFetchedBlocks: 0.,
+    reportedFetchedTo: None,
     reorgCount: 0,
     reorgDetectedBlock: None,
     rollbackTargetBlock: None,
@@ -642,6 +646,37 @@ let dispatch = (
 
 // --- Derived (pure). ---
 
+%%private(
+  // Where the fetch frontier has just landed. Below the reorg threshold a chain
+  // can only fetch the finalized range, so reaching the end of it is not
+  // reaching the head — the rest opens up once the indexer enters the threshold.
+  let fetchedTo = (cs: t) =>
+  switch cs.fetchState.endBlock {
+  | Some(endBlock) if endBlock <= cs.fetchState.knownHeight - cs.fetchState.blockLag => (
+      "the end block",
+      endBlock,
+    )
+  | _ =>
+    cs.isInReorgThreshold
+      ? ("the chain head", cs.fetchState.knownHeight)
+      : ("the safe block", cs.fetchState.knownHeight - cs.fetchState.blockLag)
+  }
+)
+
+// What this chain has just reached, the first time it reaches it. `None` once
+// it has been reported: a chain catches up to a moving head over and over, and
+// the milestone is the same one every time. A new one — the head past the
+// threshold, an end block — is a line of its own.
+let takeFetchedTo = (cs: t) => {
+  let (target, block) = cs->fetchedTo
+  if cs.reportedFetchedTo == Some(target) {
+    None
+  } else {
+    cs.reportedFetchedTo = Some(target)
+    Some((target, block))
+  }
+}
+
 let hasProcessedToEndblock = (cs: t) => {
   let {committedProgressBlockNumber, fetchState} = cs
   switch fetchState.endBlock {
@@ -1021,7 +1056,7 @@ let toMetrics = (cs: t): Metrics.chainMetrics => {
 // in-threshold block hashes are copied up front because the build reuses the
 // whole set; the block time comes as a lookup instead, since the key it needs -
 // the batch's own progress block - isn't known until the build computes it.
-let toChainBeforeBatch = (cs: t): Batch.chainBeforeBatch => {
+let toChainBeforeBatch = (cs: t, ~isRealtime): Batch.chainBeforeBatch => {
   let {blockNumbers, hashes} =
     cs.blockStore->BlockStore.getHashes(
       ~fromBlock=Pervasives.max(cs.fetchState.knownHeight - cs.maxReorgDepth, 0),
@@ -1037,8 +1072,13 @@ let toChainBeforeBatch = (cs: t): Batch.chainBeforeBatch => {
     totalEventsProcessed: cs.numEventsProcessed,
     sourceBlockNumber: cs.fetchState.knownHeight,
     scannedHashes: {blockNumbers, hashByBlockNumber},
+    // A slot that produced no block only counts as skipped where the query
+    // covered every slot in its range, which is what a chain at the head asks
+    // for.
     blockTimeAt: blockNumber =>
-      cs.blockStore->BlockStore.getTimestamp(blockNumber)->Null.toOption,
+      cs.blockStore
+      ->BlockStore.getTimestamp(blockNumber, ~allowSkippedSlot=isRealtime)
+      ->Null.toOption,
     shouldRollbackOnReorg: cs.shouldRollbackOnReorg,
     chainConfig: cs.chainConfig,
   }
@@ -1046,6 +1086,14 @@ let toChainBeforeBatch = (cs: t): Batch.chainBeforeBatch => {
 
 // Whether the chain's post-batch fetch frontier is ready to cross into the reorg
 // threshold, using the batch's progressed frontier when this chain advanced.
+// The same question asked of where the chain stands now rather than of where a
+// batch would leave it. Entering the threshold is what lifts the pre-threshold
+// lag, so a chain waiting to enter it has fetched as far as it can.
+let isReadyToEnterReorgThreshold = (cs: t) =>
+  cs.fetchState->FetchState.isReadyToEnterReorgThreshold(
+    ~tolerance=cs.reorgThresholdReadyTolerance,
+  )
+
 let isReadyToEnterReorgThresholdAfterBatch = (cs: t, ~batch: Batch.t) => {
   let fetchState = switch batch.progressedChainsById->ChainId.Dict.dangerouslyGetNonOption(
     cs.fetchState.chainId,
@@ -1194,8 +1242,12 @@ let markReady = (cs: t, ~readyAt) =>
 let rollbackCommittedProgress = (cs: t, blockNumber) =>
   if blockNumber !== cs.committedProgressBlockNumber {
     cs.committedProgressBlockNumber = blockNumber
+    // Exact block only: the rolled-back region is about to be refetched, and
+    // the next batch re-establishes the time either way.
     cs.committedProgressBlockTime =
-      cs.blockStore->BlockStore.getTimestamp(blockNumber)->Null.toOption
+      cs.blockStore
+      ->BlockStore.getTimestamp(blockNumber, ~allowSkippedSlot=false)
+      ->Null.toOption
   }
 
 type progressDiff = {blockNumber: int, eventsProcessed: float}

package/src/ChainState.res.mjs

@@ -21,6 +21,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as ContractMapping from "./ContractMapping.res.mjs";
 import * as Primitive_float from "@rescript/runtime/lib/es6/Primitive_float.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as TransactionStore from "./sources/TransactionStore.res.mjs";
 import * as SafeCheckpointTracking from "./SafeCheckpointTracking.res.mjs";
@@ -96,6 +97,7 @@ function make(chainConfig, fetchState, onEventRegistrationsOpt, addressStore, so
     blockRangeFetchCount: 0,
     blockRangeFetchedEvents: 0,
     blockRangeFetchedBlocks: 0,
+    reportedFetchedTo: undefined,
     reorgCount: 0,
     reorgDetectedBlock: undefined,
     rollbackTargetBlock: undefined,
@@ -398,6 +400,41 @@ function dispatch(cs, executeQuery, waitForNewBlock, onNewBlock, action, stateId
   return SourceManager.dispatch(cs.sourceManager, cs.fetchState, executeQuery, waitForNewBlock, onNewBlock, action, stateId);
 }
 
+function fetchedTo(cs) {
+  let endBlock = cs.fetchState.endBlock;
+  if (endBlock !== undefined && endBlock <= (cs.fetchState.knownHeight - cs.fetchState.blockLag | 0)) {
+    return [
+      "the end block",
+      endBlock
+    ];
+  }
+  if (cs.isInReorgThreshold) {
+    return [
+      "the chain head",
+      cs.fetchState.knownHeight
+    ];
+  } else {
+    return [
+      "the safe block",
+      cs.fetchState.knownHeight - cs.fetchState.blockLag | 0
+    ];
+  }
+}
+
+function takeFetchedTo(cs) {
+  let match = fetchedTo(cs);
+  let target = match[0];
+  if (Primitive_object.equal(cs.reportedFetchedTo, target)) {
+    return;
+  } else {
+    cs.reportedFetchedTo = target;
+    return [
+      target,
+      match[1]
+    ];
+  }
+}
+
 function hasProcessedToEndblock(cs) {
   let fetchState = cs.fetchState;
   let committedProgressBlockNumber = cs.committedProgressBlockNumber;
@@ -718,7 +755,7 @@ function toMetrics(cs) {
   };
 }
 
-function toChainBeforeBatch(cs) {
+function toChainBeforeBatch(cs, isRealtime) {
   let match = cs.blockStore.getHashes(Primitive_int.max(cs.fetchState.knownHeight - cs.maxReorgDepth | 0, 0), cs.fetchState.knownHeight + 1 | 0);
   let hashes = match.hashes;
   let blockNumbers = match.blockNumbers;
@@ -732,7 +769,7 @@ function toChainBeforeBatch(cs) {
       blockNumbers: blockNumbers,
       hashByBlockNumber: hashByBlockNumber
     },
-    blockTimeAt: blockNumber => Primitive_option.fromNull(cs.blockStore.getTimestamp(blockNumber)),
+    blockTimeAt: blockNumber => Primitive_option.fromNull(cs.blockStore.getTimestamp(blockNumber, isRealtime)),
     shouldRollbackOnReorg: cs.shouldRollbackOnReorg,
     progressBlockNumber: cs.committedProgressBlockNumber,
     sourceBlockNumber: cs.fetchState.knownHeight,
@@ -741,6 +778,10 @@ function toChainBeforeBatch(cs) {
   };
 }
 
+function isReadyToEnterReorgThreshold(cs) {
+  return FetchState.isReadyToEnterReorgThreshold(cs.reorgThresholdReadyTolerance, cs.fetchState);
+}
+
 function isReadyToEnterReorgThresholdAfterBatch(cs, batch) {
   let chainAfterBatch = batch.progressedChainsById[cs.fetchState.chainId];
   let fetchState = chainAfterBatch !== undefined ? chainAfterBatch.fetchState : cs.fetchState;
@@ -835,7 +876,7 @@ function markReady(cs, readyAt) {
 function rollbackCommittedProgress(cs, blockNumber) {
   if (blockNumber !== cs.committedProgressBlockNumber) {
     cs.committedProgressBlockNumber = blockNumber;
-    cs.committedProgressBlockTime = Primitive_option.fromNull(cs.blockStore.getTimestamp(blockNumber));
+    cs.committedProgressBlockTime = Primitive_option.fromNull(cs.blockStore.getTimestamp(blockNumber, false));
     return;
   }
 }
@@ -921,7 +962,9 @@ export {
   toMetrics,
   toChainMetadata,
   toChainBeforeBatch,
+  isReadyToEnterReorgThreshold,
   isReadyToEnterReorgThresholdAfterBatch,
+  takeFetchedTo,
   hasProcessedToEndblock,
   isDurablyCaughtUp,
   getHighestBlockBelowThreshold,

package/src/ChainState.resi

@@ -119,10 +119,12 @@ let dispatch: (
 // Views.
 let toMetrics: t => Metrics.chainMetrics
 let toChainMetadata: t => InternalTable.Chains.metaFields
-let toChainBeforeBatch: t => Batch.chainBeforeBatch
+let toChainBeforeBatch: (t, ~isRealtime: bool) => Batch.chainBeforeBatch
+let isReadyToEnterReorgThreshold: t => bool
 let isReadyToEnterReorgThresholdAfterBatch: (t, ~batch: Batch.t) => bool
 
 // Derived (pure).
+let takeFetchedTo: t => option<(string, int)>
 let hasProcessedToEndblock: t => bool
 let isDurablyCaughtUp: t => bool
 let getHighestBlockBelowThreshold: t => int

package/src/Config.res

@@ -625,6 +625,22 @@ let getChain = (config, ~chainId) =>
         "No chain with id " ++ chainId->ChainId.toString ++ " found in config.yaml",
       )
 
+// Whether every entity belongs to exactly one chain. Only then is a unit of
+// this indexer's work attributable to a chain at all, which is what lets a run
+// be split across processes.
+let isPerChain = (config: t) => !(config.userEntities->Array.some(entity => entity.crossChain))
+
+// What every line this process logs is attributed to. A process driving one
+// of the schema's chains while siblings drive the rest names it, on the lines
+// that had no chain in hand. One driving several has no single owner to name,
+// and its chain-scoped lines already carry theirs.
+let logContext = (config: t): option<dict<JSON.t>> =>
+  switch (config.isolated, config.chainMap->ChainMap.keys) {
+  | (true, [chainId]) =>
+    Some(Dict.fromArray([("chainId", chainId->S.reverseConvertToJsonOrThrow(ChainId.schema))]))
+  | _ => None
+  }
+
 // Narrows a config to the chains one `envio start --chain` process drives.
 // `contractMapping` is deliberately left whole: its ids are what the migration
 // that created the schema stored, and one rebuilt from a subset would hand the
@@ -1221,6 +1237,21 @@ let prime = (json: JSON.t): unit => {
   cached := None
 }
 
+// Narrows a public config to the chains one process drives. The supervisor
+// plans the split; each worker applies the plan to the config it parsed itself.
+let withIsolatedChains = (json: JSON.t, ~chainIds) =>
+  switch json->JSON.Decode.object {
+  | Some(fields) => {
+      let narrowed = fields->Dict.copy
+      narrowed->Dict.set(
+        "isolatedChains",
+        chainIds->S.reverseConvertToJsonOrThrow(S.array(ChainId.schema)),
+      )
+      JSON.Object(narrowed)
+    }
+  | None => JsError.throwWithMessage("Invalid indexer config: not an object")
+  }
+
 let getPublicConfigJson = () =>
   switch primedJson.contents {
   | Some(json) => json
@@ -1266,6 +1297,10 @@ let stripSensitiveData = (json: JSON.t): JSON.t => {
   cloned
 }
 
+// What the storage layer records as the config this schema was built from,
+// and checks a resuming run against.
+let envioInfo = () => getPublicConfigJson()->stripSensitiveData
+
 // Postgres jsonb doesn't preserve key order, so canonicalize with sorted
 // keys before string-comparing.
 let rec canonicalJson = (json: JSON.t): JSON.t =>

package/src/Config.res.mjs

@@ -13,6 +13,7 @@ import * as Logging from "./Logging.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import * as BigDecimal from "./bindings/BigDecimal.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
@@ -470,6 +471,26 @@ function getChain(config, chainId) {
   }
 }
 
+function isPerChain(config) {
+  return !config.userEntities.some(entity => entity.crossChain);
+}
+
+function logContext(config) {
+  let match = config.isolated;
+  let match$1 = ChainMap.keys(config.chainMap);
+  if (!match) {
+    return;
+  }
+  if (match$1.length !== 1) {
+    return;
+  }
+  let chainId = match$1[0];
+  return Object.fromEntries([[
+      "chainId",
+      S$RescriptSchema.reverseConvertToJsonOrThrow(chainId, ChainId.schema)
+    ]]);
+}
+
 function isolate(config, chainIds) {
   let shared = config.userEntities.filter(entityConfig => entityConfig.crossChain);
   if (shared.length !== 0) {
@@ -907,6 +928,16 @@ function prime(json) {
   cached.contents = undefined;
 }
 
+function withIsolatedChains(json, chainIds) {
+  let fields = Stdlib_JSON.Decode.object(json);
+  if (fields === undefined) {
+    return Stdlib_JsError.throwWithMessage("Invalid indexer config: not an object");
+  }
+  let narrowed = Object.assign({}, fields);
+  narrowed["isolatedChains"] = S$RescriptSchema.reverseConvertToJsonOrThrow(chainIds, S$RescriptSchema.array(ChainId.schema));
+  return narrowed;
+}
+
 function getPublicConfigJson() {
   let json = primedJson.contents;
   if (json !== undefined) {
@@ -950,6 +981,10 @@ function stripSensitiveData(json) {
   return cloned;
 }
 
+function envioInfo() {
+  return stripSensitiveData(getPublicConfigJson());
+}
+
 function canonicalJson(json) {
   if (Array.isArray(json)) {
     return json.map(canonicalJson);
@@ -1172,14 +1207,18 @@ export {
   publicConfigSchema,
   contractMappingOf,
   getChain,
+  isPerChain,
+  logContext,
   isolate,
   fromPublic,
   normalizeUserAddress,
   normalizeSimulateAddress,
   getEventConfig,
   prime,
+  withIsolatedChains,
   getPublicConfigJson,
   stripSensitiveData,
+  envioInfo,
   canonicalJson,
   diffPaths,
   throwIfIncompatible,

package/src/Core.res

@@ -166,6 +166,10 @@ let loadDevAddon: ({..}, string) => addon = %raw(`function(req, envioDir) {
     fs.copyFileSync(srcPath, nodePath);
   }
 
+  // Forked workers inherit this, so only the first process in a run pays for
+  // the cargo build (and they don't contend over the cargo lock).
+  process.env.ENVIO_DEV_ADDON = nodePath;
+
   return req(nodePath);
 }`)