envio 3.10.0 → 3.11.0-svm-alpha.1

package/src/Batch.res.mjs

@@ -1,34 +1,39 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as ChainId from "./ChainId.res.mjs";
+import * as Frontier from "./db/Frontier.res.mjs";
 import * as FetchState from "./FetchState.res.mjs";
+import * as CheckpointSequence from "./db/CheckpointSequence.res.mjs";
 
-function getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, fetchStateAfterBatch, batchSize) {
+function getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, fetchStateAfterBatch, counts) {
   if (chainBeforeBatch.progressBlockNumber < progressBlockNumberAfterBatch) {
     return {
-      batchSize: batchSize,
+      batchSize: counts.size,
       progressBlockNumber: progressBlockNumberAfterBatch,
       sourceBlockNumber: chainBeforeBatch.sourceBlockNumber,
-      totalEventsProcessed: chainBeforeBatch.totalEventsProcessed + batchSize,
+      totalEventsProcessed: chainBeforeBatch.totalEventsProcessed + counts.eventsProcessed,
       fetchState: fetchStateAfterBatch,
       isProgressAtHeadWhenBatchCreated: progressBlockNumberAfterBatch >= chainBeforeBatch.sourceBlockNumber - chainBeforeBatch.chainConfig.blockLag
     };
   }
 }
 
-function getProgressedChainsById(chainsBeforeBatch, batchSizePerChain, progressBlockNumberPerChain) {
+function getProgressedChainsById(chainsBeforeBatch, countsPerChain, progressBlockNumberPerChain) {
   let progressedChainsById = {};
   Object.values(chainsBeforeBatch).forEach(chainBeforeBatch => {
     let fetchState = chainBeforeBatch.fetchState;
     let progressBlockNumber = progressBlockNumberPerChain[ChainId.toString(fetchState.chainId)];
     let progressBlockNumberAfterBatch = progressBlockNumber !== undefined ? progressBlockNumber : chainBeforeBatch.progressBlockNumber;
-    let batchSize = batchSizePerChain[ChainId.toString(fetchState.chainId)];
+    let counts = countsPerChain[ChainId.toString(fetchState.chainId)];
     let progressedChain;
-    if (batchSize !== undefined) {
-      let leftItems = fetchState.buffer.slice(batchSize);
-      progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, FetchState.updateInternal(fetchState, undefined, leftItems, undefined, undefined, undefined), batchSize);
+    if (counts !== undefined) {
+      let leftItems = fetchState.buffer.slice(counts.size);
+      progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, FetchState.updateInternal(fetchState, undefined, leftItems, undefined, undefined, undefined), counts);
     } else {
-      progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, chainBeforeBatch.fetchState, 0);
+      progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, chainBeforeBatch.fetchState, {
+        size: 0,
+        eventsProcessed: 0
+      });
     }
     if (progressedChain !== undefined) {
       progressedChainsById[chainBeforeBatch.fetchState.chainId] = progressedChain;
@@ -52,145 +57,146 @@ function seekFirstAbove(blockNumbers, blockNumber) {
   return low;
 }
 
-function addReorgCheckpoints(prevCheckpointId, scannedHashes, shouldRollbackOnReorg, fromBlockExclusive, toBlockExclusive, chainId, mutCheckpointIds, mutCheckpointChainIds, mutCheckpointBlockNumbers, mutCheckpointBlockHashes, mutCheckpointEventsProcessed) {
+function addReorgCheckpoints(cursor, scannedHashes, shouldRollbackOnReorg, fromBlockExclusive, toBlockExclusive, chainId, mutCheckpointIds, mutCheckpointChainIds, mutCheckpointBlockNumbers, mutCheckpointBlockHashes, mutCheckpointItemsCount, mutCheckpointEventsProcessed) {
   if (!shouldRollbackOnReorg) {
-    return prevCheckpointId;
+    return;
   }
-  let prevCheckpointId$1 = prevCheckpointId;
   let blockNumbers = scannedHashes.blockNumbers;
   let length = blockNumbers.length;
   let idx = seekFirstAbove(blockNumbers, fromBlockExclusive);
   while (idx < length && blockNumbers[idx] < toBlockExclusive) {
     let blockNumber = blockNumbers[idx];
     let hash = scannedHashes.hashByBlockNumber[blockNumber];
-    let checkpointId = prevCheckpointId$1 + 1n;
-    prevCheckpointId$1 = checkpointId;
+    let checkpointId = CheckpointSequence.next(cursor, chainId);
     mutCheckpointIds.push(checkpointId);
     mutCheckpointChainIds.push(chainId);
     mutCheckpointBlockNumbers.push(blockNumber);
     mutCheckpointBlockHashes.push(hash);
+    mutCheckpointItemsCount.push(0);
     mutCheckpointEventsProcessed.push(0);
     idx = idx + 1;
   };
-  return prevCheckpointId$1;
 }
 
-function prepareBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSizeTarget, isInReorgThreshold) {
+function make(sequence, frontier, chainsBeforeBatch, batchSizeTarget, history) {
   let preparedFetchStates = FetchState.sortForBatch(Object.values(chainsBeforeBatch).map(chainBeforeBatch => chainBeforeBatch.fetchState), batchSizeTarget);
   let chainIdx = 0;
   let preparedNumber = preparedFetchStates.length;
   let totalBatchSize = 0;
-  let prevCheckpointId = checkpointIdBeforeBatch;
-  let mutBatchSizePerChain = {};
+  let cursor = CheckpointSequence.cursor(sequence, frontier);
+  let mutCountsPerChain = {};
   let mutProgressBlockNumberPerChain = {};
   let items = [];
   let checkpointIds = [];
   let checkpointChainIds = [];
   let checkpointBlockNumbers = [];
   let checkpointBlockHashes = [];
+  let checkpointItemsCount = [];
   let checkpointEventsProcessed = [];
   while (totalBatchSize < batchSizeTarget && chainIdx < preparedNumber) {
     let fetchState = preparedFetchStates[chainIdx];
     let chainBatchSize = FetchState.getReadyItemsCount(fetchState, batchSizeTarget - totalBatchSize, 0);
     let chainBeforeBatch = chainsBeforeBatch[fetchState.chainId];
     let prevBlockNumber = chainBeforeBatch.progressBlockNumber;
+    let chainEventsProcessed = 0;
     if (chainBatchSize > 0) {
       for (let idx = 0, idx_finish = chainBatchSize - 1; idx <= idx_finish; ++idx) {
         let item = fetchState.buffer[idx];
         let blockNumber = item.blockNumber;
+        let isNewEvent = idx === 0 || !FetchState.isSameLog(fetchState.buffer[idx - 1], item);
+        if (isNewEvent) {
+          chainEventsProcessed = chainEventsProcessed + 1;
+        }
         if (blockNumber !== prevBlockNumber) {
           let chainId = fetchState.chainId;
           let fromBlockExclusive = prevBlockNumber;
           let scannedHashes = chainBeforeBatch.scannedHashes;
-          let prevCheckpointId$1 = prevCheckpointId;
-          let tmp;
           if (chainBeforeBatch.shouldRollbackOnReorg) {
-            let prevCheckpointId$2 = prevCheckpointId$1;
             let blockNumbers = scannedHashes.blockNumbers;
             let length = blockNumbers.length;
             let idx$1 = seekFirstAbove(blockNumbers, fromBlockExclusive);
             while (idx$1 < length && blockNumbers[idx$1] < blockNumber) {
               let blockNumber$1 = blockNumbers[idx$1];
               let hash = scannedHashes.hashByBlockNumber[blockNumber$1];
-              let checkpointId = prevCheckpointId$2 + 1n;
-              prevCheckpointId$2 = checkpointId;
+              let checkpointId = CheckpointSequence.next(cursor, chainId);
               checkpointIds.push(checkpointId);
               checkpointChainIds.push(chainId);
               checkpointBlockNumbers.push(blockNumber$1);
               checkpointBlockHashes.push(hash);
+              checkpointItemsCount.push(0);
               checkpointEventsProcessed.push(0);
               idx$1 = idx$1 + 1;
             };
-            tmp = prevCheckpointId$2;
-          } else {
-            tmp = prevCheckpointId$1;
           }
-          prevCheckpointId = tmp;
-          let checkpointId$1 = prevCheckpointId + 1n;
+          let checkpointId$1 = CheckpointSequence.next(cursor, fetchState.chainId);
           checkpointIds.push(checkpointId$1);
           checkpointChainIds.push(fetchState.chainId);
           checkpointBlockNumbers.push(blockNumber);
           let hash$1 = chainBeforeBatch.scannedHashes.hashByBlockNumber[blockNumber];
           checkpointBlockHashes.push(hash$1 !== undefined ? hash$1 : null);
+          checkpointItemsCount.push(1);
           checkpointEventsProcessed.push(1);
           prevBlockNumber = blockNumber;
-          prevCheckpointId = checkpointId$1;
         } else {
-          let lastIndex = checkpointEventsProcessed.length - 1;
-          checkpointEventsProcessed[lastIndex] = checkpointEventsProcessed[lastIndex] + 1;
+          let lastIndex = checkpointItemsCount.length - 1;
+          checkpointItemsCount[lastIndex] = checkpointItemsCount[lastIndex] + 1;
+          if (isNewEvent) {
+            checkpointEventsProcessed[lastIndex] = checkpointEventsProcessed[lastIndex] + 1;
+          }
         }
         items.push(item);
       }
       totalBatchSize = totalBatchSize + chainBatchSize;
-      mutBatchSizePerChain[fetchState.chainId] = chainBatchSize;
+      mutCountsPerChain[fetchState.chainId] = {
+        size: chainBatchSize,
+        eventsProcessed: chainEventsProcessed
+      };
     }
     let progressBlockNumberAfterBatch = FetchState.getProgressBlockNumberAt(fetchState, chainBatchSize);
     let chainId$1 = fetchState.chainId;
     let toBlockExclusive = progressBlockNumberAfterBatch + 1;
     let fromBlockExclusive$1 = prevBlockNumber;
     let scannedHashes$1 = chainBeforeBatch.scannedHashes;
-    let prevCheckpointId$3 = prevCheckpointId;
-    let tmp$1;
     if (chainBeforeBatch.shouldRollbackOnReorg) {
-      let prevCheckpointId$4 = prevCheckpointId$3;
       let blockNumbers$1 = scannedHashes$1.blockNumbers;
       let length$1 = blockNumbers$1.length;
       let idx$2 = seekFirstAbove(blockNumbers$1, fromBlockExclusive$1);
       while (idx$2 < length$1 && blockNumbers$1[idx$2] < toBlockExclusive) {
         let blockNumber$2 = blockNumbers$1[idx$2];
         let hash$2 = scannedHashes$1.hashByBlockNumber[blockNumber$2];
-        let checkpointId$2 = prevCheckpointId$4 + 1n;
-        prevCheckpointId$4 = checkpointId$2;
+        let checkpointId$2 = CheckpointSequence.next(cursor, chainId$1);
         checkpointIds.push(checkpointId$2);
         checkpointChainIds.push(chainId$1);
         checkpointBlockNumbers.push(blockNumber$2);
         checkpointBlockHashes.push(hash$2);
+        checkpointItemsCount.push(0);
         checkpointEventsProcessed.push(0);
         idx$2 = idx$2 + 1;
       };
-      tmp$1 = prevCheckpointId$4;
-    } else {
-      tmp$1 = prevCheckpointId$3;
     }
-    prevCheckpointId = tmp$1;
     mutProgressBlockNumberPerChain[fetchState.chainId] = progressBlockNumberAfterBatch;
     chainIdx = chainIdx + 1;
   };
   return {
     totalBatchSize: totalBatchSize,
     items: items,
-    progressedChainsById: getProgressedChainsById(chainsBeforeBatch, mutBatchSizePerChain, mutProgressBlockNumberPerChain),
-    isInReorgThreshold: isInReorgThreshold,
+    progressedChainsById: getProgressedChainsById(chainsBeforeBatch, mutCountsPerChain, mutProgressBlockNumberPerChain),
+    history: history,
     checkpointIds: checkpointIds,
     checkpointChainIds: checkpointChainIds,
     checkpointBlockNumbers: checkpointBlockNumbers,
     checkpointBlockHashes: checkpointBlockHashes,
+    checkpointItemsCount: checkpointItemsCount,
     checkpointEventsProcessed: checkpointEventsProcessed,
     registeredAddresses: []
   };
 }
 
-let make = prepareBatch;
+function checkpointFrontier(batch) {
+  let frontier = Frontier.empty();
+  batch.checkpointChainIds.forEach((chainId, index) => Frontier.set(frontier, chainId, batch.checkpointIds[index]));
+  return frontier;
+}
 
 function findFirstEventBlockNumber(batch, chainId) {
   let idx = 0;
@@ -198,7 +204,7 @@ function findFirstEventBlockNumber(batch, chainId) {
   let checkpointsLength = batch.checkpointIds.length;
   while (idx < checkpointsLength && result === undefined) {
     let checkpointChainId = batch.checkpointChainIds[idx];
-    if (checkpointChainId === chainId && batch.checkpointEventsProcessed[idx] > 0) {
+    if (checkpointChainId === chainId && batch.checkpointItemsCount[idx] > 0) {
       result = batch.checkpointBlockNumbers[idx];
     } else {
       idx = idx + 1;
@@ -225,8 +231,8 @@ export {
   getProgressedChainsById,
   seekFirstAbove,
   addReorgCheckpoints,
-  prepareBatch,
   make,
+  checkpointFrontier,
   findFirstEventBlockNumber,
   findLastEventItem,
 }

package/src/BatchProcessing.res

@@ -69,17 +69,7 @@ and processNextBatch = async (state: IndexerState.t, ~scheduleFetch): unit => {
   let isInReorgThresholdBeforeUpdate = state->IndexerState.isInReorgThreshold
   let isRealtimeBeforeUpdate = state->IndexerState.isRealtime
 
-  let isRollbackBatch = switch state->IndexerState.rollbackState {
-  | RollbackReady(_) => true
-  | _ => false
-  }
-
-  let batch =
-    state->IndexerState.createBatch(
-      ~processedCheckpointId=state->IndexerState.processedCheckpointId,
-      ~batchSizeTarget=(state->IndexerState.config).batchSize,
-      ~isRollback=isRollbackBatch,
-    )
+  let batch = state->IndexerState.createBatch(~batchSizeTarget=(state->IndexerState.config).batchSize)
 
   let progressedChainsById = batch.progressedChainsById
 

package/src/BatchProcessing.res.mjs

@@ -23,10 +23,7 @@ function yieldTick() {
 async function processNextBatch(state, scheduleFetch) {
   let isInReorgThresholdBeforeUpdate = IndexerState.isInReorgThreshold(state);
   let isRealtimeBeforeUpdate = IndexerState.isRealtime(state);
-  let match = IndexerState.rollbackState(state);
-  let isRollbackBatch;
-  isRollbackBatch = typeof match !== "object" ? false : match.TAG === "RollbackReady";
-  let batch = IndexerState.createBatch(state, IndexerState.processedCheckpointId(state), IndexerState.config(state).batchSize, isRollbackBatch);
+  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));

package/src/ChainState.res

@@ -41,6 +41,8 @@ type t = {
   // detected reorg either rolls back or is only logged.
   shouldRollbackOnReorg: bool,
   maxReorgDepth: int,
+  // One-way: past it, everything the chain writes can still be rolled back.
+  mutable isInReorgThreshold: bool,
   // Holds this chain's transactions (kept in Rust) keyed by (blockNumber,
   // transactionIndex). Fetch responses merge their page in; entries are pruned
   // as the chain progresses and dropped above the target on rollback.
@@ -126,6 +128,7 @@ let make = (
   ~safeCheckpointTracking=None,
   ~shouldRollbackOnReorg,
   ~maxReorgDepth,
+  ~isInReorgThreshold=false,
   ~numEventsProcessed=0.,
   ~timestampCaughtUpToHeadOrEndblock=None,
   ~isProgressAtHead=false,
@@ -155,6 +158,7 @@ let make = (
     safeCheckpointTracking,
     shouldRollbackOnReorg,
     maxReorgDepth,
+    isInReorgThreshold,
     transactionStore,
     blockStore,
     reorgThresholdReadyTolerance,
@@ -203,7 +207,9 @@ let makeInternal = (
 
   chainConfig.contracts->Array.forEach(contract => {
     switch contract.startBlock {
-    | Some(startBlock) if startBlock < chainConfig.startBlock =>
+    // Against the resolved `~startBlock`, which came from storage:
+    // `chainConfig.startBlock` still says whatever config.yaml said.
+    | Some(contractStartBlock) if contractStartBlock < startBlock =>
       JsError.throwWithMessage(
         `The start block for contract "${contract.name}" is less than the chain start block. This is not supported yet.`,
       )
@@ -262,78 +268,12 @@ let makeInternal = (
   })
 
   // Create sources lazily here - this is where API token validation happens
-  let chainId = chainConfig.id
-  let sources = switch chainConfig.sourceConfig {
-  | Config.EvmSourceConfig({hypersync, rpcs}) =>
-    let evmRpcs: array<EvmChain.rpc> = rpcs->Array.map((rpc): EvmChain.rpc => {
-      let syncConfig = rpc.syncConfig
-      let ws = rpc.ws
-      let headers = rpc.headers
-      {
-        url: rpc.url,
-        sourceFor: rpc.sourceFor,
-        ?syncConfig,
-        ?ws,
-        ?headers,
-      }
-    })
-    EvmChain.makeSources(
-      ~chainId,
-      ~onEventRegistrations=onEventRegistrations->(
-        Utils.magic: array<Internal.onEventRegistration> => array<Internal.evmOnEventRegistration>
-      ),
-      ~hyperSync=hypersync,
-      ~rpcs=evmRpcs,
-      ~lowercaseAddresses,
-      ~addressStore,
-    )
-  | Config.FuelSourceConfig({hypersync}) => [
-      FuelHyperSyncSource.make({
-        chainId,
-        endpointUrl: hypersync,
-        apiToken: Env.envioApiToken,
-        onEventRegistrations,
-        addressStore,
-      }),
-    ]
-  | Config.SvmSourceConfig({hypersync, rpc}) =>
-    switch (hypersync, rpc) {
-    | (None, None) =>
-      JsError.throwWithMessage(`Chain ${chainId->ChainId.toString} has no SVM data source`)
-    | (None, Some(rpc)) => [Svm.makeRPCSource(~chainId, ~rpc)]
-    | (Some(hypersyncUrl), _) =>
-      // HyperSync drives instruction sync. A configured RPC is ignored for now
-      // (RPC fallback isn't wired up yet).
-      let apiToken = Env.envioApiToken
-      [
-        SvmHyperSyncSource.make({
-          chainId,
-          endpointUrl: hypersyncUrl,
-          apiToken,
-          onEventRegistrations: onEventRegistrations->(
-            Utils.magic: array<Internal.onEventRegistration> => array<
-              Internal.svmOnEventRegistration,
-            >
-          ),
-          clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis,
-          addressStore,
-        }),
-      ]
-    }
-  | Config.SimulateSourceConfig({items, endBlock, ?transactionStore, ?blockStore}) => [
-      SimulateSource.make(
-        ~items,
-        ~endBlock,
-        ~chainId,
-        ~addressStore,
-        ~ecosystem=config.ecosystem.name,
-        ~transactionStore,
-        ~blockStore,
-      ),
-    ]
-  // For tests: use ready-to-use sources directly
-  | Config.CustomSources(sources) => sources
-  }
+  let sources = ChainSources.make(
+    ~chainConfig,
+    ~onEventRegistrations,
+    ~addressStore,
+    ~lowercaseAddresses,
+  )
 
   let blockStore = BlockStore.make(
     ~ecosystem=config.ecosystem.name,
@@ -372,6 +312,7 @@ let makeInternal = (
     ~sourceManager=SourceManager.make(~sources, ~isRealtime, ~reducedPollingInterval?),
     ~shouldRollbackOnReorg=config.shouldRollbackOnReorg,
     ~maxReorgDepth,
+    ~isInReorgThreshold,
     ~safeCheckpointTracking=SafeCheckpointTracking.make(
       ~maxReorgDepth,
       ~shouldRollbackOnReorg=config.shouldRollbackOnReorg,
@@ -704,15 +645,21 @@ let hasProcessedToEndblock = (cs: t) => {
 // head has run away from it while the indexer was down.
 let isDurablyCaughtUp = (cs: t) => {
   let {committedProgressBlockNumber, fetchState} = cs
-  switch fetchState.endBlock {
-  | Some(endBlock) => committedProgressBlockNumber >= endBlock
-  | None =>
-    // The configured lag, not the fetch state's: pre-threshold that one also
-    // carries maxReorgDepth, which would read a chain a whole reorg depth behind
-    // the head as caught up.
+  let atEndBlock =
+    fetchState.endBlock->Option.mapOr(false, endBlock => committedProgressBlockNumber >= endBlock)
+  // Either one, like `isFetchingAtHead`: an `end_block` above the head is never
+  // reached, and testing only for it would leave such a chain reading as behind
+  // however long it sits at the head.
+  //
+  // The configured lag, not the fetch state's: pre-threshold that one also
+  // carries maxReorgDepth, which would read a chain a whole reorg depth behind
+  // the head as caught up. Clamped at zero: the -1 a run that has processed
+  // nothing carries would otherwise clear a chain younger than its own lag.
+  let atHead =
     fetchState.knownHeight > 0 &&
-      committedProgressBlockNumber >= fetchState.knownHeight - cs.chainConfig.blockLag
-  }
+      committedProgressBlockNumber >=
+      Pervasives.max(0, fetchState.knownHeight - cs.chainConfig.blockLag)
+  atEndBlock || atHead
 }
 
 let getHighestBlockBelowThreshold = (cs: t): int => {
@@ -993,8 +940,18 @@ let setEndBlockToFirstEvent = (cs: t, ~blockNumber) =>
   }
 
 // Shrink the fetch buffer by the configured blockLag on entering the reorg threshold.
-let enterReorgThreshold = (cs: t) =>
+let enterReorgThreshold = (cs: t) => {
+  cs.isInReorgThreshold = true
   cs.fetchState = cs.fetchState->FetchState.updateInternal(~blockLag=cs.chainConfig.blockLag)
+}
+
+let isInReorgThreshold = (cs: t) => cs.isInReorgThreshold
+
+// Whether the chain's writes need history: only what a rollback could still
+// reach. A chain with no reorg depth is never rolled back, however far its
+// progress has run.
+let shouldSaveHistory = (cs: t) =>
+  cs.shouldRollbackOnReorg && cs.maxReorgDepth > 0 && cs.isInReorgThreshold
 
 // Snapshot the chain's metadata fields for staging into the chains table.
 let toChainMetadata = (cs: t): InternalTable.Chains.metaFields => {
@@ -1043,6 +1000,8 @@ let toMetrics = (cs: t): Metrics.chainMetrics => {
   reorgCount: cs.reorgCount,
   reorgDetectedBlock: cs.reorgDetectedBlock,
   rollbackTargetBlock: cs.rollbackTargetBlock,
+  rateLimitTimeMs: cs.sourceManager->SourceManager.getRateLimitTimeMs,
+  rateLimitResetInMs: cs.sourceManager->SourceManager.getRateLimitResetInMs,
 }
 
 // Snapshot the inputs a batch build needs from this chain, including an
@@ -1199,11 +1158,11 @@ let applyBatchProgress = (cs: t, ~batch: Batch.t, ~blockTimestampName: string) =
 }
 
 // Mark the chain caught up to head/endblock. Called by CrossChainState only once
-// every chain in the indexer is caught up and the deferred schema indexes are
-// committed, so no chain flips to ready while another is still backfilling or
-// while an index the schema promises is still missing. `readyAt` is the
-// timestamp already committed to `envio_chains.ready_at` in that same
-// transaction. Sticky: a chain stays ready once set.
+// every chain this process drives is caught up and the indexes the schema
+// promises them are committed, so no chain flips to ready while an index it
+// promised is still missing. `readyAt` is the timestamp already committed to
+// `envio_chains.ready_at` in that same transaction. Sticky: a chain stays ready
+// once set.
 let markReady = (cs: t, ~readyAt) =>
   if !(cs->isReady) {
     cs.timestampCaughtUpToHeadOrEndblock = Some(readyAt)