envio 3.11.0 → 3.12.1

package/src/db/InternalTable.res.mjs

@@ -5,13 +5,16 @@ import * as Utils from "../Utils.res.mjs";
 import * as Config from "../Config.res.mjs";
 import * as Address from "../Address.res.mjs";
 import * as ChainId from "../ChainId.res.mjs";
+import * as Frontier from "./Frontier.res.mjs";
+import * as Internal from "../Internal.res.mjs";
 import * as Postgres from "../bindings/Postgres.res.mjs";
 import * as AddressRows from "../AddressRows.res.mjs";
 import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.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";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 let undefinedTableSqlState = "42P01";
@@ -158,9 +161,11 @@ let fields = [
   "first_event_block",
   "buffer_block",
   "progress_block",
+  "progress_block_time",
   "ready_at",
   "events_processed",
-  "_is_hyper_sync"
+  "_is_hyper_sync",
+  "checkpoint_id"
 ];
 
 let table$2 = Table.mkTable("envio_chains", undefined, [
@@ -175,7 +180,9 @@ let table$2 = Table.mkTable("envio_chains", undefined, [
   Table.mkField("ready_at", "Date", S$RescriptSchema.$$null(Utils.Schema.dbDate), undefined, undefined, true, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
   Table.mkField("events_processed", "UInt52", S$RescriptSchema.float, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
   Table.mkField("_is_hyper_sync", "Boolean", S$RescriptSchema.bool, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
-  Table.mkField("progress_block", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined)
+  Table.mkField("progress_block", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
+  Table.mkField("progress_block_time", "Date", S$RescriptSchema.$$null(Utils.Schema.dbDate), undefined, undefined, true, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
+  Table.mkField("checkpoint_id", "UInt64", S$RescriptSchema.bigint, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined)
 ], undefined);
 
 function initialFromConfig(chainConfig) {
@@ -187,7 +194,9 @@ function initialFromConfig(chainConfig) {
     max_reorg_depth: chainConfig.maxReorgDepth,
     source_block: 0,
     progress_block: -1,
+    progress_block_time: null,
     events_processed: 0,
+    checkpoint_id: Internal.initialCheckpointId,
     first_event_block: null,
     buffer_block: -1,
     ready_at: null,
@@ -260,7 +269,9 @@ function makeGetInitialStateQuery(pgSchema) {
 "` + "ready_at" + `" as "timestampCaughtUpToHeadOrEndblock",
 "` + "events_processed" + `"::float8 as "numEventsProcessed",
 "` + "progress_block" + `" as "progressBlockNumber",
-"` + "source_block" + `" as "sourceBlockNumber"
+"` + "progress_block_time" + `" as "progressBlockTime",
+"` + "source_block" + `" as "sourceBlockNumber",
+"` + "checkpoint_id" + `"::TEXT as "checkpointId"
 FROM "` + pgSchema + `"."` + table$2.tableName + `";`;
 }
 
@@ -281,14 +292,25 @@ async function getInitialState(sql, pgSchema) {
       timestampCaughtUpToHeadOrEndblock: rawInitialState.timestampCaughtUpToHeadOrEndblock,
       numEventsProcessed: rawInitialState.numEventsProcessed,
       progressBlockNumber: rawInitialState.progressBlockNumber,
+      progressBlockTime: rawInitialState.progressBlockTime,
       addressRows: Stdlib_Option.getOr(addressRowsByChainId[ChainId.toString(id)], AddressRows.emptySeedRows()),
-      sourceBlockNumber: rawInitialState.sourceBlockNumber
+      sourceBlockNumber: rawInitialState.sourceBlockNumber,
+      checkpointId: rawInitialState.checkpointId
     };
   });
 }
 
+function blockTimeToDb(blockTime) {
+  return Stdlib_Null.fromOption(Stdlib_Option.map(blockTime, seconds => new Date(seconds * 1000)));
+}
+
+function blockTimeFromDb(date) {
+  return Stdlib_Option.map(date === null ? undefined : Primitive_option.some(date), date => date.getTime() / 1000 | 0);
+}
+
 let progressFields = [
   "progress_block",
+  "progress_block_time",
   "events_processed",
   "source_block"
 ];
@@ -325,8 +347,10 @@ function setProgressedChains(sql, pgSchema, progressedChains) {
     let params = [];
     params.push(data.chainId);
     progressFields.forEach(field => {
-      params.push(field === "source_block" ? data.sourceBlockNumber : (
-          field === "progress_block" ? data.progressBlockNumber : data.totalEventsProcessed
+      params.push(field === "progress_block_time" ? blockTimeToDb(data.progressBlockTime) : (
+          field === "source_block" ? data.sourceBlockNumber : (
+              field === "progress_block" ? data.progressBlockNumber : data.totalEventsProcessed
+            )
         ));
     });
     promises.push(sql.unsafe(query, params, {prepare: true}));
@@ -334,6 +358,20 @@ function setProgressedChains(sql, pgSchema, progressedChains) {
   return Promise.all(promises);
 }
 
+function makeSetCheckpointFrontierQuery(pgSchema, chainIdModeOpt) {
+  let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
+  let chainIdArrayType$1 = chainIdArrayType(pgSchema, chainIdMode);
+  return `UPDATE "` + pgSchema + `"."` + table$2.tableName + `"
+SET "` + "checkpoint_id" + `" = envio_frontier.checkpoint_id
+FROM unnest($1::` + chainIdArrayType$1 + `,$2::` + "BIGINT" + `[]) AS envio_frontier(chain_id, checkpoint_id)
+WHERE "` + table$2.tableName + `"."` + "id" + `" = envio_frontier.chain_id;`;
+}
+
+function setCheckpointFrontier(sql, pgSchema, frontier, chainIdModeOpt) {
+  let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
+  return sql.unsafe(makeSetCheckpointFrontierQuery(pgSchema, chainIdMode), Frontier.unnestParams(frontier), {prepare: true});
+}
+
 let Chains = {
   fields: fields,
   table: table$2,
@@ -344,10 +382,14 @@ let Chains = {
   makeSetReadyAtQuery: makeSetReadyAtQuery,
   makeGetInitialStateQuery: makeGetInitialStateQuery,
   getInitialState: getInitialState,
+  blockTimeToDb: blockTimeToDb,
+  blockTimeFromDb: blockTimeFromDb,
   progressFields: progressFields,
   makeProgressFieldsUpdateQuery: makeProgressFieldsUpdateQuery,
   setMeta: setMeta,
-  setProgressedChains: setProgressedChains
+  setProgressedChains: setProgressedChains,
+  makeSetCheckpointFrontierQuery: makeSetCheckpointFrontierQuery,
+  setCheckpointFrontier: setCheckpointFrontier
 };
 
 let table$3 = Table.mkTable("envio_info", undefined, [
@@ -393,33 +435,78 @@ let dbSchema = S$RescriptSchema.object(s => ({
 
 let columns = [
   {
-    field: Table.mkField("id", "UInt64", S$RescriptSchema.bigint, undefined, undefined, undefined, true, undefined, undefined, undefined, undefined, undefined, undefined),
-    clickHouseFieldType: "UInt64",
-    valuesOf: batch => batch.checkpointIds
+    field: Table.mkField("chain_id", "ChainId", ChainId.schema, undefined, undefined, undefined, true, undefined, undefined, undefined, undefined, undefined, undefined),
+    clickHouseFieldType: "ChainId",
+    valuesOf: batch => batch.checkpointChainIds,
+    diffValuesOf: diffs => diffs.map(diff => diff.chainId)
   },
   {
-    field: Table.mkField("chain_id", "ChainId", ChainId.schema, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
-    clickHouseFieldType: "ChainId",
-    valuesOf: batch => batch.checkpointChainIds
+    field: Table.mkField("id", "UInt64", S$RescriptSchema.bigint, undefined, undefined, undefined, true, undefined, undefined, undefined, undefined, undefined, undefined),
+    clickHouseFieldType: "UInt64",
+    valuesOf: batch => batch.checkpointIds,
+    diffValuesOf: diffs => diffs.map(diff => diff.checkpointId)
   },
   {
     field: Table.mkField("block_number", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
     clickHouseFieldType: "Int32",
-    valuesOf: batch => batch.checkpointBlockNumbers
+    valuesOf: batch => batch.checkpointBlockNumbers,
+    diffValuesOf: diffs => diffs.map(diff => diff.blockNumber)
   },
   {
     field: Table.mkField("block_hash", "String", S$RescriptSchema.$$null(S$RescriptSchema.string), undefined, undefined, true, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
     clickHouseFieldType: "String",
-    valuesOf: batch => batch.checkpointBlockHashes
+    valuesOf: batch => batch.checkpointBlockHashes,
+    diffValuesOf: diffs => diffs.map(param => null)
   },
   {
     field: Table.mkField("events_processed", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
     clickHouseFieldType: "UInt64",
-    valuesOf: batch => batch.checkpointEventsProcessed
+    valuesOf: batch => batch.checkpointEventsProcessed,
+    diffValuesOf: diffs => diffs.map(param => 0)
   }
 ];
 
-let table$4 = Table.mkTable("envio_checkpoints", undefined, columns.map(param => param.field), undefined);
+let tableName = "envio_checkpoints";
+
+let table$4 = Table.mkTable(tableName, undefined, columns.map(param => param.field), undefined);
+
+let globalTable = Table.mkTable(tableName, undefined, columns.map(param => {
+  let column = param.field;
+  if (column.TAG !== "Field") {
+    return column;
+  }
+  let f = column._0;
+  if (f.fieldName === "chain_id") {
+    return {
+      TAG: "Field",
+      _0: {
+        fieldName: f.fieldName,
+        fieldType: f.fieldType,
+        fieldSchema: f.fieldSchema,
+        isArray: f.isArray,
+        isNullable: f.isNullable,
+        isPrimaryKey: false,
+        isIndex: f.isIndex,
+        isChainId: f.isChainId,
+        linkedEntity: f.linkedEntity,
+        defaultValue: f.defaultValue,
+        description: f.description,
+        postgresDbName: f.postgresDbName,
+        clickhouseDbName: f.clickhouseDbName
+      }
+    };
+  } else {
+    return column;
+  }
+}), undefined);
+
+function tableFor(sequence) {
+  if (sequence === "SharedAcrossChains") {
+    return globalTable;
+  } else {
+    return table$4;
+  }
+}
 
 function makeGetReorgCheckpointsQuery(pgSchema) {
   return `WITH reorg_chains AS (
@@ -443,10 +530,6 @@ WHERE cp."` + "block_hash" + `" IS NOT NULL
 ORDER BY cp."` + "id" + `";`;
 }
 
-function makeCommitedCheckpointIdQuery(pgSchema) {
-  return `SELECT COALESCE(MAX(` + "id" + `), ` + (0n).toString() + `) AS id FROM "` + pgSchema + `"."` + table$4.tableName + `";`;
-}
-
 function makeInsertCheckpointQuery(pgSchema, chainIdModeOpt) {
   let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
   let chainIdArrayType$1 = chainIdArrayType(pgSchema, chainIdMode);
@@ -471,18 +554,18 @@ let chainIdColumn = "chain_id";
 
 function rollback(sql, pgSchema, floors) {
   let tableRef = `"` + pgSchema + `"."` + table$4.tableName + `"`;
-  let bounds = CheckpointBounds.sql(floors.floors, chainIdColumn, tableRef);
-  return sql.unsafe(`DELETE FROM ` + tableRef + bounds.using + ` WHERE "` + "id" + `" > ` + bounds.checkpointId + bounds.usingMatch + `;`, CheckpointBounds.params(floors.floors), {prepare: true});
+  let bounds = CheckpointSequence.sql(floors.checkpointBounds, chainIdColumn, tableRef);
+  return sql.unsafe(`DELETE FROM ` + tableRef + bounds.using + ` WHERE "` + "id" + `" > ` + bounds.checkpointId + bounds.usingMatch + `;`, CheckpointSequence.params(floors.checkpointBounds), {prepare: true});
 }
 
 function makePruneStaleCheckpointsQuery(pgSchema, safeCheckpoints) {
   let tableRef = `"` + pgSchema + `"."` + table$4.tableName + `"`;
-  let bounds = CheckpointBounds.sql(safeCheckpoints, chainIdColumn, tableRef);
+  let bounds = CheckpointSequence.sql(safeCheckpoints, chainIdColumn, tableRef);
   return `DELETE FROM ` + tableRef + bounds.using + ` WHERE "` + "id" + `" < ` + bounds.checkpointId + bounds.usingMatch + `;`;
 }
 
 function pruneStaleCheckpoints(sql, pgSchema, safeCheckpoints) {
-  return sql.unsafe(makePruneStaleCheckpointsQuery(pgSchema, safeCheckpoints), CheckpointBounds.params(safeCheckpoints), {prepare: true});
+  return sql.unsafe(makePruneStaleCheckpointsQuery(pgSchema, safeCheckpoints), CheckpointSequence.params(safeCheckpoints), {prepare: true});
 }
 
 function makeGetRollbackTargetCheckpointQuery(pgSchema) {
@@ -503,7 +586,7 @@ function getRollbackTargetCheckpoint(sql, pgSchema, reorgChainId, lastKnownValid
 }
 
 function makeGetRollbackProgressDiffQuery(pgSchema, floors) {
-  let bounds = CheckpointBounds.sql(floors.floors, chainIdColumn, "t");
+  let bounds = CheckpointSequence.sql(floors.checkpointBounds, chainIdColumn, "t");
   return `SELECT 
   t."` + "chain_id" + `"::float8 as "` + "chain_id" + `",
   SUM(t."` + "events_processed" + `") as events_processed_diff,
@@ -514,16 +597,18 @@ GROUP BY t."` + "chain_id" + `";`;
 }
 
 function getRollbackProgressDiff(sql, pgSchema, floors) {
-  return sql.unsafe(makeGetRollbackProgressDiffQuery(pgSchema, floors), CheckpointBounds.params(floors.floors), {prepare: true});
+  return sql.unsafe(makeGetRollbackProgressDiffQuery(pgSchema, floors), CheckpointSequence.params(floors.checkpointBounds), {prepare: true});
 }
 
 let Checkpoints = {
   dbSchema: dbSchema,
   initialCheckpointId: 0n,
   columns: columns,
+  tableName: tableName,
   table: table$4,
+  globalTable: globalTable,
+  tableFor: tableFor,
   makeGetReorgCheckpointsQuery: makeGetReorgCheckpointsQuery,
-  makeCommitedCheckpointIdQuery: makeCommitedCheckpointIdQuery,
   makeInsertCheckpointQuery: makeInsertCheckpointQuery,
   insert: insert$2,
   chainIdColumn: chainIdColumn,
@@ -584,6 +669,7 @@ SELECT
   "` + "start_block" + `" AS "startBlock", 
   "` + "end_block" + `" AS "endBlock",
   "` + "progress_block" + `" AS "progressBlock",
+  "` + "progress_block_time" + `" AS "progressBlockTime",
   "` + "buffer_block" + `" AS "bufferBlock",
   "` + "first_event_block" + `" AS "firstEventBlock",
   "` + "events_processed" + `"::float4 AS "eventsProcessed",

package/src/db/RollbackFloors.res

@@ -1,55 +1,48 @@
-// How far back a reorg rollback takes each chain: the last checkpoint each keeps,
-// and for a chain whose own reorg set its floor, the last block that reorg left
-// valid. Superseding an unwritten rollback with a new one is a pointwise
-// minimum, so a merge can neither lose a chain's floor nor raise it.
+// How far back a reorg rollback takes each chain: the last checkpoint each
+// keeps, and for a chain whose own reorg set its floor, the last block that
+// reorg left valid. Superseding an unwritten rollback with a new one is a
+// pointwise minimum, so a merge can neither lose a chain's floor nor raise it.
 type t = {
-  floors: CheckpointBounds.t,
+  checkpointBounds: CheckpointSequence.checkpointBoundsByChain,
   // Progress recomputed from the surviving checkpoints alone can land above the
   // fork: the blocks between it and the chain's next checkpoint carried no
   // events on the orphaned chain, but the chain replacing it can have its own.
   // Absent for a chain dragged along by another chain's reorg.
-  forkBlockNumberByChain: array<(ChainId.t, int)>,
+  forkBlockNumberByChain: dict<int>,
 }
 
-// The rollback of a schema whose chains can't have written each other's rows.
-let isolated = (~chainId, ~floorCheckpointId, ~forkBlockNumber) => {
-  floors: PerChain([(chainId, floorCheckpointId)]),
-  forkBlockNumberByChain: [(chainId, forkBlockNumber)],
-}
-
-// The rollback of a schema with a cross-chain entity: every chain goes back to
-// the same checkpoint.
-let global = (~floorCheckpointId, ~reorgChainId, ~forkBlockNumber) => {
-  floors: EveryChain(floorCheckpointId),
-  forkBlockNumberByChain: [(reorgChainId, forkBlockNumber)],
-}
-
-let mergeByChain = (pending: array<(ChainId.t, 'a)>, next: array<(ChainId.t, 'a)>) => {
-  let merged = pending->Array.copy
-  next->Array.forEach(((chainId, value)) =>
-    switch merged->Array.findIndexOpt(((mergedChainId, _)) => mergedChainId === chainId) {
-    | Some(idx) =>
-      let (_, pendingValue) = merged->Array.getUnsafe(idx)
-      merged->Array.setUnsafe(idx, (chainId, Pervasives.min(pendingValue, value)))
-    | None => merged->Array.push((chainId, value))
-    }
-  )
-  merged
+// Under one shared sequence a reorg on any chain can have changed any chain's
+// rows, so every chain goes back to the same checkpoint; with a counter per
+// chain the floor names the reorg chain alone and every sibling is left alone.
+let make = (
+  ~sequence: CheckpointSequence.t,
+  ~chainIds: array<ChainId.t>,
+  ~reorgChainId,
+  ~floorCheckpointId,
+  ~forkBlockNumber,
+) => {
+  checkpointBounds: {
+    CheckpointSequence.sequence,
+    byChain: switch sequence {
+    | SharedAcrossChains =>
+      chainIds->Array.map(chainId => (chainId, floorCheckpointId))->Frontier.fromEntries
+    | PerChain => Frontier.fromEntries([(reorgChainId, floorCheckpointId)])
+    },
+  },
+  forkBlockNumberByChain: Dict.fromArray([(reorgChainId->ChainId.toString, forkBlockNumber)]),
 }
 
 let merge = (pending: t, next: t) => {
-  floors: switch (pending.floors, next.floors) {
-  | (EveryChain(pending), EveryChain(next)) => EveryChain(Pervasives.min(pending, next))
-  | (PerChain(pending), PerChain(next)) => PerChain(mergeByChain(pending, next))
-  | (EveryChain(_), PerChain(_)) | (PerChain(_), EveryChain(_)) =>
-    JsError.throwWithMessage(
-      "Internal error: a rollback reaching every chain can't be merged with one isolated to a chain. The schema decides which a run builds, and it doesn't change.",
-    )
+  checkpointBounds: {
+    CheckpointSequence.sequence: next.checkpointBounds.sequence,
+    byChain: Frontier.mergeMin(pending.checkpointBounds.byChain, next.checkpointBounds.byChain),
   },
-  forkBlockNumberByChain: mergeByChain(pending.forkBlockNumberByChain, next.forkBlockNumberByChain),
+  forkBlockNumberByChain: Utils.Dict.mergeWith(
+    pending.forkBlockNumberByChain,
+    next.forkBlockNumberByChain,
+    Pervasives.min,
+  ),
 }
 
 let forkBlockNumber = (floors: t, chainId) =>
-  floors.forkBlockNumberByChain
-  ->Array.find(((forkChainId, _)) => forkChainId === chainId)
-  ->Option.map(((_, forkBlockNumber)) => forkBlockNumber)
+  floors.forkBlockNumberByChain->ChainId.Dict.dangerouslyGetNonOption(chainId)

package/src/db/RollbackFloors.res.mjs

@@ -1,92 +1,48 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-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 Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
-import * as Primitive_bigint from "@rescript/runtime/lib/es6/Primitive_bigint.js";
-import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Utils from "../Utils.res.mjs";
+import * as ChainId from "../ChainId.res.mjs";
+import * as Frontier from "./Frontier.res.mjs";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 
-function isolated(chainId, floorCheckpointId, forkBlockNumber) {
-  return {
-    floors: {
-      TAG: "PerChain",
-      _0: [[
-          chainId,
-          floorCheckpointId
-        ]]
-    },
-    forkBlockNumberByChain: [[
-        chainId,
-        forkBlockNumber
-      ]]
-  };
-}
-
-function global(floorCheckpointId, reorgChainId, forkBlockNumber) {
+function make(sequence, chainIds, reorgChainId, floorCheckpointId, forkBlockNumber) {
+  let tmp;
+  tmp = sequence === "SharedAcrossChains" ? Frontier.fromEntries(chainIds.map(chainId => [
+      chainId,
+      floorCheckpointId
+    ])) : Frontier.fromEntries([[
+        reorgChainId,
+        floorCheckpointId
+      ]]);
   return {
-    floors: {
-      TAG: "EveryChain",
-      _0: floorCheckpointId
+    checkpointBounds: {
+      sequence: sequence,
+      byChain: tmp
     },
-    forkBlockNumberByChain: [[
-        reorgChainId,
+    forkBlockNumberByChain: Object.fromEntries([[
+        ChainId.toString(reorgChainId),
         forkBlockNumber
-      ]]
+      ]])
   };
 }
 
-function mergeByChain(pending, next) {
-  let merged = pending.slice();
-  next.forEach(param => {
-    let value = param[1];
-    let chainId = param[0];
-    let idx = Stdlib_Array.findIndexOpt(merged, param => param[0] === chainId);
-    if (idx !== undefined) {
-      let match = merged[idx];
-      merged[idx] = [
-        chainId,
-        Primitive_object.min(match[1], value)
-      ];
-      return;
-    }
-    merged.push([
-      chainId,
-      value
-    ]);
-  });
-  return merged;
-}
-
 function merge(pending, next) {
-  let match = pending.floors;
-  let match$1 = next.floors;
-  let tmp;
-  tmp = match.TAG === "EveryChain" ? (
-      match$1.TAG === "EveryChain" ? ({
-          TAG: "EveryChain",
-          _0: Primitive_bigint.min(match._0, match$1._0)
-        }) : Stdlib_JsError.throwWithMessage("Internal error: a rollback reaching every chain can't be merged with one isolated to a chain. The schema decides which a run builds, and it doesn't change.")
-    ) : (
-      match$1.TAG === "EveryChain" ? Stdlib_JsError.throwWithMessage("Internal error: a rollback reaching every chain can't be merged with one isolated to a chain. The schema decides which a run builds, and it doesn't change.") : ({
-          TAG: "PerChain",
-          _0: mergeByChain(match._0, match$1._0)
-        })
-    );
   return {
-    floors: tmp,
-    forkBlockNumberByChain: mergeByChain(pending.forkBlockNumberByChain, next.forkBlockNumberByChain)
+    checkpointBounds: {
+      sequence: next.checkpointBounds.sequence,
+      byChain: Frontier.mergeMin(pending.checkpointBounds.byChain, next.checkpointBounds.byChain)
+    },
+    forkBlockNumberByChain: Utils.Dict.mergeWith(pending.forkBlockNumberByChain, next.forkBlockNumberByChain, Primitive_int.min)
   };
 }
 
 function forkBlockNumber(floors, chainId) {
-  return Stdlib_Option.map(floors.forkBlockNumberByChain.find(param => param[0] === chainId), param => param[1]);
+  return floors.forkBlockNumberByChain[chainId];
 }
 
 export {
-  isolated,
-  global,
-  mergeByChain,
+  make,
   merge,
   forkBlockNumber,
 }
-/* No side effect */
+/* Utils Not a pure module */

package/src/db/Table.res

@@ -331,18 +331,31 @@ let encodeIdsToJson = (table, ids: array<EntityId.t>): JSON.t =>
 
 // TODO: Test whether it should be passed via args and match the column type
 
-let getFieldByApiName = (table, apiFieldName) =>
-  table.fields->Array.find(field =>
-    switch field {
-    | Field(f) => f->getApiFieldName
-    | DerivedFrom({fieldName}) => fieldName
-    } === apiFieldName
+// Resolved once per table, because a getWhere looks up every field it filters
+// on and scanning the array made that cost grow with the entity's width.
+let fieldsByApiName: table => dict<fieldOrDerived> = Utils.WeakMap.memoize(table => {
+  let byApiName = Dict.make()
+  table.fields->Array.forEach(field =>
+    byApiName->Dict.set(
+      switch field {
+      | Field(f) => f->getApiFieldName
+      | DerivedFrom({fieldName}) => fieldName
+      },
+      field,
+    )
   )
+  byApiName
+})
+
+let getFieldByApiName = (table, apiFieldName) =>
+  table->fieldsByApiName->Utils.Dict.dangerouslyGetNonOption(apiFieldName)
 
 // Both schema instances are created once per field: rescript-schema compiles
 // and caches operations on the schema instance, so building S.array(fieldSchema)
 // per query would recompile the serializer on every call.
 type queryField = {
+  fieldType: fieldType,
+  isArray: bool,
   fieldSchema: S.t<unknown>,
   // Serializes the values array of an "in" filter
   arrayFieldSchema: S.t<unknown>,
@@ -363,6 +376,8 @@ let queryFields: table => dict<queryField> = Utils.WeakMap.memoize(table => {
       dict->Dict.set(
         field->getApiFieldName,
         {
+          fieldType: field.fieldType,
+          isArray: field.isArray,
           fieldSchema: field.fieldSchema,
           arrayFieldSchema: switch field.fieldType {
           | Bytea => Utils.Schema.bytesArray->S.toUnknown

package/src/db/Table.res.mjs

@@ -296,12 +296,18 @@ function encodeIdsToJson(table, ids) {
   return S$RescriptSchema.reverseConvertToJsonOrThrow(ids, idsArraySchema(table));
 }
 
-function getFieldByApiName(table, apiFieldName) {
-  return table.fields.find(field => {
+let fieldsByApiName = Utils.$$WeakMap.memoize(table => {
+  let byApiName = {};
+  table.fields.forEach(field => {
     let tmp;
     tmp = field.TAG === "Field" ? getApiFieldName(field._0) : field._0.fieldName;
-    return tmp === apiFieldName;
+    byApiName[tmp] = field;
   });
+  return byApiName;
+});
+
+function getFieldByApiName(table, apiFieldName) {
+  return fieldsByApiName(table)[apiFieldName];
 }
 
 let queryFields = Utils.$$WeakMap.memoize(table => {
@@ -315,6 +321,8 @@ let queryFields = Utils.$$WeakMap.memoize(table => {
     let tmp;
     tmp = typeof match !== "object" && match === "Bytea" ? Utils.Schema.bytesArray : S$RescriptSchema.array(field$1.fieldSchema);
     dict[getApiFieldName(field$1)] = {
+      fieldType: field$1.fieldType,
+      isArray: field$1.isArray,
       fieldSchema: field$1.fieldSchema,
       arrayFieldSchema: tmp,
       pgDbFieldName: getPgDbFieldName(field$1),
@@ -420,7 +428,7 @@ function toSqlParams(table, schema, pgSchema, chainIdModeOpt) {
           }
         }
       };
-      let field = getFieldByApiName(table, location);
+      let field = fieldsByApiName(table)[location];
       let field$1;
       if (field !== undefined) {
         field$1 = field;
@@ -533,6 +541,7 @@ export {
   getIdSchema,
   idsArraySchema,
   encodeIdsToJson,
+  fieldsByApiName,
   getFieldByApiName,
   queryFields,
   makeRowsSchema,

package/src/sources/BlockStore.res

@@ -142,6 +142,14 @@ external materialize: (
 // Hash of a stored block, if the store still holds it.
 @send external getHash: (t, int) => Null.t<string> = "getHash"
 
+// Unix timestamp of a stored block - exactly that block, except for an SVM slot
+// that produced none: with `allowSkippedSlot` the last real slot below it
+// answers instead, which is what chain time is at a skipped slot. Only set it
+// where the query covered every slot in its range, or a slot that was never
+// asked about reads as one the chain skipped.
+@send
+external getTimestamp: (t, int, ~allowSkippedSlot: bool) => Null.t<int> = "getTimestamp"
+
 // Block numbers in `[fromBlock, belowBlock)` with a stored hash, ascending.
 @send
 external getHashedBlockNumbers: (t, ~fromBlock: int, ~belowBlock: int) => array<int> =

package/src/sources/EvmHyperSyncSource.res

@@ -84,6 +84,7 @@ let make = (
     ~fromBlock,
     ~toBlock,
     ~addressSet,
+    ~includeAllBlocks,
     ~knownHeight,
     ~partitionId as _,
     ~selection: FetchState.selection,
@@ -104,6 +105,7 @@ let make = (
       ~registrationIndexes=selection.onEventRegistrations->Array.map(reg => reg.index),
       ~addressSet,
       ~clientFilteredContracts=selection.clientFilteredContracts,
+      ~includeAllBlocks,
     ) catch {
     | HyperSync.GetLogs.Error(WrongInstance) =>
       throw(Source.SourceBehindHead({blockNumber: fromBlock, requestStats: []}))
@@ -141,7 +143,9 @@ let make = (
     }
 
     let pageFetchTime = startFetchingBatchTimeRef->Performance.secondsSince
-    let requestStats = [{Source.method: "getLogs", seconds: pageFetchTime}]
+    let requestStats = [
+      {Source.method: "getLogs", seconds: pageFetchTime, responseBlocks: pageUnsafe.responseBlocks},
+    ]
 
     //set height and next from block
     let knownHeight = pageUnsafe.archiveHeight