envio 3.0.2 → 3.1.0-rc.1

package/src/PgStorage.res.mjs

@@ -19,6 +19,7 @@ import * as Persistence from "./Persistence.res.mjs";
 import * as ChainFetcher from "./ChainFetcher.res.mjs";
 import * as EntityHistory from "./db/EntityHistory.res.mjs";
 import * as InternalTable from "./db/InternalTable.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Child_process from "child_process";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
@@ -125,7 +126,8 @@ function getEntityHistory(entityConfig) {
           isPrimaryKey: true,
           isIndex: field$1.isIndex,
           linkedEntity: field$1.linkedEntity,
-          defaultValue: field$1.defaultValue
+          defaultValue: field$1.defaultValue,
+          description: field$1.description
         }
       };
     } else {
@@ -140,19 +142,20 @@ function getEntityHistory(entityConfig) {
           isPrimaryKey: field$1.isPrimaryKey,
           isIndex: false,
           linkedEntity: field$1.linkedEntity,
-          defaultValue: field$1.defaultValue
+          defaultValue: field$1.defaultValue,
+          description: field$1.description
         }
       };
     }
   });
-  let actionField = Table.mkField(EntityHistory.changeFieldName, EntityHistory.changeFieldType, S$RescriptSchema.never, undefined, undefined, undefined, undefined, undefined, undefined);
-  let checkpointIdField = Table.mkField(EntityHistory.checkpointIdFieldName, EntityHistory.checkpointIdFieldType, EntityHistory.unsafeCheckpointIdSchema, undefined, undefined, undefined, true, undefined, undefined);
+  let actionField = Table.mkField(EntityHistory.changeFieldName, EntityHistory.changeFieldType, S$RescriptSchema.never, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+  let checkpointIdField = Table.mkField(EntityHistory.checkpointIdFieldName, EntityHistory.checkpointIdFieldType, EntityHistory.unsafeCheckpointIdSchema, undefined, undefined, undefined, true, undefined, undefined, undefined);
   let entityTableName = entityConfig.table.tableName;
   let historyTableName = EntityHistory.historyTableName(entityTableName, entityConfig.index);
   let table = Table.mkTable(historyTableName, undefined, Belt_Array.concat(dataFields, [
     checkpointIdField,
     actionField
-  ]));
+  ]), undefined);
   let setChangeSchema = EntityHistory.makeSetUpdateSchema(entityConfig.schema);
   let cache_setChangeSchemaRows = S$RescriptSchema.array(setChangeSchema);
   let cache$1 = {
@@ -506,7 +509,7 @@ function executeSet(sql, items, dbFunction) {
   }
 }
 
-async function writeBatch(sql, batch, rawEvents, pgSchema, rollbackTargetCheckpointId, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, escapeTables) {
+async function writeBatch(sql, batch, rawEvents, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, escapeTables) {
   try {
     let shouldSaveHistory = Config.shouldSaveHistory(config, isInReorgThreshold);
     let specificError = {
@@ -514,41 +517,54 @@ async function writeBatch(sql, batch, rawEvents, pgSchema, rollbackTargetCheckpo
     };
     let setRawEvents = __x => executeSet(__x, rawEvents, (sql, items) => setOrThrow(sql, items, InternalTable.RawEvents.table, InternalTable.RawEvents.schema, pgSchema));
     let setEntities = Belt_Array.map(updatedEntities, param => {
-      let updates = param.updates;
       let entityConfig = param.entityConfig;
       let entitiesToSet = [];
       let idsToDelete = [];
-      updates.forEach(row => {
-        let match = row.latestChange;
+      let diffCheckpointId = Stdlib_Option.map(rollback, r => r.diffCheckpointId);
+      let batchSetUpdates = [];
+      let batchDeleteEntityIds = [];
+      let batchDeleteCheckpointIds = [];
+      let idsWithDiff = new Set();
+      let latestChangeById = {};
+      let orderedIds = [];
+      Belt_Array.forEach(param.changes, change => {
+        let entityId = change.entityId;
+        if (Stdlib_Option.isNone(latestChangeById[entityId])) {
+          orderedIds.push(entityId);
+        }
+        latestChangeById[entityId] = change;
+        if (!shouldSaveHistory) {
+          return;
+        }
+        if (change.checkpointId === diffCheckpointId) {
+          idsWithDiff.add(entityId);
+          return;
+        }
+        if (change.type === "SET") {
+          batchSetUpdates.push(change);
+          return;
+        }
+        batchDeleteEntityIds.push(change.entityId);
+        batchDeleteCheckpointIds.push(change.checkpointId);
+      });
+      let backfillHistoryIds = new Set();
+      Belt_Array.forEach(orderedIds, entityId => {
+        let match = latestChangeById[entityId];
         if (match.type === "SET") {
           entitiesToSet.push(match.entity);
+        } else {
+          idsToDelete.push(match.entityId);
+        }
+        if (shouldSaveHistory && !idsWithDiff.has(entityId)) {
+          backfillHistoryIds.add(entityId);
           return;
         }
-        idsToDelete.push(match.entityId);
       });
       let shouldRemoveInvalidUtf8 = escapeTables !== undefined ? Primitive_option.valFromOption(escapeTables).has(entityConfig.table) : false;
       return async sql => {
         try {
           let promises = [];
           if (shouldSaveHistory) {
-            let backfillHistoryIds = new Set();
-            let batchSetUpdates = [];
-            let batchDeleteCheckpointIds = [];
-            let batchDeleteEntityIds = [];
-            updates.forEach(update => {
-              let containsRollbackDiffChange = update.containsRollbackDiffChange;
-              update.history.forEach(change => {
-                if (!containsRollbackDiffChange) {
-                  backfillHistoryIds.add(change.entityId);
-                }
-                if (change.type === "SET") {
-                  batchSetUpdates.push(change);
-                  return;
-                }
-                batchDeleteEntityIds.push(change.entityId);
-                batchDeleteCheckpointIds.push(change.checkpointId);
-              });
-            });
             if (backfillHistoryIds.size !== 0) {
               await EntityHistory.backfillHistory(sql, pgSchema, entityConfig.name, entityConfig.index, Array.from(backfillHistoryIds));
             }
@@ -615,11 +631,17 @@ async function writeBatch(sql, batch, rawEvents, pgSchema, rollbackTargetCheckpo
         }
       };
     });
-    let rollbackTables = rollbackTargetCheckpointId !== undefined ? sql => {
+    let rollbackTables;
+    if (rollback !== undefined) {
+      let rollbackTargetCheckpointId = rollback.targetCheckpointId;
+      rollbackTables = sql => {
         let promises = allEntities.map(entityConfig => EntityHistory.rollback(sql, pgSchema, entityConfig.name, entityConfig.index, rollbackTargetCheckpointId));
         promises.push(InternalTable.Checkpoints.rollback(sql, pgSchema, rollbackTargetCheckpointId));
         return Promise.all(promises);
-      } : undefined;
+      };
+    } else {
+      rollbackTables = undefined;
+    }
     try {
       await Promise.all([
         sql.begin(async sql => {
@@ -665,7 +687,7 @@ async function writeBatch(sql, batch, rawEvents, pgSchema, rollbackTargetCheckpo
     if (exn$1.RE_EXN_ID === PgEncodingError) {
       let escapeTables$1 = escapeTables !== undefined ? Primitive_option.valFromOption(escapeTables) : new Set();
       escapeTables$1.add(exn$1.table);
-      return await writeBatch(sql, batch, rawEvents, pgSchema, rollbackTargetCheckpointId, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, Primitive_option.some(escapeTables$1));
+      return await writeBatch(sql, batch, rawEvents, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, Primitive_option.some(escapeTables$1));
     }
     throw exn$1;
   }
@@ -1020,7 +1042,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
     sql.unsafe(makeGetRollbackRemovedIdsQuery(entityConfig, pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true}),
     sql.unsafe(makeGetRollbackRestoredEntitiesQuery(entityConfig, pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true})
   ]);
-  let writeBatchMethod = async (batch, rawEvents, rollbackTargetCheckpointId, isInReorgThreshold, config, allEntities, updatedEffectsCache, updatedEntities) => {
+  let writeBatchMethod = async (batch, rawEvents, rollback, isInReorgThreshold, config, allEntities, updatedEffectsCache, updatedEntities) => {
     let pgUpdates = [];
     let chUpdates = [];
     for (let i = 0, i_finish = updatedEntities.length; i < i_finish; ++i) {
@@ -1043,7 +1065,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
       sinkPromise = undefined;
     }
     let primaryTimerRef = Hrtime.makeTimer();
-    await writeBatch(sql, batch, rawEvents, pgSchema, rollbackTargetCheckpointId, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, pgUpdates, sinkPromise, undefined);
+    await writeBatch(sql, batch, rawEvents, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, pgUpdates, sinkPromise, undefined);
     return Prometheus.StorageWrite.increment("postgres", Hrtime.toSecondsFloat(Hrtime.timeSince(primaryTimerRef)));
   };
   let close = () => sql.end();
@@ -1103,7 +1125,11 @@ function makeStorageFromEnv(config, sqlOpt, pgSchemaOpt, isHasuraEnabledOpt) {
     }, pgSchema, Config.getPgUserEntities(config), Env.Hasura.aggregateEntities, Env.Hasura.responseLimit, Schema.make(Belt_Array.map(config.allEntities, e => e.table))), err => Promise.resolve(Logging.errorWithExn(Utils.prettifyExn(err), `Error tracking tables`))) : undefined, isHasuraEnabled ? tableNames => Stdlib_Promise.$$catch(Hasura.trackTables(Env.Hasura.graphqlEndpoint, {
       role: Env.Hasura.role,
       secret: Env.Hasura.secret
-    }, pgSchema, tableNames), err => Promise.resolve(Logging.errorWithExn(Utils.prettifyExn(err), `Error tracking new tables`))) : undefined);
+    }, pgSchema, tableNames.map(tableName => ({
+      tableName: tableName,
+      description: undefined,
+      columnDescriptions: {}
+    }))), err => Promise.resolve(Logging.errorWithExn(Utils.prettifyExn(err), `Error tracking new tables`))) : undefined);
 }
 
 function makePersistenceFromConfig(config, storageOpt) {

package/src/ReorgDetection.res

@@ -12,11 +12,6 @@ type blockData = {
 
 external generalizeBlockDataWithTimestamp: blockDataWithTimestamp => blockData = "%identity"
 
-type reorgGuard = {
-  rangeLastBlock: blockData,
-  prevRangeLastBlock: option<blockData>,
-}
-
 type reorgDetected = {
   scannedBlock: blockData,
   receivedBlock: blockData,
@@ -94,75 +89,57 @@ let getDataByBlockNumberCopyInThreshold = ({dataByBlockNumber, maxReorgDepth}: t
   copy
 }
 
-/** Registers a new reorg guard, prunes unneeded data, and returns the updated state.
- * Resets internal state if shouldRollbackOnReorg is false (detect-only mode)
-  */
+/** Registers observed (blockNumber, blockHash) pairs from a range fetch, prunes
+ * unneeded data, and returns the updated state.
+ *
+ * Iterates the provided block hashes, skips entries outside the reorg threshold,
+ * and compares each one against the previously scanned data. Returns on the first
+ * mismatch as `ReorgDetected`.
+ *
+ * Resets internal state if shouldRollbackOnReorg is false (detect-only mode).
+ */
 let registerReorgGuard = (
   {maxReorgDepth, shouldRollbackOnReorg} as self: t,
-  ~reorgGuard: reorgGuard,
+  ~blockHashes: array<blockData>,
   ~knownHeight,
 ) => {
   let dataByBlockNumberCopyInThreshold = self->getDataByBlockNumberCopyInThreshold(~knownHeight)
+  let thresholdBlockNumber = knownHeight - maxReorgDepth
 
-  let {rangeLastBlock, prevRangeLastBlock} = reorgGuard
-
-  let maybeReorgDetected = switch dataByBlockNumberCopyInThreshold->Utils.Dict.dangerouslyGetNonOption(
-    rangeLastBlock.blockNumber->Int.toString,
-  ) {
-  | Some(scannedBlock) if scannedBlock.blockHash !== rangeLastBlock.blockHash =>
-    Some({
-      receivedBlock: rangeLastBlock,
-      scannedBlock,
-    })
-  | _ =>
-    switch prevRangeLastBlock {
-    //If parentHash is None, then it's the genesis block (no reorg)
-    //Need to check that parentHash matches because of the dynamic contracts
-    | None => None
-    | Some(prevRangeLastBlock) =>
-      switch dataByBlockNumberCopyInThreshold->Utils.Dict.dangerouslyGetNonOption(
-        prevRangeLastBlock.blockNumber->Int.toString,
-      ) {
-      | Some(scannedBlock) if scannedBlock.blockHash !== prevRangeLastBlock.blockHash =>
-        Some({
-          receivedBlock: prevRangeLastBlock,
-          scannedBlock,
-        })
-      | _ => None
+  let maybeReorgDetected = ref(None)
+  let idx = ref(0)
+  while maybeReorgDetected.contents === None && idx.contents < blockHashes->Array.length {
+    let receivedBlock = blockHashes->Array.getUnsafe(idx.contents)
+    if receivedBlock.blockNumber >= thresholdBlockNumber {
+      let key = receivedBlock.blockNumber->Int.toString
+      // The working copy contains both previously scanned blocks AND blocks
+      // already written by earlier iterations of this same call, so a duplicate
+      // block number with a mismatching hash inside `blockHashes` itself is
+      // flagged as a reorg.
+      switch dataByBlockNumberCopyInThreshold->Utils.Dict.dangerouslyGetNonOption(key) {
+      | Some(scannedBlock) if scannedBlock.blockHash !== receivedBlock.blockHash =>
+        maybeReorgDetected := Some({receivedBlock, scannedBlock})
+      | _ => dataByBlockNumberCopyInThreshold->Dict.set(key, receivedBlock)
       }
     }
+    idx := idx.contents + 1
   }
 
-  switch maybeReorgDetected {
+  switch maybeReorgDetected.contents {
   | Some(reorgDetected) => (
       shouldRollbackOnReorg
         ? self
         : make(~chainReorgCheckpoints=[], ~maxReorgDepth, ~shouldRollbackOnReorg),
       ReorgDetected(reorgDetected),
     )
-  | None => {
-      dataByBlockNumberCopyInThreshold->Dict.set(
-        rangeLastBlock.blockNumber->Int.toString,
-        rangeLastBlock,
-      )
-      switch prevRangeLastBlock {
-      | None => ()
-      | Some(prevRangeLastBlock) =>
-        dataByBlockNumberCopyInThreshold->Dict.set(
-          prevRangeLastBlock.blockNumber->Int.toString,
-          prevRangeLastBlock,
-        )
-      }
-
-      (
-        {
-          maxReorgDepth,
-          dataByBlockNumber: dataByBlockNumberCopyInThreshold,
-          shouldRollbackOnReorg,
-        },
-        NoReorg,
-      )
-    }
+  | None => (
+      {
+        maxReorgDepth,
+        dataByBlockNumber: dataByBlockNumberCopyInThreshold,
+        shouldRollbackOnReorg,
+      },
+      NoReorg,
+    )
   }
 }
 

package/src/ReorgDetection.res.mjs

@@ -46,47 +46,39 @@ function getDataByBlockNumberCopyInThreshold(param, knownHeight) {
   return copy;
 }
 
-function registerReorgGuard(self, reorgGuard, knownHeight) {
+function registerReorgGuard(self, blockHashes, knownHeight) {
   let maxReorgDepth = self.maxReorgDepth;
   let shouldRollbackOnReorg = self.shouldRollbackOnReorg;
   let dataByBlockNumberCopyInThreshold = getDataByBlockNumberCopyInThreshold(self, knownHeight);
-  let prevRangeLastBlock = reorgGuard.prevRangeLastBlock;
-  let rangeLastBlock = reorgGuard.rangeLastBlock;
-  let scannedBlock = dataByBlockNumberCopyInThreshold[rangeLastBlock.blockNumber.toString()];
+  let thresholdBlockNumber = knownHeight - maxReorgDepth | 0;
   let maybeReorgDetected;
-  let exit = 0;
-  if (scannedBlock !== undefined && scannedBlock.blockHash !== rangeLastBlock.blockHash) {
-    maybeReorgDetected = {
-      scannedBlock: scannedBlock,
-      receivedBlock: rangeLastBlock
-    };
-  } else {
-    exit = 1;
-  }
-  if (exit === 1) {
-    if (prevRangeLastBlock !== undefined) {
-      let scannedBlock$1 = dataByBlockNumberCopyInThreshold[prevRangeLastBlock.blockNumber.toString()];
-      maybeReorgDetected = scannedBlock$1 !== undefined && scannedBlock$1.blockHash !== prevRangeLastBlock.blockHash ? ({
-          scannedBlock: scannedBlock$1,
-          receivedBlock: prevRangeLastBlock
-        }) : undefined;
-    } else {
-      maybeReorgDetected = undefined;
+  let idx = 0;
+  while (maybeReorgDetected === undefined && idx < blockHashes.length) {
+    let receivedBlock = blockHashes[idx];
+    if (receivedBlock.blockNumber >= thresholdBlockNumber) {
+      let key = receivedBlock.blockNumber.toString();
+      let scannedBlock = dataByBlockNumberCopyInThreshold[key];
+      if (scannedBlock !== undefined && scannedBlock.blockHash !== receivedBlock.blockHash) {
+        maybeReorgDetected = {
+          scannedBlock: scannedBlock,
+          receivedBlock: receivedBlock
+        };
+      } else {
+        dataByBlockNumberCopyInThreshold[key] = receivedBlock;
+      }
     }
-  }
-  if (maybeReorgDetected !== undefined) {
+    idx = idx + 1 | 0;
+  };
+  let reorgDetected = maybeReorgDetected;
+  if (reorgDetected !== undefined) {
     return [
       shouldRollbackOnReorg ? self : make([], maxReorgDepth, shouldRollbackOnReorg),
       {
         TAG: "ReorgDetected",
-        _0: maybeReorgDetected
+        _0: reorgDetected
       }
     ];
   } else {
-    dataByBlockNumberCopyInThreshold[rangeLastBlock.blockNumber.toString()] = rangeLastBlock;
-    if (prevRangeLastBlock !== undefined) {
-      dataByBlockNumberCopyInThreshold[prevRangeLastBlock.blockNumber.toString()] = prevRangeLastBlock;
-    }
     return [
       {
         shouldRollbackOnReorg: shouldRollbackOnReorg,

package/src/SimulateItems.res.mjs

@@ -281,9 +281,27 @@ function patchConfig(config, processConfig) {
     newrecord.startBlock = startBlock;
     return newrecord;
   });
-  let newrecord = {...config};
-  newrecord.chainMap = newChainMap;
-  return newrecord;
+  return {
+    name: config.name,
+    description: config.description,
+    handlers: config.handlers,
+    contractHandlers: config.contractHandlers,
+    shouldRollbackOnReorg: config.shouldRollbackOnReorg,
+    shouldSaveFullHistory: config.shouldSaveFullHistory,
+    storage: config.storage,
+    chainMap: newChainMap,
+    defaultChain: config.defaultChain,
+    ecosystem: config.ecosystem,
+    enableRawEvents: config.enableRawEvents,
+    maxAddrInPartition: config.maxAddrInPartition,
+    batchSize: config.batchSize,
+    lowercaseAddresses: config.lowercaseAddresses,
+    isDev: config.isDev,
+    userEntitiesByName: config.userEntitiesByName,
+    userEntities: config.userEntities,
+    allEntities: config.allEntities,
+    allEnums: config.allEnums
+  };
 }
 
 export {

package/src/Sink.res

@@ -34,8 +34,8 @@ let makeClickHouse = (~host, ~database, ~username, ~password): t => {
     },
     writeBatch: async (~batch, ~updatedEntities) => {
       await Promise.all(
-        updatedEntities->Belt.Array.map(({entityConfig, updates}) => {
-          ClickHouse.setUpdatesOrThrow(client, ~cache, ~updates, ~entityConfig, ~database)
+        updatedEntities->Belt.Array.map(({entityConfig, changes}) => {
+          ClickHouse.setUpdatesOrThrow(client, ~cache, ~changes, ~entityConfig, ~database)
         }),
       )->Utils.Promise.ignoreValue
       await ClickHouse.setCheckpointsOrThrow(client, ~batch, ~database)

package/src/Sink.res.mjs

@@ -21,7 +21,7 @@ function makeClickHouse(host, database, username, password) {
     },
     resume: checkpointId => ClickHouse.resume(client, database, checkpointId),
     writeBatch: async (batch, updatedEntities) => {
-      await Promise.all(Belt_Array.map(updatedEntities, param => ClickHouse.setUpdatesOrThrow(client, cache, param.updates, param.entityConfig, database)));
+      await Promise.all(Belt_Array.map(updatedEntities, param => ClickHouse.setUpdatesOrThrow(client, cache, param.changes, param.entityConfig, database)));
       return await ClickHouse.setCheckpointsOrThrow(client, batch, database);
     }
   };

package/src/TableIndices.res

@@ -69,9 +69,14 @@ module SingleIndex = {
     operator,
   }
 
-  // Should much hashing logic in InMemoryTable
+  // Lookups against the in-memory index table reconstruct this key from raw
+  // (fieldName, operator, serialized value) parts, so this is the single
+  // source of truth for the key format.
+  let toStringByParts = (~fieldName, ~operator: Operator.t, ~fieldValueHash) =>
+    `${fieldName}:${(operator :> string)}:${fieldValueHash}`
+
   let toString = ({fieldName, fieldValue, operator}) =>
-    `${fieldName}:${(operator :> string)}:${fieldValue->FieldValue.toString}`
+    toStringByParts(~fieldName, ~operator, ~fieldValueHash=fieldValue->FieldValue.toString)
 
   let evaluate = (self: t, ~fieldName, ~fieldValue) =>
     self.fieldName === fieldName &&
@@ -101,6 +106,8 @@ module Index = {
     | Single(index) => index->SingleIndex.toString
     }
 
+  let toStringByParts = SingleIndex.toStringByParts
+
   let evaluate = (index: t, ~fieldName, ~fieldValue) =>
     switch index {
     | Single(index) => SingleIndex.evaluate(index, ~fieldName, ~fieldValue)

package/src/TableIndices.res.mjs

@@ -81,8 +81,12 @@ function make(fieldName, fieldValue, operator) {
   };
 }
 
+function toStringByParts(fieldName, operator, fieldValueHash) {
+  return fieldName + `:` + operator + `:` + fieldValueHash;
+}
+
 function toString$2(param) {
-  return param.fieldName + `:` + param.operator + `:` + toString$1(param.fieldValue);
+  return toStringByParts(param.fieldName, param.operator, toString$1(param.fieldValue));
 }
 
 function evaluate(self, fieldName, fieldValue) {
@@ -102,6 +106,7 @@ function evaluate(self, fieldName, fieldValue) {
 
 let SingleIndex = {
   make: make,
+  toStringByParts: toStringByParts,
   toString: toString$2,
   evaluate: evaluate
 };
@@ -126,6 +131,7 @@ let Index = {
   makeSingle: makeSingle,
   getFieldName: getFieldName,
   toString: toString$3,
+  toStringByParts: toStringByParts,
   evaluate: evaluate$1
 };
 

package/src/TestIndexer.res

@@ -122,7 +122,7 @@ let handleWriteBatch = (
   // checkpointId -> entityName -> entityChange
   let changesByCheckpoint: dict<dict<entityChange>> = Dict.make()
 
-  updatedEntities->Array.forEach(({entityName, updates}) => {
+  updatedEntities->Array.forEach(({entityName, changes}) => {
     let entityDict = switch state.entities->Dict.get(entityName) {
     | Some(dict) => dict
     | None =>
@@ -132,68 +132,61 @@ let handleWriteBatch = (
     }
     let entityConfig = state.entityConfigs->Dict.getUnsafe(entityName)
 
-    updates->Array.forEach(update => {
-      // Helper to process a single change (Set or Delete)
-      let processChange = (change: TestIndexerProxyStorage.serializableChange) => {
-        switch change {
-        | Set({entityId, entity, checkpointId}) =>
-          // Parse entity immediately to store decoded values for proper comparisons
-          // (bigint/BigDecimal need actual values, not JSON strings)
-          let parsedEntity = entity->S.parseOrThrow(entityConfig.schema)
-
-          // Update entities dict with parsed entity for load operations
-          entityDict->Dict.set(entityId, parsedEntity)
-
-          // Track change by checkpoint
-          let checkpointKey = checkpointId->BigInt.toString
-          let entityChanges = switch changesByCheckpoint->Dict.get(checkpointKey) {
-          | Some(changes) => changes
-          | None =>
-            let changes = Dict.make()
-            changesByCheckpoint->Dict.set(checkpointKey, changes)
-            changes
-          }
-          let entityChange = switch entityChanges->Dict.get(entityName) {
-          | Some(change) => change
-          | None =>
-            let change = {sets: [], deleted: []}
-            entityChanges->Dict.set(entityName, change)
-            change
-          }
-          entityChange.sets->Array.push(parsedEntity->Utils.magic)->ignore
-
-        | Delete({entityId, checkpointId}) =>
-          // Update entities dict for load operations
-          Dict.delete(entityDict->Obj.magic, entityId)
-
-          // Track change by checkpoint
-          let checkpointKey = checkpointId->BigInt.toString
-          let entityChanges = switch changesByCheckpoint->Dict.get(checkpointKey) {
-          | Some(changes) => changes
-          | None =>
-            let changes = Dict.make()
-            changesByCheckpoint->Dict.set(checkpointKey, changes)
-            changes
-          }
-          let entityChange = switch entityChanges->Dict.get(entityName) {
-          | Some(change) => change
-          | None =>
-            let change = {sets: [], deleted: []}
-            entityChanges->Dict.set(entityName, change)
-            change
-          }
-          entityChange.deleted->Array.push(entityId)->ignore
+    let processChange = (change: TestIndexerProxyStorage.serializableChange) => {
+      switch change {
+      | Set({entityId, entity, checkpointId}) =>
+        // Parse entity immediately to store decoded values for proper comparisons
+        // (bigint/BigDecimal need actual values, not JSON strings)
+        let parsedEntity = entity->S.parseOrThrow(entityConfig.schema)
+
+        // Update entities dict with parsed entity for load operations
+        entityDict->Dict.set(entityId, parsedEntity)
+
+        // Track change by checkpoint
+        let checkpointKey = checkpointId->BigInt.toString
+        let entityChanges = switch changesByCheckpoint->Dict.get(checkpointKey) {
+        | Some(changes) => changes
+        | None =>
+          let changes = Dict.make()
+          changesByCheckpoint->Dict.set(checkpointKey, changes)
+          changes
+        }
+        let entityChange = switch entityChanges->Dict.get(entityName) {
+        | Some(change) => change
+        | None =>
+          let change = {sets: [], deleted: []}
+          entityChanges->Dict.set(entityName, change)
+          change
+        }
+        entityChange.sets->Array.push(parsedEntity->Utils.magic)->ignore
+
+      | Delete({entityId, checkpointId}) =>
+        // Update entities dict for load operations
+        Dict.delete(entityDict->Obj.magic, entityId)
+
+        // Track change by checkpoint
+        let checkpointKey = checkpointId->BigInt.toString
+        let entityChanges = switch changesByCheckpoint->Dict.get(checkpointKey) {
+        | Some(changes) => changes
+        | None =>
+          let changes = Dict.make()
+          changesByCheckpoint->Dict.set(checkpointKey, changes)
+          changes
         }
+        let entityChange = switch entityChanges->Dict.get(entityName) {
+        | Some(change) => change
+        | None =>
+          let change = {sets: [], deleted: []}
+          entityChanges->Dict.set(entityName, change)
+          change
+        }
+        entityChange.deleted->Array.push(entityId)->ignore
       }
+    }
 
-      // Iterate over all history entries (mirroring PgStorage.res behavior)
-      update.history->Array.forEach(processChange)
-
-      // Also include latestChange if history is empty (fallback for backwards compatibility)
-      if update.history->Array.length === 0 {
-        processChange(update.latestChange)
-      }
-    })
+    // Every change carries its own checkpointId and each (id, checkpointId)
+    // appears at most once in the batch, so record them all into their buckets.
+    changes->Array.forEach(processChange)
   })
 
   // Build combined checkpoint + entity changes objects