envio 3.5.0 → 3.5.1-svm-alpha.2

package/src/InMemoryStore.res

@@ -2,11 +2,45 @@
 // mutations route through IndexerState's domain operations; the write loop and
 // capacity/flush coordination live in Writing.
 
+// The scope must match the entity's own: a cross-chain entity has one table on
+// the indexer, a per-chain entity one table per ChainState. Taking the scope
+// rather than an optional chain id keeps a dummy chain id unrepresentable.
 let getInMemTable = (
   state: IndexerState.t,
   ~entityConfig: Internal.entityConfig,
+  ~scope: Internal.chainScope,
 ): InMemoryTable.Entity.t =>
-  state->IndexerState.entities->IndexerState.EntityTables.get(~entityName=entityConfig.name)
+  switch scope {
+  | CrossChain => state->IndexerState.entities
+  | Chain(chainId) => state->IndexerState.getChainState(~chainId)->ChainState.entities
+  }->EntityTables.get(~entityName=entityConfig.name)
+
+// The scope a given entity's rows live in when reached from a handler running
+// on `chainId`.
+let entityScope = (entityConfig: Internal.entityConfig, ~chainId): Internal.chainScope =>
+  entityConfig.crossChain ? CrossChain : Chain(chainId)
+
+// The chain a row loaded from storage belongs to, taken off the row so what's
+// left matches the entity schema the handlers see. A per-chain entity whose row
+// carries no chain id would silently land in the wrong partition, so it throws.
+let takeRowScope = (
+  entity: Internal.entity,
+  ~entityConfig: Internal.entityConfig,
+): Internal.chainScope =>
+  switch entityConfig.table->Table.getChainIdField {
+  | None => CrossChain
+  | Some(field) =>
+    let row = entity->(Utils.magic: Internal.entity => dict<ChainId.t>)
+    switch row->Utils.Dict.dangerouslyGetNonOption(field.fieldName) {
+    | Some(chainId) =>
+      row->Utils.Dict.deleteInPlace(field.fieldName)
+      Chain(chainId)
+    | None =>
+      JsError.throwWithMessage(
+        `Rollback row for the per-chain entity "${entityConfig.name}" with id "${entity.id}" is missing its "${field.fieldName}" value.`,
+      )
+    }
+  }
 
 let getEffectInMemTable = (
   state: IndexerState.t,
@@ -114,16 +148,16 @@ let prepareRollbackDiff = async (
   let _ = await persistence.allEntities
   ->Array.filter(entityConfig => entityConfig.storage.postgres)
   ->Array.map(async entityConfig => {
-    let entityTable = state->getInMemTable(~entityConfig)
-
-    let (removedIds, restoredEntitiesResult) = await persistence.storage.getRollbackData(
+    let (removals, restoredEntitiesResult) = await persistence.storage.getRollbackData(
       ~entityConfig,
       ~rollbackTargetCheckpointId,
     )
 
-    removedIds->Array.forEach(entityId => {
+    removals->Array.forEach(({entityId, scope}: Persistence.rollbackRemoval) => {
       deletedEntities->Utils.Dict.push(entityConfig.name, entityId)
-      entityTable->InMemoryTable.Entity.set(
+      state
+      ->getInMemTable(~entityConfig, ~scope)
+      ->InMemoryTable.Entity.set(
         ~committedCheckpointId,
         Delete({
           entityId,
@@ -138,8 +172,11 @@ let prepareRollbackDiff = async (
       ->(Utils.magic: array<unknown> => array<Internal.entity>)
 
     restoredEntities->Array.forEach((entity: Internal.entity) => {
+      let scope = entity->takeRowScope(~entityConfig)
       setEntities->Utils.Dict.push(entityConfig.name, entity.id)
-      entityTable->InMemoryTable.Entity.set(
+      state
+      ->getInMemTable(~entityConfig, ~scope)
+      ->InMemoryTable.Entity.set(
         ~committedCheckpointId,
         Set({
           entityId: entity.id->EntityId.unsafeOfString,
@@ -157,46 +194,61 @@ let prepareRollbackDiff = async (
   }
 }
 
+// Stages the addresses registered by this batch's events for the write. They're
+// drained from each chain's address store rather than carried on the items that
+// registered them: the store is where they already live, and it knows which
+// ones the database hasn't seen yet.
 let setBatchDcs = (state: IndexerState.t, ~batch: Batch.t) => {
-  let inMemTable = state->getInMemTable(~entityConfig=InternalTable.EnvioAddresses.entityConfig)
+  let inMemTable = state->getInMemTable(
+    ~entityConfig=InternalTable.EnvioAddresses.entityConfig,
+    ~scope=CrossChain,
+  )
   let committedCheckpointId = state->IndexerState.committedCheckpointId
 
-  let itemIdx = ref(0)
-
-  for checkpoint in 0 to batch.checkpointIds->Array.length - 1 {
-    let checkpointId = batch.checkpointIds->Array.getUnsafe(checkpoint)
-    let chainId = batch.checkpointChainIds->Array.getUnsafe(checkpoint)
-    let checkpointEventsProcessed = batch.checkpointEventsProcessed->Array.getUnsafe(checkpoint)
-
-    for idx in 0 to checkpointEventsProcessed - 1 {
-      let item = batch.items->Array.getUnsafe(itemIdx.contents + idx)
-      switch item->Internal.getItemDcs {
-      | None => ()
-      | Some(dcs) =>
-        // Currently only events support contract registration, so we can cast to event item
-        let eventItem = item->Internal.castUnsafeEventItem
-        for dcIdx in 0 to dcs->Array.length - 1 {
-          let dc = dcs->Array.getUnsafe(dcIdx)
-          let entity: InternalTable.EnvioAddresses.t = {
-            id: InternalTable.EnvioAddresses.makeId(~chainId, ~address=dc.address),
-            chainId,
-            contractName: dc.contractName,
-            registrationBlock: eventItem.blockNumber,
-            registrationLogIndex: eventItem.logIndex,
-          }
-
-          inMemTable->InMemoryTable.Entity.set(
-            ~committedCheckpointId,
-            Set({
-              entityId: entity.id->EntityId.unsafeOfString,
-              checkpointId,
-              entity: entity->InternalTable.EnvioAddresses.castToInternal,
-            }),
-          )
+  batch.progressedChainsById->Utils.Dict.forEach(progressedChain => {
+    let chainId = progressedChain.fetchState.chainId
+    let chainState = state->IndexerState.getChainState(~chainId)
+
+    // Most batches register nothing, so the checkpoints are only collected for a
+    // chain that has something waiting.
+    if chainState->ChainState.hasAddressesToWrite {
+      // The store pairs each drained registration with a checkpoint of its own
+      // chain, so only this chain's checkpoints go in — and the index it returns
+      // points back into these two parallel arrays.
+      let checkpointIds = []
+      let checkpointBlockNumbers = []
+      for idx in 0 to batch.checkpointIds->Array.length - 1 {
+        if batch.checkpointChainIds->Array.getUnsafe(idx) === chainId {
+          checkpointIds->Array.push(batch.checkpointIds->Array.getUnsafe(idx))
+          checkpointBlockNumbers->Array.push(batch.checkpointBlockNumbers->Array.getUnsafe(idx))
         }
       }
-    }
 
-    itemIdx := itemIdx.contents + checkpointEventsProcessed
-  }
+      chainState
+      ->ChainState.drainAddressesForWrite(
+        ~toBlockInclusive=progressedChain.progressBlockNumber,
+        ~checkpointBlockNumbers,
+      )
+      ->Array.forEach(dc => {
+        let entity: InternalTable.EnvioAddresses.t = {
+          id: InternalTable.EnvioAddresses.makeId(~chainId, ~address=dc.address),
+          chainId,
+          contractName: dc.contractName,
+          registrationBlock: dc.registrationBlock,
+          // Only ever written, never read back. Kept on the table so the column
+          // doesn't need a migration.
+          registrationLogIndex: -1,
+        }
+
+        inMemTable->InMemoryTable.Entity.set(
+          ~committedCheckpointId,
+          Set({
+            entityId: entity.id->EntityId.unsafeOfString,
+            checkpointId: checkpointIds->Array.getUnsafe(dc.checkpointIdx),
+            entity: entity->InternalTable.EnvioAddresses.castToInternal,
+          }),
+        )
+      })
+    }
+  })
 }

package/src/InMemoryStore.res.mjs

@@ -4,14 +4,42 @@ import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as Internal from "./Internal.res.mjs";
+import * as ChainState from "./ChainState.res.mjs";
 import * as EffectState from "./EffectState.res.mjs";
+import * as EntityTables from "./EntityTables.res.mjs";
 import * as IndexerState from "./IndexerState.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 Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
-function getInMemTable(state, entityConfig) {
-  return IndexerState.EntityTables.get(IndexerState.entities(state), entityConfig.name);
+function getInMemTable(state, entityConfig, scope) {
+  let tmp;
+  tmp = scope === "crossChain" ? IndexerState.entities(state) : ChainState.entities(IndexerState.getChainState(state, scope));
+  return EntityTables.get(tmp, entityConfig.name);
+}
+
+function entityScope(entityConfig, chainId) {
+  if (entityConfig.crossChain) {
+    return "crossChain";
+  } else {
+    return chainId;
+  }
+}
+
+function takeRowScope(entity, entityConfig) {
+  let field = Table.getChainIdField(entityConfig.table);
+  if (field === undefined) {
+    return "crossChain";
+  }
+  let chainId = entity[field.fieldName];
+  if (chainId !== undefined) {
+    Utils.Dict.deleteInPlace(entity, field.fieldName);
+    return Primitive_option.valFromOption(chainId);
+  } else {
+    return Stdlib_JsError.throwWithMessage(`Rollback row for the per-chain entity "` + entityConfig.name + `" with id "` + entity.id + `" is missing its "` + field.fieldName + `" value.`);
+  }
 }
 
 function getEffectInMemTable(state, effect, scope) {
@@ -87,11 +115,11 @@ async function prepareRollbackDiff(state, rollbackTargetCheckpointId, rollbackDi
   let deletedEntities = {};
   let setEntities = {};
   await Promise.all(persistence.allEntities.filter(entityConfig => entityConfig.storage.postgres).map(async entityConfig => {
-    let entityTable = getInMemTable(state, entityConfig);
     let match = await persistence.storage.getRollbackData(entityConfig, rollbackTargetCheckpointId);
-    match[0].forEach(entityId => {
+    match[0].forEach(param => {
+      let entityId = param.entityId;
       Utils.Dict.push(deletedEntities, entityConfig.name, entityId);
-      InMemoryTable.Entity.set(entityTable, committedCheckpointId, {
+      InMemoryTable.Entity.set(getInMemTable(state, entityConfig, param.scope), committedCheckpointId, {
         type: "DELETE",
         entityId: entityId,
         checkpointId: rollbackDiffCheckpointId
@@ -99,8 +127,9 @@ async function prepareRollbackDiff(state, rollbackTargetCheckpointId, rollbackDi
     });
     let restoredEntities = S$RescriptSchema.parseOrThrow(match[1], Table.pgRowsSchema(entityConfig.table));
     restoredEntities.forEach(entity => {
+      let scope = takeRowScope(entity, entityConfig);
       Utils.Dict.push(setEntities, entityConfig.name, entity.id);
-      InMemoryTable.Entity.set(entityTable, committedCheckpointId, {
+      InMemoryTable.Entity.set(getInMemTable(state, entityConfig, scope), committedCheckpointId, {
         type: "SET",
         entityId: entity.id,
         entity: entity,
@@ -115,45 +144,47 @@ async function prepareRollbackDiff(state, rollbackTargetCheckpointId, rollbackDi
 }
 
 function setBatchDcs(state, batch) {
-  let inMemTable = getInMemTable(state, Config.EnvioAddresses.entityConfig);
+  let inMemTable = getInMemTable(state, Config.EnvioAddresses.entityConfig, "crossChain");
   let committedCheckpointId = IndexerState.committedCheckpointId(state);
-  let itemIdx = 0;
-  for (let checkpoint = 0, checkpoint_finish = batch.checkpointIds.length; checkpoint < checkpoint_finish; ++checkpoint) {
-    let checkpointId = batch.checkpointIds[checkpoint];
-    let chainId = batch.checkpointChainIds[checkpoint];
-    let checkpointEventsProcessed = batch.checkpointEventsProcessed[checkpoint];
-    for (let idx = 0; idx < checkpointEventsProcessed; ++idx) {
-      let item = batch.items[itemIdx + idx | 0];
-      let dcs = item.dcs;
-      if (dcs !== undefined) {
-        for (let dcIdx = 0, dcIdx_finish = dcs.length; dcIdx < dcIdx_finish; ++dcIdx) {
-          let dc = dcs[dcIdx];
-          let entity_id = Config.EnvioAddresses.makeId(chainId, dc.address);
-          let entity_registration_block = item.blockNumber;
-          let entity_registration_log_index = item.logIndex;
-          let entity_contract_name = dc.contractName;
-          let entity = {
-            id: entity_id,
-            chain_id: chainId,
-            registration_block: entity_registration_block,
-            registration_log_index: entity_registration_log_index,
-            contract_name: entity_contract_name
-          };
-          InMemoryTable.Entity.set(inMemTable, committedCheckpointId, {
-            type: "SET",
-            entityId: entity_id,
-            entity: entity,
-            checkpointId: checkpointId
-          });
-        }
+  Utils.Dict.forEach(batch.progressedChainsById, progressedChain => {
+    let chainId = progressedChain.fetchState.chainId;
+    let chainState = IndexerState.getChainState(state, chainId);
+    if (!ChainState.hasAddressesToWrite(chainState)) {
+      return;
+    }
+    let checkpointIds = [];
+    let checkpointBlockNumbers = [];
+    for (let idx = 0, idx_finish = batch.checkpointIds.length; idx < idx_finish; ++idx) {
+      if (batch.checkpointChainIds[idx] === chainId) {
+        checkpointIds.push(batch.checkpointIds[idx]);
+        checkpointBlockNumbers.push(batch.checkpointBlockNumbers[idx]);
       }
     }
-    itemIdx = itemIdx + checkpointEventsProcessed | 0;
-  }
+    ChainState.drainAddressesForWrite(chainState, progressedChain.progressBlockNumber, checkpointBlockNumbers).forEach(dc => {
+      let entity_id = Config.EnvioAddresses.makeId(chainId, dc.address);
+      let entity_registration_block = dc.registrationBlock;
+      let entity_contract_name = dc.contractName;
+      let entity = {
+        id: entity_id,
+        chain_id: chainId,
+        registration_block: entity_registration_block,
+        registration_log_index: -1,
+        contract_name: entity_contract_name
+      };
+      InMemoryTable.Entity.set(inMemTable, committedCheckpointId, {
+        type: "SET",
+        entityId: entity_id,
+        entity: entity,
+        checkpointId: checkpointIds[dc.checkpointIdx]
+      });
+    });
+  });
 }
 
 export {
   getInMemTable,
+  entityScope,
+  takeRowScope,
   getEffectInMemTable,
   hasEffectOutput,
   getEffectOutputUnsafe,

package/src/IndexerState.res

@@ -5,28 +5,6 @@ type rollbackState =
   | FoundReorgDepth({chainId: ChainId.t, rollbackTargetBlockNumber: int})
   | RollbackReady({eventsProcessedDiffByChain: dict<float>})
 
-module EntityTables = {
-  type t = dict<InMemoryTable.Entity.t>
-  exception UndefinedEntity({entityName: string})
-  let make = (entities: array<Internal.entityConfig>): t => {
-    let init = Dict.make()
-    entities->Array.forEach(entityConfig => {
-      init->Dict.set((entityConfig.name :> string), InMemoryTable.Entity.make())
-    })
-    init
-  }
-
-  let get = (self: t, ~entityName: string) => {
-    switch self->Utils.Dict.dangerouslyGetNonOption(entityName) {
-    | Some(table) => table
-    | None =>
-      UndefinedEntity({entityName: entityName})->ErrorHandling.mkLogAndRaise(
-        ~msg="Unexpected, entity InMemoryTable is undefined",
-      )
-    }
-  }
-}
-
 // Per-(contract, event) handler counters rendered into the
 // envio_processing_handler_* and envio_preload_handler_* metrics.
 type handlerStat = {
@@ -75,6 +53,8 @@ type t = {
   persistence: Persistence.t,
   // --- In-memory store: entity/effect tables and the pending-write queue. ---
   allEntities: array<Internal.entityConfig>,
+  // Cross-chain entities only; each ChainState holds its own partition for the
+  // per-chain ones.
   mutable entities: EntityTables.t,
   effectState: EffectState.t,
   mutable rollback: option<Persistence.rollback>,
@@ -186,7 +166,7 @@ let make = (
     config,
     persistence,
     allEntities: persistence.allEntities,
-    entities: EntityTables.make(persistence.allEntities),
+    entities: EntityTables.make(persistence.allEntities->EntityTables.crossChain),
     effectState: EffectState.make(),
     rollback: None,
     committedCheckpointId,
@@ -467,6 +447,30 @@ let config = (state: t) => state.config
 let persistence = (state: t) => state.persistence
 let allEntities = (state: t) => state.allEntities
 let entities = (state: t) => state.entities
+
+// Every in-memory entity table across all scopes, cross-chain first. The size,
+// drop and flush passes walk the whole store this way instead of assuming a
+// single partition.
+let eachEntityTable = (state: t, fn: (~entityConfig: Internal.entityConfig, ~scope: Internal.chainScope, ~table: InMemoryTable.Entity.t) => unit) => {
+  let chainStates = state.crossChainState->CrossChainState.chainStates
+  state.allEntities->Array.forEach(entityConfig =>
+    if entityConfig.crossChain {
+      fn(
+        ~entityConfig,
+        ~scope=Internal.CrossChain,
+        ~table=state.entities->EntityTables.get(~entityName=entityConfig.name),
+      )
+    } else {
+      chainStates->Utils.Dict.forEach(chainState => {
+        fn(
+          ~entityConfig,
+          ~scope=Internal.Chain((chainState->ChainState.chainConfig).id),
+          ~table=chainState->ChainState.entities->EntityTables.get(~entityName=entityConfig.name),
+        )
+      })
+    }
+  )
+}
 let effectState = (state: t) => state.effectState
 let committedCheckpointId = (state: t) => state.committedCheckpointId
 let processedCheckpointId = (state: t) => state.processedCheckpointId
@@ -802,7 +806,9 @@ let beginRollbackDiff = (
   ~diffCheckpointId,
   ~progressBlockNumberByChainId,
 ) => {
-  state.entities = EntityTables.make(state.allEntities)
+  let perChainEntities = state.allEntities->EntityTables.perChain
+  state.entities = EntityTables.make(state.allEntities->EntityTables.crossChain)
+  state->chainStates->Utils.Dict.forEach(cs => cs->ChainState.resetEntities(~perChainEntities))
   state.effectState->EffectState.resetForRollback
   state.rollback = Some({
     targetCheckpointId,

package/src/IndexerState.res.mjs

@@ -12,40 +12,17 @@ import * as ChainState from "./ChainState.res.mjs";
 import * as EffectState from "./EffectState.res.mjs";
 import * as LoadManager from "./LoadManager.res.mjs";
 import * as Performance from "./bindings/Performance.res.mjs";
+import * as EntityTables from "./EntityTables.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
-import * as InMemoryTable from "./InMemoryTable.res.mjs";
 import * as SourceManager from "./sources/SourceManager.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 CrossChainState from "./CrossChainState.res.mjs";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
-import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as SimulateDeadInputTracker from "./SimulateDeadInputTracker.res.mjs";
 
-let UndefinedEntity = /* @__PURE__ */Primitive_exceptions.create("IndexerState.EntityTables.UndefinedEntity");
-
-function make(entities) {
-  let init = {};
-  entities.forEach(entityConfig => {
-    init[entityConfig.name] = InMemoryTable.Entity.make();
-  });
-  return init;
-}
-
-function get(self, entityName) {
-  let table = self[entityName];
-  if (table !== undefined) {
-    return table;
-  } else {
-    return ErrorHandling.mkLogAndRaise(undefined, "Unexpected, entity InMemoryTable is undefined", {
-      RE_EXN_ID: UndefinedEntity,
-      entityName: entityName
-    });
-  }
-}
-
-function make$1(config, persistence, chainStates, isInReorgThreshold, isRealtime, targetBufferSizeOpt, committedCheckpointIdOpt, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, onError, onExit) {
+function make(config, persistence, chainStates, isInReorgThreshold, isRealtime, targetBufferSizeOpt, committedCheckpointIdOpt, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, onError, onExit) {
   let targetBufferSize = targetBufferSizeOpt !== undefined ? targetBufferSizeOpt : CrossChainState.calculateTargetBufferSize();
   let committedCheckpointId = committedCheckpointIdOpt !== undefined ? committedCheckpointIdOpt : Internal.initialCheckpointId;
   let isDevelopmentMode = isDevelopmentModeOpt !== undefined ? isDevelopmentModeOpt : false;
@@ -60,7 +37,7 @@ function make$1(config, persistence, chainStates, isInReorgThreshold, isRealtime
     config: config,
     persistence: persistence,
     allEntities: persistence.allEntities,
-    entities: make(persistence.allEntities),
+    entities: EntityTables.make(EntityTables.crossChain(persistence.allEntities)),
     effectState: EffectState.make(),
     rollback: undefined,
     committedCheckpointId: committedCheckpointId,
@@ -125,7 +102,7 @@ function makeFromDbState(config, persistence, initialState, registrationsByChain
     let chainConfig = ChainMap.get(config.chainMap, chainId);
     chainStates[resumedChainState.id] = ChainState.makeFromDbState(chainConfig, resumedChainState, initialState.reorgCheckpoints, isInReorgThreshold, isRealtime, config, registrationsByChainId, reducedPollingInterval);
   });
-  let state = make$1(config, persistence, chainStates, isInReorgThreshold, isRealtime, targetBufferSize, initialState.checkpointId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, onError, onExit);
+  let state = make(config, persistence, chainStates, isInReorgThreshold, isRealtime, targetBufferSize, initialState.checkpointId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, onError, onExit);
   CrossChainState.markCaughtUpOnResume(state.crossChainState);
   Utils.Dict.forEach(initialState.cache, param => {
     let count = param.count;
@@ -288,6 +265,17 @@ function entities(state) {
   return state.entities;
 }
 
+function eachEntityTable(state, fn) {
+  let chainStates = CrossChainState.chainStates(state.crossChainState);
+  state.allEntities.forEach(entityConfig => {
+    if (entityConfig.crossChain) {
+      return fn(entityConfig, "crossChain", EntityTables.get(state.entities, entityConfig.name));
+    } else {
+      return Utils.Dict.forEach(chainStates, chainState => fn(entityConfig, ChainState.chainConfig(chainState).id, EntityTables.get(ChainState.entities(chainState), entityConfig.name)));
+    }
+  });
+}
+
 function effectState(state) {
   return state.effectState;
 }
@@ -678,7 +666,9 @@ function markCommitted(state, upToCheckpointId) {
 }
 
 function beginRollbackDiff(state, targetCheckpointId, diffCheckpointId, progressBlockNumberByChainId) {
-  state.entities = make(state.allEntities);
+  let perChainEntities = EntityTables.perChain(state.allEntities);
+  state.entities = EntityTables.make(EntityTables.crossChain(state.allEntities));
+  Utils.Dict.forEach(CrossChainState.chainStates(state.crossChainState), cs => ChainState.resetEntities(cs, perChainEntities));
   EffectState.resetForRollback(state.effectState);
   state.rollback = {
     targetCheckpointId: targetCheckpointId,
@@ -745,16 +735,10 @@ function takeChainMetaSnapshot(state) {
   }
 }
 
-let EntityTables = {
-  make: make,
-  get: get
-};
-
 let unexpectedErrorMsg = "Indexer has failed with an unexpected error";
 
 export {
-  EntityTables,
-  make$1 as make,
+  make,
   makeFromDbState,
   unexpectedErrorMsg,
   isStale,
@@ -781,6 +765,7 @@ export {
   persistence,
   allEntities,
   entities,
+  eachEntityTable,
   effectState,
   committedCheckpointId,
   processedCheckpointId,

package/src/IndexerState.resi

@@ -9,12 +9,6 @@ type rollbackState =
   | FoundReorgDepth({chainId: ChainId.t, rollbackTargetBlockNumber: int})
   | RollbackReady({eventsProcessedDiffByChain: dict<float>})
 
-module EntityTables: {
-  type t = dict<InMemoryTable.Entity.t>
-  let make: array<Internal.entityConfig> => t
-  let get: (t, ~entityName: string) => InMemoryTable.Entity.t
-}
-
 type t
 
 let make: (
@@ -80,6 +74,14 @@ let config: t => Config.t
 let persistence: t => Persistence.t
 let allEntities: t => array<Internal.entityConfig>
 let entities: t => EntityTables.t
+let eachEntityTable: (
+  t,
+  (
+    ~entityConfig: Internal.entityConfig,
+    ~scope: Internal.chainScope,
+    ~table: InMemoryTable.Entity.t,
+  ) => unit,
+) => unit
 let effectState: t => EffectState.t
 let committedCheckpointId: t => Internal.checkpointId
 let processedCheckpointId: t => Internal.checkpointId

package/src/Internal.res

@@ -616,8 +616,6 @@ type indexingAddress = {
   registrationBlock: int,
 }
 
-type dcs = array<indexingAddress>
-
 // Duplicate the type from item to keep item properly unboxed. Runtime event
 // items carry the registration their source already resolved from the
 // ChainState-owned registration array.
@@ -698,11 +696,6 @@ let getItemChainId = item =>
   | Block({onBlockRegistration: {chainId}}) => chainId
   }
 
-@get
-external getItemDcs: item => option<dcs> = "dcs"
-@set
-external setItemDcs: (item, dcs) => unit = "dcs"
-
 type eventOptions<'where> = {
   wildcard?: bool,
   where?: 'where,
@@ -751,6 +744,10 @@ type genericEntityConfig<'entity> = {
   schema: S.t<'entity>,
   table: Table.table,
   storage: entityStorage,
+  // Resolved by the CLI against the config's `defaultCrossChain` and the
+  // entity's `@crossChain`. When false the table carries a chain-id column in
+  // its primary key and every row belongs to exactly one chain.
+  crossChain: bool,
 }
 type entityConfig = genericEntityConfig<entity>
 external fromGenericEntityConfig: genericEntityConfig<'entity> => entityConfig = "%identity"
@@ -780,10 +777,11 @@ type effect = {
   handler: effectArgs => promise<effectOutput>,
   storageMeta: effectCacheStorageMeta,
   defaultShouldCache: bool,
-  // When true (the default) a single cache is shared across every chain and the
-  // handler must not read context.chain. When false the cache is isolated per
-  // chain and context.chain.id is available.
-  crossChain: bool,
+  // When true a single cache is shared across every chain and the handler must
+  // not read context.chain. When false the cache is isolated per chain and
+  // context.chain.id is available. None means the effect didn't say, and the
+  // config's `defaultCrossChain` decides.
+  crossChain: option<bool>,
   output: S.t<effectOutput>,
   input: S.t<effectInput>,
   rateLimit: option<rateLimitOptions>,
@@ -798,6 +796,26 @@ type chainScope =
   | @as("crossChain") CrossChain
   | Chain(ChainId.t)
 
+let chainScopeToString = scope =>
+  switch scope {
+  | CrossChain => "crossChain"
+  | Chain(chainId) => chainId->ChainId.toString
+  }
+
+let chainScopeChainId = scope =>
+  switch scope {
+  | CrossChain => None
+  | Chain(chainId) => Some(chainId)
+  }
+
+// A copy of the entity carrying the chain-id column a per-chain entity's row
+// needs. Never mutates the handler's object, which stays in the in-memory table.
+let stampChainId = (entity: entity, ~fieldName, ~chainId: ChainId.t): entity =>
+  Utils.Dict.merge(
+    entity->(Utils.magic: entity => dict<unknown>),
+    Dict.fromArray([(fieldName, chainId->(Utils.magic: ChainId.t => unknown))]),
+  )->(Utils.magic: dict<unknown> => entity)
+
 let cacheTablePrefix = "envio_effect_"
 
 // The single reversible mapping between an effect's (name, scope) and its
@@ -813,13 +831,6 @@ module EffectCache = {
     | Chain(chainId) => `envio_${chainId->ChainId.toString}_effect_${effectName}`
     }
 
-  // "crossChain" or the decimal chain id. Used as the `scope` Prometheus label.
-  let scopeToString = scope =>
-    switch scope {
-    | CrossChain => "crossChain"
-    | Chain(chainId) => chainId->ChainId.toString
-    }
-
   // Only accepts a canonical decimal chain id ("7", not "007" or "1foo") —
   // the schema's parser follows parseFloat semantics and accepts both.
   let parseChainId = str =>