envio 3.5.1 → 3.6.1-subgraph

package/src/UserContext.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
+import * as ChainId from "./ChainId.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import * as Ecosystem from "./Ecosystem.res.mjs";
@@ -12,8 +13,70 @@ 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 Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 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 Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+let Suspend = /* @__PURE__ */Primitive_exceptions.create("UserContext.Suspend");
+
+function isSuspend(exn) {
+  return exn.RE_EXN_ID === Suspend;
+}
+
+function makeSyncState() {
+  return {
+    status: "Active",
+    pending: undefined,
+    memo: undefined
+  };
+}
+
+function getPending(sync) {
+  let pending = sync.pending;
+  if (pending !== undefined) {
+    return pending;
+  }
+  let pending$1 = [];
+  sync.pending = pending$1;
+  return pending$1;
+}
+
+function getMemo(sync) {
+  let memo = sync.memo;
+  if (memo !== undefined) {
+    return memo;
+  }
+  let memo$1 = {};
+  sync.memo = memo$1;
+  return memo$1;
+}
+
+function checkStatusOrThrow(params, access) {
+  let exn = params.sync.status;
+  if (typeof exn !== "object") {
+    if (exn === "Active") {
+      return;
+    } else {
+      return ErrorHandling.mkLogAndRaise(Ecosystem.getItemLogger(params.item, params.config.ecosystem), undefined, new Error(`Impossible to access ` + access + ` after the handler is resolved. Make sure you didn't miss an await in the handler.`));
+    }
+  }
+  throw exn._0;
+}
+
+function scheduleAndSuspend(params, promise) {
+  getPending(params.sync).push(promise);
+  params.sync.status = {
+    TAG: "Aborted",
+    _0: {
+      RE_EXN_ID: Suspend
+    }
+  };
+  throw {
+    RE_EXN_ID: Suspend,
+    Error: new Error()
+  };
+}
 
 let paramsByThis = new WeakMap();
 
@@ -47,36 +110,82 @@ var EffectContext = function(params, chainId, effectName, defaultShouldCache, ca
 EffectContext.prototype = effectContextPrototype;
 ;
 
+function prepareEffectCall(params, effect, input, caller) {
+  let isCrossChain = effect => Stdlib_Option.getOr(effect.crossChain, params.config.defaultCrossChain);
+  let scope = isCrossChain(effect) ? "crossChain" : Internal.getItemChainId(params.item);
+  if (caller !== undefined && isCrossChain(caller) && !isCrossChain(effect)) {
+    Stdlib_JsError.throwWithMessage(`The cross-chain effect "` + caller.name + `" cannot call the chain-scoped effect "` + effect.name + `", because a cross-chain effect isn't tied to a single chain. Make "` + effect.name + `" cross-chain (\`crossChain: true\`), or make "` + caller.name + `" chain-scoped (\`crossChain: false\`).`);
+  }
+  let tmp;
+  tmp = scope === "crossChain" ? undefined : Primitive_option.some(scope);
+  let effectContext = new EffectContext(params, tmp, effect.name, effect.defaultShouldCache, (nested, nestedInput) => callEffectAsync(params, nested, nestedInput, effect));
+  let effectArgs_cacheKey = Utils.Hash.makeOrThrow(S$RescriptSchema.reverseConvertOrThrow(input, effect.input));
+  let effectArgs_checkpointId = params.checkpointId;
+  let effectArgs = {
+    input: input,
+    context: effectContext,
+    cacheKey: effectArgs_cacheKey,
+    checkpointId: effectArgs_checkpointId
+  };
+  return [
+    scope,
+    effectArgs
+  ];
+}
+
+function callEffectAsync(params, effect, input, caller) {
+  let match = prepareEffectCall(params, effect, input, caller);
+  return LoadLayer.loadEffect(params.loadManager, params.persistence, effect, match[1], match[0], params.indexerState, params.isPreload, params.item, params.config.ecosystem);
+}
+
 function initEffect(params) {
-  let handlerChainId = Internal.getItemChainId(params.item);
-  let makeCaller = caller => ((effect, input) => {
-    let scope = effect.crossChain ? "crossChain" : handlerChainId;
-    if (caller !== undefined && caller.crossChain && !effect.crossChain) {
-      Stdlib_JsError.throwWithMessage(`The cross-chain effect "` + caller.name + `" cannot call the chain-scoped effect "` + effect.name + `", because a cross-chain effect isn't tied to a single chain. Make "` + effect.name + `" cross-chain (\`crossChain: true\`), or make "` + caller.name + `" chain-scoped (\`crossChain: false\`).`);
+  return (effect, input) => {
+    checkStatusOrThrow(params, "context.effect");
+    return callEffectAsync(params, effect, input, undefined);
+  };
+}
+
+function effectMemoKey(effect, scope, cacheKey) {
+  if (scope === "crossChain") {
+    return effect.name + `.` + cacheKey;
+  } else {
+    return effect.name + `.` + ChainId.toString(scope) + `.` + cacheKey;
+  }
+}
+
+function initEffectSync(params) {
+  return (effect, input) => {
+    checkStatusOrThrow(params, "context.effectSync");
+    let match = prepareEffectCall(params, effect, input, undefined);
+    let effectArgs = match[1];
+    let scope = match[0];
+    let memo = getMemo(params.sync);
+    let memoKey = effectMemoKey(effect, scope, effectArgs.cacheKey);
+    let output = memo[memoKey];
+    if (output !== undefined) {
+      return Primitive_option.valFromOption(output);
     }
-    let tmp;
-    tmp = scope === "crossChain" ? undefined : Primitive_option.some(scope);
-    let effectContext = new EffectContext(params, tmp, effect.name, effect.defaultShouldCache, makeCaller(effect));
-    let effectArgs_cacheKey = Utils.Hash.makeOrThrow(S$RescriptSchema.reverseConvertOrThrow(input, effect.input));
-    let effectArgs_checkpointId = params.checkpointId;
-    let effectArgs = {
-      input: input,
-      context: effectContext,
-      cacheKey: effectArgs_cacheKey,
-      checkpointId: effectArgs_checkpointId
-    };
-    return LoadLayer.loadEffect(params.loadManager, params.persistence, effect, effectArgs, scope, params.indexerState, params.isPreload, params.item, params.config.ecosystem);
-  });
-  return makeCaller(undefined);
+    let inMemTable = InMemoryStore.getEffectInMemTable(params.indexerState, effect, scope);
+    if (!InMemoryStore.hasEffectOutput(inMemTable, effectArgs.cacheKey)) {
+      return scheduleAndSuspend(params, LoadLayer.loadEffect(params.loadManager, params.persistence, effect, effectArgs, scope, params.indexerState, params.isPreload, params.item, params.config.ecosystem));
+    }
+    let output$1 = InMemoryStore.getEffectOutputUnsafe(inMemTable, effectArgs.cacheKey);
+    memo[memoKey] = output$1;
+    return output$1;
+  };
+}
+
+function entityScope(params) {
+  return InMemoryStore.entityScope(params.entityConfig, Internal.getItemChainId(params.item));
 }
 
 function getWhereHandler(params, filter) {
   let entityConfig = params.entityConfig;
   let filters = EntityFilter.parseGetWhereOrThrow(filter, entityConfig.name, entityConfig.table);
   if (filters.length !== 1) {
-    return Promise.all(filters.map(filter => LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, filter))).then(results => results.flat());
+    return Promise.all(filters.map(filter => LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, filter))).then(results => results.flat());
   } else {
-    return LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, filters[0]);
+    return LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, filters[0]);
   }
 }
 
@@ -92,36 +201,97 @@ function throwClickHouseReadOnly(entityConfig, op) {
   return Stdlib_JsError.throwWithMessage(`context.` + entityConfig.name + `.` + op + `() is unavailable: ClickHouse storage is currently write-only. Follow Envio releases to be notified when ClickHouse supports both reads and writes from handlers.`);
 }
 
+function getSyncHandler(params, entityId) {
+  let inMemTable = InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, entityScope(params));
+  if (entityId in inMemTable.latestEntityChangeById) {
+    return InMemoryTable.Entity.getUnsafe(inMemTable)(entityId);
+  } else {
+    return scheduleAndSuspend(params, LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, entityId));
+  }
+}
+
+function getWhereSyncHandler(params, filter) {
+  let entityConfig = params.entityConfig;
+  let inMemTable = InMemoryStore.getInMemTable(params.indexerState, entityConfig, entityScope(params));
+  let hasIndex = InMemoryTable.Entity.hasIndex(inMemTable);
+  let getOnIndex = InMemoryTable.Entity.getUnsafeOnIndex(inMemTable);
+  let filters = EntityFilter.parseGetWhereOrThrow(filter, entityConfig.name, entityConfig.table);
+  let missing = [];
+  let entities = [];
+  filters.forEach(filter => {
+    let filterKey = EntityFilter.toString(filter);
+    if (hasIndex(filterKey)) {
+      entities.push(...getOnIndex(filterKey));
+    } else {
+      missing.push(LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, filter));
+    }
+  });
+  if (Utils.$$Array.notEmpty(missing)) {
+    let pending = getPending(params.sync);
+    missing.forEach(promise => {
+      pending.push(promise);
+    });
+    params.sync.status = {
+      TAG: "Aborted",
+      _0: {
+        RE_EXN_ID: Suspend
+      }
+    };
+    throw {
+      RE_EXN_ID: Suspend,
+      Error: new Error()
+    };
+  }
+  return entities;
+}
+
+function getInBlockSyncHandler(params, entityId) {
+  let inMemTable = InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, entityScope(params));
+  let change = inMemTable.latestEntityChangeById[entityId];
+  if (change !== undefined && change.checkpointId === params.checkpointId) {
+    return InMemoryTable.Entity.mapChangeToEntity(change);
+  }
+}
+
 let entityTraps_get = (params, prop) => {
+  checkStatusOrThrow(params, `context.` + params.entityConfig.name + `.` + prop);
   let isClickHouseOnly = !params.entityConfig.storage.postgres;
-  let set = params.isPreload ? noopSet : entity => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig), IndexerState.committedCheckpointId(params.indexerState), {
-      type: "SET",
-      entityId: entity.id,
-      entity: entity,
-      checkpointId: params.checkpointId
-    });
+  let set = params.isPreload ? noopSet : entity => {
+      checkStatusOrThrow(params, `context.` + params.entityConfig.name + `.set`);
+      InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, entityScope(params)), IndexerState.committedCheckpointId(params.indexerState), {
+        type: "SET",
+        entityId: entity.id,
+        entity: entity,
+        checkpointId: params.checkpointId
+      });
+    };
   switch (prop) {
     case "deleteUnsafe" :
       if (params.isPreload) {
         return noopDeleteUnsafe;
       } else {
-        return entityId => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig), IndexerState.committedCheckpointId(params.indexerState), {
-          type: "DELETE",
-          entityId: entityId,
-          checkpointId: params.checkpointId
-        });
+        return entityId => {
+          checkStatusOrThrow(params, `context.` + params.entityConfig.name + `.deleteUnsafe`);
+          InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, entityScope(params)), IndexerState.committedCheckpointId(params.indexerState), {
+            type: "DELETE",
+            entityId: entityId,
+            checkpointId: params.checkpointId
+          });
+        };
       }
     case "get" :
       if (isClickHouseOnly) {
         return _entityId => throwClickHouseReadOnly(params.entityConfig, "get");
       } else {
-        return entityId => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, entityId);
+        return entityId => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, entityId);
       }
+    case "getInBlockSync" :
+      return entityId => getInBlockSyncHandler(params, entityId);
     case "getOrCreate" :
       if (isClickHouseOnly) {
         return _entity => throwClickHouseReadOnly(params.entityConfig, "getOrCreate");
       } else {
-        return entity => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, entity.id).then(storageEntity => {
+        return entity => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, entity.id).then(storageEntity => {
           if (storageEntity !== undefined) {
             return storageEntity;
           } else {
@@ -134,7 +304,7 @@ let entityTraps_get = (params, prop) => {
       if (isClickHouseOnly) {
         return (_entityId, param) => throwClickHouseReadOnly(params.entityConfig, "getOrThrow");
       } else {
-        return (entityId, message) => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, entityId).then(entity => {
+        return (entityId, message) => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, entityId).then(entity => {
           if (entity !== undefined) {
             return entity;
           } else {
@@ -142,12 +312,16 @@ let entityTraps_get = (params, prop) => {
           }
         });
       }
+    case "getSync" :
+      return entityId => getSyncHandler(params, entityId);
     case "getWhere" :
       if (isClickHouseOnly) {
         return _filter => throwClickHouseReadOnly(params.entityConfig, "getWhere");
       } else {
         return filter => getWhereHandler(params, filter);
       }
+    case "getWhereSync" :
+      return filter => getWhereSyncHandler(params, filter);
     case "set" :
       return set;
     default:
@@ -159,16 +333,63 @@ let entityTraps = {
   get: entityTraps_get
 };
 
-let handlerTraps_get = (params, prop) => {
-  if (params.isResolved) {
-    ErrorHandling.mkLogAndRaise(Ecosystem.getItemLogger(params.item, params.config.ecosystem), undefined, new Error(`Impossible to access context.` + prop + ` after the handler is resolved. Make sure you didn't miss an await in the handler.`));
+async function runSyncRound(params, fn, round) {
+  if (round > 10000) {
+    Stdlib_JsError.throwWithMessage(`The handler suspended on a synchronous read too many times: gave up after ` + (10000).toString() + ` rounds. This usually means the code isn't deterministic across reruns.`);
+  }
+  params.sync.status = "Active";
+  params.sync.pending = undefined;
+  let suspended;
+  try {
+    fn();
+    suspended = false;
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    if (exn.RE_EXN_ID === Suspend) {
+      suspended = true;
+    } else {
+      let pending = params.sync.pending;
+      if (pending !== undefined) {
+        params.sync.pending = undefined;
+        pending.forEach(promise => {
+          Utils.$$Promise.silentCatch(promise);
+        });
+      }
+      throw exn;
+    }
   }
+  let pending$1 = params.sync.pending;
+  if (pending$1 === undefined) {
+    return;
+  }
+  params.sync.pending = undefined;
+  if (suspended) {
+    let errors = [];
+    await Promise.all(pending$1.map(promise => Stdlib_Promise.$$catch(promise, exn => {
+      errors.push(exn);
+      return Promise.resolve();
+    })));
+    let exn$1 = errors[0];
+    if (exn$1 !== undefined) {
+      throw exn$1;
+    }
+    return await runSyncRound(params, fn, round + 1 | 0);
+  }
+  pending$1.forEach(promise => {
+    Utils.$$Promise.silentCatch(promise);
+  });
+}
+
+let handlerTraps_get = (params, prop) => {
+  checkStatusOrThrow(params, `context.` + prop);
   switch (prop) {
     case "chain" :
       let chainId = Internal.getItemChainId(params.item);
       return params.chains[chainId];
     case "effect" :
       return initEffect(params);
+    case "effectSync" :
+      return initEffectSync(params);
     case "isPreload" :
       return params.isPreload;
     case "log" :
@@ -177,6 +398,8 @@ let handlerTraps_get = (params, prop) => {
       } else {
         return Ecosystem.getItemUserLogger(params.item, params.config.ecosystem);
       }
+    case "runSync" :
+      return fn => runSyncRound(params, fn, 1);
     default:
       let entityConfig = params.config.userEntitiesByName[prop];
       if (entityConfig !== undefined) {
@@ -189,7 +412,7 @@ let handlerTraps_get = (params, prop) => {
           isPreload: params.isPreload,
           chains: params.chains,
           config: params.config,
-          isResolved: params.isResolved,
+          sync: params.sync,
           entityConfig: entityConfig
         }, entityTraps);
       } else {
@@ -206,15 +429,34 @@ function getHandlerContext(params) {
   return new Proxy(params, handlerTraps);
 }
 
+let maxSyncRounds = 10000;
+
 export {
+  Suspend,
+  isSuspend,
+  makeSyncState,
+  getPending,
+  getMemo,
+  checkStatusOrThrow,
+  scheduleAndSuspend,
   paramsByThis,
   effectContextPrototype,
+  prepareEffectCall,
+  callEffectAsync,
   initEffect,
+  effectMemoKey,
+  initEffectSync,
+  entityScope,
   getWhereHandler,
   noopSet,
   noopDeleteUnsafe,
   throwClickHouseReadOnly,
+  getSyncHandler,
+  getWhereSyncHandler,
+  getInBlockSyncHandler,
   entityTraps,
+  maxSyncRounds,
+  runSyncRound,
   handlerTraps,
   getHandlerContext,
 }

package/src/Writing.res

@@ -10,10 +10,8 @@ let keepLatestChangesLimit = Env.inMemoryObjectsTarget
 
 let getChangesCount = (state: IndexerState.t) => {
   let total = ref(0.)
-  state
-  ->IndexerState.allEntities
-  ->Array.forEach(entityConfig => {
-    total := total.contents +. (state->InMemoryStore.getInMemTable(~entityConfig)).changesCount
+  state->IndexerState.eachEntityTable((~entityConfig as _, ~scope as _, ~table) => {
+    total := total.contents +. table.changesCount
   })
   state
   ->IndexerState.effectState
@@ -113,14 +111,12 @@ let runOneWrite = async (state: IndexerState.t) => {
 
     let rollback = state->IndexerState.takeRollback
 
-    let updatedEntities = persistence.allEntities->Array.filterMap(entityConfig => {
-      let table = state->InMemoryStore.getInMemTable(~entityConfig)
+    let updatedEntities = []
+    state->IndexerState.eachEntityTable((~entityConfig, ~scope, ~table) => {
       let changes =
         table->InMemoryTable.Entity.snapshotChanges(~committedCheckpointId, ~upToCheckpointId)
-      if changes->Utils.Array.isEmpty {
-        None
-      } else {
-        Some(({entityConfig, changes}: Persistence.updatedEntity))
+      if changes->Utils.Array.notEmpty {
+        updatedEntities->Array.push(({entityConfig, scope, changes}: Persistence.updatedEntity))
       }
     })
     let updatedEffectsCache = snapshotEffects(state, ~cache)
@@ -221,12 +217,8 @@ let commitBatch = (state: IndexerState.t, ~batch: Batch.t) => {
 // keepLoadedFromDb, entries seeded from a db read are spared.
 let dropCommitted = (state: IndexerState.t, ~keepLoadedFromDb) => {
   let committedCheckpointId = state->IndexerState.committedCheckpointId
-  state
-  ->IndexerState.allEntities
-  ->Array.forEach(entityConfig =>
-    state
-    ->InMemoryStore.getInMemTable(~entityConfig)
-    ->InMemoryTable.Entity.dropCommittedChanges(~committedCheckpointId, ~keepLoadedFromDb)
+  state->IndexerState.eachEntityTable((~entityConfig as _, ~scope as _, ~table) =>
+    table->InMemoryTable.Entity.dropCommittedChanges(~committedCheckpointId, ~keepLoadedFromDb)
   )
   state
   ->IndexerState.effectState

package/src/Writing.res.mjs

@@ -19,8 +19,8 @@ function getChangesCount(state) {
   let total = {
     contents: 0
   };
-  IndexerState.allEntities(state).forEach(entityConfig => {
-    total.contents = total.contents + InMemoryStore.getInMemTable(state, entityConfig).changesCount;
+  IndexerState.eachEntityTable(state, (param, param$1, table) => {
+    total.contents = total.contents + table.changesCount;
   });
   EffectState.forEach(IndexerState.effectState(state), inMemTable => {
     total.contents = total.contents + inMemTable.changesCount;
@@ -105,16 +105,16 @@ async function runOneWrite(state) {
   let checkpointId = Utils.$$Array.last(batch.checkpointIds);
   let upToCheckpointId = checkpointId !== undefined ? checkpointId : committedCheckpointId;
   let rollback = IndexerState.takeRollback(state);
-  let updatedEntities = Stdlib_Array.filterMap(persistence.allEntities, entityConfig => {
-    let table = InMemoryStore.getInMemTable(state, entityConfig);
+  let updatedEntities = [];
+  IndexerState.eachEntityTable(state, (entityConfig, scope, table) => {
     let changes = InMemoryTable.Entity.snapshotChanges(table, committedCheckpointId, upToCheckpointId);
-    if (Utils.$$Array.isEmpty(changes)) {
-      return;
-    } else {
-      return {
+    if (Utils.$$Array.notEmpty(changes)) {
+      updatedEntities.push({
         entityConfig: entityConfig,
+        scope: scope,
         changes: changes
-      };
+      });
+      return;
     }
   });
   let updatedEffectsCache = snapshotEffects(state, cache);
@@ -179,7 +179,7 @@ function commitBatch(state, batch) {
 
 function dropCommitted(state, keepLoadedFromDb) {
   let committedCheckpointId = IndexerState.committedCheckpointId(state);
-  IndexerState.allEntities(state).forEach(entityConfig => InMemoryTable.Entity.dropCommittedChanges(InMemoryStore.getInMemTable(state, entityConfig), committedCheckpointId, keepLoadedFromDb));
+  IndexerState.eachEntityTable(state, (param, param$1, table) => InMemoryTable.Entity.dropCommittedChanges(table, committedCheckpointId, keepLoadedFromDb));
   EffectState.forEach(IndexerState.effectState(state), inMemTable => InMemoryStore.dropCommittedEffects(inMemTable, committedCheckpointId, keepLoadedFromDb));
 }
 

package/src/bindings/ClickHouse.res

@@ -248,15 +248,21 @@ type setUpdatesCache = {
 
 let setUpdatesOrThrow = async (
   client,
-  ~cache: Utils.WeakMap.t<Internal.entityConfig, setUpdatesCache>,
+  ~cache: dict<setUpdatesCache>,
   ~changes: array<Change.t<Internal.entity>>,
   ~entityConfig: Internal.entityConfig,
+  ~scope: Internal.chainScope,
   ~database: string,
 ) => {
   if changes->Array.length === 0 {
     ()
   } else {
-    let {convertOrThrow, tableName} = switch cache->Utils.WeakMap.get(entityConfig) {
+    let chainIdField = entityConfig.table->Table.getChainIdField
+    let scopeChainId = scope->Internal.chainScopeChainId
+    // A delete row carries no entity to stamp, so the chain id is baked into
+    // the schema instead — which is why the cache is keyed per scope.
+    let cacheKey = `${entityConfig.name}|${scope->Internal.chainScopeToString}`
+    let {convertOrThrow, tableName} = switch cache->Utils.Dict.dangerouslyGetNonOption(cacheKey) {
     | Some(cached) => cached
     | None =>
       let cached: setUpdatesCache = {
@@ -273,6 +279,11 @@ let setUpdatesOrThrow = async (
               ),
               S.object(s => {
                 s.tag(EntityHistory.changeFieldName, EntityHistory.RowAction.DELETE)
+                switch (chainIdField, scopeChainId) {
+                | (Some(field), Some(chainId)) =>
+                  s.tag(field->Table.getClickHouseDbFieldName, chainId)
+                | _ => ()
+                }
                 Change.Delete({
                   entityId: s.field(Table.idFieldName, entityConfig.table->Table.getIdSchema),
                   checkpointId: s.field(
@@ -294,10 +305,25 @@ let setUpdatesOrThrow = async (
         ),
       }
 
-      cache->Utils.WeakMap.set(entityConfig, cached)->ignore
+      cache->Dict.set(cacheKey, cached)
       cached
     }
 
+    let changes = switch (chainIdField, scopeChainId) {
+    | (Some(field), Some(chainId)) =>
+      changes->Array.map(change =>
+        switch change {
+        | Change.Set(set) =>
+          Change.Set({
+            ...set,
+            entity: set.entity->Internal.stampChainId(~fieldName=field.fieldName, ~chainId),
+          })
+        | Delete(_) => change
+        }
+      )
+    | _ => changes
+    }
+
     try {
       // The entity history table is the source of truth for ClickHouse, so every
       // intermediate change must be persisted, not only the current value.
@@ -505,6 +531,16 @@ let makeCreateViewQuery = (
     ~entityIndex=entityConfig.index,
   )
 
+  // A per-chain entity's rows are only comparable within a chain, so the
+  // current-state dedup keys on (id, chain id).
+  let dedupKey =
+    switch entityConfig.table->Table.getChainIdField {
+    | Some(field) => [Table.idFieldName, field->Table.getClickHouseDbFieldName]
+    | None => [Table.idFieldName]
+    }
+    ->Array.map(name => `\`${name}\``)
+    ->Array.joinUnsafe(", ")
+
   let checkpointsTableName = InternalTable.Checkpoints.table.tableName
   let checkpointIdField = (#id: InternalTable.Checkpoints.field :> string)
 
@@ -528,7 +564,7 @@ FROM (
   FROM ${database}.\`${historyTableName}\`
   WHERE \`${EntityHistory.checkpointIdFieldName}\` <= (SELECT max(${checkpointIdField}) FROM ${database}.\`${checkpointsTableName}\`)
   ORDER BY \`${EntityHistory.checkpointIdFieldName}\` DESC
-  LIMIT 1 BY \`${Table.idFieldName}\`
+  LIMIT 1 BY ${dedupKey}
 )
 WHERE \`${EntityHistory.changeFieldName}\` = '${(EntityHistory.RowAction.SET :> string)}'`
 }