envio 3.11.0 → 3.12.0

package/src/Config.res.mjs

@@ -21,6 +21,7 @@ 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 Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as CheckpointSequence from "./db/CheckpointSequence.res.mjs";
 import * as EventConfigBuilder from "./EventConfigBuilder.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
@@ -436,6 +437,7 @@ let publicConfigSchema = S$RescriptSchema.schema(s => ({
   description: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
   handlers: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
   isDev: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
+  isolatedChains: s.m(S$RescriptSchema.option(S$RescriptSchema.array(ChainId.schema))),
   fullBatchSize: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
   rollbackOnReorg: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   saveFullHistory: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
@@ -460,6 +462,33 @@ function contractMappingOf(chainConfigs) {
   return ContractMapping.make(names);
 }
 
+function getChain(config, chainId) {
+  if (ChainMap.has(config.chainMap, chainId)) {
+    return chainId;
+  } else {
+    return Stdlib_JsError.throwWithMessage("No chain with id " + ChainId.toString(chainId) + " found in config.yaml");
+  }
+}
+
+function isolate(config, chainIds) {
+  let shared = config.userEntities.filter(entityConfig => entityConfig.crossChain);
+  if (shared.length !== 0) {
+    Stdlib_JsError.throwWithMessage(`Only a schema whose entities are all per-chain can be split across processes. Shared across chains: ` + shared.map(entityConfig => entityConfig.name).join(", ") + `.`);
+  }
+  chainIds.forEach(chainId => {
+    getChain(config, chainId);
+  });
+  let chains = ChainMap.values(config.chainMap).filter(chain => chainIds.includes(chain.id));
+  let newrecord = {...config};
+  newrecord.isolated = true;
+  newrecord.defaultChain = chains[0];
+  newrecord.chainMap = ChainMap.fromArrayUnsafe(chains.map(chain => [
+    chain.id,
+    chain
+  ]));
+  return newrecord;
+}
+
 function fromPublic(publicConfigJson) {
   let publicConfig;
   try {
@@ -755,38 +784,50 @@ function fromPublic(publicConfigJson) {
       name: Utils.$$String.capitalize(param[0]),
       handler: param[1].handler
     })) : [];
-  return {
-    name: publicConfig.name,
-    description: publicConfig.description,
-    handlers: Stdlib_Option.getOr(publicConfig.handlers, "src/handlers"),
+  let config_name = publicConfig.name;
+  let config_description = publicConfig.description;
+  let config_handlers = Stdlib_Option.getOr(publicConfig.handlers, "src/handlers");
+  let config_shouldRollbackOnReorg = Stdlib_Option.getOr(publicConfig.rollbackOnReorg, true);
+  let config_shouldSaveFullHistory = Stdlib_Option.getOr(publicConfig.saveFullHistory, false);
+  let config_chainIdMode = Stdlib_Option.getOr(publicConfig.chainIdMode, "int32");
+  let config_contractMapping = contractMappingOf(chains);
+  let config_defaultChain = chains[0];
+  let config_enableRawEvents = Stdlib_Option.getOr(publicConfig.rawEvents, false);
+  let config_batchSize = Stdlib_Option.getOr(publicConfig.fullBatchSize, 5000);
+  let config_isDev = Stdlib_Option.getOr(publicConfig.isDev, false);
+  let config_checkpointSequence = CheckpointSequence.fromEntities(userEntities);
+  let config = {
+    name: config_name,
+    description: config_description,
+    handlers: config_handlers,
     contractHandlers: contractHandlers,
-    shouldRollbackOnReorg: Stdlib_Option.getOr(publicConfig.rollbackOnReorg, true),
-    shouldSaveFullHistory: Stdlib_Option.getOr(publicConfig.saveFullHistory, false),
+    shouldRollbackOnReorg: config_shouldRollbackOnReorg,
+    shouldSaveFullHistory: config_shouldSaveFullHistory,
     defaultCrossChain: defaultCrossChain,
     storage: globalStorage,
-    chainIdMode: Stdlib_Option.getOr(publicConfig.chainIdMode, "int32"),
+    chainIdMode: config_chainIdMode,
     chainMap: chainMap,
-    contractMapping: contractMappingOf(chains),
-    defaultChain: chains[0],
+    contractMapping: config_contractMapping,
+    defaultChain: config_defaultChain,
     ecosystem: ecosystem,
-    enableRawEvents: Stdlib_Option.getOr(publicConfig.rawEvents, false),
+    enableRawEvents: config_enableRawEvents,
     maxAddrInPartition: Env.maxAddrInPartition,
     clientFilterAddressThreshold: Env.clientFilterAddressThreshold,
-    batchSize: Stdlib_Option.getOr(publicConfig.fullBatchSize, 5000),
+    batchSize: config_batchSize,
     reorgThresholdReadyTolerance: 100,
     lowercaseAddresses: lowercaseAddresses,
-    isDev: Stdlib_Option.getOr(publicConfig.isDev, false),
+    isDev: config_isDev,
+    isolated: false,
     userEntitiesByName: userEntitiesByName,
     userEntities: userEntities,
-    allEnums: allEnums
+    allEnums: allEnums,
+    checkpointSequence: config_checkpointSequence
   };
-}
-
-function isIsolatedMultichain(config) {
-  if (ChainMap.keys(config.chainMap).length > 1) {
-    return config.userEntities.every(entityConfig => !entityConfig.crossChain);
+  let chainIds = publicConfig.isolatedChains;
+  if (chainIds !== undefined) {
+    return isolate(config, chainIds);
   } else {
-    return false;
+    return config;
   }
 }
 
@@ -853,36 +894,6 @@ function getEventConfig(config, contractName, eventName, chainId) {
   });
 }
 
-function shouldSaveHistory(config, isInReorgThreshold, chainId) {
-  if (config.shouldSaveFullHistory) {
-    return true;
-  } else if (config.shouldRollbackOnReorg && isInReorgThreshold) {
-    if (chainId !== undefined && isIsolatedMultichain(config)) {
-      return ChainMap.get(config.chainMap, Primitive_option.valFromOption(chainId)).maxReorgDepth > 0;
-    } else {
-      return true;
-    }
-  } else {
-    return false;
-  }
-}
-
-function shouldPruneHistory(config, isInReorgThreshold) {
-  if (!config.shouldSaveFullHistory && config.shouldRollbackOnReorg) {
-    return isInReorgThreshold;
-  } else {
-    return false;
-  }
-}
-
-function getChain(config, chainId) {
-  if (ChainMap.has(config.chainMap, chainId)) {
-    return chainId;
-  } else {
-    return Stdlib_JsError.throwWithMessage("No chain with id " + ChainId.toString(chainId) + " found in config.yaml");
-  }
-}
-
 let primedJson = {
   contents: undefined
 };
@@ -931,6 +942,7 @@ function stripSensitiveData(json) {
   };
   if (typeof cloned === "object" && cloned !== null && !Array.isArray(cloned)) {
     Utils.Dict.deleteInPlace(cloned, "isDev");
+    Utils.Dict.deleteInPlace(cloned, "isolatedChains");
     stripChains(cloned["evm"]);
     stripChains(cloned["fuel"]);
     stripChains(cloned["svm"]);
@@ -1159,14 +1171,12 @@ export {
   publicConfigStorageSchema,
   publicConfigSchema,
   contractMappingOf,
+  getChain,
+  isolate,
   fromPublic,
-  isIsolatedMultichain,
   normalizeUserAddress,
   normalizeSimulateAddress,
   getEventConfig,
-  shouldSaveHistory,
-  shouldPruneHistory,
-  getChain,
   prime,
   getPublicConfigJson,
   stripSensitiveData,

package/src/CrossChainState.res

@@ -8,13 +8,13 @@ type t = {
   // Chain ids in a stable order, so the cross-chain loops iterate the chains
   // without allocating a values array on every tick.
   chainIds: array<ChainId.t>,
-  // True once every chain has caught up to head/endBlock. Monotonic during a run.
+  // True once every chain this process drives has caught up to head/endBlock and
+  // the indexes they owe are committed. Monotonic during a run.
   mutable isRealtime: bool,
-  // True once every chain has caught up and there's nothing left to process,
-  // but before the deferred schema indexes and `ready_at` are committed. The
-  // gap between this and `isRealtime` is the FinalizingIndexes phase.
+  // True once those chains have caught up and there's nothing left to process,
+  // but before the deferred schema indexes and `ready_at` are committed. The gap
+  // between this and `isRealtime` is the FinalizingIndexes phase.
   mutable isCaughtUp: bool,
-  mutable isInReorgThreshold: bool,
   // Indexer-wide fetch buffer pool (item count), shared across all chains.
   targetBufferSize: int,
 }
@@ -26,18 +26,12 @@ let calculateTargetBufferSize = () =>
   | None => 100_000
   }
 
-let make = (
-  ~chainStates,
-  ~isInReorgThreshold,
-  ~isRealtime,
-  ~targetBufferSize=calculateTargetBufferSize(),
-): t => {
+let make = (~chainStates, ~isRealtime, ~targetBufferSize=calculateTargetBufferSize()): t => {
   {
     chainStates,
     chainIds: chainStates->Dict.valuesToArray->Array.map(cs => (cs->ChainState.chainConfig).id),
     isRealtime,
     isCaughtUp: isRealtime,
-    isInReorgThreshold,
     targetBufferSize,
   }
 }
@@ -51,10 +45,21 @@ let getChainState = (crossChainState: t, chainId) =>
 
 let chainStates = (crossChainState: t) => crossChainState.chainStates
 let isRealtime = (crossChainState: t) => crossChainState.isRealtime
+let chainIds = (crossChainState: t) => crossChainState.chainIds
 let isCaughtUp = (crossChainState: t) => crossChainState.isCaughtUp
-let isInReorgThreshold = (crossChainState: t) => crossChainState.isInReorgThreshold
+// Chains enter the threshold together. It is the run-wide reading; what a
+// write keeps is decided per chain.
+let isInReorgThreshold = (crossChainState: t) => {
+  let chainStates = crossChainState.chainStates->Dict.valuesToArray
+  chainStates->Utils.Array.notEmpty && chainStates->Array.every(ChainState.isInReorgThreshold)
+}
 let targetBufferSize = (crossChainState: t) => crossChainState.targetBufferSize
 
+// Whether each chain's writes still need history, keyed by chain id — what the
+// history policy is built from.
+let shouldSaveHistory = (crossChainState: t) =>
+  crossChainState.chainStates->Utils.Dict.mapValues(ChainState.shouldSaveHistory)
+
 // Ready-to-process items across every chain — the live draw against
 // targetBufferSize, which is a budget of processable events (items stuck behind
 // a gap don't count toward the goal of keeping ~targetBufferSize ready).
@@ -74,14 +79,20 @@ let nextItemIsNone = (crossChainState: t): bool =>
 
 // Each chain's safe checkpoint: the last one a reorg on that chain can no longer
 // reach, or None while it has nothing safe yet. A chain that can't be rolled
-// back (maxReorgDepth = 0) tracks none, and everything it has committed is safe.
-let getSafeCheckpointIdByChain = (crossChainState: t, ~committedCheckpointId) =>
+// back (maxReorgDepth = 0) tracks none, and everything committed is safe from
+// it: under one shared sequence that is the run's highest id, not the chain's
+// own — an idle chain's would hold every other chain's prune back.
+let getSafeCheckpointIdByChain = (
+  crossChainState: t,
+  ~sequence: CheckpointSequence.t,
+  ~committedFrontier,
+) =>
   crossChainState.chainIds->Array.map(chainId => {
     let cs = crossChainState->getChainState(chainId)
     (
       chainId,
       switch cs->ChainState.safeCheckpointTracking {
-      | None => Some(committedCheckpointId)
+      | None => Some(sequence->CheckpointSequence.position(committedFrontier, ~chainId))
       | Some(tracking) =>
         tracking->SafeCheckpointTracking.getSafeCheckpointId(
           ~sourceBlockNumber=cs->ChainState.knownHeight,
@@ -94,18 +105,14 @@ let getSafeCheckpointIdByChain = (crossChainState: t, ~committedCheckpointId) =>
 
 let createBatch = (
   crossChainState: t,
-  ~processedCheckpointId,
+  ~config: Config.t,
+  ~frontier,
   ~batchSizeTarget: int,
-  ~isRollback: bool,
 ): Batch.t => {
   Batch.make(
-    ~isInReorgThreshold=crossChainState.isInReorgThreshold,
-    ~checkpointIdBeforeBatch=processedCheckpointId->BigInt.add(
-      // Since for rollback we have a diff checkpoint id.
-      // This is needed to currectly overwrite old state
-      // in an append-only ClickHouse insert.
-      isRollback ? 1n : 0n,
-    ),
+    ~sequence=config.checkpointSequence,
+    ~history=config->HistoryPolicy.decide(~shouldSaveHistory=crossChainState->shouldSaveHistory),
+    ~frontier,
     ~chainsBeforeBatch=crossChainState.chainStates->Utils.Dict.mapValues(
       ChainState.toChainBeforeBatch,
     ),
@@ -123,8 +130,6 @@ let enterReorgThreshold = (crossChainState: t) => {
     ->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
     ->ChainState.enterReorgThreshold
   }
-
-  crossChainState.isInReorgThreshold = true
 }
 
 // Commit each progressed chain's batch progress, then record whether the whole
@@ -146,17 +151,6 @@ let applyBatchProgress = (crossChainState: t, ~batch: Batch.t, ~blockTimestampNa
 
   crossChainState.isCaughtUp =
     crossChainState.isCaughtUp || (crossChainState->nextItemIsNone && everyChainCaughtUp.contents)
-
-  // A run resumed with every chain already stamped ready needs no finalize —
-  // the indexes were committed together with those stamps.
-  let allChainsReady = ref(true)
-  for i in 0 to chainIds->Array.length - 1 {
-    if !(crossChainState->getChainState(chainIds->Array.getUnsafe(i))->ChainState.isReady) {
-      allChainsReady := false
-    }
-  }
-
-  crossChainState.isRealtime = crossChainState.isRealtime || allChainsReady.contents
 }
 
 // Every chain has buffered up to its head (or endblock) with nothing
@@ -191,29 +185,25 @@ let markCaughtUpIfSettled = (crossChainState: t) =>
 // may have moved on — at which point no chain looks at head any more and the
 // indexes it still owes would wait out another whole backfill. Deciding here,
 // before any source request, keeps that debt tied to the progress that was
-// actually committed. Skipped once every chain carries `ready_at`: those indexes
-// were committed together with the stamps.
+// actually committed. Skipped when the run resumed realtime, which is exactly
+// the case where the indexes are already committed and nothing is owed.
 let markCaughtUpOnResume = (crossChainState: t) => {
   let everyChainCaughtUp = ref(crossChainState.chainIds->Array.length > 0)
-  let everyChainReady = ref(true)
   for i in 0 to crossChainState.chainIds->Array.length - 1 {
     let cs = crossChainState->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
     if !(cs->ChainState.isDurablyCaughtUp) {
       everyChainCaughtUp := false
     }
-    if !(cs->ChainState.isReady) {
-      everyChainReady := false
-    }
   }
 
-  if everyChainCaughtUp.contents && !everyChainReady.contents && crossChainState->nextItemIsNone {
+  if everyChainCaughtUp.contents && !crossChainState.isRealtime && crossChainState->nextItemIsNone {
     crossChainState.isCaughtUp = true
   }
 }
 
-// Concludes the FinalizingIndexes phase: stamps every chain with the `ready_at`
-// already committed alongside the deferred schema indexes and switches the
-// indexer to realtime.
+// Concludes the FinalizingIndexes phase: stamps every chain this process drives
+// with the `ready_at` already committed alongside their deferred schema indexes,
+// and switches the indexer to realtime.
 let markReady = (crossChainState: t, ~readyAt) => {
   for i in 0 to crossChainState.chainIds->Array.length - 1 {
     crossChainState
@@ -267,6 +257,10 @@ let idleOrWaitAction = (cs: ChainState.t) =>
     ? FetchState.NothingToQuery
     : FetchState.WaitingForNewBlock
 
+// How far past the alignment anchor's frontier progress a follower may fetch,
+// as a fraction of its own alignable range.
+let alignmentMargin = 0.2
+
 // Dispatch a fetch tick across the whole indexer from one shared pool of
 // ~targetBufferSize ready events, as a waterfall: visit chains furthest-behind
 // first, hand each the budget remaining at that point (plus its own
@@ -350,11 +344,14 @@ let checkAndFetch = async (
         (isCold ? Pervasives.min(remaining.contents, coldChainBudget) : remaining.contents) +.
         cs->ChainState.pendingBudget
       let maxTargetBlock = switch alignment {
-      // 10% margin past the anchor's line: chains whose progress tracks the
+      // 20% margin past the anchor's line: chains whose progress tracks the
       // anchor closely would otherwise flap in and out of the clamp on every
-      // small frontier move, stalling their pipeline every other tick.
+      // small frontier move, stalling their pipeline every other tick. The
+      // margin is also the headroom a follower keeps buffered while the anchor
+      // is mid-fetch, so it has to outlast a slow anchor response, not just
+      // absorb frontier jitter.
       | Some((anchorChainId, progress)) if anchorChainId !== chainId =>
-        Some(cs->ChainState.blockAtProgress(~progress=progress +. 0.1))
+        Some(cs->ChainState.blockAtProgress(~progress=progress +. alignmentMargin))
       | _ => None
       }
       switch cs->ChainState.getNextQuery(~chainTargetItems, ~maxTargetBlock?) {
@@ -404,7 +401,7 @@ let checkAndFetch = async (
     switch actionByChain->ChainId.Dict.dangerouslyGetNonOption(chainId) {
     | Some(NothingToQuery)
     | None => ()
-    | Some(action) => promises->Array.push(dispatchChain(~chainId=chainId, ~action))
+    | Some(action) => promises->Array.push(dispatchChain(~chainId, ~action))
     }
   }
   let _ = await promises->Promise.all

package/src/CrossChainState.res.mjs

@@ -6,8 +6,10 @@ import * as Utils from "./Utils.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as HistoryPolicy from "./HistoryPolicy.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_float from "@rescript/runtime/lib/es6/Primitive_float.js";
+import * as CheckpointSequence from "./db/CheckpointSequence.res.mjs";
 import * as SafeCheckpointTracking from "./SafeCheckpointTracking.res.mjs";
 
 function calculateTargetBufferSize() {
@@ -18,7 +20,7 @@ function calculateTargetBufferSize() {
   }
 }
 
-function make(chainStates, isInReorgThreshold, isRealtime, targetBufferSizeOpt) {
+function make(chainStates, isRealtime, targetBufferSizeOpt) {
   let targetBufferSize = targetBufferSizeOpt !== undefined ? targetBufferSizeOpt : (
       Env.targetBufferSize !== undefined ? Env.targetBufferSize : 100000
     );
@@ -27,7 +29,6 @@ function make(chainStates, isInReorgThreshold, isRealtime, targetBufferSizeOpt)
     chainIds: Object.values(chainStates).map(cs => ChainState.chainConfig(cs).id),
     isRealtime: isRealtime,
     isCaughtUp: isRealtime,
-    isInReorgThreshold: isInReorgThreshold,
     targetBufferSize: targetBufferSize
   };
 }
@@ -40,18 +41,31 @@ function isRealtime(crossChainState) {
   return crossChainState.isRealtime;
 }
 
+function chainIds(crossChainState) {
+  return crossChainState.chainIds;
+}
+
 function isCaughtUp(crossChainState) {
   return crossChainState.isCaughtUp;
 }
 
 function isInReorgThreshold(crossChainState) {
-  return crossChainState.isInReorgThreshold;
+  let chainStates = Object.values(crossChainState.chainStates);
+  if (Utils.$$Array.notEmpty(chainStates)) {
+    return chainStates.every(ChainState.isInReorgThreshold);
+  } else {
+    return false;
+  }
 }
 
 function targetBufferSize(crossChainState) {
   return crossChainState.targetBufferSize;
 }
 
+function shouldSaveHistory(crossChainState) {
+  return Utils.Dict.mapValues(crossChainState.chainStates, ChainState.shouldSaveHistory);
+}
+
 function totalReadyCount(crossChainState) {
   let total = 0;
   for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
@@ -65,21 +79,19 @@ function nextItemIsNone(crossChainState) {
   return !Object.values(crossChainState.chainStates).some(ChainState.hasReadyItem);
 }
 
-function getSafeCheckpointIdByChain(crossChainState, committedCheckpointId) {
+function getSafeCheckpointIdByChain(crossChainState, sequence, committedFrontier) {
   return crossChainState.chainIds.map(chainId => {
     let cs = crossChainState.chainStates[chainId];
     let tracking = ChainState.safeCheckpointTracking(cs);
     return [
       chainId,
-      tracking !== undefined ? SafeCheckpointTracking.getSafeCheckpointId(tracking, ChainState.knownHeight(cs)) : committedCheckpointId
+      tracking !== undefined ? SafeCheckpointTracking.getSafeCheckpointId(tracking, ChainState.knownHeight(cs)) : CheckpointSequence.position(sequence, committedFrontier, chainId)
     ];
   });
 }
 
-function createBatch(crossChainState, processedCheckpointId, batchSizeTarget, isRollback) {
-  return Batch.make(processedCheckpointId + (
-    isRollback ? 1n : 0n
-  ), Utils.Dict.mapValues(crossChainState.chainStates, ChainState.toChainBeforeBatch), batchSizeTarget, crossChainState.isInReorgThreshold);
+function createBatch(crossChainState, config, frontier, batchSizeTarget) {
+  return Batch.make(config.checkpointSequence, frontier, Utils.Dict.mapValues(crossChainState.chainStates, ChainState.toChainBeforeBatch), batchSizeTarget, HistoryPolicy.decide(config, shouldSaveHistory(crossChainState)));
 }
 
 function enterReorgThreshold(crossChainState) {
@@ -87,7 +99,6 @@ function enterReorgThreshold(crossChainState) {
   for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
     ChainState.enterReorgThreshold(crossChainState.chainStates[crossChainState.chainIds[i]]);
   }
-  crossChainState.isInReorgThreshold = true;
 }
 
 function applyBatchProgress(crossChainState, batch, blockTimestampName) {
@@ -101,13 +112,6 @@ function applyBatchProgress(crossChainState, batch, blockTimestampName) {
     }
   }
   crossChainState.isCaughtUp = crossChainState.isCaughtUp || nextItemIsNone(crossChainState) && everyChainCaughtUp;
-  let allChainsReady = true;
-  for (let i$1 = 0, i_finish$1 = chainIds.length; i$1 < i_finish$1; ++i$1) {
-    if (!ChainState.isReady(crossChainState.chainStates[chainIds[i$1]])) {
-      allChainsReady = false;
-    }
-  }
-  crossChainState.isRealtime = crossChainState.isRealtime || allChainsReady;
 }
 
 function isSettledAtHead(crossChainState) {
@@ -129,17 +133,13 @@ function markCaughtUpIfSettled(crossChainState) {
 
 function markCaughtUpOnResume(crossChainState) {
   let everyChainCaughtUp = crossChainState.chainIds.length !== 0;
-  let everyChainReady = true;
   for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
     let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
     if (!ChainState.isDurablyCaughtUp(cs)) {
       everyChainCaughtUp = false;
     }
-    if (!ChainState.isReady(cs)) {
-      everyChainReady = false;
-    }
   }
-  if (everyChainCaughtUp && !everyChainReady && nextItemIsNone(crossChainState)) {
+  if (everyChainCaughtUp && !crossChainState.isRealtime && nextItemIsNone(crossChainState)) {
     crossChainState.isCaughtUp = true;
     return;
   }
@@ -199,7 +199,7 @@ async function checkAndFetch(crossChainState, dispatchChain) {
     let chainTargetItems = (
       isCold ? Primitive_float.min(remaining.contents, minimumAdmissionBudget) : remaining.contents
     ) + ChainState.pendingBudget(cs);
-    let maxTargetBlock = alignment !== undefined && alignment[0] !== chainId ? ChainState.blockAtProgress(cs, alignment[1] + 0.1) : undefined;
+    let maxTargetBlock = alignment !== undefined && alignment[0] !== chainId ? ChainState.blockAtProgress(cs, alignment[1] + 0.2) : undefined;
     let action = ChainState.getNextQuery(cs, chainTargetItems, maxTargetBlock);
     if (typeof action !== "object") {
       if (action === "WaitingForNewBlock") {
@@ -249,9 +249,11 @@ export {
   make,
   chainStates,
   isRealtime,
+  chainIds,
   isCaughtUp,
   isInReorgThreshold,
   targetBufferSize,
+  shouldSaveHistory,
   nextItemIsNone,
   getSafeCheckpointIdByChain,
   createBatch,

package/src/CrossChainState.resi

@@ -5,34 +5,27 @@ type t
 
 let calculateTargetBufferSize: unit => int
 
-let make: (
-  ~chainStates: dict<ChainState.t>,
-  ~isInReorgThreshold: bool,
-  ~isRealtime: bool,
-  ~targetBufferSize: int=?,
-) => t
+let make: (~chainStates: dict<ChainState.t>, ~isRealtime: bool, ~targetBufferSize: int=?) => t
 
 // Accessors.
 let chainStates: t => dict<ChainState.t>
 let isRealtime: t => bool
+let chainIds: t => array<ChainId.t>
 let isCaughtUp: t => bool
 let isInReorgThreshold: t => bool
 let targetBufferSize: t => int
+let shouldSaveHistory: t => dict<bool>
 
 // Derived (pure).
 let nextItemIsNone: t => bool
 let getSafeCheckpointIdByChain: (
   t,
-  ~committedCheckpointId: Internal.checkpointId,
+  ~sequence: CheckpointSequence.t,
+  ~committedFrontier: Frontier.t,
 ) => array<(ChainId.t, option<Internal.checkpointId>)>
 
 // Cross-chain transitions.
-let createBatch: (
-  t,
-  ~processedCheckpointId: Internal.checkpointId,
-  ~batchSizeTarget: int,
-  ~isRollback: bool,
-) => Batch.t
+let createBatch: (t, ~config: Config.t, ~frontier: Frontier.t, ~batchSizeTarget: int) => Batch.t
 let enterReorgThreshold: t => unit
 let applyBatchProgress: (t, ~batch: Batch.t, ~blockTimestampName: string) => unit
 let markCaughtUpIfSettled: t => unit

package/src/EffectState.res

@@ -36,15 +36,24 @@ type effectStats = {
   mutable hasCache: bool,
 }
 
+// A handler output, stamped with the checkpoint that produced it on the chain
+// whose handler ran it. A cross-chain effect's entries come from several
+// chains, and under per-chain sequences an id only compares against its own
+// chain's committed one.
+type cacheEntry = {
+  output: Internal.effectOutput,
+  chainId: ChainId.t,
+  checkpointId: Internal.checkpointId,
+}
+
 type effectCacheInMemTable = {
   // Cache keys whose handler output is persisted on the next write. Drained
   // each write; eviction is driven by the per-entry checkpointId instead.
   mutable idsToStore: array<string>,
   mutable invalidationsCount: int,
-  // Each entry is stamped with the checkpoint that referenced it (or
-  // loadedFromDbCheckpointId for db reads), so committed entries can be
-  // dropped once persisted/re-derivable, mirroring entity changes.
-  mutable dict: dict<Change.t<Internal.effectOutput>>,
+  // Committed entries are dropped once persisted or re-derivable, mirroring
+  // entity changes; a db read is stamped loadedFromDbCheckpointId.
+  mutable dict: dict<cacheEntry>,
   mutable changesCount: float,
   effect: Internal.effect,
   // The scope this cache is for and its resolved db table (the address). The

package/src/EffectState.resi

@@ -11,10 +11,16 @@ type effectRateLimitState = {
 // toMetrics.
 type effectStats
 
+type cacheEntry = {
+  output: Internal.effectOutput,
+  chainId: ChainId.t,
+  checkpointId: Internal.checkpointId,
+}
+
 type effectCacheInMemTable = {
   mutable idsToStore: array<string>,
   mutable invalidationsCount: int,
-  mutable dict: dict<Change.t<Internal.effectOutput>>,
+  mutable dict: dict<cacheEntry>,
   mutable changesCount: float,
   effect: Internal.effect,
   scope: Internal.chainScope,

package/src/EventProcessing.res

@@ -157,9 +157,9 @@ let preloadBatchOrThrow = async (
 
   for checkpointIdx in 0 to batch.checkpointIds->Array.length - 1 {
     let checkpointId = batch.checkpointIds->Array.getUnsafe(checkpointIdx)
-    let checkpointEventsProcessed = batch.checkpointEventsProcessed->Array.getUnsafe(checkpointIdx)
+    let checkpointItemsCount = batch.checkpointItemsCount->Array.getUnsafe(checkpointIdx)
 
-    for idx in 0 to checkpointEventsProcessed - 1 {
+    for idx in 0 to checkpointItemsCount - 1 {
       let item = batch.items->Array.getUnsafe(itemIdx.contents + idx)
       switch item {
       | Event(_) =>
@@ -233,7 +233,7 @@ let preloadBatchOrThrow = async (
       }
     }
 
-    itemIdx := itemIdx.contents + checkpointEventsProcessed
+    itemIdx := itemIdx.contents + checkpointItemsCount
   }
 
   let _ = await Promise.all(promises)
@@ -251,9 +251,9 @@ let runBatchHandlersOrThrow = async (
 
   for checkpointIdx in 0 to batch.checkpointIds->Array.length - 1 {
     let checkpointId = batch.checkpointIds->Array.getUnsafe(checkpointIdx)
-    let checkpointEventsProcessed = batch.checkpointEventsProcessed->Array.getUnsafe(checkpointIdx)
+    let checkpointItemsCount = batch.checkpointItemsCount->Array.getUnsafe(checkpointIdx)
 
-    for idx in 0 to checkpointEventsProcessed - 1 {
+    for idx in 0 to checkpointItemsCount - 1 {
       let item = batch.items->Array.getUnsafe(itemIdx.contents + idx)
 
       await runHandlerOrThrow(
@@ -266,7 +266,7 @@ let runBatchHandlersOrThrow = async (
         ~chains,
       )
     }
-    itemIdx := itemIdx.contents + checkpointEventsProcessed
+    itemIdx := itemIdx.contents + checkpointItemsCount
   }
 }