envio 3.11.0 → 3.12.0

package/src/IndexerState.res

@@ -58,12 +58,12 @@ type t = {
   mutable entities: EntityTables.t,
   effectState: EffectState.t,
   mutable rollback: option<Persistence.rollback>,
-  // Last checkpoint persisted to the db.
-  mutable committedCheckpointId: Internal.checkpointId,
-  // Processing frontier; runs ahead of committedCheckpointId while writes lag.
-  mutable processedCheckpointId: Internal.checkpointId,
+  // Last checkpoint each chain has persisted to the db.
+  mutable committedFrontier: Frontier.t,
+  // Processing frontier; runs ahead of committedFrontier while writes lag.
+  mutable processedFrontier: Frontier.t,
   // Processed but unwritten. The cycle drains them, splitting each write at a
-  // change in isInReorgThreshold so it never mixes history-saving modes.
+  // change in the history policy so it never mixes history-saving modes.
   mutable processedBatches: array<Batch.t>,
   // Count of processed batches; version-independent progress counter.
   mutable processedBatchesCount: int,
@@ -139,10 +139,9 @@ let make = (
   ~config: Config.t,
   ~persistence: Persistence.t,
   ~chainStates: dict<ChainState.t>,
-  ~isInReorgThreshold: bool,
   ~isRealtime: bool,
   ~targetBufferSize=CrossChainState.calculateTargetBufferSize(),
-  ~committedCheckpointId=Internal.initialCheckpointId,
+  ~committedFrontier=Frontier.empty(),
   ~isDevelopmentMode=false,
   ~shouldUseTui=false,
   ~exitAfterFirstEventBlock=false,
@@ -169,8 +168,8 @@ let make = (
     entities: EntityTables.make(persistence.allEntities->EntityTables.crossChain),
     effectState: EffectState.make(),
     rollback: None,
-    committedCheckpointId,
-    processedCheckpointId: committedCheckpointId,
+    committedFrontier,
+    processedFrontier: committedFrontier->Frontier.copy,
     processedBatches: [],
     processedBatchesCount: 0,
     writeFiber: None,
@@ -181,12 +180,7 @@ let make = (
     chainMetaDirty: false,
     chainMetaThrottler,
     isProcessing: false,
-    crossChainState: CrossChainState.make(
-      ~chainStates,
-      ~isInReorgThreshold,
-      ~isRealtime,
-      ~targetBufferSize,
-    ),
+    crossChainState: CrossChainState.make(~chainStates, ~isRealtime, ~targetBufferSize),
     indexerStartTime: Date.make(),
     indexerStartTimeRef: Performance.now(),
     rollbackState: NoRollback,
@@ -278,10 +272,9 @@ let makeFromDbState = (
     ~config,
     ~persistence,
     ~chainStates,
-    ~isInReorgThreshold,
     ~isRealtime,
     ~targetBufferSize,
-    ~committedCheckpointId=initialState.checkpointId,
+    ~committedFrontier=initialState.checkpointFrontier,
     ~isDevelopmentMode,
     ~shouldUseTui,
     ~exitAfterFirstEventBlock,
@@ -357,19 +350,15 @@ let getChainState = (state: t, ~chainId: ChainId.t): ChainState.t =>
 
 let getSafeCheckpointIdByChain = (state: t) =>
   state.crossChainState->CrossChainState.getSafeCheckpointIdByChain(
-    ~committedCheckpointId=state.committedCheckpointId,
+    ~sequence=state.config.checkpointSequence,
+    ~committedFrontier=state.committedFrontier,
   )
 
-let createBatch = (
-  state: t,
-  ~processedCheckpointId,
-  ~batchSizeTarget: int,
-  ~isRollback: bool,
-): Batch.t =>
+let createBatch = (state: t, ~batchSizeTarget: int): Batch.t =>
   state.crossChainState->CrossChainState.createBatch(
-    ~processedCheckpointId,
+    ~config=state.config,
+    ~frontier=state.processedFrontier,
     ~batchSizeTarget,
-    ~isRollback,
   )
 
 let enterReorgThreshold = (state: t) => state.crossChainState->CrossChainState.enterReorgThreshold
@@ -483,8 +472,13 @@ let eachEntityTable = (
   )
 }
 let effectState = (state: t) => state.effectState
-let committedCheckpointId = (state: t) => state.committedCheckpointId
-let processedCheckpointId = (state: t) => state.processedCheckpointId
+let committedFrontier = (state: t) => state.committedFrontier
+let processedFrontier = (state: t) => state.processedFrontier
+
+// The committed id a scope's in-memory rows compare against.
+let committedCheckpointIdFor = (state: t, ~scope) =>
+  state.config.checkpointSequence->CheckpointSequence.forScope(state.committedFrontier, ~scope)
+
 let processedBatches = (state: t) => state.processedBatches
 let processedBatchesCount = (state: t) => state.processedBatchesCount
 let writeFiber = (state: t) => state.writeFiber
@@ -495,11 +489,13 @@ let chainMetaThrottler = (state: t) => state.chainMetaThrottler
 let crossChainState = (state: t) => state.crossChainState
 let chainStates = (state: t) => state.crossChainState->CrossChainState.chainStates
 let isInReorgThreshold = (state: t) => state.crossChainState->CrossChainState.isInReorgThreshold
+let shouldSaveHistory = (state: t) => state.crossChainState->CrossChainState.shouldSaveHistory
 let isRealtime = (state: t) => state.crossChainState->CrossChainState.isRealtime
 
 // The indexer runs Backfilling → FinalizingIndexes → Ready. This is true only
-// in the middle phase: every chain has caught up, but the deferred schema
-// indexes and `ready_at` haven't been committed yet.
+// in the middle phase: the chains this process drives have caught up, but the
+// indexes the schema promises them and their `ready_at` haven't been committed
+// yet.
 let isFinalizingIndexes = (state: t) =>
   state.crossChainState->CrossChainState.isCaughtUp &&
     !(state.crossChainState->CrossChainState.isRealtime)
@@ -538,6 +534,8 @@ let toMetrics = (state: t): Metrics.t => {
         method: s.method,
         count: s.count,
         seconds: s.seconds,
+        responseBlocks: s.responseBlocks,
+        emptyResponseCount: s.emptyResponseCount,
       })
     )
     sourceManager
@@ -758,18 +756,18 @@ let recordRollbackSuccess = (state: t, ~timeSeconds, ~rollbackedProcessedEvents)
 // Queue a processed batch for writing and advance the processing frontier.
 let queueProcessedBatch = (state: t, ~batch: Batch.t) => {
   state.processedBatches->Array.push(batch)->ignore
-  switch batch.checkpointIds->Utils.Array.last {
-  | Some(checkpointId) => state.processedCheckpointId = checkpointId
-  | None => ()
-  }
+  state.processedFrontier = Frontier.mergeMax(
+    state.processedFrontier,
+    batch->Batch.checkpointFrontier,
+  )
 }
 
-// Take the leading run of queued batches sharing isInReorgThreshold as one merged
+// Take the leading run of queued batches sharing a history policy as one merged
 // batch, leaving the rest queued for the next write. Caller guarantees the queue
 // is non-empty.
 let drainBatchRun = (state: t): Batch.t => {
   let all = state.processedBatches
-  let isInReorgThreshold = (all->Array.getUnsafe(0)).isInReorgThreshold
+  let history = (all->Array.getUnsafe(0)).history
 
   let rest = []
   let progressedChainsById = Dict.make()
@@ -779,11 +777,12 @@ let drainBatchRun = (state: t): Batch.t => {
   let checkpointChainIds = []
   let checkpointBlockNumbers = []
   let checkpointBlockHashes = []
+  let checkpointItemsCount = []
   let checkpointEventsProcessed = []
   let registeredAddresses = []
   all->Array.forEach(batch => {
     // Once one batch lands in rest, all later ones follow it, preserving order.
-    if rest->Utils.Array.isEmpty && batch.isInReorgThreshold == isInReorgThreshold {
+    if rest->Utils.Array.isEmpty && batch.history == history {
       batch.progressedChainsById->Utils.Dict.forEachWithKey((chainAfterBatch, key) =>
         progressedChainsById->Dict.set(key, chainAfterBatch)
       )
@@ -793,6 +792,7 @@ let drainBatchRun = (state: t): Batch.t => {
       checkpointChainIds->Array.pushMany(batch.checkpointChainIds)
       checkpointBlockNumbers->Array.pushMany(batch.checkpointBlockNumbers)
       checkpointBlockHashes->Array.pushMany(batch.checkpointBlockHashes)
+      checkpointItemsCount->Array.pushMany(batch.checkpointItemsCount)
       checkpointEventsProcessed->Array.pushMany(batch.checkpointEventsProcessed)
       registeredAddresses->Array.pushMany(batch.registeredAddresses)
     } else {
@@ -805,11 +805,12 @@ let drainBatchRun = (state: t): Batch.t => {
     totalBatchSize: totalBatchSize.contents,
     items,
     progressedChainsById,
-    isInReorgThreshold,
+    history,
     checkpointIds,
     checkpointChainIds,
     checkpointBlockNumbers,
     checkpointBlockHashes,
+    checkpointItemsCount,
     checkpointEventsProcessed,
     registeredAddresses,
   }
@@ -829,18 +830,30 @@ let takeRollback = (state: t): option<Persistence.rollback> => {
 // committed. A failed write keeps them, and re-inserting a row the database
 // already has is a no-op. Rows staged while the write was in flight belong to
 // later checkpoints — ids only ever grow — so this can't drop one unwritten.
-let markCommitted = (state: t, ~upToCheckpointId) => {
-  state.committedCheckpointId = upToCheckpointId
+let markCommitted = (state: t, ~writtenFrontier) => {
+  state.committedFrontier = Frontier.mergeMax(state.committedFrontier, writtenFrontier)
 }
 
-// Reset the in-memory tables and arm the rollback diff that the next write commits.
+// Reset the in-memory tables and arm the rollback diff that the next write
+// commits. The diff ids start from the committed frontier — a rollback that
+// supersedes an unwritten one takes over its ids along with its rows. A sibling
+// the rollback leaves alone gets no diff row: burning an id on it would leave a
+// hole in its sequence.
 let beginRollbackDiff = (
   state: t,
-  ~diffCheckpointId,
-  ~floors,
+  ~floors: RollbackFloors.t,
   ~progressedChains: array<InternalTable.Chains.progressedChain>,
   ~rolledBackAddresses,
-) => {
+): Frontier.t => {
+  let diffFrontier = {
+    let cursor =
+      state.config.checkpointSequence->CheckpointSequence.cursor(~frontier=state.committedFrontier)
+    floors.checkpointBounds.byChain
+    ->Frontier.chainIds
+    ->Array.map(chainId => (chainId, cursor->CheckpointSequence.next(~chainId)))
+    ->Frontier.fromEntries
+  }
+  state.processedFrontier = Frontier.mergeMax(state.processedFrontier, diffFrontier)
   let perChainEntities = state.allEntities->EntityTables.perChain
   state.entities = EntityTables.make(state.allEntities->EntityTables.crossChain)
   state->chainStates->Utils.Dict.forEach(cs => cs->ChainState.resetEntities(~perChainEntities))
@@ -867,11 +880,19 @@ let beginRollbackDiff = (
   | None => progressedChains
   }
   state.rollback = Some({
-    diffCheckpointId,
+    diffFrontier,
+    diffCheckpoints: diffFrontier
+    ->Frontier.entries
+    ->Array.map(((chainId, checkpointId)): InternalTable.Checkpoints.diffCheckpoint => {
+      chainId,
+      checkpointId,
+      blockNumber: state->getChainState(~chainId)->ChainState.committedProgressBlockNumber,
+    }),
     floors,
     progressedChains,
     rolledBackAddresses,
   })
+  diffFrontier
 }
 
 // Stop the write loop and surface the failure; the error itself goes to onError.

package/src/IndexerState.res.mjs

@@ -1,12 +1,13 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Env from "./Env.res.mjs";
+import * as Batch from "./Batch.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as ChainId from "./ChainId.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
-import * as Internal from "./Internal.res.mjs";
+import * as Frontier from "./db/Frontier.res.mjs";
 import * as Throttler from "./Throttler.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
 import * as EffectState from "./EffectState.res.mjs";
@@ -20,11 +21,12 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as CrossChainState from "./CrossChainState.res.mjs";
 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 CheckpointSequence from "./db/CheckpointSequence.res.mjs";
 import * as SimulateDeadInputTracker from "./SimulateDeadInputTracker.res.mjs";
 
-function make(config, persistence, chainStates, isInReorgThreshold, isRealtime, targetBufferSizeOpt, committedCheckpointIdOpt, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, onError, onExit) {
+function make(config, persistence, chainStates, isRealtime, targetBufferSizeOpt, committedFrontierOpt, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, onError, onExit) {
   let targetBufferSize = targetBufferSizeOpt !== undefined ? targetBufferSizeOpt : CrossChainState.calculateTargetBufferSize();
-  let committedCheckpointId = committedCheckpointIdOpt !== undefined ? committedCheckpointIdOpt : Internal.initialCheckpointId;
+  let committedFrontier = committedFrontierOpt !== undefined ? committedFrontierOpt : Frontier.empty();
   let isDevelopmentMode = isDevelopmentModeOpt !== undefined ? isDevelopmentModeOpt : false;
   let shouldUseTui = shouldUseTuiOpt !== undefined ? shouldUseTuiOpt : false;
   let exitAfterFirstEventBlock = exitAfterFirstEventBlockOpt !== undefined ? exitAfterFirstEventBlockOpt : false;
@@ -40,8 +42,8 @@ function make(config, persistence, chainStates, isInReorgThreshold, isRealtime,
     entities: EntityTables.make(EntityTables.crossChain(persistence.allEntities)),
     effectState: EffectState.make(),
     rollback: undefined,
-    committedCheckpointId: committedCheckpointId,
-    processedCheckpointId: committedCheckpointId,
+    committedFrontier: committedFrontier,
+    processedFrontier: Frontier.copy(committedFrontier),
     processedBatches: [],
     processedBatchesCount: 0,
     writeFiber: undefined,
@@ -52,7 +54,7 @@ function make(config, persistence, chainStates, isInReorgThreshold, isRealtime,
     chainMetaDirty: false,
     chainMetaThrottler: chainMetaThrottler,
     isProcessing: false,
-    crossChainState: CrossChainState.make(chainStates, isInReorgThreshold, isRealtime, targetBufferSize),
+    crossChainState: CrossChainState.make(chainStates, isRealtime, targetBufferSize),
     rollbackState: "NoRollback",
     indexerStartTime: new Date(),
     indexerStartTimeRef: Performance.now(),
@@ -102,7 +104,7 @@ function makeFromDbState(config, persistence, initialState, registrationsByChain
     let chainConfig = ChainMap.get(config.chainMap, chainId);
     chainStates[resumedChainState.id] = ChainState.makeFromDbState(chainConfig, resumedChainState, initialState.reorgCheckpoints, isInReorgThreshold, isRealtime, config, initialState.contractMapping, registrationsByChainId, reducedPollingInterval);
   });
-  let state = make(config, persistence, chainStates, isInReorgThreshold, isRealtime, targetBufferSize, initialState.checkpointId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, onError, onExit);
+  let state = make(config, persistence, chainStates, isRealtime, targetBufferSize, initialState.checkpointFrontier, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, onError, onExit);
   CrossChainState.markCaughtUpOnResume(state.crossChainState);
   Utils.Dict.forEach(initialState.cache, param => {
     let count = param.count;
@@ -160,11 +162,11 @@ function getChainState(state, chainId) {
 }
 
 function getSafeCheckpointIdByChain(state) {
-  return CrossChainState.getSafeCheckpointIdByChain(state.crossChainState, state.committedCheckpointId);
+  return CrossChainState.getSafeCheckpointIdByChain(state.crossChainState, state.config.checkpointSequence, state.committedFrontier);
 }
 
-function createBatch(state, processedCheckpointId, batchSizeTarget, isRollback) {
-  return CrossChainState.createBatch(state.crossChainState, processedCheckpointId, batchSizeTarget, isRollback);
+function createBatch(state, batchSizeTarget) {
+  return CrossChainState.createBatch(state.crossChainState, state.config, state.processedFrontier, batchSizeTarget);
 }
 
 function enterReorgThreshold(state) {
@@ -280,12 +282,16 @@ function effectState(state) {
   return state.effectState;
 }
 
-function committedCheckpointId(state) {
-  return state.committedCheckpointId;
+function committedFrontier(state) {
+  return state.committedFrontier;
 }
 
-function processedCheckpointId(state) {
-  return state.processedCheckpointId;
+function processedFrontier(state) {
+  return state.processedFrontier;
+}
+
+function committedCheckpointIdFor(state, scope) {
+  return CheckpointSequence.forScope(state.config.checkpointSequence, state.committedFrontier, scope);
 }
 
 function processedBatches(state) {
@@ -328,6 +334,10 @@ function isInReorgThreshold(state) {
   return CrossChainState.isInReorgThreshold(state.crossChainState);
 }
 
+function shouldSaveHistory(state) {
+  return CrossChainState.shouldSaveHistory(state.crossChainState);
+}
+
 function isRealtime(state) {
   return CrossChainState.isRealtime(state.crossChainState);
 }
@@ -401,7 +411,9 @@ function toMetrics(state) {
         chainId: s.chainId,
         method: s.method,
         count: s.count,
-        seconds: s.seconds
+        seconds: s.seconds,
+        responseBlocks: s.responseBlocks,
+        emptyResponseCount: s.emptyResponseCount
       });
     });
     SourceManager.getSourceHeightSamples(sourceManager).forEach(s => {
@@ -614,16 +626,12 @@ function recordRollbackSuccess(state, timeSeconds, rollbackedProcessedEvents) {
 
 function queueProcessedBatch(state, batch) {
   state.processedBatches.push(batch);
-  let checkpointId = Utils.$$Array.last(batch.checkpointIds);
-  if (checkpointId !== undefined) {
-    state.processedCheckpointId = checkpointId;
-    return;
-  }
+  state.processedFrontier = Frontier.mergeMax(state.processedFrontier, Batch.checkpointFrontier(batch));
 }
 
 function drainBatchRun(state) {
   let all = state.processedBatches;
-  let isInReorgThreshold = all[0].isInReorgThreshold;
+  let history = all[0].history;
   let rest = [];
   let progressedChainsById = {};
   let totalBatchSize = {
@@ -634,10 +642,11 @@ function drainBatchRun(state) {
   let checkpointChainIds = [];
   let checkpointBlockNumbers = [];
   let checkpointBlockHashes = [];
+  let checkpointItemsCount = [];
   let checkpointEventsProcessed = [];
   let registeredAddresses = [];
   all.forEach(batch => {
-    if (Utils.$$Array.isEmpty(rest) && batch.isInReorgThreshold === isInReorgThreshold) {
+    if (Utils.$$Array.isEmpty(rest) && Primitive_object.equal(batch.history, history)) {
       Utils.Dict.forEachWithKey(batch.progressedChainsById, (chainAfterBatch, key) => {
         progressedChainsById[key] = chainAfterBatch;
       });
@@ -647,6 +656,7 @@ function drainBatchRun(state) {
       checkpointChainIds.push(...batch.checkpointChainIds);
       checkpointBlockNumbers.push(...batch.checkpointBlockNumbers);
       checkpointBlockHashes.push(...batch.checkpointBlockHashes);
+      checkpointItemsCount.push(...batch.checkpointItemsCount);
       checkpointEventsProcessed.push(...batch.checkpointEventsProcessed);
       registeredAddresses.push(...batch.registeredAddresses);
     } else {
@@ -658,11 +668,12 @@ function drainBatchRun(state) {
     totalBatchSize: totalBatchSize.contents,
     items: items,
     progressedChainsById: progressedChainsById,
-    isInReorgThreshold: isInReorgThreshold,
+    history: history,
     checkpointIds: checkpointIds,
     checkpointChainIds: checkpointChainIds,
     checkpointBlockNumbers: checkpointBlockNumbers,
     checkpointBlockHashes: checkpointBlockHashes,
+    checkpointItemsCount: checkpointItemsCount,
     checkpointEventsProcessed: checkpointEventsProcessed,
     registeredAddresses: registeredAddresses
   };
@@ -678,11 +689,17 @@ function takeRollback(state) {
   return rollback;
 }
 
-function markCommitted(state, upToCheckpointId) {
-  state.committedCheckpointId = upToCheckpointId;
+function markCommitted(state, writtenFrontier) {
+  state.committedFrontier = Frontier.mergeMax(state.committedFrontier, writtenFrontier);
 }
 
-function beginRollbackDiff(state, diffCheckpointId, floors, progressedChains, rolledBackAddresses) {
+function beginRollbackDiff(state, floors, progressedChains, rolledBackAddresses) {
+  let cursor = CheckpointSequence.cursor(state.config.checkpointSequence, state.committedFrontier);
+  let diffFrontier = Frontier.fromEntries(Frontier.chainIds(floors.checkpointBounds.byChain).map(chainId => [
+    chainId,
+    CheckpointSequence.next(cursor, chainId)
+  ]));
+  state.processedFrontier = Frontier.mergeMax(state.processedFrontier, diffFrontier);
   let perChainEntities = EntityTables.perChain(state.allEntities);
   state.entities = EntityTables.make(EntityTables.crossChain(state.allEntities));
   Utils.Dict.forEach(CrossChainState.chainStates(state.crossChainState), cs => ChainState.resetEntities(cs, perChainEntities));
@@ -704,11 +721,20 @@ function beginRollbackDiff(state, diffCheckpointId, floors, progressedChains, ro
     progressedChains$1 = progressedChains;
   }
   state.rollback = {
-    diffCheckpointId: diffCheckpointId,
+    diffFrontier: diffFrontier,
+    diffCheckpoints: Frontier.entries(diffFrontier).map(param => {
+      let chainId = param[0];
+      return {
+        chainId: chainId,
+        checkpointId: param[1],
+        blockNumber: ChainState.committedProgressBlockNumber(getChainState(state, chainId))
+      };
+    }),
     floors: floors,
     rolledBackAddresses: rolledBackAddresses$1,
     progressedChains: progressedChains$1
   };
+  return diffFrontier;
 }
 
 function recordWriteFailure(state, exn) {
@@ -801,8 +827,9 @@ export {
   entities,
   eachEntityTable,
   effectState,
-  committedCheckpointId,
-  processedCheckpointId,
+  committedFrontier,
+  processedFrontier,
+  committedCheckpointIdFor,
   processedBatches,
   processedBatchesCount,
   writeFiber,
@@ -813,6 +840,7 @@ export {
   crossChainState,
   chainStates,
   isInReorgThreshold,
+  shouldSaveHistory,
   isRealtime,
   isFinalizingIndexes,
   markCaughtUpIfSettled,

package/src/IndexerState.resi

@@ -14,10 +14,9 @@ let make: (
   ~config: Config.t,
   ~persistence: Persistence.t,
   ~chainStates: dict<ChainState.t>,
-  ~isInReorgThreshold: bool,
   ~isRealtime: bool,
   ~targetBufferSize: int=?,
-  ~committedCheckpointId: Internal.checkpointId=?,
+  ~committedFrontier: Frontier.t=?,
   ~isDevelopmentMode: bool=?,
   ~shouldUseTui: bool=?,
   ~exitAfterFirstEventBlock: bool=?,
@@ -60,12 +59,7 @@ let beginProcessing: t => unit
 let endProcessing: t => unit
 let markProcessingStalledOnFetch: t => unit
 let recordProcessedBatch: t => unit
-let createBatch: (
-  t,
-  ~processedCheckpointId: Internal.checkpointId,
-  ~batchSizeTarget: int,
-  ~isRollback: bool,
-) => Batch.t
+let createBatch: (t, ~batchSizeTarget: int) => Batch.t
 let getSafeCheckpointIdByChain: t => array<(ChainId.t, option<Internal.checkpointId>)>
 
 // Accessors.
@@ -82,8 +76,9 @@ let eachEntityTable: (
   ) => unit,
 ) => unit
 let effectState: t => EffectState.t
-let committedCheckpointId: t => Internal.checkpointId
-let processedCheckpointId: t => Internal.checkpointId
+let committedFrontier: t => Frontier.t
+let processedFrontier: t => Frontier.t
+let committedCheckpointIdFor: (t, ~scope: Internal.chainScope) => Internal.checkpointId
 let processedBatches: t => array<Batch.t>
 let processedBatchesCount: t => int
 let writeFiber: t => option<promise<unit>>
@@ -94,6 +89,7 @@ let chainMetaThrottler: t => Throttler.t
 let crossChainState: t => CrossChainState.t
 let chainStates: t => dict<ChainState.t>
 let isInReorgThreshold: t => bool
+let shouldSaveHistory: t => dict<bool>
 let isRealtime: t => bool
 let isFinalizingIndexes: t => bool
 let markCaughtUpIfSettled: t => unit
@@ -137,14 +133,13 @@ let queueProcessedBatch: (t, ~batch: Batch.t) => unit
 let drainBatchRun: t => Batch.t
 let pendingRollback: t => option<Persistence.rollback>
 let takeRollback: t => option<Persistence.rollback>
-let markCommitted: (t, ~upToCheckpointId: Internal.checkpointId) => unit
+let markCommitted: (t, ~writtenFrontier: Frontier.t) => unit
 let beginRollbackDiff: (
   t,
-  ~diffCheckpointId: Internal.checkpointId,
   ~floors: RollbackFloors.t,
   ~progressedChains: array<InternalTable.Chains.progressedChain>,
   ~rolledBackAddresses: array<AddressRows.key>,
-) => unit
+) => Frontier.t
 let recordWriteFailure: (t, exn) => unit
 let beginWriteFiber: (t, promise<unit>) => unit
 let endWriteFiber: t => unit

package/src/Internal.res

@@ -854,8 +854,10 @@ type effectArgs = {
   input: effectInput,
   context: effectContext,
   cacheKey: string,
-  // The processing checkpoint that referenced this effect; stamped on the
-  // in-memory cache entry so it's evicted once the checkpoint commits.
+  // The processing checkpoint that referenced this effect, on the chain whose
+  // handler ran it; stamped on the in-memory cache entry so it's evicted once
+  // that chain commits the checkpoint.
+  chainId: ChainId.t,
   checkpointId: bigint,
 }
 type effectCacheItem = {id: string, output: effectOutput}

package/src/LoadLayer.res

@@ -69,9 +69,10 @@ let loadById = (
       let entity = dbEntities->Array.getUnsafe(idx)
       entitiesMap->Dict.set(entity.id, entity)
     }
+    let committedCheckpointId = indexerState->IndexerState.committedCheckpointIdFor(~scope)
     idsToLoad->Array.forEach(entityId => {
       inMemTable->InMemoryTable.Entity.initValue(
-        ~committedCheckpointId=indexerState->IndexerState.committedCheckpointId,
+        ~committedCheckpointId,
         ~key=entityId,
         ~entity=entitiesMap->Utils.Dict.dangerouslyGetNonOption(entityId),
       )
@@ -109,6 +110,7 @@ let callEffect = (
   effect.handler(arg)
   ->Promise.thenResolve(output => {
     inMemTable->InMemoryStore.setEffectOutput(
+      ~chainId=arg.chainId,
       ~checkpointId=arg.checkpointId,
       ~cacheKey=arg.cacheKey,
       ~output,
@@ -294,7 +296,11 @@ let loadEffect = (
         try {
           let output = dbEntity.output->S.parseOrThrow(outputSchema)
           idsFromCache->Utils.Set.add(dbEntity.id)->ignore
-          inMemTable->InMemoryStore.initEffectOutputFromDb(~cacheKey=dbEntity.id, ~output)
+          inMemTable->InMemoryStore.initEffectOutputFromDb(
+            ~chainId=item->Internal.getItemChainId,
+            ~cacheKey=dbEntity.id,
+            ~output,
+          )
         } catch {
         | S.Raised(error) =>
           inMemTable->EffectState.recordInvalidation
@@ -379,7 +385,7 @@ let loadByFilter = (
     // Inside the load timing: waiting on the build is time the handler spends
     // waiting for this operation, and it's the only thing that explains an
     // occasional very slow getWhere.
-    await storage.ensureQueryIndexes(~table=entityConfig.table, ~filters)
+    await storage.ensureQueryIndexes(~entityConfig, ~scope, ~filters)
 
     // Loading a superset of rows via a merged query is safe: every loaded
     // entity is matched against all registered indexes, not only the
@@ -397,9 +403,10 @@ let loadByFilter = (
             )
           )->(Utils.magic: array<unknown> => array<Internal.entity>)
 
+        let committedCheckpointId = indexerState->IndexerState.committedCheckpointIdFor(~scope)
         entities->Array.forEach(entity => {
           inMemTable->InMemoryTable.Entity.initValue(
-            ~committedCheckpointId=indexerState->IndexerState.committedCheckpointId,
+            ~committedCheckpointId,
             ~key=entity.id,
             ~entity=Some(entity),
           )

package/src/LoadLayer.res.mjs

@@ -4,6 +4,7 @@ import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as ChainId from "./ChainId.res.mjs";
 import * as Logging from "./Logging.res.mjs";
+import * as Internal from "./Internal.res.mjs";
 import * as Ecosystem from "./Ecosystem.res.mjs";
 import * as EffectState from "./EffectState.res.mjs";
 import * as LoadManager from "./LoadManager.res.mjs";
@@ -71,7 +72,8 @@ function loadById(loadManager, persistence, entityConfig, scope, indexerState, s
       let entity = dbEntities[idx];
       entitiesMap[entity.id] = entity;
     }
-    idsToLoad.forEach(entityId => InMemoryTable.Entity.initValue(inMemTable, IndexerState.committedCheckpointId(indexerState), entityId, entitiesMap[entityId]));
+    let committedCheckpointId = IndexerState.committedCheckpointIdFor(indexerState, scope);
+    idsToLoad.forEach(entityId => InMemoryTable.Entity.initValue(inMemTable, committedCheckpointId, entityId, entitiesMap[entityId]));
     return IndexerState.endStorageLoad(indexerState, timerRef, storage.name, key, idsToLoad.length, dbEntities.length);
   };
   return LoadManager.call(loadManager, entityId, key, load, LoadManager.noopHasher, shouldGroup, hash => hash in inMemTable.latestEntityChangeById, InMemoryTable.Entity.getUnsafe(inMemTable));
@@ -79,7 +81,7 @@ function loadById(loadManager, persistence, entityConfig, scope, indexerState, s
 
 function callEffect(effect, arg, inMemTable, timerRef, onError) {
   EffectState.startCall(inMemTable.stats, timerRef);
-  return effect.handler(arg).then(output => InMemoryStore.setEffectOutput(inMemTable, arg.checkpointId, arg.cacheKey, output, arg.context.cache)).catch(exn => onError(arg.cacheKey, exn)).finally(() => EffectState.endCall(inMemTable.stats, timerRef));
+  return effect.handler(arg).then(output => InMemoryStore.setEffectOutput(inMemTable, arg.chainId, arg.checkpointId, arg.cacheKey, output, arg.context.cache)).catch(exn => onError(arg.cacheKey, exn)).finally(() => EffectState.endCall(inMemTable.stats, timerRef));
 }
 
 function executeWithRateLimit(effect, effectArgs, inMemTable, onError, isFromQueue) {
@@ -173,7 +175,7 @@ function loadEffect(loadManager, persistence, effect, effectArgs, scope, indexer
         try {
           let output = S$RescriptSchema.parseOrThrow(dbEntity.output, outputSchema);
           idsFromCache.add(dbEntity.id);
-          return InMemoryStore.initEffectOutputFromDb(inMemTable, dbEntity.id, output);
+          return InMemoryStore.initEffectOutputFromDb(inMemTable, Internal.getItemChainId(item), dbEntity.id, output);
         } catch (raw_error) {
           let error = Primitive_exceptions.internalToException(raw_error);
           if (error.RE_EXN_ID === S$RescriptSchema.Raised) {
@@ -218,12 +220,13 @@ function loadByFilter(loadManager, persistence, entityConfig, scope, indexerStat
       contents: 0
     };
     filters.forEach(filter => InMemoryTable.Entity.addEmptyIndex(inMemTable, filter));
-    await storage.ensureQueryIndexes(entityConfig.table, filters);
+    await storage.ensureQueryIndexes(entityConfig, scope, filters);
     let queries = EntityFilter.merge(filters);
     await Promise.all(queries.map(async filter => {
       try {
         let entities = await storage.loadOrThrow(scopeFilter(filter, entityConfig.table, scope), entityConfig.table);
-        entities.forEach(entity => InMemoryTable.Entity.initValue(inMemTable, IndexerState.committedCheckpointId(indexerState), entity.id, entity));
+        let committedCheckpointId = IndexerState.committedCheckpointIdFor(indexerState, scope);
+        entities.forEach(entity => InMemoryTable.Entity.initValue(inMemTable, committedCheckpointId, entity.id, entity));
         size.contents = size.contents + entities.length | 0;
         return;
       } catch (raw_exn) {