envio 3.11.0 → 3.12.0

package/src/TestIndexer.res

@@ -266,6 +266,7 @@ let makeInitialState = (
       sourceBlockNumber: processChainConfig.endBlock->Option.getOr(0),
       maxReorgDepth: 0, // No reorg support in test indexer
       progressBlockNumber: -1,
+      progressBlockTime: None,
       numEventsProcessed: 0.,
       firstEventBlockNumber: None,
       timestampCaughtUpToHeadOrEndblock: None,
@@ -279,7 +280,7 @@ let makeInitialState = (
     envioInfo: Some(JSON.Encode.object(Dict.make())),
     cache: Dict.make(),
     chains,
-    checkpointId: InternalTable.Checkpoints.initialCheckpointId,
+    checkpointFrontier: Frontier.empty(),
     reorgCheckpoints: [],
   }
 }
@@ -590,7 +591,7 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
     JsError.throwWithMessage(
       "TestIndexer: initialize should not be called; the initial state is derived from config.",
     ),
-  resumeInitialState: async (~entities as _, ~throwIfIncompatible as _) =>
+  resumeInitialState: async (~entities as _, ~chainIds as _, ~throwIfIncompatible as _) =>
     JsError.throwWithMessage(
       "TestIndexer: resumeInitialState should not be called; the initial state is derived from config.",
     ),
@@ -599,13 +600,12 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
     ->handleLoad(~tableName=table.tableName, ~filter)
     ->(Utils.magic: array<Internal.entity> => array<unknown>),
   // The in-memory storage has no indexes to build, and it's always ready.
-  ensureQueryIndexes: async (~table as _, ~filters as _) => (),
-  ensureSchemaIndexes: async (~entities as _) => (),
+  ensureQueryIndexes: async (~entityConfig as _, ~scope as _, ~filters as _) => (),
+  ensureSchemaIndexes: async (~entities as _, ~chainIds as _) => (),
   finalizeBackfill: async (~entities as _, ~chainIds as _, ~readyAt as _) => (),
   writeBatch: async (
     ~batch,
     ~rollback as _,
-    ~isInReorgThreshold as _,
     ~config,
     ~allEntities as _,
     ~updatedEffectsCache as _,

package/src/TestIndexer.res.mjs

@@ -8,6 +8,7 @@ import * as ChainId from "./ChainId.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as EntityId from "./EntityId.res.mjs";
+import * as Frontier from "./db/Frontier.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
@@ -19,7 +20,6 @@ import * as EntityFilter from "./db/EntityFilter.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as HandlerLoader from "./HandlerLoader.res.mjs";
-import * as InternalTable from "./db/InternalTable.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as SimulateItems from "./SimulateItems.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
@@ -183,6 +183,7 @@ function makeInitialState(config, processConfigChains, addressRowsByChain, contr
       endBlock: processChainConfig.endBlock,
       maxReorgDepth: 0,
       progressBlockNumber: -1,
+      progressBlockTime: undefined,
       numEventsProcessed: 0,
       firstEventBlockNumber: undefined,
       timestampCaughtUpToHeadOrEndblock: undefined,
@@ -196,7 +197,7 @@ function makeInitialState(config, processConfigChains, addressRowsByChain, contr
     envioInfo: {},
     cache: {},
     chains: chains,
-    checkpointId: InternalTable.Checkpoints.initialCheckpointId,
+    checkpointFrontier: Frontier.empty(),
     reorgCheckpoints: []
   };
 }
@@ -386,10 +387,10 @@ function makeInMemoryStorage(state) {
     name: "test-inmemory",
     isInitialized: async () => true,
     initialize: async (param, param$1, param$2, param$3, param$4) => Stdlib_JsError.throwWithMessage("TestIndexer: initialize should not be called; the initial state is derived from config."),
-    resumeInitialState: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: resumeInitialState should not be called; the initial state is derived from config."),
+    resumeInitialState: async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("TestIndexer: resumeInitialState should not be called; the initial state is derived from config."),
     loadOrThrow: async (filter, table) => handleLoad(state, table.tableName, filter),
-    ensureQueryIndexes: async (param, param$1) => {},
-    ensureSchemaIndexes: async param => {},
+    ensureQueryIndexes: async (param, param$1, param$2) => {},
+    ensureSchemaIndexes: async (param, param$1) => {},
     finalizeBackfill: async (param, param$1, param$2) => {},
     dumpEffectCache: async () => {},
     reset: async () => {},
@@ -399,7 +400,7 @@ function makeInMemoryStorage(state) {
     getRollbackTargetCheckpoint: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
     getRollbackProgressDiff: async param => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
     getRollbackData: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
-    writeBatch: async (batch, param, param$1, config, param$2, param$3, updatedEntities, registeredAddresses, param$4, param$5) => handleWriteBatch(state, config, updatedEntities, registeredAddresses, batch.checkpointIds, batch.checkpointChainIds, batch.checkpointBlockNumbers, batch.checkpointEventsProcessed),
+    writeBatch: async (batch, param, config, param$1, param$2, updatedEntities, registeredAddresses, param$3, param$4) => handleWriteBatch(state, config, updatedEntities, registeredAddresses, batch.checkpointIds, batch.checkpointChainIds, batch.checkpointBlockNumbers, batch.checkpointEventsProcessed),
     close: async () => {}
   };
 }

package/src/UserContext.res

@@ -95,6 +95,7 @@ let initEffect = (params: contextParams) => {
         input,
         context: effectContext,
         cacheKey: input->S.reverseConvertOrThrow(effect.input)->Utils.Hash.makeOrThrow,
+        chainId: handlerChainId,
         checkpointId: params.checkpointId,
       }
       LoadLayer.loadEffect(
@@ -171,14 +172,16 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
     let prop = prop->(Utils.magic: unknown => string)
 
     let isClickHouseOnly = !params.entityConfig.storage.postgres
+    let scope = params->entityScope
+    let committedCheckpointId = params.indexerState->IndexerState.committedCheckpointIdFor(~scope)
 
     let set = params.isPreload
       ? noopSet
       : (entity: Internal.entity) => {
           params.indexerState
-          ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig, ~scope=params->entityScope)
+          ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig, ~scope)
           ->InMemoryTable.Entity.set(
-            ~committedCheckpointId=params.indexerState->IndexerState.committedCheckpointId,
+            ~committedCheckpointId,
             Set({
               entityId: entity.id->EntityId.unsafeOfString,
               checkpointId: params.checkpointId,
@@ -288,9 +291,9 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
       } else {
         entityId => {
           params.indexerState
-          ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig, ~scope=params->entityScope)
+          ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig, ~scope)
           ->InMemoryTable.Entity.set(
-            ~committedCheckpointId=params.indexerState->IndexerState.committedCheckpointId,
+            ~committedCheckpointId,
             Delete({
               entityId,
               checkpointId: params.checkpointId,

package/src/UserContext.res.mjs

@@ -64,6 +64,7 @@ function initEffect(params) {
       input: input,
       context: effectContext,
       cacheKey: effectArgs_cacheKey,
+      chainId: handlerChainId,
       checkpointId: effectArgs_checkpointId
     };
     return LoadLayer.loadEffect(params.loadManager, params.persistence, effect, effectArgs, scope, params.indexerState, params.isPreload, params.item, params.config.ecosystem);
@@ -99,7 +100,9 @@ function throwClickHouseReadOnly(entityConfig, op) {
 
 let entityTraps_get = (params, prop) => {
   let isClickHouseOnly = !params.entityConfig.storage.postgres;
-  let set = params.isPreload ? noopSet : entity => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, entityScope(params)), IndexerState.committedCheckpointId(params.indexerState), {
+  let scope = entityScope(params);
+  let committedCheckpointId = IndexerState.committedCheckpointIdFor(params.indexerState, scope);
+  let set = params.isPreload ? noopSet : entity => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, scope), committedCheckpointId, {
       type: "SET",
       entityId: entity.id,
       entity: entity,
@@ -110,7 +113,7 @@ let entityTraps_get = (params, prop) => {
       if (params.isPreload) {
         return noopDeleteUnsafe;
       } else {
-        return entityId => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, entityScope(params)), IndexerState.committedCheckpointId(params.indexerState), {
+        return entityId => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, scope), committedCheckpointId, {
           type: "DELETE",
           entityId: entityId,
           checkpointId: params.checkpointId

package/src/Utils.res

@@ -166,6 +166,15 @@ module Dict = {
 
   let merge: (dict<'a>, dict<'a>) => dict<'a> = %raw(`(dictA, dictB) => ({...dictA, ...dictB})`)
 
+  // Keeps every key either dict has; `pick` decides a key both have.
+  let mergeWith: (dict<'a>, dict<'a>, ('a, 'a) => 'a) => dict<'a> = %raw(`(a, b, pick) => {
+    var merged = {...a}, i;
+    for (i in b) {
+      merged[i] = i in merged ? pick(merged[i], b[i]) : b[i];
+    }
+    return merged;
+  }`)
+
   @val
   external mergeInPlace: (dict<'a>, dict<'a>) => dict<'a> = "Object.assign"
 

package/src/Utils.res.mjs

@@ -114,6 +114,14 @@ function pushMany(dict, key, values) {
 
 let merge = ((dictA, dictB) => ({...dictA, ...dictB}));
 
+let mergeWith = ((a, b, pick) => {
+    var merged = {...a}, i;
+    for (i in b) {
+      merged[i] = i in merged ? pick(merged[i], b[i]) : b[i];
+    }
+    return merged;
+  });
+
 let mapValues = ((dict, f) => {
     var target = {}, i;
     for (i in dict) {
@@ -197,6 +205,7 @@ let Dict = {
   push: push,
   pushMany: pushMany,
   merge: merge,
+  mergeWith: mergeWith,
   mapValues: mapValues,
   filterMapValues: filterMapValues,
   mapValuesToArray: mapValuesToArray,

package/src/Writing.res

@@ -42,12 +42,10 @@ let snapshotEffects = (state: IndexerState.t, ~cache): array<Persistence.updated
     switch idsToStore {
     | [] => ()
     | ids =>
-      let items = ids->Array.filterMap((id): option<Internal.effectCacheItem> =>
-        switch dict->Dict.getUnsafe(id) {
-        | Set({entity: output}) => Some({id, output})
-        | Delete(_) => None
-        }
-      )
+      let items = ids->Array.map((id): Internal.effectCacheItem => {
+        id,
+        output: (dict->Dict.getUnsafe(id)).output,
+      })
       let effectName = effect.name
       let tableName = table.tableName
       let effectCacheRecord = switch cache->Utils.Dict.dangerouslyGetNonOption(tableName) {
@@ -101,22 +99,34 @@ let runOneWrite = async (state: IndexerState.t) => {
     | None => ()
     }
   | _ =>
-    let committedCheckpointId = state->IndexerState.committedCheckpointId
     let batch = state->IndexerState.drainBatchRun
-    // The run's last checkpoint; entity changes above it stay queued for the next write.
-    let upToCheckpointId = switch batch.checkpointIds->Utils.Array.last {
-    | Some(checkpointId) => checkpointId
-    | None => committedCheckpointId
-    }
 
     let rollback = state->IndexerState.takeRollback
 
+    // Entity changes above it stay queued for the next write.
+    let writtenFrontier = Persistence.writtenFrontier(~batch, ~rollback)
+
     let updatedEntities = []
     state->IndexerState.eachEntityTable((~entityConfig, ~scope, ~table) => {
       let changes =
-        table->InMemoryTable.Entity.snapshotChanges(~committedCheckpointId, ~upToCheckpointId)
+        table->InMemoryTable.Entity.snapshotChanges(
+          ~committedCheckpointId=state->IndexerState.committedCheckpointIdFor(~scope),
+          ~upToCheckpointId=config.checkpointSequence->CheckpointSequence.forScope(
+            writtenFrontier,
+            ~scope,
+          ),
+        )
       if changes->Utils.Array.notEmpty {
-        updatedEntities->Array.push(({entityConfig, scope, changes}: Persistence.updatedEntity))
+        updatedEntities->Array.push(
+          (
+            {
+              entityConfig,
+              scope,
+              changes,
+              shouldSaveHistory: batch.history->HistoryPolicy.forScope(~scope),
+            }: Persistence.updatedEntity
+          ),
+        )
       }
     })
     let updatedEffectsCache = snapshotEffects(state, ~cache)
@@ -142,7 +152,6 @@ let runOneWrite = async (state: IndexerState.t) => {
       persistence.storage.writeBatch(
         ~batch,
         ~rollback,
-        ~isInReorgThreshold=batch.isInReorgThreshold,
         ~config,
         ~allEntities=persistence.allEntities,
         ~updatedEntities,
@@ -155,7 +164,7 @@ let runOneWrite = async (state: IndexerState.t) => {
       PruneStaleHistory.runConcurrent(state, ~targets=pruneTargets),
     ))
 
-    state->IndexerState.markCommitted(~upToCheckpointId)
+    state->IndexerState.markCommitted(~writtenFrontier)
 
     switch rollback {
     | Some({progressedChains}) if RollbackCommit.callbacks->Utils.Array.notEmpty =>
@@ -218,14 +227,19 @@ let commitBatch = (state: IndexerState.t, ~batch: Batch.t) => {
 // Drops committed entity and effect entries across all tables. With
 // keepLoadedFromDb, entries seeded from a db read are spared.
 let dropCommitted = (state: IndexerState.t, ~keepLoadedFromDb) => {
-  let committedCheckpointId = state->IndexerState.committedCheckpointId
-  state->IndexerState.eachEntityTable((~entityConfig as _, ~scope as _, ~table) =>
-    table->InMemoryTable.Entity.dropCommittedChanges(~committedCheckpointId, ~keepLoadedFromDb)
+  state->IndexerState.eachEntityTable((~entityConfig as _, ~scope, ~table) =>
+    table->InMemoryTable.Entity.dropCommittedChanges(
+      ~committedCheckpointId=state->IndexerState.committedCheckpointIdFor(~scope),
+      ~keepLoadedFromDb,
+    )
   )
   state
   ->IndexerState.effectState
   ->EffectState.forEach(inMemTable =>
-    inMemTable->InMemoryStore.dropCommittedEffects(~committedCheckpointId, ~keepLoadedFromDb)
+    inMemTable->InMemoryStore.dropCommittedEffects(
+      ~committedFrontier=state->IndexerState.committedFrontier,
+      ~keepLoadedFromDb,
+    )
   )
 }
 

package/src/Writing.res.mjs

@@ -5,14 +5,16 @@ import * as Utils from "./Utils.res.mjs";
 import * as Throttler from "./Throttler.res.mjs";
 import * as EffectState from "./EffectState.res.mjs";
 import * as Performance from "./bindings/Performance.res.mjs";
+import * as Persistence from "./Persistence.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
-import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as HistoryPolicy from "./HistoryPolicy.res.mjs";
 import * as InMemoryStore from "./InMemoryStore.res.mjs";
 import * as InMemoryTable from "./InMemoryTable.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as RollbackCommit from "./RollbackCommit.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as PruneStaleHistory from "./PruneStaleHistory.res.mjs";
+import * as CheckpointSequence from "./db/CheckpointSequence.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 function getChangesCount(state) {
@@ -44,15 +46,10 @@ function snapshotEffects(state, cache) {
     let table = inMemTable.table;
     let effect = inMemTable.effect;
     if (idsToStore.length !== 0) {
-      let items = Stdlib_Array.filterMap(idsToStore, id => {
-        let match = dict[id];
-        if (match.type === "SET") {
-          return {
-            id: id,
-            output: match.entity
-          };
-        }
-      });
+      let items = idsToStore.map(id => ({
+        id: id,
+        output: dict[id].output
+      }));
       let effectName = effect.name;
       let tableName = table.tableName;
       let c = cache[tableName];
@@ -100,19 +97,18 @@ async function runOneWrite(state) {
       return;
     }
   }
-  let committedCheckpointId = IndexerState.committedCheckpointId(state);
   let batch = IndexerState.drainBatchRun(state);
-  let checkpointId = Utils.$$Array.last(batch.checkpointIds);
-  let upToCheckpointId = checkpointId !== undefined ? checkpointId : committedCheckpointId;
   let rollback = IndexerState.takeRollback(state);
+  let writtenFrontier = Persistence.writtenFrontier(batch, rollback);
   let updatedEntities = [];
   IndexerState.eachEntityTable(state, (entityConfig, scope, table) => {
-    let changes = InMemoryTable.Entity.snapshotChanges(table, committedCheckpointId, upToCheckpointId);
+    let changes = InMemoryTable.Entity.snapshotChanges(table, IndexerState.committedCheckpointIdFor(state, scope), CheckpointSequence.forScope(config.checkpointSequence, writtenFrontier, scope));
     if (Utils.$$Array.notEmpty(changes)) {
       updatedEntities.push({
         entityConfig: entityConfig,
         scope: scope,
-        changes: changes
+        changes: changes,
+        shouldSaveHistory: HistoryPolicy.forScope(batch.history, scope)
       });
       return;
     }
@@ -125,10 +121,10 @@ async function runOneWrite(state) {
   });
   let pruneTargets = PruneStaleHistory.select(state, writtenEntityNames, Stdlib_Option.isSome(rollback));
   await Promise.all([
-    persistence.storage.writeBatch(batch, rollback, batch.isInReorgThreshold, config, persistence.allEntities, updatedEffectsCache, updatedEntities, registeredAddresses, chainMetaData, (storage, timeSeconds) => IndexerState.recordStorageWrite(state, storage, timeSeconds)),
+    persistence.storage.writeBatch(batch, rollback, config, persistence.allEntities, updatedEffectsCache, updatedEntities, registeredAddresses, chainMetaData, (storage, timeSeconds) => IndexerState.recordStorageWrite(state, storage, timeSeconds)),
     PruneStaleHistory.runConcurrent(state, pruneTargets)
   ]);
-  IndexerState.markCommitted(state, upToCheckpointId);
+  IndexerState.markCommitted(state, writtenFrontier);
   if (rollback !== undefined && Utils.$$Array.notEmpty(RollbackCommit.callbacks)) {
     await RollbackCommit.fire(rollback.progressedChains);
   }
@@ -179,9 +175,8 @@ function commitBatch(state, batch) {
 }
 
 function dropCommitted(state, keepLoadedFromDb) {
-  let committedCheckpointId = IndexerState.committedCheckpointId(state);
-  IndexerState.eachEntityTable(state, (param, param$1, table) => InMemoryTable.Entity.dropCommittedChanges(table, committedCheckpointId, keepLoadedFromDb));
-  EffectState.forEach(IndexerState.effectState(state), inMemTable => InMemoryStore.dropCommittedEffects(inMemTable, committedCheckpointId, keepLoadedFromDb));
+  IndexerState.eachEntityTable(state, (param, scope, table) => InMemoryTable.Entity.dropCommittedChanges(table, IndexerState.committedCheckpointIdFor(state, scope), keepLoadedFromDb));
+  EffectState.forEach(IndexerState.effectState(state), inMemTable => InMemoryStore.dropCommittedEffects(inMemTable, IndexerState.committedFrontier(state), keepLoadedFromDb));
 }
 
 async function awaitCapacityLoop(state) {

package/src/bindings/ClickHouse.res

@@ -90,6 +90,7 @@ let makeColumnSpec = (
 type checkpointColumn = {
   spec: ClickHouseSink.columnSpec,
   valuesOf: Batch.t => array<unknown>,
+  diffValuesOf: array<InternalTable.Checkpoints.diffCheckpoint> => array<unknown>,
 }
 
 // Registration and staging both read this one list, so the column a batch's
@@ -98,12 +99,14 @@ let checkpointColumns = InternalTable.Checkpoints.columns->Array.filterMap(({
   field,
   clickHouseFieldType,
   valuesOf,
+  diffValuesOf,
 }) =>
   switch field {
   | Table.Field({fieldName, isNullable}) =>
     Some({
       spec: makeColumnSpec(~name=fieldName, ~fieldType=clickHouseFieldType, ~isNullable),
       valuesOf,
+      diffValuesOf,
     })
   | DerivedFrom(_) => None
   }
@@ -259,25 +262,18 @@ let makeRegistry = () => {
 )
 
 %%private(
-  let fillBuilders = (
-    ~table: ClickHouseSink.table,
-    ~converters,
-    ~changes: array<Change.t<Internal.entity>>,
-  ) => {
-    let rows = changes->Array.length
-    let builders = table.columns->Array.map(ClickHouseSink.makeBuilder(_, ~rows))
-    let columns = builders->Array.length
-    for row in 0 to rows - 1 {
+  let fillStage = (stage, ~converters, ~changes: array<Change.t<Internal.entity>>) => {
+    let columns = stage->Staging.columnCount
+    for row in 0 to changes->Array.length - 1 {
       let change = changes->Array.getUnsafe(row)
       let (cells, write) = switch change {
-      | Change.Set(_) => (converters.setCells, ClickHouseSink.writeValue)
-      | Delete(_) => (converters.deleteCells, ClickHouseSink.writeDeletedValue)
+      | Change.Set(_) => (converters.setCells, Staging.writeValue)
+      | Delete(_) => (converters.deleteCells, Staging.writeDeletedValue)
       }
       for column in 0 to columns - 1 {
-        builders->Array.getUnsafe(column)->write(~row, (cells->Array.getUnsafe(column))(change))
+        stage->write(~column, ~row, (cells->Array.getUnsafe(column))(change))
       }
     }
-    builders
   }
 )
 
@@ -306,31 +302,33 @@ let checkpointsTable = (sink, ~registry) =>
     table
   }
 
-let stageBuilders = (sink, ~table: ClickHouseSink.table, ~builders, ~rows) =>
-  sink->ClickHouseSink.stage(
-    ~table=table.handle,
-    ~rows,
-    ~columns=builders->Array.map(ClickHouseSink.builderPayload),
-  )
-
-let stageCheckpointsOrThrow = (sink, ~registry, ~batch: Batch.t) => {
-  let rows = batch.checkpointIds->Array.length
+let stageCheckpointsOrThrow = (
+  sink,
+  ~registry,
+  ~batch: Batch.t,
+  ~diffCheckpoints: array<InternalTable.Checkpoints.diffCheckpoint>,
+) => {
+  let rows = batch.checkpointIds->Array.length + diffCheckpoints->Array.length
   if rows === 0 {
     Null.null
   } else {
     let table = sink->checkpointsTable(~registry)
+    let stage =
+      sink->ClickHouseSink.arena->Staging.begin(~table=table.handle, ~rows, ~columns=table.columns)
     try {
       // The table was registered from `checkpointColumns`, in this order.
-      let builders = table.columns->Array.map(ClickHouseSink.makeBuilder(_, ~rows))
-      builders->Array.forEachWithIndex((builder, index) => {
-        let columnValues = (checkpointColumns->Array.getUnsafe(index)).valuesOf(batch)
+      table.columns->Array.forEachWithIndex((_, column) => {
+        let source = checkpointColumns->Array.getUnsafe(column)
+        let columnValues =
+          source.valuesOf(batch)->Array.concat(source.diffValuesOf(diffCheckpoints))
         for row in 0 to rows - 1 {
-          builder->ClickHouseSink.writeValue(~row, columnValues->Array.getUnsafe(row))
+          stage->Staging.writeValue(~column, ~row, columnValues->Array.getUnsafe(row))
         }
       })
-      Null.make(sink->stageBuilders(~table, ~builders, ~rows))
+      Null.make(stage->Staging.commit)
     } catch {
     | exn =>
+      stage->Staging.abort
       throw(
         Persistence.StorageError({
           message: `Failed to convert checkpoints for ClickHouse table "${table.name}"`,
@@ -355,6 +353,8 @@ let stageUpdatesOrThrow = (
     let table = sink->entityTable(~registry, ~entityConfig)
     let tableName = table.name
     let cacheKey = `${entityConfig.name}|${scope->Internal.chainScopeToString}`
+    let stage =
+      sink->ClickHouseSink.arena->Staging.begin(~table=table.handle, ~rows, ~columns=table.columns)
     try {
       let converters = switch registry.converters->Utils.Dict.dangerouslyGetNonOption(cacheKey) {
       | Some(cached) => cached
@@ -363,10 +363,11 @@ let stageUpdatesOrThrow = (
         registry.converters->Dict.set(cacheKey, cached)
         cached
       }
-      let builders = fillBuilders(~table, ~converters, ~changes)
-      Some(sink->stageBuilders(~table, ~builders, ~rows))
+      stage->fillStage(~converters, ~changes)
+      Some(stage->Staging.commit)
     } catch {
     | exn =>
+      stage->Staging.abort
       throw(
         Persistence.StorageError({
           message: `Failed to convert items for ClickHouse table "${tableName}"`,
@@ -415,20 +416,26 @@ let initialize = async (sink, ~entities: array<Internal.entityConfig>) => {
 
 let resume = async (
   sink,
-  ~checkpointId: Internal.checkpointId,
+  ~sequence: CheckpointSequence.t,
+  ~frontier: Frontier.t,
   ~chains: array<Persistence.initialChainState>,
   ~entities: array<Internal.entityConfig>,
 ) => {
   let chainProgress = chains->Array.map(chain => {
     ClickHouseSink.chainId: chain.id->ChainId.toString,
     progressBlockNumber: chain.progressBlockNumber,
+    committedCheckpointId: frontier->Frontier.get(chain.id)->BigInt.toString,
   })
   try await sink->ClickHouseSink.resume({
-    checkpointId: checkpointId->BigInt.toString,
+    perChain: switch sequence {
+    | PerChain => true
+    | SharedAcrossChains => false
+    },
     chainProgress,
-    historyTables: entities->Array.map(entityConfig => entitySpec(~entityConfig).historyTable),
-    replicated: Env.ClickHouse.replicated(),
-    databaseEngine: ?Env.ClickHouse.databaseEngine(),
+    historyTables: entities->Array.map(entityConfig => {
+      let spec = entitySpec(~entityConfig)
+      {ClickHouseSink.name: spec.historyTable, chainIdColumn: ?spec.chainIdColumn}
+    }),
   }) catch {
   | exn => {
       Logging.errorWithExn(exn, "Failed to resume ClickHouse storage")