envio 3.3.0-alpha.11 → 3.3.0-alpha.13

package/src/IndexerState.res

@@ -45,26 +45,13 @@ module EntityTables = {
   }
 }
 
-type effectCacheInMemTable = {
-  // Cache keys whose handler output is persisted on the next write. Drained
-  // each write; eviction is driven by the per-entry checkpointId instead.
-  mutable idsToStore: array<string>,
-  mutable invalidationsCount: int,
-  // Each entry is stamped with the checkpoint that referenced it (or
-  // loadedFromDbCheckpointId for db reads), so committed entries can be
-  // dropped once persisted/re-derivable, mirroring entity changes.
-  mutable dict: dict<Change.t<Internal.effectOutput>>,
-  mutable changesCount: float,
-  effect: Internal.effect,
-}
-
 type t = {
   config: Config.t,
   persistence: Persistence.t,
   // --- In-memory store: entity/effect tables and the pending-write queue. ---
   allEntities: array<Internal.entityConfig>,
   mutable entities: EntityTables.t,
-  mutable effects: dict<effectCacheInMemTable>,
+  effectState: EffectState.t,
   mutable rollback: option<Persistence.rollback>,
   // Last checkpoint persisted to the db.
   mutable committedCheckpointId: Internal.checkpointId,
@@ -143,7 +130,7 @@ let make = (
     persistence,
     allEntities: persistence.allEntities,
     entities: EntityTables.make(persistence.allEntities),
-    effects: Dict.make(),
+    effectState: EffectState.make(),
     rollback: None,
     committedCheckpointId,
     processedCheckpointId: committedCheckpointId,
@@ -211,8 +198,12 @@ let makeFromDbState = (
 
   Prometheus.ProcessingMaxBatchSize.set(~maxBatchSize=config.batchSize)
   Prometheus.ReorgThreshold.set(~isInReorgThreshold)
-  initialState.cache->Utils.Dict.forEach(({effectName, count}) => {
-    Prometheus.EffectCacheCount.set(~count, ~effectName)
+  initialState.cache->Utils.Dict.forEach(({effectName, count, scope}) => {
+    Prometheus.EffectCacheCount.set(
+      ~count,
+      ~effectName,
+      ~scope=scope->Internal.EffectCache.scopeToString,
+    )
   })
 
   // updateSyncTimeOnRestart wipes the saved timestamp so a restart re-enters
@@ -385,7 +376,7 @@ let config = (state: t) => state.config
 let persistence = (state: t) => state.persistence
 let allEntities = (state: t) => state.allEntities
 let entities = (state: t) => state.entities
-let effects = (state: t) => state.effects
+let effectState = (state: t) => state.effectState
 let committedCheckpointId = (state: t) => state.committedCheckpointId
 let processedCheckpointId = (state: t) => state.processedCheckpointId
 let processedBatches = (state: t) => state.processedBatches
@@ -485,7 +476,7 @@ let beginRollbackDiff = (
   ~progressBlockNumberByChainId,
 ) => {
   state.entities = EntityTables.make(state.allEntities)
-  state.effects = Dict.make()
+  state.effectState->EffectState.resetForRollback
   state.rollback = Some({
     targetCheckpointId,
     diffCheckpointId,

package/src/IndexerState.res.mjs

@@ -9,6 +9,7 @@ import * as Internal from "./Internal.res.mjs";
 import * as Throttler from "./Throttler.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
+import * as EffectState from "./EffectState.res.mjs";
 import * as LoadManager from "./LoadManager.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryTable from "./InMemoryTable.res.mjs";
@@ -70,7 +71,7 @@ function make$2(config, persistence, chainStates, isInReorgThreshold, isRealtime
     persistence: persistence,
     allEntities: persistence.allEntities,
     entities: make$1(persistence.allEntities),
-    effects: {},
+    effectState: EffectState.make(),
     rollback: undefined,
     committedCheckpointId: committedCheckpointId,
     processedCheckpointId: committedCheckpointId,
@@ -116,7 +117,7 @@ function makeFromDbState(config, persistence, initialState, registrationsByChain
   Prometheus.ReorgThreshold.set(isInReorgThreshold);
   Utils.Dict.forEach(initialState.cache, param => {
     let count = param.count;
-    Prometheus.EffectCacheCount.set(count, param.effectName);
+    Prometheus.EffectCacheCount.set(count, param.effectName, Internal.EffectCache.scopeToString(param.scope));
   });
   let isRealtime = !Env.updateSyncTimeOnRestart && initialState.chains.length !== 0 && initialState.chains.every(c => Stdlib_Option.isSome(c.timestampCaughtUpToHeadOrEndblock));
   let chainStates = {};
@@ -266,8 +267,8 @@ function entities(state) {
   return state.entities;
 }
 
-function effects(state) {
-  return state.effects;
+function effectState(state) {
+  return state.effectState;
 }
 
 function committedCheckpointId(state) {
@@ -419,7 +420,7 @@ function markCommitted(state, upToCheckpointId) {
 
 function beginRollbackDiff(state, targetCheckpointId, diffCheckpointId, progressBlockNumberByChainId) {
   state.entities = make$1(state.allEntities);
-  state.effects = {};
+  EffectState.resetForRollback(state.effectState);
   state.rollback = {
     targetCheckpointId: targetCheckpointId,
     diffCheckpointId: diffCheckpointId,
@@ -512,7 +513,7 @@ export {
   persistence,
   allEntities,
   entities,
-  effects,
+  effectState,
   committedCheckpointId,
   processedCheckpointId,
   processedBatches,

package/src/IndexerState.resi

@@ -16,14 +16,6 @@ module EntityTables: {
   let get: (t, ~entityName: string) => InMemoryTable.Entity.t
 }
 
-type effectCacheInMemTable = {
-  mutable idsToStore: array<string>,
-  mutable invalidationsCount: int,
-  mutable dict: dict<Change.t<Internal.effectOutput>>,
-  mutable changesCount: float,
-  effect: Internal.effect,
-}
-
 type t
 
 let make: (
@@ -86,7 +78,7 @@ let config: t => Config.t
 let persistence: t => Persistence.t
 let allEntities: t => array<Internal.entityConfig>
 let entities: t => EntityTables.t
-let effects: t => dict<effectCacheInMemTable>
+let effectState: t => EffectState.t
 let committedCheckpointId: t => Internal.checkpointId
 let processedCheckpointId: t => Internal.checkpointId
 let processedBatches: t => array<Batch.t>

package/src/Internal.res

@@ -752,33 +752,108 @@ type effectCacheItem = {id: string, output: effectOutput}
 type effectCacheStorageMeta = {
   itemSchema: S.t<effectCacheItem>,
   outputSchema: S.t<effectOutput>,
-  table: Table.table,
 }
-type rateLimitState = {
+type rateLimitOptions = {
   callsPerDuration: int,
   durationMs: int,
-  mutable availableCalls: int,
-  mutable windowStartTime: float,
-  mutable queueCount: int,
-  mutable nextWindowPromise: option<promise<unit>>,
 }
 type effect = {
   name: string,
   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,
   output: S.t<effectOutput>,
   input: S.t<effectInput>,
-  // The number of functions that are currently running.
-  mutable activeCallsCount: int,
-  mutable prevCallStartTimerRef: Performance.timeRef,
-  rateLimit: option<rateLimitState>,
+  rateLimit: option<rateLimitOptions>,
 }
+
+// Whether some piece of data (currently an effect cache; entities in a future
+// version) is shared across every chain or isolated to a single chain. Unboxed:
+// `CrossChain` is the string "crossChain" and `Chain(id)` is the raw chain id,
+// discriminated by runtime type.
+@unboxed
+type chainScope =
+  | @as("crossChain") CrossChain
+  | Chain(int)
+
 let cacheTablePrefix = "envio_effect_"
+
+// The single reversible mapping between an effect's (name, scope) and its
+// canonical Postgres cache-table name and .envio/cache file path. Everything
+// that needs a cache address goes through here instead of slicing prefixes.
+//   CrossChain  ->  envio_effect_<name>        <name>.tsv
+//   Chain(1)    ->  envio_1_effect_<name>      1/<name>.tsv
+//   Chain(137)  ->  envio_137_effect_<name>    137/<name>.tsv
+module EffectCache = {
+  let toTableName = (~effectName, ~scope) =>
+    switch scope {
+    | CrossChain => cacheTablePrefix ++ effectName
+    | Chain(chainId) => `envio_${chainId->Int.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->Int.toString
+    }
+
+  // Only accepts a canonical decimal chain id ("7", not "007" or "1foo") —
+  // Int.fromString alone follows parseInt semantics and accepts both.
+  let parseChainId = str =>
+    switch Int.fromString(str) {
+    | Some(chainId) if chainId >= 0 && chainId->Int.toString === str => Some(chainId)
+    | _ => None
+    }
+
+  let chainScopedRe = /^envio_([0-9]+)_effect_(.+)$/
+  let crossChainRe = /^envio_effect_(.+)$/
+
+  // Inverse of toTableName. Returns None for any table name that isn't a cache
+  // table. Chain-scoped is tried first: the `_effect_` separator keeps effect
+  // names that themselves start with digits unambiguous.
+  let fromTableName = (tableName): option<(string, chainScope)> =>
+    switch RegExp.exec(chainScopedRe, tableName) {
+    | Some(result) =>
+      switch (
+        RegExp.Result.matches(result)->Array.get(0),
+        RegExp.Result.matches(result)->Array.get(1),
+      ) {
+      | (Some(Some(chainIdStr)), Some(Some(effectName))) =>
+        switch parseChainId(chainIdStr) {
+        | Some(chainId) => Some((effectName, Chain(chainId)))
+        | None => None
+        }
+      | _ => None
+      }
+    | None =>
+      switch RegExp.exec(crossChainRe, tableName) {
+      | Some(result) =>
+        switch RegExp.Result.matches(result)->Array.get(0) {
+        | Some(Some(effectName)) => Some((effectName, CrossChain))
+        | _ => None
+        }
+      | None => None
+      }
+    }
+
+  // Relative posix path within .envio/cache. Chain-scoped caches live one
+  // directory level deep, named by chain id.
+  let toCachePath = (~effectName, ~scope) =>
+    switch scope {
+    | CrossChain => effectName ++ ".tsv"
+    | Chain(chainId) => `${chainId->Int.toString}/${effectName}.tsv`
+    }
+}
+
 let cacheOutputSchema = S.json(~validate=false)->(Utils.magic: S.t<JSON.t> => S.t<effectOutput>)
-let makeCacheTable = (~effectName) => {
+let makeCacheTable = (~effectName, ~scope) => {
   Table.mkTable(
-    cacheTablePrefix ++ effectName,
+    EffectCache.toTableName(~effectName, ~scope),
     ~fields=[
       Table.mkField("id", String, ~fieldSchema=S.string, ~isPrimaryKey=true),
       Table.mkField("output", Json, ~fieldSchema=cacheOutputSchema, ~isNullable=true),

package/src/Internal.res.mjs

@@ -3,6 +3,8 @@
 import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Address from "./Address.res.mjs";
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
 let allEvmBlockFields = [
@@ -166,10 +168,101 @@ let fuelTransferParamsSchema = S$RescriptSchema.schema(s => ({
 
 let cacheTablePrefix = "envio_effect_";
 
+function toTableName(effectName, scope) {
+  if (scope === "crossChain") {
+    return cacheTablePrefix + effectName;
+  } else {
+    return `envio_` + scope.toString() + `_effect_` + effectName;
+  }
+}
+
+function scopeToString(scope) {
+  if (scope === "crossChain") {
+    return "crossChain";
+  } else {
+    return scope.toString();
+  }
+}
+
+function parseChainId(str) {
+  let chainId = Stdlib_Int.fromString(str, undefined);
+  if (chainId !== undefined && chainId >= 0 && chainId.toString() === str) {
+    return chainId;
+  }
+}
+
+let chainScopedRe = /^envio_([0-9]+)_effect_(.+)$/;
+
+let crossChainRe = /^envio_effect_(.+)$/;
+
+function fromTableName(tableName) {
+  let result = chainScopedRe.exec(tableName);
+  if (result == null) {
+    let result$1 = crossChainRe.exec(tableName);
+    if (result$1 == null) {
+      return;
+    }
+    let match = result$1.slice(1)[0];
+    if (match === undefined) {
+      return;
+    }
+    let effectName = Primitive_option.valFromOption(match);
+    if (effectName !== undefined) {
+      return [
+        effectName,
+        "crossChain"
+      ];
+    } else {
+      return;
+    }
+  }
+  let match$1 = result.slice(1)[0];
+  let match$2 = result.slice(1)[1];
+  if (match$1 === undefined) {
+    return;
+  }
+  let chainIdStr = Primitive_option.valFromOption(match$1);
+  if (chainIdStr === undefined) {
+    return;
+  }
+  if (match$2 === undefined) {
+    return;
+  }
+  let effectName$1 = Primitive_option.valFromOption(match$2);
+  if (effectName$1 === undefined) {
+    return;
+  }
+  let chainId = parseChainId(chainIdStr);
+  if (chainId !== undefined) {
+    return [
+      effectName$1,
+      chainId
+    ];
+  }
+}
+
+function toCachePath(effectName, scope) {
+  if (scope === "crossChain") {
+    return effectName + ".tsv";
+  } else {
+    return scope.toString() + `/` + effectName + `.tsv`;
+  }
+}
+
+let EffectCache = {
+  toTableName: toTableName,
+  scopeToString: scopeToString,
+  parseChainId: parseChainId,
+  chainScopedRe: chainScopedRe,
+  crossChainRe: crossChainRe,
+  fromTableName: fromTableName,
+  toCachePath: toCachePath
+};
+
 let cacheOutputSchema = S$RescriptSchema.json(false);
 
-function makeCacheTable(effectName) {
-  return Table.mkTable(cacheTablePrefix + effectName, undefined, [
+function makeCacheTable(effectName, scope) {
+  return Table.mkTable(toTableName(effectName, scope), undefined, [
     Table.mkField("id", "String", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined, undefined, undefined, undefined),
     Table.mkField("output", "Json", cacheOutputSchema, undefined, undefined, true, undefined, undefined, undefined, undefined, undefined, undefined)
   ], undefined);
@@ -195,6 +288,7 @@ export {
   fuelSupplyParamsSchema,
   fuelTransferParamsSchema,
   cacheTablePrefix,
+  EffectCache,
   cacheOutputSchema,
   makeCacheTable,
   loadedFromDbCheckpointId,

package/src/LoadLayer.res

@@ -72,28 +72,29 @@ let loadById = (
 let callEffect = (
   ~effect: Internal.effect,
   ~arg: Internal.effectArgs,
-  ~inMemTable: IndexerState.effectCacheInMemTable,
+  ~inMemTable: EffectState.effectCacheInMemTable,
   ~timerRef,
   ~onError,
 ) => {
   let effectName = effect.name
-  let hadActiveCalls = effect.activeCallsCount > 0
-  effect.activeCallsCount = effect.activeCallsCount + 1
+  let scopeLabel = inMemTable.scope->Internal.EffectCache.scopeToString
+  let hadActiveCalls = inMemTable.activeCallsCount > 0
+  inMemTable.activeCallsCount = inMemTable.activeCallsCount + 1
   Prometheus.EffectCalls.activeCallsCount->Prometheus.SafeGauge.handleInt(
-    ~labels=effectName,
-    ~value=effect.activeCallsCount,
+    ~labels={"effect": effectName, "scope": scopeLabel},
+    ~value=inMemTable.activeCallsCount,
   )
 
   if hadActiveCalls {
-    let elapsed = Performance.secondsBetween(~from=effect.prevCallStartTimerRef, ~to=timerRef)
+    let elapsed = Performance.secondsBetween(~from=inMemTable.prevCallStartTimerRef, ~to=timerRef)
     if elapsed > 0. {
       Prometheus.EffectCalls.timeCounter->Prometheus.SafeCounter.handleFloat(
-        ~labels=effectName,
+        ~labels={"effect": effectName, "scope": scopeLabel},
         ~value=elapsed,
       )
     }
   }
-  effect.prevCallStartTimerRef = timerRef
+  inMemTable.prevCallStartTimerRef = timerRef
 
   effect.handler(arg)
   ->Promise.thenResolve(output => {
@@ -108,21 +109,23 @@ let callEffect = (
     onError(~inputKey=arg.cacheKey, ~exn)
   })
   ->Promise.finally(() => {
-    effect.activeCallsCount = effect.activeCallsCount - 1
+    inMemTable.activeCallsCount = inMemTable.activeCallsCount - 1
     Prometheus.EffectCalls.activeCallsCount->Prometheus.SafeGauge.handleInt(
-      ~labels=effectName,
-      ~value=effect.activeCallsCount,
+      ~labels={"effect": effectName, "scope": scopeLabel},
+      ~value=inMemTable.activeCallsCount,
     )
     let newTimer = Performance.now()
     Prometheus.EffectCalls.timeCounter->Prometheus.SafeCounter.handleFloat(
-      ~labels=effectName,
-      ~value=Performance.secondsBetween(~from=effect.prevCallStartTimerRef, ~to=newTimer),
+      ~labels={"effect": effectName, "scope": scopeLabel},
+      ~value=Performance.secondsBetween(~from=inMemTable.prevCallStartTimerRef, ~to=newTimer),
     )
-    effect.prevCallStartTimerRef = newTimer
+    inMemTable.prevCallStartTimerRef = newTimer
 
-    Prometheus.EffectCalls.totalCallsCount->Prometheus.SafeCounter.increment(~labels=effectName)
+    Prometheus.EffectCalls.totalCallsCount->Prometheus.SafeCounter.increment(
+      ~labels={"effect": effectName, "scope": scopeLabel},
+    )
     Prometheus.EffectCalls.sumTimeCounter->Prometheus.SafeCounter.handleFloat(
-      ~labels=effectName,
+      ~labels={"effect": effectName, "scope": scopeLabel},
       ~value=timerRef->Performance.secondsSince,
     )
   })
@@ -131,7 +134,7 @@ let callEffect = (
 let rec executeWithRateLimit = (
   ~effect: Internal.effect,
   ~effectArgs: array<Internal.effectArgs>,
-  ~inMemTable,
+  ~inMemTable: EffectState.effectCacheInMemTable,
   ~onError,
   ~isFromQueue: bool,
 ) => {
@@ -140,7 +143,7 @@ let rec executeWithRateLimit = (
   let timerRef = Performance.now()
   let promises = []
 
-  switch effect.rateLimit {
+  switch inMemTable.rateLimitState {
   | None =>
     // No rate limiting - execute all immediately
     for idx in 0 to effectArgs->Array.length - 1 {
@@ -193,7 +196,11 @@ let rec executeWithRateLimit = (
     if immediateCount > 0 && isFromQueue {
       // Update queue count metric
       state.queueCount = state.queueCount - immediateCount
-      Prometheus.EffectQueueCount.set(~count=state.queueCount, ~effectName)
+      Prometheus.EffectQueueCount.set(
+        ~count=state.queueCount,
+        ~effectName,
+        ~scope=inMemTable.scope->Internal.EffectCache.scopeToString,
+      )
     }
 
     // Handle queued items
@@ -201,7 +208,11 @@ let rec executeWithRateLimit = (
       if !isFromQueue {
         // Update queue count metric
         state.queueCount = state.queueCount + queuedArgs->Array.length
-        Prometheus.EffectQueueCount.set(~count=state.queueCount, ~effectName)
+        Prometheus.EffectQueueCount.set(
+          ~count=state.queueCount,
+          ~effectName,
+          ~scope=inMemTable.scope->Internal.EffectCache.scopeToString,
+        )
       }
 
       let millisUntilReset = ref(0)
@@ -249,14 +260,23 @@ let loadEffect = (
   ~persistence: Persistence.t,
   ~effect: Internal.effect,
   ~effectArgs,
+  ~scope: Internal.chainScope,
   ~indexerState,
   ~shouldGroup,
   ~item,
   ~ecosystem,
 ) => {
   let effectName = effect.name
-  let key = `${effectName}.effect`
-  let inMemTable = indexerState->InMemoryStore.getEffectInMemTable(~effect)
+  let inMemTable = indexerState->InMemoryStore.getEffectInMemTable(~effect, ~scope)
+  let table = inMemTable.table
+  let tableName = table.tableName
+  // The operation key must differ per scope so chain-scoped calls with the same
+  // input never dedup across chains. Cross-chain keeps the bare effect name so
+  // the storage-load metric stays stable.
+  let key = switch scope {
+  | CrossChain => `${effectName}.effect`
+  | Chain(chainId) => `${effectName}.effect.${chainId->Int.toString}`
+  }
 
   let load = async (args, ~onError) => {
     let idsToLoad = args->Array.map((arg: Internal.effectArgs) => arg.cacheKey)
@@ -264,13 +284,13 @@ let loadEffect = (
 
     if (
       switch persistence.storageStatus {
-      | Ready({cache}) => cache->Dict.has(effectName)
+      | Ready({cache}) => cache->Dict.has(tableName)
       | _ => false
       }
     ) {
       let storage = persistence->Persistence.getInitializedStorageOrThrow
       let timerRef = Prometheus.StorageLoad.startOperation(~storage=storage.name, ~operation=key)
-      let {table, outputSchema} = effect.storageMeta
+      let {outputSchema} = effect.storageMeta
 
       let dbEntities = try {
         (

package/src/LoadLayer.res.mjs

@@ -3,6 +3,7 @@
 import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Logging from "./Logging.res.mjs";
+import * as Internal from "./Internal.res.mjs";
 import * as Ecosystem from "./Ecosystem.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as LoadManager from "./LoadManager.res.mjs";
@@ -51,24 +52,43 @@ function loadById(loadManager, persistence, entityConfig, indexerState, shouldGr
 
 function callEffect(effect, arg, inMemTable, timerRef, onError) {
   let effectName = effect.name;
-  let hadActiveCalls = effect.activeCallsCount > 0;
-  effect.activeCallsCount = effect.activeCallsCount + 1 | 0;
-  Prometheus.SafeGauge.handleInt(Prometheus.EffectCalls.activeCallsCount, effectName, effect.activeCallsCount);
+  let scopeLabel = Internal.EffectCache.scopeToString(inMemTable.scope);
+  let hadActiveCalls = inMemTable.activeCallsCount > 0;
+  inMemTable.activeCallsCount = inMemTable.activeCallsCount + 1 | 0;
+  Prometheus.SafeGauge.handleInt(Prometheus.EffectCalls.activeCallsCount, {
+    effect: effectName,
+    scope: scopeLabel
+  }, inMemTable.activeCallsCount);
   if (hadActiveCalls) {
-    let elapsed = Performance.secondsBetween(effect.prevCallStartTimerRef, timerRef);
+    let elapsed = Performance.secondsBetween(inMemTable.prevCallStartTimerRef, timerRef);
     if (elapsed > 0) {
-      Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.timeCounter, effectName, elapsed);
+      Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.timeCounter, {
+        effect: effectName,
+        scope: scopeLabel
+      }, elapsed);
     }
   }
-  effect.prevCallStartTimerRef = timerRef;
+  inMemTable.prevCallStartTimerRef = timerRef;
   return effect.handler(arg).then(output => InMemoryStore.setEffectOutput(inMemTable, arg.checkpointId, arg.cacheKey, output, arg.context.cache)).catch(exn => onError(arg.cacheKey, exn)).finally(() => {
-    effect.activeCallsCount = effect.activeCallsCount - 1 | 0;
-    Prometheus.SafeGauge.handleInt(Prometheus.EffectCalls.activeCallsCount, effectName, effect.activeCallsCount);
+    inMemTable.activeCallsCount = inMemTable.activeCallsCount - 1 | 0;
+    Prometheus.SafeGauge.handleInt(Prometheus.EffectCalls.activeCallsCount, {
+      effect: effectName,
+      scope: scopeLabel
+    }, inMemTable.activeCallsCount);
     let newTimer = Performance.now();
-    Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.timeCounter, effectName, Performance.secondsBetween(effect.prevCallStartTimerRef, newTimer));
-    effect.prevCallStartTimerRef = newTimer;
-    Prometheus.SafeCounter.increment(Prometheus.EffectCalls.totalCallsCount, effectName);
-    Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.sumTimeCounter, effectName, Performance.secondsSince(timerRef));
+    Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.timeCounter, {
+      effect: effectName,
+      scope: scopeLabel
+    }, Performance.secondsBetween(inMemTable.prevCallStartTimerRef, newTimer));
+    inMemTable.prevCallStartTimerRef = newTimer;
+    Prometheus.SafeCounter.increment(Prometheus.EffectCalls.totalCallsCount, {
+      effect: effectName,
+      scope: scopeLabel
+    });
+    Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.sumTimeCounter, {
+      effect: effectName,
+      scope: scopeLabel
+    }, Performance.secondsSince(timerRef));
   });
 }
 
@@ -76,7 +96,7 @@ function executeWithRateLimit(effect, effectArgs, inMemTable, onError, isFromQue
   let effectName = effect.name;
   let timerRef = Performance.now();
   let promises = [];
-  let state = effect.rateLimit;
+  let state = inMemTable.rateLimitState;
   if (state !== undefined) {
     let now = Date.now();
     if (now >= state.windowStartTime + state.durationMs) {
@@ -93,12 +113,12 @@ function executeWithRateLimit(effect, effectArgs, inMemTable, onError, isFromQue
     }
     if (immediateCount > 0 && isFromQueue) {
       state.queueCount = state.queueCount - immediateCount | 0;
-      Prometheus.EffectQueueCount.set(state.queueCount, effectName);
+      Prometheus.EffectQueueCount.set(state.queueCount, effectName, Internal.EffectCache.scopeToString(inMemTable.scope));
     }
     if (Utils.$$Array.notEmpty(queuedArgs)) {
       if (!isFromQueue) {
         state.queueCount = state.queueCount + queuedArgs.length | 0;
-        Prometheus.EffectQueueCount.set(state.queueCount, effectName);
+        Prometheus.EffectQueueCount.set(state.queueCount, effectName, Internal.EffectCache.scopeToString(inMemTable.scope));
       }
       let millisUntilReset = {
         contents: 0
@@ -128,16 +148,19 @@ function executeWithRateLimit(effect, effectArgs, inMemTable, onError, isFromQue
   return Promise.all(promises);
 }
 
-function loadEffect(loadManager, persistence, effect, effectArgs, indexerState, shouldGroup, item, ecosystem) {
+function loadEffect(loadManager, persistence, effect, effectArgs, scope, indexerState, shouldGroup, item, ecosystem) {
   let effectName = effect.name;
-  let key = effectName + `.effect`;
-  let inMemTable = InMemoryStore.getEffectInMemTable(indexerState, effect);
+  let inMemTable = InMemoryStore.getEffectInMemTable(indexerState, effect, scope);
+  let table = inMemTable.table;
+  let tableName = table.tableName;
+  let key;
+  key = scope === "crossChain" ? effectName + `.effect` : effectName + `.effect.` + scope.toString();
   let load = async (args, onError) => {
     let idsToLoad = args.map(arg => arg.cacheKey);
     let idsFromCache = new Set();
     let match = persistence.storageStatus;
     let tmp;
-    tmp = typeof match !== "object" || match.TAG === "Initializing" ? false : effectName in match._0.cache;
+    tmp = typeof match !== "object" || match.TAG === "Initializing" ? false : tableName in match._0.cache;
     if (tmp) {
       let storage = Persistence.getInitializedStorageOrThrow(persistence);
       let timerRef = Prometheus.StorageLoad.startOperation(storage.name, key);
@@ -149,7 +172,7 @@ function loadEffect(loadManager, persistence, effect, effectArgs, indexerState,
           operator: "in",
           fieldName: Table.idFieldName,
           fieldValue: idsToLoad
-        }, match$1.table);
+        }, table);
       } catch (raw_exn) {
         let exn = Primitive_exceptions.internalToException(raw_exn);
         Logging.childWarn(Ecosystem.getItemLogger(item, ecosystem), {

package/src/LoadLayer.resi

@@ -25,6 +25,7 @@ let loadEffect: (
   ~persistence: Persistence.t,
   ~effect: Internal.effect,
   ~effectArgs: Internal.effectArgs,
+  ~scope: Internal.chainScope,
   ~indexerState: IndexerState.t,
   ~shouldGroup: bool,
   ~item: Internal.item,