envio 3.13.0-alpha.0 → 3.13.0

package/src/ChainState.res.mjs

@@ -21,7 +21,6 @@ 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";
@@ -56,7 +55,7 @@ function validateOnEventRegistrations(chainId, registrations) {
   });
 }
 
-function make(chainConfig, fetchState, onEventRegistrationsOpt, addressStore, sourceManager, committedProgressBlockNumber, committedProgressBlockTimeOpt, safeCheckpointTrackingOpt, shouldRollbackOnReorg, maxReorgDepth, isInReorgThresholdOpt, numEventsProcessedOpt, timestampCaughtUpToHeadOrEndblockOpt, isProgressAtHeadOpt, transactionStoreOpt, chainDensityOpt, blockStoreOpt, reorgThresholdReadyToleranceOpt, perChainEntitiesOpt, logger) {
+function make(chainConfig, fetchState, onEventRegistrationsOpt, addressStore, sourceManager, committedProgressBlockNumber, committedProgressBlockTimeOpt, safeCheckpointTrackingOpt, shouldRollbackOnReorg, maxReorgDepth, isInReorgThresholdOpt, numEventsProcessedOpt, timestampCaughtUpToHeadOrEndblockOpt, isProgressAtHeadOpt, transactionStoreOpt, chainDensityOpt, blockStoreOpt, shouldChecksumOpt, reorgThresholdReadyToleranceOpt, perChainEntitiesOpt, logger) {
   let onEventRegistrations = onEventRegistrationsOpt !== undefined ? onEventRegistrationsOpt : [];
   let committedProgressBlockTime = committedProgressBlockTimeOpt !== undefined ? Primitive_option.valFromOption(committedProgressBlockTimeOpt) : undefined;
   let safeCheckpointTracking = safeCheckpointTrackingOpt !== undefined ? Primitive_option.valFromOption(safeCheckpointTrackingOpt) : undefined;
@@ -64,9 +63,10 @@ function make(chainConfig, fetchState, onEventRegistrationsOpt, addressStore, so
   let numEventsProcessed = numEventsProcessedOpt !== undefined ? numEventsProcessedOpt : 0;
   let timestampCaughtUpToHeadOrEndblock = timestampCaughtUpToHeadOrEndblockOpt !== undefined ? Primitive_option.valFromOption(timestampCaughtUpToHeadOrEndblockOpt) : undefined;
   let isProgressAtHead = isProgressAtHeadOpt !== undefined ? isProgressAtHeadOpt : false;
-  let transactionStore = transactionStoreOpt !== undefined ? Primitive_option.valFromOption(transactionStoreOpt) : TransactionStore.make("evm", false);
+  let transactionStore = transactionStoreOpt !== undefined ? Primitive_option.valFromOption(transactionStoreOpt) : TransactionStore.make("evm");
   let chainDensity = chainDensityOpt !== undefined ? Primitive_option.valFromOption(chainDensityOpt) : undefined;
-  let blockStore = blockStoreOpt !== undefined ? Primitive_option.valFromOption(blockStoreOpt) : BlockStore.make("evm", false);
+  let blockStore = blockStoreOpt !== undefined ? Primitive_option.valFromOption(blockStoreOpt) : BlockStore.make("evm");
+  let shouldChecksum = shouldChecksumOpt !== undefined ? shouldChecksumOpt : false;
   let reorgThresholdReadyTolerance = reorgThresholdReadyToleranceOpt !== undefined ? reorgThresholdReadyToleranceOpt : 100;
   let perChainEntities = perChainEntitiesOpt !== undefined ? perChainEntitiesOpt : [];
   validateOnEventRegistrations(chainConfig.id, onEventRegistrations);
@@ -89,6 +89,7 @@ function make(chainConfig, fetchState, onEventRegistrationsOpt, addressStore, so
     shouldRollbackOnReorg: shouldRollbackOnReorg,
     maxReorgDepth: maxReorgDepth,
     isInReorgThreshold: isInReorgThreshold,
+    shouldChecksum: shouldChecksum,
     transactionStore: transactionStore,
     blockStore: blockStore,
     reorgThresholdReadyTolerance: reorgThresholdReadyTolerance,
@@ -97,7 +98,7 @@ function make(chainConfig, fetchState, onEventRegistrationsOpt, addressStore, so
     blockRangeFetchCount: 0,
     blockRangeFetchedEvents: 0,
     blockRangeFetchedBlocks: 0,
-    reportedFetchedTo: undefined,
+    reportedFinished: false,
     reorgCount: 0,
     reorgDetectedBlock: undefined,
     rollbackTargetBlock: undefined,
@@ -138,7 +139,7 @@ function makeFromDbState(chainConfig, resumedChainState, reorgCheckpoints, isInR
     }
   });
   let lowercaseAddresses = config.lowercaseAddresses;
-  let addressStore = AddressStore.make(config.ecosystem.name, !lowercaseAddresses, AddressStore.contractsOf(onEventRegistrations, contractMapping));
+  let addressStore = AddressStore.make(config.ecosystem.name, AddressStore.contractsOf(onEventRegistrations, contractMapping));
   let match$1 = config.ecosystem.name;
   let tmp;
   switch (match$1) {
@@ -156,18 +157,19 @@ function makeFromDbState(chainConfig, resumedChainState, reorgCheckpoints, isInR
       return reorgCheckpoint;
     }
   });
-  let sources = ChainSources.make(chainConfig, onEventRegistrations, addressStore, lowercaseAddresses);
-  let blockStore = BlockStore.make(config.ecosystem.name, !lowercaseAddresses);
+  let blockStore = BlockStore.make(config.ecosystem.name);
+  let transactionStore = TransactionStore.make(config.ecosystem.name);
+  let sources = ChainSources.make(chainConfig, onEventRegistrations, addressStore, lowercaseAddresses, blockStore, transactionStore);
   if (Utils.$$Array.notEmpty(chainReorgCheckpoints)) {
     let seedPage = BlockStore.fromJs(chainReorgCheckpoints.map(cp => ({
       blockNumber: cp.block_number,
       blockHash: cp.block_hash
-    })), config.ecosystem.name, !lowercaseAddresses);
+    })), config.ecosystem.name);
     blockStore.merge(seedPage, 0, false);
   }
   let firstEventBlock$1 = fetchState.firstEventBlock;
   let chainDensity = firstEventBlock$1 !== undefined && progressBlockNumber > firstEventBlock$1 && numEventsProcessed > 0 ? numEventsProcessed / (progressBlockNumber - firstEventBlock$1 | 0) : undefined;
-  return make(chainConfig, fetchState, onEventRegistrations, addressStore, SourceManager.make(sources, isRealtime, undefined, undefined, undefined, reducedPollingInterval, undefined, undefined), progressBlockNumber, Primitive_option.some(committedProgressBlockTime), Primitive_option.some(SafeCheckpointTracking.make(maxReorgDepth, config.shouldRollbackOnReorg, chainReorgCheckpoints)), config.shouldRollbackOnReorg, maxReorgDepth, isInReorgThreshold, numEventsProcessed, Primitive_option.some(timestampCaughtUpToHeadOrEndblock), undefined, Primitive_option.some(TransactionStore.make(config.ecosystem.name, !lowercaseAddresses)), Primitive_option.some(chainDensity), Primitive_option.some(blockStore), config.reorgThresholdReadyTolerance, EntityTables.perChain(config.userEntities), logger);
+  return make(chainConfig, fetchState, onEventRegistrations, addressStore, SourceManager.make(sources, isRealtime, undefined, undefined, undefined, reducedPollingInterval, undefined, undefined), progressBlockNumber, Primitive_option.some(committedProgressBlockTime), Primitive_option.some(SafeCheckpointTracking.make(maxReorgDepth, config.shouldRollbackOnReorg, chainReorgCheckpoints)), config.shouldRollbackOnReorg, maxReorgDepth, isInReorgThreshold, numEventsProcessed, Primitive_option.some(timestampCaughtUpToHeadOrEndblock), undefined, Primitive_option.some(transactionStore), Primitive_option.some(chainDensity), Primitive_option.some(blockStore), !lowercaseAddresses, config.reorgThresholdReadyTolerance, EntityTables.perChain(config.userEntities), logger);
 }
 
 function logger(cs) {
@@ -178,6 +180,14 @@ function blockStore(cs) {
   return cs.blockStore;
 }
 
+function transactionStore(cs) {
+  return cs.transactionStore;
+}
+
+function shouldChecksum(cs) {
+  return cs.shouldChecksum;
+}
+
 function entities(cs) {
   return cs.entities;
 }
@@ -210,10 +220,6 @@ function safeCheckpointTracking(cs) {
   return cs.safeCheckpointTracking;
 }
 
-function isProgressAtHead(cs) {
-  return cs.isProgressAtHead;
-}
-
 function committedProgressBlockNumber(cs) {
   return cs.committedProgressBlockNumber;
 }
@@ -256,7 +262,7 @@ function knownHeight(cs) {
 }
 
 function contractAddresses(cs, contractName) {
-  return cs.addressStore.contractAddresses(contractName);
+  return cs.addressStore.contractAddresses(contractName, cs.shouldChecksum);
 }
 
 function drainAddressesForWrite(cs, toBlockInclusive, checkpointBlockNumbers) {
@@ -400,41 +406,6 @@ 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;
@@ -446,15 +417,46 @@ function hasProcessedToEndblock(cs) {
   }
 }
 
-function isDurablyCaughtUp(cs) {
-  let fetchState = cs.fetchState;
-  let committedProgressBlockNumber = cs.committedProgressBlockNumber;
-  let atEndBlock = Stdlib_Option.mapOr(fetchState.endBlock, false, endBlock => committedProgressBlockNumber >= endBlock);
-  let atHead = fetchState.knownHeight > 0 && committedProgressBlockNumber >= Primitive_int.max(0, fetchState.knownHeight - cs.chainConfig.blockLag | 0);
-  if (atEndBlock) {
+function hasCaughtUp(cs) {
+  if (cs.isProgressAtHead) {
     return true;
   } else {
-    return atHead;
+    let fetchState = cs.fetchState;
+    let committedProgressBlockNumber = cs.committedProgressBlockNumber;
+    let atEndBlock = Stdlib_Option.mapOr(fetchState.endBlock, false, endBlock => committedProgressBlockNumber >= endBlock);
+    let atHead = fetchState.knownHeight > 0 && committedProgressBlockNumber >= Primitive_int.max(0, fetchState.knownHeight - cs.chainConfig.blockLag | 0);
+    if (atEndBlock) {
+      return true;
+    } else {
+      return atHead;
+    }
+  }
+}
+
+function takeFinished(cs) {
+  if (cs.reportedFinished) {
+    return;
+  }
+  let match = cs.fetchState.endBlock;
+  let match$1 = hasProcessedToEndblock(cs);
+  let match$2 = hasCaughtUp(cs);
+  if (match !== undefined && match$1) {
+    cs.reportedFinished = true;
+    return {
+      TAG: "EndBlock",
+      _0: match
+    };
+  }
+  if (match$2) {
+    cs.reportedFinished = true;
+    if (cs.timestampCaughtUpToHeadOrEndblock !== undefined) {
+      return;
+    } else {
+      return {
+        TAG: "Backfill",
+        _0: cs.committedProgressBlockNumber
+      };
+    }
   }
 }
 
@@ -548,12 +550,12 @@ function groupBatchItems(items) {
   ];
 }
 
-async function applyTransactionGroups(store, g) {
+async function applyTransactionGroups(store, g, shouldChecksum) {
   if (!Utils.$$Array.notEmpty(g.payloadGroups)) {
     return;
   }
   if (g.anyTransactionFieldSelected) {
-    let txs = await store.materialize(g.txBlockNumbers, g.transactionIndices, g.transactionMasks);
+    let txs = await store.materialize(g.txBlockNumbers, g.transactionIndices, g.transactionMasks, shouldChecksum);
     g.payloadGroups.forEach((payloads, i) => {
       let tx = txs[i];
       payloads.forEach(payload => {
@@ -574,11 +576,11 @@ async function applyTransactionGroups(store, g) {
   });
 }
 
-async function applyBlockGroups(store, g) {
+async function applyBlockGroups(store, g, shouldChecksum) {
   if (!Utils.$$Array.notEmpty(g.blockItemGroups)) {
     return;
   }
-  let blocks = await store.materialize(g.blockBlockNumbers, g.blockMasks);
+  let blocks = await store.materialize(g.blockBlockNumbers, g.blockMasks, shouldChecksum);
   g.blockItemGroups.forEach((group, i) => {
     let block = blocks[i];
     group.forEach(ei => {
@@ -590,23 +592,20 @@ async function applyBlockGroups(store, g) {
 async function materializeBatchItems(cs, items) {
   let match = groupBatchItems(items);
   await Promise.all([
-    applyTransactionGroups(cs.transactionStore, match[0]),
-    applyBlockGroups(cs.blockStore, match[1])
+    applyTransactionGroups(cs.transactionStore, match[0], cs.shouldChecksum),
+    applyBlockGroups(cs.blockStore, match[1], cs.shouldChecksum)
   ]);
 }
 
-async function materializePageItems(items, transactionStore, blockStore) {
+async function materializePageItems(items, transactionStore, blockStore, shouldChecksum) {
   let match = groupBatchItems(items);
   await Promise.all([
-    transactionStore !== undefined ? applyTransactionGroups(Primitive_option.valFromOption(transactionStore), match[0]) : Promise.resolve(),
-    applyBlockGroups(blockStore, match[1])
+    applyTransactionGroups(transactionStore, match[0], shouldChecksum),
+    applyBlockGroups(blockStore, match[1], shouldChecksum)
   ]);
 }
 
-function handleQueryResult(cs, query, newItems, newRegistrations, latestFetchedBlock, knownHeight, txPage) {
-  if (txPage !== undefined) {
-    cs.transactionStore.merge(Primitive_option.valFromOption(txPage));
-  }
+function handleQueryResult(cs, query, newItems, newRegistrations, latestFetchedBlock, knownHeight) {
   let fs = newRegistrations.length !== 0 ? FetchState.registerDynamicContracts(cs.fetchState, cs.addressStore, Primitive_int.max(knownHeight, latestFetchedBlock), newRegistrations) : cs.fetchState;
   cs.fetchState = FetchState.updateKnownHeight(FetchState.handleQueryResult(fs, query, latestFetchedBlock, newItems), knownHeight);
   cs.pendingBudget = Primitive_float.max(0, cs.pendingBudget - query.itemsEst);
@@ -703,6 +702,19 @@ function shouldSaveHistory(cs) {
   }
 }
 
+function reorgThresholdLiftsCeiling(cs) {
+  let ceiling = blockLag => {
+    let head = Primitive_int.max(0, cs.fetchState.knownHeight - blockLag | 0);
+    let endBlock = cs.fetchState.endBlock;
+    if (endBlock !== undefined) {
+      return Primitive_int.min(endBlock, head);
+    } else {
+      return head;
+    }
+  };
+  return ceiling(cs.chainConfig.blockLag) > ceiling(cs.fetchState.blockLag);
+}
+
 function toChainMetadata(cs) {
   return {
     first_event_block: Stdlib_Null.fromOption(cs.fetchState.firstEventBlock),
@@ -919,6 +931,8 @@ function rollback(cs, rolledBackTo) {
   return rolledBackAddresses$1;
 }
 
+let reorgThresholdEntryMessage = "Indexing the latest blocks now. These can be reorged, so the indexer starts storing a history of every change to roll back with.";
+
 export {
   configStorageRows,
   seedConfigAddresses,
@@ -926,6 +940,8 @@ export {
   makeFromDbState,
   logger,
   blockStore,
+  transactionStore,
+  shouldChecksum,
   entities,
   resetEntities,
   sourceManager,
@@ -934,7 +950,6 @@ export {
   getReorgThresholdBlockNumbersBelow,
   getLatestValidScannedBlock,
   safeCheckpointTracking,
-  isProgressAtHead,
   committedProgressBlockNumber,
   committedProgressBlockTime,
   numEventsProcessed,
@@ -964,9 +979,11 @@ export {
   toChainBeforeBatch,
   isReadyToEnterReorgThreshold,
   isReadyToEnterReorgThresholdAfterBatch,
-  takeFetchedTo,
+  takeFinished,
+  reorgThresholdLiftsCeiling,
+  reorgThresholdEntryMessage,
   hasProcessedToEndblock,
-  isDurablyCaughtUp,
+  hasCaughtUp,
   getHighestBlockBelowThreshold,
   isActivelyIndexing,
   isReady,

package/src/ChainState.resi

@@ -34,6 +34,7 @@ let make: (
   ~transactionStore: TransactionStore.t=?,
   ~chainDensity: option<float>=?,
   ~blockStore: BlockStore.t=?,
+  ~shouldChecksum: bool=?,
   ~reorgThresholdReadyTolerance: int=?,
   ~perChainEntities: array<Internal.entityConfig>=?,
   ~logger: Pino.t,
@@ -54,6 +55,8 @@ let makeFromDbState: (
 // Accessors.
 let logger: t => Pino.t
 let blockStore: t => BlockStore.t
+let transactionStore: t => TransactionStore.t
+let shouldChecksum: t => bool
 let entities: t => EntityTables.t
 let resetEntities: (t, ~perChainEntities: array<Internal.entityConfig>) => unit
 let sourceManager: t => SourceManager.t
@@ -67,7 +70,6 @@ let getLatestValidScannedBlock: (
   ~blockNumbers: array<int>,
 ) => option<int>
 let safeCheckpointTracking: t => option<SafeCheckpointTracking.t>
-let isProgressAtHead: t => bool
 let committedProgressBlockNumber: t => int
 let committedProgressBlockTime: t => option<int>
 let numEventsProcessed: t => float
@@ -124,9 +126,12 @@ let isReadyToEnterReorgThreshold: t => bool
 let isReadyToEnterReorgThresholdAfterBatch: (t, ~batch: Batch.t) => bool
 
 // Derived (pure).
-let takeFetchedTo: t => option<(string, int)>
+type finished = EndBlock(int) | Backfill(int)
+let takeFinished: t => option<finished>
+let reorgThresholdLiftsCeiling: t => bool
+let reorgThresholdEntryMessage: string
 let hasProcessedToEndblock: t => bool
-let isDurablyCaughtUp: t => bool
+let hasCaughtUp: t => bool
 let getHighestBlockBelowThreshold: t => int
 let isActivelyIndexing: t => bool
 let isReady: t => bool
@@ -141,14 +146,18 @@ let handleQueryResult: (
   ~newRegistrations: array<AddressStore.registration>,
   ~latestFetchedBlock: int,
   ~knownHeight: int,
-  ~transactionStore: option<TransactionStore.t>,
 ) => unit
 let materializeBatchItems: (t, ~items: array<Internal.item>) => promise<unit>
 let materializePageItems: (
   ~items: array<Internal.item>,
-  ~transactionStore: option<TransactionStore.t>,
+  ~transactionStore: TransactionStore.t,
   ~blockStore: BlockStore.t,
+  ~shouldChecksum: bool,
 ) => promise<unit>
+// Merges the page's blocks into the chain's store as it checks them: the check
+// is the merge's own conflict report, so a page that passes is already applied.
+// Its transactions are a separate page, merged by the caller once this returns
+// no reorg.
 let registerReorgGuard: (
   t,
   ~blockStore: BlockStore.t,

package/src/Config.res

@@ -625,20 +625,14 @@ 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
+// Whether every entity belongs to exactly one chain. Read off the checkpoint
+// sequence rather than the entities again: a chain gets a counter of its own
+// only when no other chain can reach its rows, which is the same fact and the
+// one that makes splitting a run across processes safe.
+let isPerChain = (config: t) =>
+  switch config.checkpointSequence {
+  | PerChain => true
+  | SharedAcrossChains => false
   }
 
 // Narrows a config to the chains one `envio start --chain` process drives.
@@ -1237,9 +1231,11 @@ 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) =>
+// What the command decided rather than the project's files: which chains this
+// process drives, and whether the run is a dev run. A worker parses the same
+// files its supervisor did, so these are the only two it cannot arrive at on
+// its own.
+let withCommandFields = (json: JSON.t, ~chainIds, ~isDev) =>
   switch json->JSON.Decode.object {
   | Some(fields) => {
       let narrowed = fields->Dict.copy
@@ -1247,6 +1243,7 @@ let withIsolatedChains = (json: JSON.t, ~chainIds) =>
         "isolatedChains",
         chainIds->S.reverseConvertToJsonOrThrow(S.array(ChainId.schema)),
       )
+      narrowed->Dict.set("isDev", JSON.Encode.bool(isDev))
       JSON.Object(narrowed)
     }
   | None => JsError.throwWithMessage("Invalid indexer config: not an object")

package/src/Config.res.mjs

@@ -472,23 +472,8 @@ 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)
-    ]]);
+  let match = config.checkpointSequence;
+  return match !== "SharedAcrossChains";
 }
 
 function isolate(config, chainIds) {
@@ -928,13 +913,14 @@ function prime(json) {
   cached.contents = undefined;
 }
 
-function withIsolatedChains(json, chainIds) {
+function withCommandFields(json, chainIds, isDev) {
   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));
+  narrowed["isDev"] = isDev;
   return narrowed;
 }
 
@@ -1208,14 +1194,13 @@ export {
   contractMappingOf,
   getChain,
   isPerChain,
-  logContext,
   isolate,
   fromPublic,
   normalizeUserAddress,
   normalizeSimulateAddress,
   getEventConfig,
   prime,
-  withIsolatedChains,
+  withCommandFields,
   getPublicConfigJson,
   stripSensitiveData,
   envioInfo,

package/src/CrossChainState.res

@@ -70,10 +70,10 @@ let isHoldingRealtime = (crossChainState: t) => crossChainState.holdRealtime
 let hasArrivedAtHead = (crossChainState: t) =>
   crossChainState.isCaughtUp ||
   crossChainState.isRealtime || {
-      let chainStates = crossChainState.chainStates->Dict.valuesToArray
-      chainStates->Utils.Array.notEmpty &&
-        chainStates->Array.every(ChainState.isReadyToEnterReorgThreshold)
-    }
+    let chainStates = crossChainState.chainStates->Dict.valuesToArray
+    chainStates->Utils.Array.notEmpty &&
+      chainStates->Array.every(ChainState.isReadyToEnterReorgThreshold)
+  }
 
 // Resolve a chain's state by id. The id always comes from `chainIds`, which is
 // derived from `chainStates`, so the entry is guaranteed present.
@@ -167,17 +167,23 @@ let createBatch = (
 // holds the others back whatever process it runs in.
 let isReadyToEnterReorgThreshold = (crossChainState: t, ~batch) =>
   !crossChainState.holdRealtime &&
-    crossChainState.chainStates
-    ->Dict.valuesToArray
-    ->Array.every(cs => cs->ChainState.isReadyToEnterReorgThresholdAfterBatch(~batch))
+  crossChainState.chainStates
+  ->Dict.valuesToArray
+  ->Array.every(cs => cs->ChainState.isReadyToEnterReorgThresholdAfterBatch(~batch))
 
+// Said by each chain rather than once for the indexer: what crossing changes
+// is a chain's own, and the chains of a split run cross in processes that can
+// only speak for the ones they drive.
 let enterReorgThreshold = (crossChainState: t) => {
-  Logging.info("Reorg threshold reached")
-
   for i in 0 to crossChainState.chainIds->Array.length - 1 {
-    crossChainState
-    ->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
-    ->ChainState.enterReorgThreshold
+    let cs = crossChainState->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
+    // A chain whose end block sits below these blocks says nothing: crossing
+    // gives it nothing more to index, and it will never reach one of them.
+    let liftsCeiling = cs->ChainState.reorgThresholdLiftsCeiling
+    cs->ChainState.enterReorgThreshold
+    if liftsCeiling {
+      cs->ChainState.logger->Logging.childInfo(ChainState.reorgThresholdEntryMessage)
+    }
   }
 }
 
@@ -193,16 +199,16 @@ let applyBatchProgress = (crossChainState: t, ~batch: Batch.t, ~blockTimestampNa
   for i in 0 to chainIds->Array.length - 1 {
     let cs = crossChainState->getChainState(chainIds->Array.getUnsafe(i))
     cs->ChainState.applyBatchProgress(~batch, ~blockTimestampName)
-    if !(cs->ChainState.hasProcessedToEndblock || cs->ChainState.isProgressAtHead) {
+    if !(cs->ChainState.hasCaughtUp) {
       everyChainCaughtUp := false
     }
   }
 
   crossChainState.isCaughtUp =
     crossChainState.isCaughtUp ||
-      (!crossChainState.holdRealtime &&
-      crossChainState->nextItemIsNone &&
-      everyChainCaughtUp.contents)
+    (!crossChainState.holdRealtime &&
+    crossChainState->nextItemIsNone &&
+    everyChainCaughtUp.contents)
 }
 
 // Every chain has buffered up to its head (or endblock) with nothing
@@ -248,7 +254,7 @@ let markCaughtUpOnResume = (crossChainState: t) => {
   let everyChainCaughtUp = ref(crossChainState.chainIds->Array.length > 0)
   for i in 0 to crossChainState.chainIds->Array.length - 1 {
     let cs = crossChainState->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
-    if !(cs->ChainState.isDurablyCaughtUp) {
+    if !(cs->ChainState.hasCaughtUp) {
       everyChainCaughtUp := false
     }
   }
@@ -263,13 +269,55 @@ let markCaughtUpOnResume = (crossChainState: t) => {
 // and switches the indexer to realtime.
 let markReady = (crossChainState: t, ~readyAt) => {
   for i in 0 to crossChainState.chainIds->Array.length - 1 {
-    crossChainState
-    ->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
-    ->ChainState.markReady(~readyAt)
+    let cs = crossChainState->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
+    let wasReady = cs->ChainState.isReady
+    cs->ChainState.markReady(~readyAt)
+
+    // One line per chain, because `ready_at` is one column per chain: what the
+    // log says and what a reader finds in the row are the same fact.
+    if !wasReady {
+      cs
+      ->ChainState.logger
+      ->Logging.childInfo("Ready. Fully indexed for queries.")
+    }
   }
   crossChainState.isRealtime = true
 }
 
+// What a caught-up chain is waiting on before its process can finalize: the run
+// holding the process back, or another chain it drives still behind. Read when
+// the chain speaks, so "waiting" is said only while it is true.
+let isWaitingOnOthers = (crossChainState: t, cs: ChainState.t) =>
+  crossChainState.holdRealtime ||
+  crossChainState.chainStates
+  ->Dict.valuesToArray
+  ->Array.some(other => other !== cs && !(other->ChainState.hasCaughtUp))
+
+// Each chain that has just finished indexing, said once, by the chain it is
+// about — so a chain that finishes early says so then, rather than when the
+// last chain in its process catches up.
+let reportFinished = (crossChainState: t) =>
+  crossChainState.chainStates
+  ->Dict.valuesToArray
+  ->Array.forEach(cs =>
+    switch cs->ChainState.takeFinished {
+    | Some(EndBlock(block)) =>
+      cs
+      ->ChainState.logger
+      ->Logging.childInfo({"msg": "Indexed to the end block. This chain is done.", "block": block})
+    | Some(Backfill(block)) =>
+      cs
+      ->ChainState.logger
+      ->Logging.childInfo({
+        "msg": crossChainState->isWaitingOnOthers(cs)
+          ? "Finished backfill. Waiting for the other chains."
+          : "Finished backfill.",
+        "block": block,
+      })
+    | None => ()
+    }
+  )
+
 // --- Fetch control. ---
 
 // Chains ordered furthest-behind first by fetch-frontier progress, so the