envio 3.9.0 → 3.10.0

package/src/db/CheckpointBounds.res

@@ -0,0 +1,53 @@
+// A checkpoint id per chain that a query compares each chain's rows against. A
+// schema with a cross-chain entity gets one bound for every chain, since a reorg
+// on any chain reaches every chain's rows; otherwise each chain has its own, and
+// a chain absent from them is left alone.
+type t =
+  | EveryChain(Internal.checkpointId)
+  | PerChain(array<(ChainId.t, Internal.checkpointId)>)
+
+// The pieces a query splices in to read its bound as `checkpointId`: a SELECT
+// joins the bounds next to its table with `join`, a DELETE names them with
+// `using` and matches the chain with `usingMatch` in its WHERE.
+type sql = {
+  join: string,
+  using: string,
+  usingMatch: string,
+  checkpointId: string,
+}
+
+// The chain ids are cast to the widest integer type rather than the column's
+// own: nothing indexes the join, so the values only have to compare.
+let relation = `unnest($1::${(Postgres.BigInt :> string)}[],$2::${(Postgres.BigInt :> string)}[]) AS envio_bounds(chain_id, checkpoint_id)`
+
+let sql = (bounds: t, ~chainIdColumn: option<string>, ~tableRef: string): sql =>
+  switch (bounds, chainIdColumn) {
+  | (EveryChain(_), _) => {join: "", using: "", usingMatch: "", checkpointId: "$1"}
+  | (PerChain(_), Some(column)) =>
+    let chainMatch = `envio_bounds.chain_id = ${tableRef}."${column}"`
+    {
+      join: ` JOIN ${relation} ON ${chainMatch}`,
+      using: ` USING ${relation}`,
+      usingMatch: ` AND ${chainMatch}`,
+      checkpointId: "envio_bounds.checkpoint_id",
+    }
+  | (PerChain(_), None) =>
+    JsError.throwWithMessage(
+      "Internal error: per-chain checkpoint bounds can't bound a table with no chain-id column. Only a schema whose entities are all per-chain has them.",
+    )
+  }
+
+// Bound in the order `sql` reads them: the one bound as `$1`, or the chains and
+// their bounds as the two parallel arrays the relation unnests.
+let params = (bounds: t): unknown =>
+  switch bounds {
+  | EveryChain(checkpointId) =>
+    [checkpointId->BigInt.toString]->(Utils.magic: array<string> => unknown)
+  | PerChain(byChain) =>
+    [
+      byChain->Array.map(((chainId, _)) => chainId)->(Utils.magic: array<ChainId.t> => unknown),
+      byChain
+      ->Array.map(((_, checkpointId)) => checkpointId->BigInt.toString)
+      ->(Utils.magic: array<string> => unknown),
+    ]->(Utils.magic: array<unknown> => unknown)
+  }

package/src/db/CheckpointBounds.res.mjs

@@ -0,0 +1,44 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+
+let relation = `unnest($1::` + "BIGINT" + `[],$2::` + "BIGINT" + `[]) AS envio_bounds(chain_id, checkpoint_id)`;
+
+function sql(bounds, chainIdColumn, tableRef) {
+  if (bounds.TAG === "EveryChain") {
+    return {
+      join: "",
+      using: "",
+      usingMatch: "",
+      checkpointId: "$1"
+    };
+  }
+  if (chainIdColumn === undefined) {
+    return Stdlib_JsError.throwWithMessage("Internal error: per-chain checkpoint bounds can't bound a table with no chain-id column. Only a schema whose entities are all per-chain has them.");
+  }
+  let chainMatch = `envio_bounds.chain_id = ` + tableRef + `."` + chainIdColumn + `"`;
+  return {
+    join: ` JOIN ` + relation + ` ON ` + chainMatch,
+    using: ` USING ` + relation,
+    usingMatch: ` AND ` + chainMatch,
+    checkpointId: "envio_bounds.checkpoint_id"
+  };
+}
+
+function params(bounds) {
+  if (bounds.TAG === "EveryChain") {
+    return [bounds._0.toString()];
+  }
+  let byChain = bounds._0;
+  return [
+    byChain.map(param => param[0]),
+    byChain.map(param => param[1].toString())
+  ];
+}
+
+export {
+  relation,
+  sql,
+  params,
+}
+/* No side effect */

package/src/db/EntityFilter.res

@@ -23,34 +23,53 @@ module FieldValue = {
   //and serialize the types without parsing/wrapping them
   type t = option<tNonOptional>
 
+  // A Uint8Array is an object like a BigDecimal, so the unboxed variant can't
+  // tell them apart on its own.
+  let asBytes = (value: t) => value->(Utils.magic: t => unknown)->Utils.Bytes.asUint8Array
+
   let toString = (value: t) =>
-    switch value {
-    | Some(v) => v->toString
-    | None => "undefined"
+    switch (value, value->asBytes) {
+    | (_, Some(bytes)) => bytes->Utils.Bytes.toHex
+    | (Some(v), None) => v->toString
+    | (None, None) => "undefined"
     }
 
   external castFrom: 'a => t = "%identity"
 
-  let eq = (a, b) =>
-    switch (a, b) {
+  let compareWith = (a, b, ~bigDecimal, ~bytes, ~fallback) =>
+    switch (a, b, a->asBytes, b->asBytes) {
+    | (_, _, Some(bytesA), Some(bytesB)) => bytes(Utils.Bytes.compare(bytesA, bytesB))
     //For big decimal use custom equals operator otherwise let Caml_obj.equal do its magic
-    | (Some(BigDecimal(bdA)), Some(BigDecimal(bdB))) => BigDecimal.equals(bdA, bdB)
-    | (a, b) => a == b
+    | (Some(BigDecimal(bdA)), Some(BigDecimal(bdB)), _, _) => bigDecimal(bdA, bdB)
+    | (a, b, _, _) => fallback(a, b)
     }
 
+  let eq = (a, b) =>
+    compareWith(
+      a,
+      b,
+      ~bigDecimal=BigDecimal.equals,
+      ~bytes=order => order === 0.,
+      ~fallback=(a, b) => a == b,
+    )
+
   let gt = (a, b) =>
-    switch (a, b) {
-    //For big decimal use custom equals operator otherwise let Caml_obj.equal do its magic
-    | (Some(BigDecimal(bdA)), Some(BigDecimal(bdB))) => BigDecimal.gt(bdA, bdB)
-    | (a, b) => a > b
-    }
+    compareWith(
+      a,
+      b,
+      ~bigDecimal=BigDecimal.gt,
+      ~bytes=order => order > 0.,
+      ~fallback=(a, b) => a > b,
+    )
 
   let lt = (a, b) =>
-    switch (a, b) {
-    //For big decimal use custom equals operator otherwise let Caml_obj.equal do its magic
-    | (Some(BigDecimal(bdA)), Some(BigDecimal(bdB))) => BigDecimal.lt(bdA, bdB)
-    | (a, b) => a < b
-    }
+    compareWith(
+      a,
+      b,
+      ~bigDecimal=BigDecimal.lt,
+      ~bytes=order => order < 0.,
+      ~fallback=(a, b) => a < b,
+    )
 }
 
 // The And case requires at least one nested filter (storage throws otherwise),

package/src/db/EntityFilter.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Table from "./Table.res.mjs";
+import * as Utils from "../Utils.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
@@ -26,40 +27,50 @@ function toString(tNonOptional) {
   }
 }
 
+function asBytes(value) {
+  return Utils.Bytes.asUint8Array(value);
+}
+
 function toString$1(value) {
-  if (value !== undefined) {
+  let match = Utils.Bytes.asUint8Array(value);
+  if (match !== undefined) {
+    return Utils.Bytes.toHex(match);
+  } else if (value !== undefined) {
     return toString(value);
   } else {
     return "undefined";
   }
 }
 
-function eq(a, b) {
+function compareWith(a, b, bigDecimal, bytes, fallback) {
+  let match = Utils.Bytes.asUint8Array(a);
+  let match$1 = Utils.Bytes.asUint8Array(b);
+  if (match !== undefined && match$1 !== undefined) {
+    return bytes(Utils.Bytes.compare(match, match$1));
+  }
   if (typeof a === "object" && !Array.isArray(a) && typeof b === "object" && !Array.isArray(b)) {
-    return a.isEqualTo(b);
+    return bigDecimal(a, b);
   } else {
-    return Primitive_object.equal(a, b);
+    return fallback(a, b);
   }
 }
 
+function eq(a, b) {
+  return compareWith(a, b, (prim0, prim1) => prim0.isEqualTo(prim1), order => order === 0, Primitive_object.equal);
+}
+
 function gt(a, b) {
-  if (typeof a === "object" && !Array.isArray(a) && typeof b === "object" && !Array.isArray(b)) {
-    return a.isGreaterThan(b);
-  } else {
-    return Primitive_object.greaterthan(a, b);
-  }
+  return compareWith(a, b, (prim0, prim1) => prim0.isGreaterThan(prim1), order => order > 0, Primitive_object.greaterthan);
 }
 
 function lt(a, b) {
-  if (typeof a === "object" && !Array.isArray(a) && typeof b === "object" && !Array.isArray(b)) {
-    return a.isLessThan(b);
-  } else {
-    return Primitive_object.lessthan(a, b);
-  }
+  return compareWith(a, b, (prim0, prim1) => prim0.isLessThan(prim1), order => order < 0, Primitive_object.lessthan);
 }
 
 let FieldValue = {
+  asBytes: asBytes,
   toString: toString$1,
+  compareWith: compareWith,
   eq: eq,
   gt: gt,
   lt: lt

package/src/db/EntityHistory.res

@@ -30,11 +30,20 @@ let unsafeCheckpointIdSchema =
     serializer: bigint => bigint->BigInt.toString,
   })
 
-let makeSetUpdateSchema = (~idSchema: S.t<EntityId.t>, entitySchema: S.t<'entity>): S.t<
-  Change.t<'entity>,
-> => {
+// `chainIdTag` carries the (column, chain id) of a per-chain entity whose rows
+// all belong to one chain: the column is then a constant of the schema rather
+// than a field read off every entity.
+let makeSetUpdateSchema = (
+  ~idSchema: S.t<EntityId.t>,
+  ~chainIdTag: option<(string, ChainId.t)>=?,
+  entitySchema: S.t<'entity>,
+): S.t<Change.t<'entity>> => {
   S.object(s => {
     s.tag(changeFieldName, RowAction.SET)
+    switch chainIdTag {
+    | Some((column, chainId)) => s.tag(column, chainId)
+    | None => ()
+    }
     Change.Set({
       checkpointId: s.field(checkpointIdFieldName, unsafeCheckpointIdSchema),
       entityId: s.field(Table.idFieldName, idSchema),
@@ -91,27 +100,38 @@ let makeKeyMatch = (~chainIdColumn, ~left, ~right) =>
   ->Array.map(column => `${left}.${column} = ${right}.${column}`)
   ->Array.joinUnsafe(" AND ")
 
-let makePruneStaleEntityHistoryQuery = (~entityName, ~entityIndex, ~pgSchema, ~chainIdColumn) => {
+let makePruneStaleEntityHistoryQuery = (
+  ~entityName,
+  ~entityIndex,
+  ~pgSchema,
+  ~chainIdColumn,
+  ~safeCheckpoints: CheckpointBounds.t,
+) => {
   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")
 
   // 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
-  // rather than as a per-row correlated lookup.
-  // `d.envio_checkpoint_id <= $1` is implied by the rest of the predicate — it
+  // rather than as a per-row correlated lookup. The DELETE's `<=` on the row
   // is there to keep the rows above the safe checkpoint out of the join.
+  //
+  // Per-chain bounds are joined in rather than run as a statement each: the
+  // anchors aggregate the whole table however narrow the bound is, and history
+  // carries no index to narrow the scan with.
   `WITH anchors AS (
   SELECT ${anchorKeys},
-    MAX(t.${checkpointIdFieldName}) FILTER (WHERE t.${checkpointIdFieldName} <= $1) AS keep_checkpoint_id,
-    bool_or(t.${checkpointIdFieldName} > $1) AS has_above
-  FROM ${historyTableRef} t
+    MAX(t.${checkpointIdFieldName}) FILTER (WHERE t.${checkpointIdFieldName} <= ${bounds.checkpointId}) AS keep_checkpoint_id,
+    bool_or(t.${checkpointIdFieldName} > ${bounds.checkpointId}) AS has_above,
+    MIN(${bounds.checkpointId}) AS safe_checkpoint_id
+  FROM ${historyTableRef} t${bounds.join}
   GROUP BY ${anchorKeys}
 )
 DELETE FROM ${historyTableRef} d
 USING anchors a
 WHERE ${makeKeyMatch(~chainIdColumn, ~left="d", ~right="a")}
-  AND d.${checkpointIdFieldName} <= $1
+  AND d.${checkpointIdFieldName} <= a.safe_checkpoint_id
   AND (d.${checkpointIdFieldName} < a.keep_checkpoint_id OR NOT a.has_above);`
 }
 
@@ -121,13 +141,18 @@ let pruneStaleEntityHistory = (
   ~entityIndex,
   ~pgSchema,
   ~chainIdColumn,
-  ~safeCheckpointId,
-): promise<unit> => {
+  ~safeCheckpoints,
+): promise<unit> =>
   sql->Postgres.preparedUnsafe(
-    makePruneStaleEntityHistoryQuery(~entityName, ~entityIndex, ~pgSchema, ~chainIdColumn),
-    [safeCheckpointId->BigInt.toString]->(Utils.magic: array<string> => unknown),
+    makePruneStaleEntityHistoryQuery(
+      ~entityName,
+      ~entityIndex,
+      ~pgSchema,
+      ~chainIdColumn,
+      ~safeCheckpoints,
+    ),
+    safeCheckpoints->CheckpointBounds.params,
   )
-}
 
 // If an entity doesn't have a history before the update
 // we create it automatically with envio_checkpoint_id 0
@@ -173,7 +198,7 @@ let backfillHistory = (
   ~ids: array<EntityId.t>,
 ) => {
   let idPgType = table->Table.getIdPgFieldType(~pgSchema)
-  let chainIdColumn = table->Table.getChainIdField->Option.map(Table.getPgDbFieldName)
+  let chainIdColumn = table->Table.getPgChainIdColumn
   let params = [table->Table.encodeIdsToJson(ids)->(Utils.magic: JSON.t => unknown)]
   sql
   ->Postgres.preparedUnsafe(
@@ -195,15 +220,15 @@ let rollback = (
   ~pgSchema,
   ~entityName,
   ~entityIndex,
-  ~rollbackTargetCheckpointId: Internal.checkpointId,
+  ~chainIdColumn,
+  ~floors: RollbackFloors.t,
 ) => {
+  let historyTableRef = `"${pgSchema}"."${historyTableName(~entityName, ~entityIndex)}"`
+  let bounds = floors.floors->CheckpointBounds.sql(~chainIdColumn, ~tableRef=historyTableRef)
   sql
   ->Postgres.preparedUnsafe(
-    `DELETE FROM "${pgSchema}"."${historyTableName(
-        ~entityName,
-        ~entityIndex,
-      )}" WHERE "${checkpointIdFieldName}" > $1;`,
-    [rollbackTargetCheckpointId->BigInt.toString]->(Utils.magic: array<string> => unknown),
+    `DELETE FROM ${historyTableRef}${bounds.using} WHERE "${checkpointIdFieldName}" > ${bounds.checkpointId}${bounds.usingMatch};`,
+    floors.floors->CheckpointBounds.params,
   )
   ->Utils.Promise.ignoreValue
 }

package/src/db/EntityHistory.res.mjs

@@ -3,7 +3,7 @@
 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 Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.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";
 
@@ -50,9 +50,12 @@ let unsafeCheckpointIdSchema = S$RescriptSchema.transform(S$RescriptSchema.setNa
   s: bigint => bigint.toString()
 }));
 
-function makeSetUpdateSchema(idSchema, entitySchema) {
+function makeSetUpdateSchema(idSchema, chainIdTag, entitySchema) {
   return S$RescriptSchema.object(s => {
     s.tag(changeFieldName, "SET");
+    if (chainIdTag !== undefined) {
+      s.tag(chainIdTag[0], chainIdTag[1]);
+    }
     return {
       type: "SET",
       entityId: s.f(Table.idFieldName, idSchema),
@@ -83,26 +86,28 @@ function makeKeyMatch(chainIdColumn, left, right) {
   return makeKeyColumns(chainIdColumn).map(column => left + `.` + column + ` = ` + right + `.` + column).join(" AND ");
 }
 
-function makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema, chainIdColumn) {
+function makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema, chainIdColumn, safeCheckpoints) {
   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");
   return `WITH anchors AS (
   SELECT ` + anchorKeys + `,
-    MAX(t.` + checkpointIdFieldName + `) FILTER (WHERE t.` + checkpointIdFieldName + ` <= $1) AS keep_checkpoint_id,
-    bool_or(t.` + checkpointIdFieldName + ` > $1) AS has_above
-  FROM ` + historyTableRef + ` t
+    MAX(t.` + checkpointIdFieldName + `) FILTER (WHERE t.` + checkpointIdFieldName + ` <= ` + bounds.checkpointId + `) AS keep_checkpoint_id,
+    bool_or(t.` + checkpointIdFieldName + ` > ` + bounds.checkpointId + `) AS has_above,
+    MIN(` + bounds.checkpointId + `) AS safe_checkpoint_id
+  FROM ` + historyTableRef + ` t` + bounds.join + `
   GROUP BY ` + anchorKeys + `
 )
 DELETE FROM ` + historyTableRef + ` d
 USING anchors a
 WHERE ` + makeKeyMatch(chainIdColumn, "d", "a") + `
-  AND d.` + checkpointIdFieldName + ` <= $1
+  AND d.` + checkpointIdFieldName + ` <= a.safe_checkpoint_id
   AND (d.` + checkpointIdFieldName + ` < a.keep_checkpoint_id OR NOT a.has_above);`;
 }
 
-function pruneStaleEntityHistory(sql, entityName, entityIndex, pgSchema, chainIdColumn, safeCheckpointId) {
-  return sql.unsafe(makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema, chainIdColumn), [safeCheckpointId.toString()], {prepare: true});
+function pruneStaleEntityHistory(sql, entityName, entityIndex, pgSchema, chainIdColumn, safeCheckpoints) {
+  return sql.unsafe(makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema, chainIdColumn, safeCheckpoints), CheckpointBounds.params(safeCheckpoints), {prepare: true});
 }
 
 function makeBackfillHistoryQuery(pgSchema, entityName, entityIndex, idPgType, chainIdColumn, chainId) {
@@ -125,13 +130,15 @@ FROM missing_history;`;
 
 function backfillHistory(sql, pgSchema, table, entityIndex, chainId, ids) {
   let idPgType = Table.getIdPgFieldType(table, pgSchema);
-  let chainIdColumn = Stdlib_Option.map(Table.getChainIdField(table), Table.getPgDbFieldName);
+  let chainIdColumn = Table.getPgChainIdColumn(table);
   let params = [Table.encodeIdsToJson(table, ids)];
   return sql.unsafe(makeBackfillHistoryQuery(pgSchema, table.tableName, entityIndex, idPgType, chainIdColumn, chainId), params, {prepare: true});
 }
 
-function rollback(sql, pgSchema, entityName, entityIndex, rollbackTargetCheckpointId) {
-  return sql.unsafe(`DELETE FROM "` + pgSchema + `"."` + historyTableName(entityName, entityIndex) + `" WHERE "` + checkpointIdFieldName + `" > $1;`, [rollbackTargetCheckpointId.toString()], {prepare: true});
+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 checkpointIdFieldType = "UInt64";

package/src/db/InternalTable.res

@@ -556,18 +556,64 @@ module Checkpoints = {
 
   let initialCheckpointId = 0n
 
-  let table = mkTable(
-    "envio_checkpoints",
-    ~fields=[
-      mkField((#id: field :> string), UInt64, ~fieldSchema=S.bigint, ~isPrimaryKey),
-      mkField((#chain_id: field :> string), ChainId, ~fieldSchema=ChainId.schema),
-      mkField((#block_number: field :> string), Int32, ~fieldSchema=S.int),
-      mkField((#block_hash: field :> string), String, ~fieldSchema=S.null(S.string), ~isNullable),
-      mkField((#events_processed: field :> string), Int32, ~fieldSchema=S.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.
+  type column = {
+    field: fieldOrDerived,
+    clickHouseFieldType: fieldType,
+    valuesOf: Batch.t => array<unknown>,
+  }
+
+  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),
+      clickHouseFieldType: ChainId,
+      valuesOf: batch =>
+        batch.checkpointChainIds->(Utils.magic: array<ChainId.t> => array<unknown>),
+    },
+    {
+      field: mkField((#block_number: field :> string), Int32, ~fieldSchema=S.int),
+      clickHouseFieldType: Int32,
+      valuesOf: batch => batch.checkpointBlockNumbers->(Utils.magic: array<int> => array<unknown>),
+    },
+    {
+      field: mkField(
+        (#block_hash: field :> string),
+        String,
+        ~fieldSchema=S.null(S.string),
+        ~isNullable,
+      ),
+      clickHouseFieldType: String,
+      valuesOf: batch =>
+        batch.checkpointBlockHashes->(Utils.magic: array<Null.t<string>> => array<unknown>),
+    },
+    {
+      field: mkField((#events_processed: field :> string), Int32, ~fieldSchema=S.int),
+      // A count of every event a chain has processed outgrows an Int32 where
+      // Postgres keeps one, and ClickHouse has the id's width to spare.
+      clickHouseFieldType: UInt64,
+      valuesOf: batch =>
+        batch.checkpointEventsProcessed->(Utils.magic: array<int> => array<unknown>),
+    },
+  ]
+
+  let table = mkTable("envio_checkpoints", ~fields=columns->Array.map(({field}) => field))
 
   let makeGetReorgCheckpointsQuery = (~pgSchema): string => {
+    // The safe_block checkpoint itself is included, so it can be used for safe
+    // checkpoint tracking.
+    //
+    // Ordered by id, which within a chain is block order: both consumers of
+    // these rows — the safe-checkpoint scan and the block-store seed — read them
+    // as ascending. Physical row order can't stand in for that, since a rollback
+    // frees space that later checkpoints are written back into.
+    //
     // Use CTE to pre-filter chains and compute safe_block once per chain
     // This is faster because:
     // 1. Chains table is small, so filtering it first is cheap
@@ -590,7 +636,8 @@ FROM "${pgSchema}"."${table.tableName}" cp
 INNER JOIN reorg_chains rc 
   ON cp."${(#chain_id: field :> string)}" = rc.id
 WHERE cp."${(#block_hash: field :> string)}" IS NOT NULL
-  AND cp."${(#block_number: field :> string)}" >= rc.safe_block;` // Include safe_block checkpoint to use it for safe checkpoint tracking
+  AND cp."${(#block_number: field :> string)}" >= rc.safe_block
+ORDER BY cp."${(#id: field :> string)}";`
   }
 
   let makeCommitedCheckpointIdQuery = (~pgSchema) => {
@@ -635,27 +682,33 @@ SELECT * FROM unnest($1::${(BigInt: Postgres.columnType :> string)}[],$2::${chai
     ->Utils.Promise.ignoreValue
   }
 
-  let rollback = (sql, ~pgSchema, ~rollbackTargetCheckpointId: Internal.checkpointId) => {
+  // Optional to match the entity tables', where a cross-chain entity has none.
+  let chainIdColumn = Some((#chain_id: field :> string))
+
+  let rollback = (sql, ~pgSchema, ~floors: RollbackFloors.t) => {
+    let tableRef = `"${pgSchema}"."${table.tableName}"`
+    let bounds = floors.floors->CheckpointBounds.sql(~chainIdColumn, ~tableRef)
     sql
     ->Postgres.preparedUnsafe(
-      `DELETE FROM "${pgSchema}"."${table.tableName}" WHERE "${(#id: field :> string)}" > $1;`,
-      [rollbackTargetCheckpointId->BigInt.toString]->(Utils.magic: array<string> => unknown),
+      `DELETE FROM ${tableRef}${bounds.using} WHERE "${(#id: field :> string)}" > ${bounds.checkpointId}${bounds.usingMatch};`,
+      floors.floors->CheckpointBounds.params,
     )
     ->Utils.Promise.ignoreValue
   }
 
-  let makePruneStaleCheckpointsQuery = (~pgSchema) => {
-    `DELETE FROM "${pgSchema}"."${table.tableName}" WHERE "${(#id: field :> string)}" < $1;`
+  let makePruneStaleCheckpointsQuery = (~pgSchema, ~safeCheckpoints: CheckpointBounds.t) => {
+    let tableRef = `"${pgSchema}"."${table.tableName}"`
+    let bounds = safeCheckpoints->CheckpointBounds.sql(~chainIdColumn, ~tableRef)
+    `DELETE FROM ${tableRef}${bounds.using} WHERE "${(#id: field :> string)}" < ${bounds.checkpointId}${bounds.usingMatch};`
   }
 
-  let pruneStaleCheckpoints = (sql, ~pgSchema, ~safeCheckpointId: bigint) => {
+  let pruneStaleCheckpoints = (sql, ~pgSchema, ~safeCheckpoints) =>
     sql
     ->Postgres.preparedUnsafe(
-      makePruneStaleCheckpointsQuery(~pgSchema),
-      [safeCheckpointId->BigInt.toString]->Obj.magic,
+      makePruneStaleCheckpointsQuery(~pgSchema, ~safeCheckpoints),
+      safeCheckpoints->CheckpointBounds.params,
     )
     ->Utils.Promise.ignoreValue
-  }
 
   let makeGetRollbackTargetCheckpointQuery = (~pgSchema) => {
     `SELECT "${(#id: field :> string)}" FROM "${pgSchema}"."${table.tableName}"
@@ -684,25 +737,22 @@ LIMIT 1;`
     })
   }
 
-  let makeGetRollbackProgressDiffQuery = (~pgSchema) => {
+  let makeGetRollbackProgressDiffQuery = (~pgSchema, ~floors: RollbackFloors.t) => {
+    let bounds = floors.floors->CheckpointBounds.sql(~chainIdColumn, ~tableRef="t")
     `SELECT 
-  "${(#chain_id: field :> string)}"::float8 as "${(#chain_id: field :> string)}",
-  SUM("${(#events_processed: field :> string)}") as events_processed_diff,
-  MIN("${(#block_number: field :> string)}") - 1 as new_progress_block_number
-FROM "${pgSchema}"."${table.tableName}"
-WHERE "${(#id: field :> string)}" > $1
-GROUP BY "${(#chain_id: field :> string)}";`
+  t."${(#chain_id: field :> string)}"::float8 as "${(#chain_id: field :> string)}",
+  SUM(t."${(#events_processed: field :> string)}") as events_processed_diff,
+  MIN(t."${(#block_number: field :> string)}") - 1 as new_progress_block_number
+FROM "${pgSchema}"."${table.tableName}" t${bounds.join}
+WHERE t."${(#id: field :> string)}" > ${bounds.checkpointId}
+GROUP BY t."${(#chain_id: field :> string)}";`
   }
 
-  let getRollbackProgressDiff = (
-    sql,
-    ~pgSchema,
-    ~rollbackTargetCheckpointId: Internal.checkpointId,
-  ) => {
+  let getRollbackProgressDiff = (sql, ~pgSchema, ~floors: RollbackFloors.t) =>
     sql
     ->Postgres.preparedUnsafe(
-      makeGetRollbackProgressDiffQuery(~pgSchema),
-      [rollbackTargetCheckpointId->BigInt.toString]->Obj.magic,
+      makeGetRollbackProgressDiffQuery(~pgSchema, ~floors),
+      floors.floors->CheckpointBounds.params,
     )
     ->(
       Utils.magic: promise<unknown> => promise<
@@ -713,7 +763,6 @@ GROUP BY "${(#chain_id: field :> string)}";`
         }>,
       >
     )
-  }
 }
 
 module RawEvents = {