envio 3.9.0 → 3.10.0-subgraph

package/src/PruneStaleHistory.res

@@ -12,11 +12,43 @@ let maxEntitiesPerWrite = 5
 let forcedIntervalMultiplier = 5.
 
 type targets = {
-  safeCheckpointId: Internal.checkpointId,
+  safeCheckpoints: CheckpointBounds.t,
   concurrent: array<Internal.entityConfig>,
   forced: array<Internal.entityConfig>,
 }
 
+// Where each chain's history may be pruned back to, or None while nowhere can.
+//
+// A rollback only ever deletes a chain's rows down to that chain's own floor,
+// which is set by its own reorg and so never reaches below its own safe
+// checkpoint. Each chain can therefore prune to its own, and a chain with
+// nothing safe yet holds only itself back.
+//
+// Unless the schema has a cross-chain entity: a reorg on any chain then rolls
+// every chain back to one checkpoint, which can sit below another chain's safe
+// point, so the lowest is the only bound every chain agrees on.
+let selectSafeCheckpoints = (state: IndexerState.t) => {
+  let byChain = state->IndexerState.getSafeCheckpointIdByChain
+  let safe =
+    byChain->Array.filterMap(((chainId, checkpointId)) =>
+      checkpointId->Option.map(checkpointId => (chainId, checkpointId))
+    )
+  if state->IndexerState.config->Config.isIsolatedMultichain {
+    safe->Utils.Array.notEmpty ? Some(CheckpointBounds.PerChain(safe)) : None
+  } else if safe->Array.length === byChain->Array.length {
+    let (_, lowest) = safe->Array.getUnsafe(0)
+    Some(
+      CheckpointBounds.EveryChain(
+        safe->Array.reduce(lowest, (lowest, (_, checkpointId)) =>
+          Pervasives.min(lowest, checkpointId)
+        ),
+      ),
+    )
+  } else {
+    None
+  }
+}
+
 let selectFrom = (
   ~allEntities: array<Internal.entityConfig>,
   ~lastPrunedAtMillis: dict<float>,
@@ -24,7 +56,7 @@ let selectFrom = (
   ~isRollback,
   ~nowMillis,
   ~intervalMillis,
-  ~safeCheckpointId,
+  ~safeCheckpoints,
 ) => {
   let byOldestPrune = ((a, _), (b, _)) => a -. b
   let toEntities = candidates => candidates->Array.map(((_, entityConfig)) => entityConfig)
@@ -60,7 +92,7 @@ let selectFrom = (
   }
 
   {
-    safeCheckpointId,
+    safeCheckpoints,
     concurrent: sortedConcurrent->Array.slice(~start=0, ~end=maxEntitiesPerWrite)->toEntities,
     forced: forcedCandidates
     ->Array.toSorted(byOldestPrune)
@@ -72,62 +104,63 @@ let selectFrom = (
 let select = (state: IndexerState.t, ~writtenEntityNames, ~isRollback) => {
   let config = state->IndexerState.config
   if config->Config.shouldPruneHistory(~isInReorgThreshold=state->IndexerState.isInReorgThreshold) {
-    switch state->IndexerState.getSafeCheckpointId {
-    | None => None
-    | Some(safeCheckpointId) =>
-      Some(
-        selectFrom(
-          ~allEntities=(state->IndexerState.persistence).allEntities,
-          ~lastPrunedAtMillis=state->IndexerState.lastPrunedAtMillis,
-          ~writtenEntityNames,
-          ~isRollback,
-          ~nowMillis=Date.now(),
-          ~intervalMillis=Env.ThrottleWrites.pruneStaleDataIntervalMillis->Int.toFloat,
-          ~safeCheckpointId,
-        ),
+    state
+    ->selectSafeCheckpoints
+    ->Option.map(safeCheckpoints =>
+      selectFrom(
+        ~allEntities=(state->IndexerState.persistence).allEntities,
+        ~lastPrunedAtMillis=state->IndexerState.lastPrunedAtMillis,
+        ~writtenEntityNames,
+        ~isRollback,
+        ~nowMillis=Date.now(),
+        ~intervalMillis=Env.ThrottleWrites.pruneStaleDataIntervalMillis->Int.toFloat,
+        ~safeCheckpoints,
       )
-    }
+    )
   } else {
     None
   }
 }
 
-let pruneEntities = async (state: IndexerState.t, ~entities, ~safeCheckpointId) => {
+let pruneEntity = async (
+  state: IndexerState.t,
+  ~entityConfig: Internal.entityConfig,
+  ~safeCheckpoints,
+) => {
   let persistence = state->IndexerState.persistence
-  for idx in 0 to entities->Array.length - 1 {
-    let entityConfig: Internal.entityConfig = entities->Array.getUnsafe(idx)
-    let timeRef = Performance.now()
-    // Recorded for failures too, so a failing prune retries on the same
-    // interval instead of on every write.
-    state->IndexerState.lastPrunedAtMillis->Dict.set(entityConfig.name, Date.now())
-    switch await persistence.storage.pruneStaleEntityHistory(
+  let timeRef = Performance.now()
+  // Recorded for failures too, so a failing prune retries on the same
+  // interval instead of on every write.
+  state->IndexerState.lastPrunedAtMillis->Dict.set(entityConfig.name, Date.now())
+  switch await persistence.storage.pruneStaleEntityHistory(
+    ~entityName=entityConfig.name,
+    ~entityIndex=entityConfig.index,
+    ~chainIdColumn=entityConfig.table->Table.getPgChainIdColumn,
+    ~safeCheckpoints,
+  ) {
+  | () =>
+    state->IndexerState.recordHistoryPrune(
+      ~timeSeconds=Performance.secondsSince(timeRef),
       ~entityName=entityConfig.name,
-      ~entityIndex=entityConfig.index,
-      ~chainIdColumn=entityConfig.table->Table.getChainIdField->Option.map(Table.getPgDbFieldName),
-      ~safeCheckpointId,
-    ) {
-    | () =>
-      state->IndexerState.recordHistoryPrune(
-        ~timeSeconds=Performance.secondsSince(timeRef),
-        ~entityName=entityConfig.name,
-      )
-    | exception exn =>
-      // Pruning is cleanup; a failure must not fail the write loop.
-      Logging.createChild(
-        ~params={
-          "entityName": entityConfig.name,
-          "safeCheckpointId": safeCheckpointId,
-        },
-      )->Logging.childErrorWithExn(exn->Utils.prettifyExn, `Failed to prune stale entity history`)
-    }
+    )
+  | exception exn =>
+    // Pruning is cleanup; a failure must not fail the write loop.
+    Logging.createChild(
+      ~params={"entityName": entityConfig.name, "safeCheckpoints": safeCheckpoints},
+    )->Logging.childErrorWithExn(exn->Utils.prettifyExn, `Failed to prune stale entity history`)
   }
 }
 
-let pruneCheckpoints = async (state: IndexerState.t, ~safeCheckpointId) => {
-  switch await (state->IndexerState.persistence).storage.pruneStaleCheckpoints(~safeCheckpointId) {
+let pruneEntities = (state: IndexerState.t, ~entities, ~safeCheckpoints) =>
+  entities->Utils.Array.awaitEach(entityConfig =>
+    state->pruneEntity(~entityConfig, ~safeCheckpoints)
+  )
+
+let pruneCheckpoints = async (state: IndexerState.t, ~safeCheckpoints) => {
+  switch await (state->IndexerState.persistence).storage.pruneStaleCheckpoints(~safeCheckpoints) {
   | () => ()
   | exception exn =>
-    Logging.createChild(~params={"safeCheckpointId": safeCheckpointId})->Logging.childErrorWithExn(
+    Logging.createChild(~params={"safeCheckpoints": safeCheckpoints})->Logging.childErrorWithExn(
       exn->Utils.prettifyExn,
       `Failed to prune stale checkpoints`,
     )
@@ -136,22 +169,22 @@ let pruneCheckpoints = async (state: IndexerState.t, ~safeCheckpointId) => {
 
 let runConcurrent = async (state: IndexerState.t, ~targets) => {
   switch targets {
-  | Some({safeCheckpointId, concurrent}) if concurrent->Utils.Array.notEmpty =>
-    await pruneCheckpoints(state, ~safeCheckpointId)
-    await pruneEntities(state, ~entities=concurrent, ~safeCheckpointId)
+  | Some({safeCheckpoints, concurrent}) if concurrent->Utils.Array.notEmpty =>
+    await pruneCheckpoints(state, ~safeCheckpoints)
+    await pruneEntities(state, ~entities=concurrent, ~safeCheckpoints)
   | Some(_) | None => ()
   }
 }
 
 let runForced = async (state: IndexerState.t, ~targets) => {
   switch targets {
-  | Some({safeCheckpointId, concurrent, forced}) if forced->Utils.Array.notEmpty =>
+  | Some({safeCheckpoints, concurrent, forced}) if forced->Utils.Array.notEmpty =>
     // When nothing ran concurrently (eg a rollback write), checkpoint pruning
     // lands here, after the write, so it never overlaps a rollback transaction.
     if concurrent->Utils.Array.isEmpty {
-      await pruneCheckpoints(state, ~safeCheckpointId)
+      await pruneCheckpoints(state, ~safeCheckpoints)
     }
-    await pruneEntities(state, ~entities=forced, ~safeCheckpointId)
+    await pruneEntities(state, ~entities=forced, ~safeCheckpoints)
   | Some(_) | None => ()
   }
 }

package/src/PruneStaleHistory.res.mjs

@@ -7,10 +7,41 @@ import * as Config from "./Config.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Performance from "./bindings/Performance.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_bigint from "@rescript/runtime/lib/es6/Primitive_bigint.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-function selectFrom(allEntities, lastPrunedAtMillis, writtenEntityNames, isRollback, nowMillis, intervalMillis, safeCheckpointId) {
+function selectSafeCheckpoints(state) {
+  let byChain = IndexerState.getSafeCheckpointIdByChain(state);
+  let safe = Stdlib_Array.filterMap(byChain, param => {
+    let chainId = param[0];
+    return Stdlib_Option.map(param[1], checkpointId => [
+      chainId,
+      checkpointId
+    ]);
+  });
+  if (Config.isIsolatedMultichain(IndexerState.config(state))) {
+    if (Utils.$$Array.notEmpty(safe)) {
+      return {
+        TAG: "PerChain",
+        _0: safe
+      };
+    } else {
+      return;
+    }
+  }
+  if (safe.length !== byChain.length) {
+    return;
+  }
+  let match = safe[0];
+  return {
+    TAG: "EveryChain",
+    _0: Stdlib_Array.reduce(safe, match[1], (lowest, param) => Primitive_bigint.min(lowest, param[1]))
+  };
+}
+
+function selectFrom(allEntities, lastPrunedAtMillis, writtenEntityNames, isRollback, nowMillis, intervalMillis, safeCheckpoints) {
   let byOldestPrune = (param, param$1) => param[0] - param$1[0];
   let toEntities = candidates => candidates.map(param => param[1]);
   let concurrentCandidates = [];
@@ -44,7 +75,7 @@ function selectFrom(allEntities, lastPrunedAtMillis, writtenEntityNames, isRollb
     }
   }
   return {
-    safeCheckpointId: safeCheckpointId,
+    safeCheckpoints: safeCheckpoints,
     concurrent: toEntities(sortedConcurrent.slice(0, 5)),
     forced: toEntities(forcedCandidates.toSorted(byOldestPrune).slice(0, 5))
   };
@@ -52,47 +83,40 @@ function selectFrom(allEntities, lastPrunedAtMillis, writtenEntityNames, isRollb
 
 function select(state, writtenEntityNames, isRollback) {
   let config = IndexerState.config(state);
-  if (!Config.shouldPruneHistory(config, IndexerState.isInReorgThreshold(state))) {
-    return;
-  }
-  let safeCheckpointId = IndexerState.getSafeCheckpointId(state);
-  if (safeCheckpointId !== undefined) {
-    return selectFrom(IndexerState.persistence(state).allEntities, IndexerState.lastPrunedAtMillis(state), writtenEntityNames, isRollback, Date.now(), Env.ThrottleWrites.pruneStaleDataIntervalMillis, safeCheckpointId);
+  if (Config.shouldPruneHistory(config, IndexerState.isInReorgThreshold(state))) {
+    return Stdlib_Option.map(selectSafeCheckpoints(state), safeCheckpoints => selectFrom(IndexerState.persistence(state).allEntities, IndexerState.lastPrunedAtMillis(state), writtenEntityNames, isRollback, Date.now(), Env.ThrottleWrites.pruneStaleDataIntervalMillis, safeCheckpoints));
   }
 }
 
-async function pruneEntities(state, entities, safeCheckpointId) {
+async function pruneEntity(state, entityConfig, safeCheckpoints) {
   let persistence = IndexerState.persistence(state);
-  for (let idx = 0, idx_finish = entities.length; idx < idx_finish; ++idx) {
-    let entityConfig = entities[idx];
-    let timeRef = Performance.now();
-    IndexerState.lastPrunedAtMillis(state)[entityConfig.name] = Date.now();
-    let exit = 0;
-    let val;
-    try {
-      val = await persistence.storage.pruneStaleEntityHistory(entityConfig.name, entityConfig.index, Stdlib_Option.map(Table.getChainIdField(entityConfig.table), Table.getPgDbFieldName), safeCheckpointId);
-      exit = 1;
-    } catch (raw_exn) {
-      let exn = Primitive_exceptions.internalToException(raw_exn);
-      Logging.childErrorWithExn(Logging.createChild({
-        entityName: entityConfig.name,
-        safeCheckpointId: safeCheckpointId
-      }), Utils.prettifyExn(exn), `Failed to prune stale entity history`);
-    }
-    if (exit === 1) {
-      IndexerState.recordHistoryPrune(state, entityConfig.name, Performance.secondsSince(timeRef));
-    }
+  let timeRef = Performance.now();
+  IndexerState.lastPrunedAtMillis(state)[entityConfig.name] = Date.now();
+  let val;
+  try {
+    val = await persistence.storage.pruneStaleEntityHistory(entityConfig.name, entityConfig.index, Table.getPgChainIdColumn(entityConfig.table), safeCheckpoints);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    return Logging.childErrorWithExn(Logging.createChild({
+      entityName: entityConfig.name,
+      safeCheckpoints: safeCheckpoints
+    }), Utils.prettifyExn(exn), `Failed to prune stale entity history`);
   }
+  return IndexerState.recordHistoryPrune(state, entityConfig.name, Performance.secondsSince(timeRef));
+}
+
+function pruneEntities(state, entities, safeCheckpoints) {
+  return Utils.$$Array.awaitEach(entities, entityConfig => pruneEntity(state, entityConfig, safeCheckpoints));
 }
 
-async function pruneCheckpoints(state, safeCheckpointId) {
+async function pruneCheckpoints(state, safeCheckpoints) {
   try {
-    await IndexerState.persistence(state).storage.pruneStaleCheckpoints(safeCheckpointId);
+    await IndexerState.persistence(state).storage.pruneStaleCheckpoints(safeCheckpoints);
     return;
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     return Logging.childErrorWithExn(Logging.createChild({
-      safeCheckpointId: safeCheckpointId
+      safeCheckpoints: safeCheckpoints
     }), Utils.prettifyExn(exn), `Failed to prune stale checkpoints`);
   }
 }
@@ -102,10 +126,10 @@ async function runConcurrent(state, targets) {
     return;
   }
   let concurrent = targets.concurrent;
-  let safeCheckpointId = targets.safeCheckpointId;
+  let safeCheckpoints = targets.safeCheckpoints;
   if (Utils.$$Array.notEmpty(concurrent)) {
-    await pruneCheckpoints(state, safeCheckpointId);
-    return await pruneEntities(state, concurrent, safeCheckpointId);
+    await pruneCheckpoints(state, safeCheckpoints);
+    return await pruneEntities(state, concurrent, safeCheckpoints);
   }
 }
 
@@ -114,12 +138,12 @@ async function runForced(state, targets) {
     return;
   }
   let forced = targets.forced;
-  let safeCheckpointId = targets.safeCheckpointId;
+  let safeCheckpoints = targets.safeCheckpoints;
   if (Utils.$$Array.notEmpty(forced)) {
     if (Utils.$$Array.isEmpty(targets.concurrent)) {
-      await pruneCheckpoints(state, safeCheckpointId);
+      await pruneCheckpoints(state, safeCheckpoints);
     }
-    return await pruneEntities(state, forced, safeCheckpointId);
+    return await pruneEntities(state, forced, safeCheckpoints);
   }
 }
 
@@ -130,8 +154,10 @@ let forcedIntervalMultiplier = 5;
 export {
   maxEntitiesPerWrite,
   forcedIntervalMultiplier,
+  selectSafeCheckpoints,
   selectFrom,
   select,
+  pruneEntity,
   pruneEntities,
   pruneCheckpoints,
   runConcurrent,

package/src/Rollback.res

@@ -127,86 +127,105 @@ and executeRollback = async (
     }
   }
 
-  let eventsProcessedDiffByChain = Dict.make()
-  let newProgressBlockNumberPerChain = Dict.make()
+  // The diff computed here replaces a pending one rather than merging with it,
+  // so its deletes have to cover everything that one would have deleted. The
+  // flush above leaves a diff pending only when no batch has come along to
+  // carry it.
+  let floors = {
+    let next = if state->IndexerState.config->Config.isIsolatedMultichain {
+      RollbackFloors.isolated(
+        ~chainId=reorgChain,
+        ~floorCheckpointId=rollbackTargetCheckpointId,
+        ~forkBlockNumber=rollbackTargetBlockNumber,
+      )
+    } else {
+      RollbackFloors.global(
+        ~floorCheckpointId=rollbackTargetCheckpointId,
+        ~reorgChainId=reorgChain,
+        ~forkBlockNumber=rollbackTargetBlockNumber,
+      )
+    }
+    switch state->IndexerState.pendingRollback {
+    | None => next
+    | Some({floors: pending}) => RollbackFloors.merge(pending, next)
+    }
+  }
+
+  let progressDiffByChain: dict<ChainState.progressDiff> = Dict.make()
   let rollbackedProcessedEvents = ref(0.)
 
   {
     let rollbackProgressDiff = await (
       state->IndexerState.persistence
-    ).storage.getRollbackProgressDiff(~rollbackTargetCheckpointId)
+    ).storage.getRollbackProgressDiff(~floors)
     for idx in 0 to rollbackProgressDiff->Array.length - 1 {
       let diff = rollbackProgressDiff->Array.getUnsafe(idx)
-      eventsProcessedDiffByChain->ChainId.Dict.set(
-        diff["chain_id"],
+      let chainId = diff["chain_id"]
+      let eventsProcessed = Float.fromString(diff["events_processed_diff"])->Option.getOrThrow
+      rollbackedProcessedEvents := rollbackedProcessedEvents.contents +. eventsProcessed
+      progressDiffByChain->ChainId.Dict.set(
+        chainId,
         {
-          let eventsProcessedDiff =
-            Float.fromString(diff["events_processed_diff"])->Option.getOrThrow
-          rollbackedProcessedEvents := rollbackedProcessedEvents.contents +. eventsProcessedDiff
-          eventsProcessedDiff
-        },
-      )
-      newProgressBlockNumberPerChain->ChainId.Dict.set(
-        diff["chain_id"],
-        if rollbackTargetCheckpointId === 0n && diff["chain_id"] === reorgChain {
-          Pervasives.min(diff["new_progress_block_number"], rollbackTargetBlockNumber)
-        } else {
-          diff["new_progress_block_number"]
+          blockNumber: diff["new_progress_block_number"],
+          eventsProcessed,
         },
       )
     }
   }
 
-  let rolledBackChains = []
+  // Where the rollback leaves each chain it moved, written with the diff: the
+  // batch that carries it may belong to a chain the rollback never touched.
+  let rolledBackChains: array<InternalTable.Chains.progressedChain> = []
   let rolledBackAddresses = []
   state
   ->IndexerState.chainStates
   ->Utils.Dict.forEach(cs => {
     let chainId = (cs->ChainState.chainConfig).id
     let fromBlock = cs->ChainState.committedProgressBlockNumber
-    let killedAddresses =
-      cs->ChainState.rollback(
-        ~newProgressBlockNumber=newProgressBlockNumberPerChain->ChainId.Dict.dangerouslyGetNonOption(
-          chainId,
-        ),
-        ~eventsProcessedDiff=eventsProcessedDiffByChain->ChainId.Dict.dangerouslyGetNonOption(
-          chainId,
-        ),
-        ~rollbackTargetBlockNumber,
-        ~isReorgChain=chainId === reorgChain,
-      )
+    let progressDiff = progressDiffByChain->ChainId.Dict.dangerouslyGetNonOption(chainId)
+    let killedAddresses = cs->ChainState.rollback(
+      ~rolledBackTo=switch (progressDiff, floors->RollbackFloors.forkBlockNumber(chainId)) {
+      | (Some(progressDiff), forkBlockNumber) =>
+        RecomputedProgress({
+          ...progressDiff,
+          blockNumber: forkBlockNumber->Option.mapOr(progressDiff.blockNumber, forkBlockNumber =>
+            Pervasives.min(progressDiff.blockNumber, forkBlockNumber)
+          ),
+        })
+      // Nothing of this chain's is above its floor, so there are no checkpoints
+      // to recompute from.
+      | (None, Some(forkBlockNumber)) => ForkBlock(forkBlockNumber)
+      | (None, None) => Untouched
+      },
+    )
     rolledBackAddresses->Array.pushMany(killedAddresses)->ignore
     let toBlock = cs->ChainState.committedProgressBlockNumber
     if fromBlock !== toBlock {
       rolledBackChains
       ->Array.push({
+        chainId,
+        progressBlockNumber: toBlock,
+        sourceBlockNumber: cs->ChainState.knownHeight,
+        totalEventsProcessed: cs->ChainState.numEventsProcessed,
+      })
+      ->ignore
+      logger->Logging.childInfo({
+        "msg": "Rollbacked",
         "chainId": chainId,
         "fromBlock": fromBlock,
         "toBlock": toBlock,
-        "rollbackedEvents": eventsProcessedDiffByChain
-        ->ChainId.Dict.dangerouslyGetNonOption(chainId)
-        ->Option.getOr(0.),
+        "rollbackedEvents": progressDiff->Option.mapOr(0., diff => diff.eventsProcessed),
       })
-      ->ignore
     }
   })
 
   let diff = await state->InMemoryStore.prepareRollbackDiff(
-    ~rollbackTargetCheckpointId,
+    ~floors,
     ~rollbackDiffCheckpointId=state->IndexerState.committedCheckpointId->BigInt.add(1n),
-    ~progressBlockNumberByChainId=newProgressBlockNumberPerChain,
+    ~progressedChains=rolledBackChains,
     ~rolledBackAddresses,
   )
 
-  rolledBackChains->Array.forEach(rolledBack => {
-    logger->Logging.childInfo({
-      "msg": "Rollbacked",
-      "chainId": rolledBack["chainId"],
-      "fromBlock": rolledBack["fromBlock"],
-      "toBlock": rolledBack["toBlock"],
-      "rollbackedEvents": rolledBack["rollbackedEvents"],
-    })
-  })
   logger->Logging.childTrace({
     "msg": "Rollback entity changes",
     "deleted": diff["deletedEntities"],
@@ -217,7 +236,11 @@ and executeRollback = async (
     ~rollbackedProcessedEvents=rollbackedProcessedEvents.contents,
   )
 
-  state->IndexerState.completeRollback(~eventsProcessedDiffByChain)
+  state->IndexerState.completeRollback(
+    ~eventsProcessedDiffByChain=progressDiffByChain->Utils.Dict.mapValues(diff =>
+      diff.eventsProcessed
+    ),
+  )
   scheduleFetch()
   scheduleProcessing()
 }

package/src/Rollback.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
+import * as Config from "./Config.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Writing from "./Writing.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
@@ -12,6 +13,7 @@ import * as InMemoryStore from "./InMemoryStore.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as SourceManager from "./sources/SourceManager.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as RollbackFloors from "./db/RollbackFloors.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
@@ -42,50 +44,67 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
   await Writing.flush(state);
   let checkpointId = await IndexerState.persistence(state).storage.getRollbackTargetCheckpoint(reorgChain, rollbackTargetBlockNumber);
   let rollbackTargetCheckpointId = checkpointId !== undefined ? checkpointId : 0n;
-  let eventsProcessedDiffByChain = {};
-  let newProgressBlockNumberPerChain = {};
+  let next = Config.isIsolatedMultichain(IndexerState.config(state)) ? RollbackFloors.isolated(reorgChain, rollbackTargetCheckpointId, rollbackTargetBlockNumber) : RollbackFloors.global(rollbackTargetCheckpointId, reorgChain, rollbackTargetBlockNumber);
+  let match = IndexerState.pendingRollback(state);
+  let floors = match !== undefined ? RollbackFloors.merge(match.floors, next) : next;
+  let progressDiffByChain = {};
   let rollbackedProcessedEvents = 0;
-  let rollbackProgressDiff = await IndexerState.persistence(state).storage.getRollbackProgressDiff(rollbackTargetCheckpointId);
+  let rollbackProgressDiff = await IndexerState.persistence(state).storage.getRollbackProgressDiff(floors);
   for (let idx = 0, idx_finish = rollbackProgressDiff.length; idx < idx_finish; ++idx) {
     let diff = rollbackProgressDiff[idx];
-    let eventsProcessedDiff = Stdlib_Option.getOrThrow(Stdlib_Float.fromString(diff.events_processed_diff), undefined);
-    rollbackedProcessedEvents = rollbackedProcessedEvents + eventsProcessedDiff;
-    eventsProcessedDiffByChain[diff.chain_id] = eventsProcessedDiff;
-    newProgressBlockNumberPerChain[diff.chain_id] = rollbackTargetCheckpointId === 0n && diff.chain_id === reorgChain ? Primitive_int.min(diff.new_progress_block_number, rollbackTargetBlockNumber) : diff.new_progress_block_number;
+    let chainId = diff.chain_id;
+    let eventsProcessed = Stdlib_Option.getOrThrow(Stdlib_Float.fromString(diff.events_processed_diff), undefined);
+    rollbackedProcessedEvents = rollbackedProcessedEvents + eventsProcessed;
+    progressDiffByChain[chainId] = {
+      blockNumber: diff.new_progress_block_number,
+      eventsProcessed: eventsProcessed
+    };
   }
   let rolledBackChains = [];
   let rolledBackAddresses = [];
   Utils.Dict.forEach(IndexerState.chainStates(state), cs => {
     let chainId = ChainState.chainConfig(cs).id;
     let fromBlock = ChainState.committedProgressBlockNumber(cs);
-    let killedAddresses = ChainState.rollback(cs, newProgressBlockNumberPerChain[chainId], eventsProcessedDiffByChain[chainId], rollbackTargetBlockNumber, chainId === reorgChain);
+    let progressDiff = progressDiffByChain[chainId];
+    let match = RollbackFloors.forkBlockNumber(floors, chainId);
+    let killedAddresses = ChainState.rollback(cs, progressDiff !== undefined ? ({
+        TAG: "RecomputedProgress",
+        _0: {
+          blockNumber: Stdlib_Option.mapOr(match, progressDiff.blockNumber, forkBlockNumber => Primitive_int.min(progressDiff.blockNumber, forkBlockNumber)),
+          eventsProcessed: progressDiff.eventsProcessed
+        }
+      }) : (
+        match !== undefined ? ({
+            TAG: "ForkBlock",
+            _0: match
+          }) : "Untouched"
+      ));
     rolledBackAddresses.push(...killedAddresses);
     let toBlock = ChainState.committedProgressBlockNumber(cs);
     if (fromBlock !== toBlock) {
       rolledBackChains.push({
+        chainId: chainId,
+        progressBlockNumber: toBlock,
+        sourceBlockNumber: ChainState.knownHeight(cs),
+        totalEventsProcessed: ChainState.numEventsProcessed(cs)
+      });
+      return Logging.childInfo(logger, {
+        msg: "Rollbacked",
         chainId: chainId,
         fromBlock: fromBlock,
         toBlock: toBlock,
-        rollbackedEvents: Stdlib_Option.getOr(eventsProcessedDiffByChain[chainId], 0)
+        rollbackedEvents: Stdlib_Option.mapOr(progressDiff, 0, diff => diff.eventsProcessed)
       });
-      return;
     }
   });
-  let diff$1 = await InMemoryStore.prepareRollbackDiff(state, rollbackTargetCheckpointId, IndexerState.committedCheckpointId(state) + 1n, newProgressBlockNumberPerChain, rolledBackAddresses);
-  rolledBackChains.forEach(rolledBack => Logging.childInfo(logger, {
-    msg: "Rollbacked",
-    chainId: rolledBack.chainId,
-    fromBlock: rolledBack.fromBlock,
-    toBlock: rolledBack.toBlock,
-    rollbackedEvents: rolledBack.rollbackedEvents
-  }));
+  let diff$1 = await InMemoryStore.prepareRollbackDiff(state, floors, IndexerState.committedCheckpointId(state) + 1n, rolledBackChains, rolledBackAddresses);
   Logging.childTrace(logger, {
     msg: "Rollback entity changes",
     deleted: diff$1.deletedEntities,
     upserted: diff$1.setEntities
   });
   IndexerState.recordRollbackSuccess(state, Performance.secondsSince(startTime), rollbackedProcessedEvents);
-  IndexerState.completeRollback(state, eventsProcessedDiffByChain);
+  IndexerState.completeRollback(state, Utils.Dict.mapValues(progressDiffByChain, diff => diff.eventsProcessed));
   scheduleFetch();
   return scheduleProcessing();
 }

package/src/RollbackCommit.res

@@ -20,15 +20,13 @@ let register = (callback: callback) => {
     }
 }
 
-// Fired after a rollback diff is durably written, once per affected chain.
-// `progressBlockNumberByChainId` is the last valid block per chain, taken from
-// the in-memory store's rollback object. A throwing callback bubbles to the
-// write loop's onError, crashing the indexer like a failed write.
-let fire = async (~progressBlockNumberByChainId: dict<int>) => {
-  let _ = await progressBlockNumberByChainId
-  ->Dict.toArray
-  ->Array.flatMap(((chainIdKey, rollbackToBlock)) => {
-    let args = {chainId: chainIdKey->ChainId.normalizeOrThrow, rollbackToBlock}
+// Fired after a rollback diff is durably written, once per affected chain, with
+// the last valid block the rollback left that chain at. A throwing callback
+// bubbles to the write loop's onError, crashing the indexer like a failed write.
+let fire = async (~progressedChains: array<InternalTable.Chains.progressedChain>) => {
+  let _ = await progressedChains
+  ->Array.flatMap(({chainId, progressBlockNumber}) => {
+    let args = {chainId, rollbackToBlock: progressBlockNumber}
     callbacks->Array.map(callback => callback(args))
   })
   ->Promise.all