envio 3.11.0 → 3.12.1

package/src/db/EntityHistory.res

@@ -105,12 +105,12 @@ let makePruneStaleEntityHistoryQuery = (
   ~entityIndex,
   ~pgSchema,
   ~chainIdColumn,
-  ~safeCheckpoints: CheckpointBounds.t,
+  ~safeCheckpoints: CheckpointSequence.checkpointBoundsByChain,
 ) => {
   let historyTableRef = `"${pgSchema}"."${historyTableName(~entityName, ~entityIndex)}"`
   let keyColumns = makeKeyColumns(~chainIdColumn)
   let anchorKeys = keyColumns->Array.map(column => `t.${column}`)->Array.joinUnsafe(", ")
-  let bounds = safeCheckpoints->CheckpointBounds.sql(~chainIdColumn, ~tableRef="t")
+  let bounds = safeCheckpoints->CheckpointSequence.sql(~chainIdColumn, ~tableRef="t")
 
   // Whether a key still has a row above the safe checkpoint is an aggregate
   // over the same groups as the anchor, so it's computed in the one pass
@@ -151,7 +151,7 @@ let pruneStaleEntityHistory = (
       ~chainIdColumn,
       ~safeCheckpoints,
     ),
-    safeCheckpoints->CheckpointBounds.params,
+    safeCheckpoints->CheckpointSequence.params,
   )
 
 // If an entity doesn't have a history before the update
@@ -224,11 +224,12 @@ let rollback = (
   ~floors: RollbackFloors.t,
 ) => {
   let historyTableRef = `"${pgSchema}"."${historyTableName(~entityName, ~entityIndex)}"`
-  let bounds = floors.floors->CheckpointBounds.sql(~chainIdColumn, ~tableRef=historyTableRef)
+  let bounds =
+    floors.checkpointBounds->CheckpointSequence.sql(~chainIdColumn, ~tableRef=historyTableRef)
   sql
   ->Postgres.preparedUnsafe(
     `DELETE FROM ${historyTableRef}${bounds.using} WHERE "${checkpointIdFieldName}" > ${bounds.checkpointId}${bounds.usingMatch};`,
-    floors.floors->CheckpointBounds.params,
+    floors.checkpointBounds->CheckpointSequence.params,
   )
   ->Utils.Promise.ignoreValue
 }

package/src/db/EntityHistory.res.mjs

@@ -3,9 +3,9 @@
 import * as Table from "./Table.res.mjs";
 import * as ChainId from "../ChainId.res.mjs";
 import * as Stdlib_BigInt from "@rescript/runtime/lib/es6/Stdlib_BigInt.js";
-import * as CheckpointBounds from "./CheckpointBounds.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as CheckpointSequence from "./CheckpointSequence.res.mjs";
 
 let variants = [
   "SET",
@@ -90,7 +90,7 @@ function makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema, cha
   let historyTableRef = `"` + pgSchema + `"."` + historyTableName(entityName, entityIndex) + `"`;
   let keyColumns = makeKeyColumns(chainIdColumn);
   let anchorKeys = keyColumns.map(column => `t.` + column).join(", ");
-  let bounds = CheckpointBounds.sql(safeCheckpoints, chainIdColumn, "t");
+  let bounds = CheckpointSequence.sql(safeCheckpoints, chainIdColumn, "t");
   return `WITH anchors AS (
   SELECT ` + anchorKeys + `,
     MAX(t.` + checkpointIdFieldName + `) FILTER (WHERE t.` + checkpointIdFieldName + ` <= ` + bounds.checkpointId + `) AS keep_checkpoint_id,
@@ -107,7 +107,7 @@ WHERE ` + makeKeyMatch(chainIdColumn, "d", "a") + `
 }
 
 function pruneStaleEntityHistory(sql, entityName, entityIndex, pgSchema, chainIdColumn, safeCheckpoints) {
-  return sql.unsafe(makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema, chainIdColumn, safeCheckpoints), CheckpointBounds.params(safeCheckpoints), {prepare: true});
+  return sql.unsafe(makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema, chainIdColumn, safeCheckpoints), CheckpointSequence.params(safeCheckpoints), {prepare: true});
 }
 
 function makeBackfillHistoryQuery(pgSchema, entityName, entityIndex, idPgType, chainIdColumn, chainId) {
@@ -137,8 +137,8 @@ function backfillHistory(sql, pgSchema, table, entityIndex, chainId, ids) {
 
 function rollback(sql, pgSchema, entityName, entityIndex, chainIdColumn, floors) {
   let historyTableRef = `"` + pgSchema + `"."` + historyTableName(entityName, entityIndex) + `"`;
-  let bounds = CheckpointBounds.sql(floors.floors, chainIdColumn, historyTableRef);
-  return sql.unsafe(`DELETE FROM ` + historyTableRef + bounds.using + ` WHERE "` + checkpointIdFieldName + `" > ` + bounds.checkpointId + bounds.usingMatch + `;`, CheckpointBounds.params(floors.floors), {prepare: true});
+  let bounds = CheckpointSequence.sql(floors.checkpointBounds, chainIdColumn, historyTableRef);
+  return sql.unsafe(`DELETE FROM ` + historyTableRef + bounds.using + ` WHERE "` + checkpointIdFieldName + `" > ` + bounds.checkpointId + bounds.usingMatch + `;`, CheckpointSequence.params(floors.checkpointBounds), {prepare: true});
 }
 
 let checkpointIdFieldType = "UInt64";

package/src/db/Frontier.res

@@ -0,0 +1,86 @@
+// Where each chain stands in its checkpoint sequence.
+type t = dict<Internal.checkpointId>
+
+let empty = (): t => Dict.make()
+
+let fromEntries = (entries: array<(ChainId.t, Internal.checkpointId)>): t => {
+  let frontier = Dict.make()
+  entries->Array.forEach(((chainId, checkpointId)) =>
+    frontier->ChainId.Dict.set(chainId, checkpointId)
+  )
+  frontier
+}
+
+let copy = (frontier: t): t => frontier->Dict.copy
+
+// A chain the frontier doesn't name has committed nothing yet, which is what
+// the initial checkpoint id means.
+let get = (frontier: t, chainId): Internal.checkpointId =>
+  switch frontier->ChainId.Dict.dangerouslyGetNonOption(chainId) {
+  | Some(checkpointId) => checkpointId
+  | None => Internal.initialCheckpointId
+  }
+
+// Whether the frontier names the chain at all, as opposed to `get`'s reading of
+// an absent chain as the initial id. A rollback frontier names only the chains
+// it moved, and "no id" is not the same answer as "id zero" there.
+let find = (frontier: t, chainId): option<Internal.checkpointId> =>
+  frontier->ChainId.Dict.dangerouslyGetNonOption(chainId)
+
+let set = (frontier: t, chainId, checkpointId) => frontier->ChainId.Dict.set(chainId, checkpointId)
+
+let entries = (frontier: t): array<(ChainId.t, Internal.checkpointId)> =>
+  frontier
+  ->Dict.toArray
+  ->Array.map(((key, checkpointId)) => (key->ChainId.normalizeOrThrow, checkpointId))
+
+let chainIds = (frontier: t): array<ChainId.t> =>
+  frontier->Dict.keysToArray->Array.map(ChainId.normalizeOrThrow)
+
+// The two parallel arrays an `unnest($1, $2) AS ...(chain_id, checkpoint_id)`
+// relation reads positionally.
+type unnestParams = (array<ChainId.t>, array<string>)
+
+let unnestParams = (frontier: t): unnestParams => {
+  let chainIds = []
+  let checkpointIds = []
+  frontier->Utils.Dict.forEachWithKey((checkpointId, key) => {
+    chainIds->Array.push(key->ChainId.normalizeOrThrow)
+    checkpointIds->Array.push(checkpointId->BigInt.toString)
+  })
+  (chainIds, checkpointIds)
+}
+
+%%private(
+  let fold = (frontier: t, pick) =>
+    frontier
+    ->Dict.valuesToArray
+    ->Array.reduce(None, (acc, checkpointId) =>
+      switch acc {
+      | None => Some(checkpointId)
+      | Some(picked) => Some(pick(picked, checkpointId))
+      }
+    )
+)
+
+// A frontier naming no chain has committed nothing anywhere.
+let max = (frontier: t) =>
+  frontier->fold(Pervasives.max)->Option.getOr(Internal.initialCheckpointId)
+let min = (frontier: t) =>
+  frontier->fold(Pervasives.min)->Option.getOr(Internal.initialCheckpointId)
+
+let mergeMin = (a: t, b: t): t => Utils.Dict.mergeWith(a, b, Pervasives.min)
+let mergeMax = (a: t, b: t): t => Utils.Dict.mergeWith(a, b, Pervasives.max)
+
+let equals = (a: t, b: t) => {
+  let same = (a: t, b: t) =>
+    a
+    ->Dict.toArray
+    ->Array.every(((key, checkpointId)) =>
+      switch b->Utils.Dict.dangerouslyGetNonOption(key) {
+      | Some(other) => other == checkpointId
+      | None => checkpointId == Internal.initialCheckpointId
+      }
+    )
+  same(a, b) && same(b, a)
+}

package/src/db/Frontier.res.mjs

@@ -0,0 +1,126 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "../Utils.res.mjs";
+import * as ChainId from "../ChainId.res.mjs";
+import * as Internal from "../Internal.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";
+
+function empty() {
+  return {};
+}
+
+function fromEntries(entries) {
+  let frontier = {};
+  entries.forEach(param => {
+    frontier[param[0]] = param[1];
+  });
+  return frontier;
+}
+
+function copy(frontier) {
+  return Object.assign({}, frontier);
+}
+
+function get(frontier, chainId) {
+  let checkpointId = frontier[chainId];
+  if (checkpointId !== undefined) {
+    return checkpointId;
+  } else {
+    return Internal.initialCheckpointId;
+  }
+}
+
+function find(frontier, chainId) {
+  return frontier[chainId];
+}
+
+function set(frontier, chainId, checkpointId) {
+  frontier[chainId] = checkpointId;
+}
+
+function entries(frontier) {
+  return Object.entries(frontier).map(param => [
+    ChainId.normalizeOrThrow(param[0]),
+    param[1]
+  ]);
+}
+
+function chainIds(frontier) {
+  return Object.keys(frontier).map(ChainId.normalizeOrThrow);
+}
+
+function unnestParams(frontier) {
+  let chainIds = [];
+  let checkpointIds = [];
+  Utils.Dict.forEachWithKey(frontier, (checkpointId, key) => {
+    chainIds.push(ChainId.normalizeOrThrow(key));
+    checkpointIds.push(checkpointId.toString());
+  });
+  return [
+    chainIds,
+    checkpointIds
+  ];
+}
+
+function fold(frontier, pick) {
+  return Stdlib_Array.reduce(Object.values(frontier), undefined, (acc, checkpointId) => {
+    if (acc !== undefined) {
+      return pick(acc, checkpointId);
+    } else {
+      return checkpointId;
+    }
+  });
+}
+
+function max(frontier) {
+  return Stdlib_Option.getOr(fold(frontier, Primitive_bigint.max), Internal.initialCheckpointId);
+}
+
+function min(frontier) {
+  return Stdlib_Option.getOr(fold(frontier, Primitive_bigint.min), Internal.initialCheckpointId);
+}
+
+function mergeMin(a, b) {
+  return Utils.Dict.mergeWith(a, b, Primitive_bigint.min);
+}
+
+function mergeMax(a, b) {
+  return Utils.Dict.mergeWith(a, b, Primitive_bigint.max);
+}
+
+function equals(a, b) {
+  let same = (a, b) => Object.entries(a).every(param => {
+    let checkpointId = param[1];
+    let other = b[param[0]];
+    if (other !== undefined) {
+      return other === checkpointId;
+    } else {
+      return checkpointId === Internal.initialCheckpointId;
+    }
+  });
+  if (same(a, b)) {
+    return same(b, a);
+  } else {
+    return false;
+  }
+}
+
+export {
+  empty,
+  fromEntries,
+  copy,
+  get,
+  find,
+  set,
+  entries,
+  chainIds,
+  unnestParams,
+  max,
+  min,
+  mergeMin,
+  mergeMax,
+  equals,
+}
+/* Utils Not a pure module */

package/src/db/InternalTable.res

@@ -170,6 +170,7 @@ FROM "${pgSchema}"."${table.tableName}";`
 module Chains = {
   type progressFields = [
     | #progress_block
+    | #progress_block_time
     | #events_processed
     | #source_block
   ]
@@ -186,6 +187,7 @@ module Chains = {
     | #buffer_block
     | #ready_at
     | #_is_hyper_sync
+    | #checkpoint_id
   ]
 
   let fields: array<field> = [
@@ -198,19 +200,16 @@ module Chains = {
     #first_event_block,
     #buffer_block,
     #progress_block,
+    #progress_block_time,
     #ready_at,
     #events_processed,
     #_is_hyper_sync,
+    #checkpoint_id,
   ]
 
   type metaFields = {
     @as("first_event_block")
-    firstEventBlockNumber: Null.t<
-      // Push id first (for WHERE clause)
-
-      // Then push all updateable field values (for SET clause)
-      int,
-    >,
+    firstEventBlockNumber: Null.t<int>,
     @as("buffer_block") latestFetchedBlockNumber: int,
     @as("ready_at")
     timestampCaughtUpToHeadOrEndblock: Null.t<Date.t>,
@@ -225,7 +224,9 @@ module Chains = {
     @as("max_reorg_depth") maxReorgDepth: int,
     @as("source_block") blockHeight: int,
     @as("progress_block") progressBlockNumber: int,
+    @as("progress_block_time") progressBlockTime: Null.t<Date.t>,
     @as("events_processed") numEventsProcessed: float,
+    @as("checkpoint_id") checkpointId: Internal.checkpointId,
     ...metaFields,
   }
 
@@ -265,6 +266,22 @@ module Chains = {
       mkField((#_is_hyper_sync: field :> string), Boolean, ~fieldSchema=S.bool),
       // Fully processed block number
       mkField((#progress_block: field :> string), Int32, ~fieldSchema=S.int),
+      // When the block in progress_block was produced, so that `now() -
+      // progress_block_time` is how far behind chain time the indexer is. Null
+      // while the source hasn't reported that block's header.
+      mkField(
+        (#progress_block_time: field :> string),
+        Date,
+        ~fieldSchema=S.null(Utils.Schema.dbDate),
+        ~isNullable,
+      ),
+      // The last checkpoint id the chain has committed. Kept here rather than
+      // read off the checkpoints table: checkpoint rows are only written while
+      // a rollback could reach them, but an append-only sink holds a row for
+      // every id ever handed out and resolves current state through them, so a
+      // resume has to continue the sequence even where no checkpoint row backs
+      // it.
+      mkField((#checkpoint_id: field :> string), UInt64, ~fieldSchema=S.bigint),
     ],
   )
 
@@ -280,8 +297,10 @@ module Chains = {
       latestFetchedBlockNumber: -1,
       timestampCaughtUpToHeadOrEndblock: Null.null,
       progressBlockNumber: -1,
+      progressBlockTime: Null.null,
       isHyperSync: false,
       numEventsProcessed: 0.,
+      checkpointId: Internal.initialCheckpointId,
     }
   }
 
@@ -358,8 +377,11 @@ WHERE "${(#id: field :> string)}" = $2
     timestampCaughtUpToHeadOrEndblock: Null.t<Date.t>,
     numEventsProcessed: float,
     progressBlockNumber: int,
+    progressBlockTime: Null.t<Date.t>,
     addressRows: AddressRows.seedRows,
     sourceBlockNumber: int,
+    // BIGINT, which the driver hands back as a string.
+    checkpointId: string,
   }
 
   let makeGetInitialStateQuery = (~pgSchema) => {
@@ -371,7 +393,9 @@ WHERE "${(#id: field :> string)}" = $2
 "${(#ready_at: field :> string)}" as "timestampCaughtUpToHeadOrEndblock",
 "${(#events_processed: field :> string)}"::float8 as "numEventsProcessed",
 "${(#progress_block: field :> string)}" as "progressBlockNumber",
-"${(#source_block: field :> string)}" as "sourceBlockNumber"
+"${(#progress_block_time: field :> string)}" as "progressBlockTime",
+"${(#source_block: field :> string)}" as "sourceBlockNumber",
+"${(#checkpoint_id: field :> string)}"::TEXT as "checkpointId"
 FROM "${pgSchema}"."${table.tableName}";`
   }
 
@@ -403,7 +427,20 @@ FROM "${pgSchema}"."${table.tableName}";`
     })
   }
 
-  let progressFields: array<progressFields> = [#progress_block, #events_processed, #source_block]
+  // Block timestamps are unix seconds everywhere inside the indexer - that's
+  // what a block header carries - and a timestamp in storage, where `now() -
+  // progress_block_time` is the query the column exists for.
+  let blockTimeToDb = (blockTime: option<int>) =>
+    blockTime->Option.map(seconds => Date.fromTime(seconds->Int.toFloat *. 1000.))->Null.fromOption
+  let blockTimeFromDb = (date: Null.t<Date.t>) =>
+    date->Null.toOption->Option.map(date => (date->Date.getTime /. 1000.)->Float.toInt)
+
+  let progressFields: array<progressFields> = [
+    #progress_block,
+    #progress_block_time,
+    #events_processed,
+    #source_block,
+  ]
 
   let makeProgressFieldsUpdateQuery = (~pgSchema) => {
     let setClauses = Array.mapWithIndex(progressFields, (field, index) => {
@@ -444,6 +481,7 @@ WHERE "id" = $1;`
   type progressedChain = {
     chainId: ChainId.t,
     progressBlockNumber: int,
+    progressBlockTime: option<int>,
     sourceBlockNumber: int,
     totalEventsProcessed: float,
   }
@@ -463,6 +501,8 @@ WHERE "id" = $1;`
         ->Array.push(
           switch field {
           | #progress_block => data.progressBlockNumber->(Utils.magic: int => unknown)
+          | #progress_block_time =>
+            data.progressBlockTime->blockTimeToDb->(Utils.magic: Null.t<Date.t> => unknown)
           | #events_processed => data.totalEventsProcessed->(Utils.magic: float => unknown)
           | #source_block => data.sourceBlockNumber->(Utils.magic: int => unknown)
           },
@@ -475,6 +515,31 @@ WHERE "id" = $1;`
 
     Promise.all(promises)->Utils.Promise.ignoreValue
   }
+
+  let makeSetCheckpointFrontierQuery = (~pgSchema, ~chainIdMode: ChainId.mode=Int32) => {
+    let chainIdArrayType = chainIdArrayType(~pgSchema, ~chainIdMode)
+    `UPDATE "${pgSchema}"."${table.tableName}"
+SET "${(#checkpoint_id: field :> string)}" = envio_frontier.checkpoint_id
+FROM unnest($1::${chainIdArrayType},$2::${(BigInt: Postgres.columnType :> string)}[]) AS envio_frontier(chain_id, checkpoint_id)
+WHERE "${table.tableName}"."${(#id: field :> string)}" = envio_frontier.chain_id;`
+  }
+
+  // The chains the write moved, in one statement and in the batch's own
+  // transaction — so a chain's stored id can never outlive the rows it covers,
+  // nor lag behind them.
+  let setCheckpointFrontier = (
+    sql,
+    ~pgSchema,
+    ~frontier: Frontier.t,
+    ~chainIdMode: ChainId.mode=Int32,
+  ) => {
+    sql
+    ->Postgres.preparedUnsafe(
+      makeSetCheckpointFrontierQuery(~pgSchema, ~chainIdMode),
+      frontier->Frontier.unnestParams->(Utils.magic: Frontier.unnestParams => unknown),
+    )
+    ->Utils.Promise.ignoreValue
+  }
 }
 
 module EnvioInfo = {
@@ -556,31 +621,58 @@ module Checkpoints = {
 
   let initialCheckpointId = 0n
 
+  // The checkpoint a rollback's diff rows are stamped with. It never reaches
+  // Postgres — there the diff is written straight to the entity table — but an
+  // append-only sink resolves current state through the checkpoints, so without
+  // one of these the diff sits above the frontier while the rows it supersedes
+  // sit below it, and the orphaned values are what a reader sees.
+  type diffCheckpoint = {
+    chainId: ChainId.t,
+    checkpointId: Internal.checkpointId,
+    // Where the rollback left the chain. At or below its stored progress, so a
+    // resume counts the row as covered rather than as something to trim back to.
+    blockNumber: int,
+  }
+
   // One definition per column, carrying what each storage needs: the field
   // itself, the type ClickHouse gives it where that differs from Postgres, and
-  // where a batch keeps the column's values.
+  // where a batch — or a rollback diff — keeps the column's values.
   type column = {
     field: fieldOrDerived,
     clickHouseFieldType: fieldType,
     valuesOf: Batch.t => array<unknown>,
+    diffValuesOf: array<diffCheckpoint> => array<unknown>,
   }
 
+  // The chain leads the key: ids are only unique within a chain, and every
+  // query that narrows to one chain reads a contiguous run of it.
   let columns: array<column> = [
     {
-      field: mkField((#id: field :> string), UInt64, ~fieldSchema=S.bigint, ~isPrimaryKey),
-      clickHouseFieldType: UInt64,
-      valuesOf: batch => batch.checkpointIds->(Utils.magic: array<bigint> => array<unknown>),
-    },
-    {
-      field: mkField((#chain_id: field :> string), ChainId, ~fieldSchema=ChainId.schema),
+      field: mkField(
+        (#chain_id: field :> string),
+        ChainId,
+        ~fieldSchema=ChainId.schema,
+        ~isPrimaryKey,
+      ),
       clickHouseFieldType: ChainId,
       valuesOf: batch =>
         batch.checkpointChainIds->(Utils.magic: array<ChainId.t> => array<unknown>),
+      diffValuesOf: diffs =>
+        diffs->Array.map(diff => diff.chainId->(Utils.magic: ChainId.t => unknown)),
+    },
+    {
+      field: mkField((#id: field :> string), UInt64, ~fieldSchema=S.bigint, ~isPrimaryKey),
+      clickHouseFieldType: UInt64,
+      valuesOf: batch => batch.checkpointIds->(Utils.magic: array<bigint> => array<unknown>),
+      diffValuesOf: diffs =>
+        diffs->Array.map(diff => diff.checkpointId->(Utils.magic: bigint => unknown)),
     },
     {
       field: mkField((#block_number: field :> string), Int32, ~fieldSchema=S.int),
       clickHouseFieldType: Int32,
       valuesOf: batch => batch.checkpointBlockNumbers->(Utils.magic: array<int> => array<unknown>),
+      diffValuesOf: diffs =>
+        diffs->Array.map(diff => diff.blockNumber->(Utils.magic: int => unknown)),
     },
     {
       field: mkField(
@@ -592,6 +684,8 @@ module Checkpoints = {
       clickHouseFieldType: String,
       valuesOf: batch =>
         batch.checkpointBlockHashes->(Utils.magic: array<Null.t<string>> => array<unknown>),
+      diffValuesOf: diffs =>
+        diffs->Array.map(_ => Null.Null->(Utils.magic: Null.t<string> => unknown)),
     },
     {
       field: mkField((#events_processed: field :> string), Int32, ~fieldSchema=S.int),
@@ -600,10 +694,34 @@ module Checkpoints = {
       clickHouseFieldType: UInt64,
       valuesOf: batch =>
         batch.checkpointEventsProcessed->(Utils.magic: array<int> => array<unknown>),
+      diffValuesOf: diffs => diffs->Array.map(_ => 0->(Utils.magic: int => unknown)),
     },
   ]
 
-  let table = mkTable("envio_checkpoints", ~fields=columns->Array.map(({field}) => field))
+  let tableName = "envio_checkpoints"
+
+  let table = mkTable(tableName, ~fields=columns->Array.map(({field}) => field))
+
+  // Where each chain counts its own ids the chain has to be part of the key,
+  // and every bound a rollback or a prune applies names it. Under one shared
+  // sequence the id is unique by itself and those bounds are id ranges with no
+  // chain in them — which a key led by the chain can't serve.
+  let globalTable = mkTable(
+    tableName,
+    ~fields=columns->Array.map(({field: column}) =>
+      switch column {
+      | Table.Field(f) if f.fieldName === (#chain_id: field :> string) =>
+        Table.Field({...f, isPrimaryKey: false})
+      | column => column
+      }
+    ),
+  )
+
+  let tableFor = (sequence: CheckpointSequence.t) =>
+    switch sequence {
+    | SharedAcrossChains => globalTable
+    | PerChain => table
+    }
 
   let makeGetReorgCheckpointsQuery = (~pgSchema): string => {
     // The safe_block checkpoint itself is included, so it can be used for safe
@@ -640,10 +758,6 @@ WHERE cp."${(#block_hash: field :> string)}" IS NOT NULL
 ORDER BY cp."${(#id: field :> string)}";`
   }
 
-  let makeCommitedCheckpointIdQuery = (~pgSchema) => {
-    `SELECT COALESCE(MAX(${(#id: field :> string)}), ${initialCheckpointId->BigInt.toString}) AS id FROM "${pgSchema}"."${table.tableName}";`
-  }
-
   let makeInsertCheckpointQuery = (~pgSchema, ~chainIdMode: ChainId.mode=Int32) => {
     let chainIdArrayType = chainIdArrayType(~pgSchema, ~chainIdMode)
     `INSERT INTO "${pgSchema}"."${table.tableName}" ("${(#id: field :> string)}", "${(#chain_id: field :> string)}", "${(#block_number: field :> string)}", "${(#block_hash: field :> string)}", "${(#events_processed: field :> string)}")
@@ -687,18 +801,21 @@ SELECT * FROM unnest($1::${(BigInt: Postgres.columnType :> string)}[],$2::${chai
 
   let rollback = (sql, ~pgSchema, ~floors: RollbackFloors.t) => {
     let tableRef = `"${pgSchema}"."${table.tableName}"`
-    let bounds = floors.floors->CheckpointBounds.sql(~chainIdColumn, ~tableRef)
+    let bounds = floors.checkpointBounds->CheckpointSequence.sql(~chainIdColumn, ~tableRef)
     sql
     ->Postgres.preparedUnsafe(
       `DELETE FROM ${tableRef}${bounds.using} WHERE "${(#id: field :> string)}" > ${bounds.checkpointId}${bounds.usingMatch};`,
-      floors.floors->CheckpointBounds.params,
+      floors.checkpointBounds->CheckpointSequence.params,
     )
     ->Utils.Promise.ignoreValue
   }
 
-  let makePruneStaleCheckpointsQuery = (~pgSchema, ~safeCheckpoints: CheckpointBounds.t) => {
+  let makePruneStaleCheckpointsQuery = (
+    ~pgSchema,
+    ~safeCheckpoints: CheckpointSequence.checkpointBoundsByChain,
+  ) => {
     let tableRef = `"${pgSchema}"."${table.tableName}"`
-    let bounds = safeCheckpoints->CheckpointBounds.sql(~chainIdColumn, ~tableRef)
+    let bounds = safeCheckpoints->CheckpointSequence.sql(~chainIdColumn, ~tableRef)
     `DELETE FROM ${tableRef}${bounds.using} WHERE "${(#id: field :> string)}" < ${bounds.checkpointId}${bounds.usingMatch};`
   }
 
@@ -706,7 +823,7 @@ SELECT * FROM unnest($1::${(BigInt: Postgres.columnType :> string)}[],$2::${chai
     sql
     ->Postgres.preparedUnsafe(
       makePruneStaleCheckpointsQuery(~pgSchema, ~safeCheckpoints),
-      safeCheckpoints->CheckpointBounds.params,
+      safeCheckpoints->CheckpointSequence.params,
     )
     ->Utils.Promise.ignoreValue
 
@@ -738,7 +855,7 @@ LIMIT 1;`
   }
 
   let makeGetRollbackProgressDiffQuery = (~pgSchema, ~floors: RollbackFloors.t) => {
-    let bounds = floors.floors->CheckpointBounds.sql(~chainIdColumn, ~tableRef="t")
+    let bounds = floors.checkpointBounds->CheckpointSequence.sql(~chainIdColumn, ~tableRef="t")
     `SELECT 
   t."${(#chain_id: field :> string)}"::float8 as "${(#chain_id: field :> string)}",
   SUM(t."${(#events_processed: field :> string)}") as events_processed_diff,
@@ -752,7 +869,7 @@ GROUP BY t."${(#chain_id: field :> string)}";`
     sql
     ->Postgres.preparedUnsafe(
       makeGetRollbackProgressDiffQuery(~pgSchema, ~floors),
-      floors.floors->CheckpointBounds.params,
+      floors.checkpointBounds->CheckpointSequence.params,
     )
     ->(
       Utils.magic: promise<unknown> => promise<
@@ -816,6 +933,7 @@ SELECT
   "${(#start_block: Chains.field :> string)}" AS "startBlock", 
   "${(#end_block: Chains.field :> string)}" AS "endBlock",
   "${(#progress_block: Chains.field :> string)}" AS "progressBlock",
+  "${(#progress_block_time: Chains.field :> string)}" AS "progressBlockTime",
   "${(#buffer_block: Chains.field :> string)}" AS "bufferBlock",
   "${(#first_event_block: Chains.field :> string)}" AS "firstEventBlock",
   "${(#events_processed: Chains.field :> string)}"::float4 AS "eventsProcessed",