envio 3.9.0 → 3.10.0

package/src/PgStorage.res.mjs

@@ -29,6 +29,7 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as ContractMapping from "./ContractMapping.res.mjs";
 import * as IndexDefinition from "./db/IndexDefinition.res.mjs";
+import * as CheckpointBounds from "./db/CheckpointBounds.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 S$RescriptSchema from "rescript-schema/src/S.res.mjs";
@@ -207,7 +208,7 @@ function getEntityHistory(entityConfig) {
     checkpointIdField,
     actionField
   ]), undefined);
-  let setChangeSchema = EntityHistory.makeSetUpdateSchema(Table.getIdSchema(entityConfig.table), getRowSchema(entityConfig));
+  let setChangeSchema = EntityHistory.makeSetUpdateSchema(Table.getIdSchema(entityConfig.table), undefined, getRowSchema(entityConfig));
   let cache_setChangeSchemaRows = S$RescriptSchema.array(setChangeSchema);
   let cache$1 = {
     table: table,
@@ -296,7 +297,7 @@ function makeFilterCondition(filter, table, params) {
   let serializeParamOrThrow = (queryField, fieldName, fieldValue, isArray) => {
     let param;
     try {
-      param = S$RescriptSchema.reverseConvertToJsonOrThrow(fieldValue, isArray ? queryField.arrayFieldSchema : queryField.fieldSchema);
+      param = S$RescriptSchema.reverseConvertOrThrow(fieldValue, isArray ? queryField.arrayFieldSchema : queryField.fieldSchema);
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       throw {
@@ -410,12 +411,20 @@ VALUES` + placeholders + (
 function makeTableBatchSetQuery(pgSchema, table, itemSchema, chainIdModeOpt) {
   let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
   let match = Table.toSqlParams(table, itemSchema, pgSchema, chainIdMode);
+  let byteaColumnIndexes = match.byteaColumnIndexes;
   let isRawEvents = table.tableName === InternalTable.RawEvents.table.tableName;
   let isHistoryUpdate = table.tableName.startsWith(EntityHistory.historyTablePrefix);
   if ((isRawEvents || !match.hasArrayField) && !isHistoryUpdate) {
     return {
       query: makeInsertUnnestSetQuery(pgSchema, table, itemSchema, isRawEvents, chainIdMode),
-      convertOrThrow: S$RescriptSchema.compile(S$RescriptSchema.unnest(match.dbSchema), "Output", "Input", "Sync", false),
+      convertOrThrow: S$RescriptSchema.compile(S$RescriptSchema.preprocess(S$RescriptSchema.unnest(match.dbSchema), param => ({
+        s: columns => {
+          byteaColumnIndexes.forEach(index => {
+            columns[index] = Utils.Bytes.toPgArrayLiteral(columns[index]);
+          });
+          return columns;
+        }
+      })), "Output", "Input", "Sync", false),
       isInsertValues: false
     };
   } else {
@@ -681,7 +690,7 @@ function executeSet(sql, items, dbFunction) {
 async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, setQueryCache, updatedEffectsCache, updatedEntities, registeredAddresses, sinkPromise, chainMetaData, escapeTables) {
   try {
     let chainIdMode = config.chainIdMode;
-    let shouldSaveHistory = Config.shouldSaveHistory(config, isInReorgThreshold);
+    let shouldSaveHistory = Config.shouldSaveHistory(config, isInReorgThreshold, undefined);
     let specificError = {
       contents: undefined
     };
@@ -723,6 +732,7 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
       let idsToDelete = [];
       let scopeChainId;
       scopeChainId = scope === "crossChain" ? undefined : Primitive_option.some(scope);
+      let shouldSaveHistory = Config.shouldSaveHistory(config, isInReorgThreshold, scopeChainId);
       let match = Table.getChainIdField(entityConfig.table);
       let changes$1;
       if (match !== undefined && scopeChainId !== undefined) {
@@ -835,11 +845,15 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
     });
     let rollbackTables;
     if (rollback !== undefined) {
+      let progressedChains = rollback.progressedChains;
       let rolledBackAddresses = rollback.rolledBackAddresses;
-      let rollbackTargetCheckpointId = rollback.targetCheckpointId;
+      let floors = rollback.floors;
       rollbackTables = sql => {
-        let promises = allEntities.filter(entityConfig => entityConfig.storage.postgres).map(entityConfig => EntityHistory.rollback(sql, pgSchema, entityConfig.name, entityConfig.index, rollbackTargetCheckpointId));
-        promises.push(InternalTable.Checkpoints.rollback(sql, pgSchema, rollbackTargetCheckpointId));
+        let promises = allEntities.filter(entityConfig => entityConfig.storage.postgres).map(entityConfig => EntityHistory.rollback(sql, pgSchema, entityConfig.name, entityConfig.index, Table.getPgChainIdColumn(entityConfig.table), floors));
+        promises.push(InternalTable.Checkpoints.rollback(sql, pgSchema, floors));
+        if (Utils.$$Array.notEmpty(progressedChains)) {
+          promises.push(InternalTable.Chains.setProgressedChains(sql, pgSchema, progressedChains));
+        }
         if (Utils.$$Array.notEmpty(rolledBackAddresses)) {
           promises.push(InternalTable.EnvioAddresses.$$delete(sql, pgSchema, rolledBackAddresses, chainIdMode));
         }
@@ -917,41 +931,45 @@ function rollbackKeyColumns(entityConfig) {
   }
 }
 
-function makeGetRollbackPreTargetRowsQuery(entityConfig, pgSchema) {
+function makeGetRollbackPreTargetRowsQuery(entityConfig, pgSchema, floors) {
   let dataFieldNames = Stdlib_Array.filterMap(entityConfig.table.fields, fieldOrDerived => {
     if (fieldOrDerived.TAG === "Field") {
       return Table.getPgDbFieldName(fieldOrDerived._0);
     }
   });
-  let dataFieldsCommaSeparated = dataFieldNames.map(name => `"` + name + `"`).join(", ");
   let historyTableName = EntityHistory.historyTableName(entityConfig.name, entityConfig.index);
+  let tableRef = `"` + historyTableName + `"`;
+  let dataFieldsCommaSeparated = dataFieldNames.map(name => tableRef + `."` + name + `"`).join(", ");
   let keyColumns = rollbackKeyColumns(entityConfig);
-  let keyColumnsCommaSeparated = keyColumns.map(c => `"` + c + `"`).join(", ");
-  let keyMatch = keyColumns.map(c => `h."` + c + `" = "` + historyTableName + `"."` + c + `"`).join(" AND ");
-  return `SELECT DISTINCT ON (` + keyColumnsCommaSeparated + `) ` + dataFieldsCommaSeparated + `, "` + EntityHistory.changeFieldName + `"
-  FROM "` + pgSchema + `"."` + historyTableName + `"
-  WHERE "` + EntityHistory.checkpointIdFieldName + `" <= $1
+  let keyColumnsCommaSeparated = keyColumns.map(c => tableRef + `."` + c + `"`).join(", ");
+  let keyMatch = keyColumns.map(c => `h."` + c + `" = ` + tableRef + `."` + c + `"`).join(" AND ");
+  let bounds = CheckpointBounds.sql(floors.floors, Table.getPgChainIdColumn(entityConfig.table), tableRef);
+  return `SELECT DISTINCT ON (` + keyColumnsCommaSeparated + `) ` + dataFieldsCommaSeparated + `, ` + tableRef + `."` + EntityHistory.changeFieldName + `"
+  FROM "` + pgSchema + `"."` + historyTableName + `"` + bounds.join + `
+  WHERE ` + tableRef + `."` + EntityHistory.checkpointIdFieldName + `" <= ` + bounds.checkpointId + `
     AND EXISTS (
       SELECT 1
       FROM "` + pgSchema + `"."` + historyTableName + `" h
       WHERE ` + keyMatch + `
-        AND h."` + EntityHistory.checkpointIdFieldName + `" > $1
+        AND h."` + EntityHistory.checkpointIdFieldName + `" > ` + bounds.checkpointId + `
     )
-  ORDER BY ` + keyColumnsCommaSeparated + `, "` + EntityHistory.checkpointIdFieldName + `" DESC`;
+  ORDER BY ` + keyColumnsCommaSeparated + `, ` + tableRef + `."` + EntityHistory.checkpointIdFieldName + `" DESC`;
 }
 
-function makeGetRollbackRemovedIdsQuery(entityConfig, pgSchema) {
+function makeGetRollbackRemovedIdsQuery(entityConfig, pgSchema, floors) {
   let historyTableName = EntityHistory.historyTableName(entityConfig.name, entityConfig.index);
+  let tableRef = `"` + historyTableName + `"`;
   let keyColumns = rollbackKeyColumns(entityConfig);
-  let keyMatch = keyColumns.map(c => `h."` + c + `" = "` + historyTableName + `"."` + c + `"`).join(" AND ");
-  return `SELECT DISTINCT ` + keyColumns.map(c => `"` + c + `"`).join(", ") + `
-  FROM "` + pgSchema + `"."` + historyTableName + `"
-  WHERE "` + EntityHistory.checkpointIdFieldName + `" > $1
+  let keyMatch = keyColumns.map(c => `h."` + c + `" = ` + tableRef + `."` + c + `"`).join(" AND ");
+  let bounds = CheckpointBounds.sql(floors.floors, Table.getPgChainIdColumn(entityConfig.table), tableRef);
+  return `SELECT DISTINCT ` + keyColumns.map(c => tableRef + `."` + c + `"`).join(", ") + `
+  FROM "` + pgSchema + `"."` + historyTableName + `"` + bounds.join + `
+  WHERE ` + tableRef + `."` + EntityHistory.checkpointIdFieldName + `" > ` + bounds.checkpointId + `
     AND NOT EXISTS (
       SELECT 1
       FROM "` + pgSchema + `"."` + historyTableName + `" h
       WHERE ` + keyMatch + `
-        AND h."` + EntityHistory.checkpointIdFieldName + `" <= $1
+        AND h."` + EntityHistory.checkpointIdFieldName + `" <= ` + bounds.checkpointId + `
     )`;
 }
 
@@ -1113,13 +1131,12 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
     let entities = entitiesOpt !== undefined ? entitiesOpt : [];
     let enums = enumsOpt !== undefined ? enumsOpt : [];
     let pgEntities = entities.filter(e => e.storage.postgres);
-    let chEntities = entities.filter(e => e.storage.clickhouse);
     let schemaTableNames = await sql.unsafe(makeSchemaTableNamesQuery(pgSchema));
     if (Utils.$$Array.notEmpty(schemaTableNames) && !schemaTableNames.some(table => table.table_name === InternalTable.Chains.table.tableName ? true : table.table_name === "event_sync_state")) {
       Stdlib_JsError.throwWithMessage(`Cannot run Envio migrations on PostgreSQL schema "` + pgSchema + `" because it contains non-Envio tables. Running migrations would delete all data in this schema.\n\nTo resolve this:\n1. If you want to use this schema, first backup any important data, then drop it with: "pnpm envio local db-migrate down"\n2. Or specify a different schema name by setting the "ENVIO_PG_SCHEMA" environment variable\n3. Or manually drop the schema in your database if you're certain the data is not needed.`);
     }
     if (sink !== undefined) {
-      await sink.initialize(chainConfigs, chEntities, enums);
+      await sink.initialize(entities);
     }
     let queries = makeInitializeTransaction(pgSchema, pgUser, isHasuraEnabled, chainConfigs, pgEntities, enums, Utils.$$Array.isEmpty(schemaTableNames), true, chainIdMode);
     let rowsByChain = chainConfigs.map(chainConfig => ChainState.configStorageRows(chainConfig, ecosystem, contractMapping));
@@ -1398,7 +1415,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
       return Logging.errorWithExn(Utils.prettifyExn(exn$1), `Failed to dump cache.`);
     }
   };
-  let resumeInitialState = async () => {
+  let resumeInitialState = async (entities, throwIfIncompatible) => {
     let match = await Promise.all([
       restoreEffectCache(false),
       InternalTable.Chains.getInitialState(sql, pgSchema).then(rawInitialStates => rawInitialStates.map(rawInitialState => ({
@@ -1435,6 +1452,10 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
       })
     ]);
     let match$1 = match[4];
+    let storedContractMapping = match$1[1];
+    let storedEnvioInfo = match$1[0];
+    let chains = match[1];
+    throwIfIncompatible(storedEnvioInfo, storedContractMapping);
     await reloadIndexCatalog();
     let checkpointId = BigInt(match[2][0].id);
     let reorgCheckpoints = match[3].map(raw => ({
@@ -1444,14 +1465,14 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
       block_hash: raw.block_hash
     }));
     if (sink !== undefined) {
-      await sink.resume(checkpointId);
+      await sink.resume(checkpointId, chains, entities);
     }
     return {
       cleanRun: false,
-      contractMapping: match$1[1],
-      envioInfo: match$1[0],
+      contractMapping: storedContractMapping,
+      envioInfo: storedEnvioInfo,
       cache: match[0],
-      chains: match[1],
+      chains: chains,
       checkpointId: checkpointId,
       reorgCheckpoints: reorgCheckpoints
     };
@@ -1461,14 +1482,15 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
     return await sql.unsafe(query);
   };
   let setChainMeta = chainsData => InternalTable.Chains.setMeta(sql, pgSchema, chainsData).then(param => (undefined));
-  let pruneStaleCheckpoints = safeCheckpointId => InternalTable.Checkpoints.pruneStaleCheckpoints(sql, pgSchema, safeCheckpointId);
-  let pruneStaleEntityHistory = (entityName, entityIndex, chainIdColumn, safeCheckpointId) => EntityHistory.pruneStaleEntityHistory(sql, entityName, entityIndex, pgSchema, chainIdColumn, safeCheckpointId);
+  let pruneStaleCheckpoints = safeCheckpoints => InternalTable.Checkpoints.pruneStaleCheckpoints(sql, pgSchema, safeCheckpoints);
+  let pruneStaleEntityHistory = (entityName, entityIndex, chainIdColumn, safeCheckpoints) => EntityHistory.pruneStaleEntityHistory(sql, entityName, entityIndex, pgSchema, chainIdColumn, safeCheckpoints);
   let getRollbackTargetCheckpoint = (reorgChainId, lastKnownValidBlockNumber) => InternalTable.Checkpoints.getRollbackTargetCheckpoint(sql, pgSchema, reorgChainId, lastKnownValidBlockNumber);
-  let getRollbackProgressDiff = rollbackTargetCheckpointId => InternalTable.Checkpoints.getRollbackProgressDiff(sql, pgSchema, rollbackTargetCheckpointId);
-  let getRollbackData = async (entityConfig, rollbackTargetCheckpointId) => {
+  let getRollbackProgressDiff = floors => InternalTable.Checkpoints.getRollbackProgressDiff(sql, pgSchema, floors);
+  let getRollbackData = async (entityConfig, floors) => {
+    let params = CheckpointBounds.params(floors.floors);
     let match = await Promise.all([
-      sql.unsafe(makeGetRollbackRemovedIdsQuery(entityConfig, pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true}),
-      sql.unsafe(makeGetRollbackPreTargetRowsQuery(entityConfig, pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true})
+      sql.unsafe(makeGetRollbackRemovedIdsQuery(entityConfig, pgSchema, floors), params, {prepare: true}),
+      sql.unsafe(makeGetRollbackPreTargetRowsQuery(entityConfig, pgSchema, floors), params, {prepare: true})
     ]);
     let chainIdSchema = rollbackChainIdSchema(entityConfig.table);
     let scopeOf = row => {

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,