envio 3.3.0-alpha.9 → 3.3.0

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,

package/src/LogSelection.res

@@ -1,65 +1,3 @@
-exception MissingRequiredTopic0
-let makeTopicSelection = (~topic0, ~topic1=[], ~topic2=[], ~topic3=[]): result<
-  Internal.topicSelection,
-  exn,
-> =>
-  if topic0->Utils.Array.isEmpty {
-    Error(MissingRequiredTopic0)
-  } else {
-    {
-      Internal.topic0,
-      topic1,
-      topic2,
-      topic3,
-    }->Ok
-  }
-
-let hasFilters = ({topic1, topic2, topic3}: Internal.topicSelection) => {
-  [topic1, topic2, topic3]->Array.find(topic => !Utils.Array.isEmpty(topic))->Option.isSome
-}
-
-/**
-For a group of topic selections, if multiple only use topic0, then they can be compressed into one
-selection combining the topic0s
-*/
-let compressTopicSelections = (topicSelections: array<Internal.topicSelection>) => {
-  let topic0sOfSelectionsWithoutFilters = []
-
-  let selectionsWithFilters = []
-
-  topicSelections->Array.forEach(selection => {
-    if selection->hasFilters {
-      selectionsWithFilters->Array.push(selection)->ignore
-    } else {
-      selection.topic0->Array.forEach(topic0 => {
-        topic0sOfSelectionsWithoutFilters->Array.push(topic0)->ignore
-      })
-    }
-  })
-
-  switch topic0sOfSelectionsWithoutFilters {
-  | [] => selectionsWithFilters
-  | topic0 =>
-    let selectionWithoutFilters: Internal.topicSelection = {
-      topic0,
-      topic1: [],
-      topic2: [],
-      topic3: [],
-    }
-    Array.concat([selectionWithoutFilters], selectionsWithFilters)
-  }
-}
-
-type t = {
-  addresses: array<Address.t>,
-  topicSelections: array<Internal.topicSelection>,
-}
-
-let make = (~addresses, ~topicSelections) => {
-  let topicSelections = compressTopicSelections(topicSelections)
-  {addresses, topicSelections}
-}
-
 // Expand a resolved topic selection into concrete topic values for a query:
 // `ContractAddresses` markers become the given partition addresses encoded as
 // topics; `Values` pass through.

package/src/LogSelection.res.mjs

@@ -8,75 +8,6 @@ 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 MissingRequiredTopic0 = /* @__PURE__ */Primitive_exceptions.create("LogSelection.MissingRequiredTopic0");
-
-function makeTopicSelection(topic0, topic1Opt, topic2Opt, topic3Opt) {
-  let topic1 = topic1Opt !== undefined ? topic1Opt : [];
-  let topic2 = topic2Opt !== undefined ? topic2Opt : [];
-  let topic3 = topic3Opt !== undefined ? topic3Opt : [];
-  if (Utils.$$Array.isEmpty(topic0)) {
-    return {
-      TAG: "Error",
-      _0: {
-        RE_EXN_ID: MissingRequiredTopic0
-      }
-    };
-  } else {
-    return {
-      TAG: "Ok",
-      _0: {
-        topic0: topic0,
-        topic1: topic1,
-        topic2: topic2,
-        topic3: topic3
-      }
-    };
-  }
-}
-
-function hasFilters(param) {
-  return Stdlib_Option.isSome([
-    param.topic1,
-    param.topic2,
-    param.topic3
-  ].find(topic => !Utils.$$Array.isEmpty(topic)));
-}
-
-function compressTopicSelections(topicSelections) {
-  let topic0sOfSelectionsWithoutFilters = [];
-  let selectionsWithFilters = [];
-  topicSelections.forEach(selection => {
-    if (hasFilters(selection)) {
-      selectionsWithFilters.push(selection);
-    } else {
-      selection.topic0.forEach(topic0 => {
-        topic0sOfSelectionsWithoutFilters.push(topic0);
-      });
-    }
-  });
-  if (topic0sOfSelectionsWithoutFilters.length === 0) {
-    return selectionsWithFilters;
-  }
-  let selectionWithoutFilters_topic1 = [];
-  let selectionWithoutFilters_topic2 = [];
-  let selectionWithoutFilters_topic3 = [];
-  let selectionWithoutFilters = {
-    topic0: topic0sOfSelectionsWithoutFilters,
-    topic1: selectionWithoutFilters_topic1,
-    topic2: selectionWithoutFilters_topic2,
-    topic3: selectionWithoutFilters_topic3
-  };
-  return [selectionWithoutFilters].concat(selectionsWithFilters);
-}
-
-function make(addresses, topicSelections) {
-  let topicSelections$1 = compressTopicSelections(topicSelections);
-  return {
-    addresses: addresses,
-    topicSelections: topicSelections$1
-  };
-}
-
 function materializeTopicFilter(filter, addresses) {
   if (filter.TAG === "Values") {
     return filter._0;
@@ -299,11 +230,6 @@ function parseWhereOrThrow(where, sighash, params, contractName, chainId, onEven
 }
 
 export {
-  MissingRequiredTopic0,
-  makeTopicSelection,
-  hasFilters,
-  compressTopicSelections,
-  make,
   materializeTopicFilter,
   materializeTopicSelections,
   eventBlockRangeSchema,

package/src/Metrics.res

@@ -47,7 +47,7 @@ let renderSourceRequests = (~samples: array<SourceManager.requestStatSample>) =>
       if sample.seconds !== 0. {
         secondsOut :=
           secondsOut.contents ++
-          `\n${sourceRequestSecondsTotalName}${labels} ${sample.seconds->Float.toString}`
+          `\n${sourceRequestSecondsTotalName}${labels} ${sample.seconds->Float.toFixed(~digits=3)}`
       }
     })
     countOut.contents ++ secondsOut.contents

package/src/Metrics.res.mjs

@@ -44,7 +44,7 @@ function renderSourceRequests(samples) {
     let labels = `{source="` + sample.sourceName + `",chainId="` + sample.chainId.toString() + `",method="` + sample.method + `"}`;
     countOut.contents = countOut.contents + (`\n` + sourceRequestTotalName + labels + ` ` + sample.count.toString());
     if (sample.seconds !== 0) {
-      secondsOut.contents = secondsOut.contents + (`\n` + sourceRequestSecondsTotalName + labels + ` ` + sample.seconds.toString());
+      secondsOut.contents = secondsOut.contents + (`\n` + sourceRequestSecondsTotalName + labels + ` ` + sample.seconds.toFixed(3));
       return;
     }
   });

package/src/Persistence.res

@@ -6,9 +6,14 @@
 // DbFunctions, Db, Migrations, InMemoryStore modules which use codegen code directly.
 
 // The type reflects an cache table in the db
-// It might be present even if the effect is not used in the application
+// It might be present even if the effect is not used in the application.
+// `initialState.cache` is keyed by `tableName` (the full cache address), so a
+// cross-chain and a chain-scoped cache for the same effect are tracked
+// independently.
 type effectCacheRecord = {
   effectName: string,
+  scope: Internal.chainScope,
+  tableName: string,
   // Number of rows in the table
   mutable count: int,
 }
@@ -40,8 +45,12 @@ type initialState = {
   envioInfo: option<JSON.t>,
 }
 
+// Carries the already-resolved cache address (`table`) rather than an effect +
+// scope: the scope is contextual (resolved per call from the handler's chain),
+// so the write layer only needs the concrete table it targets.
 type updatedEffectCache = {
-  effect: Internal.effect,
+  table: Table.table,
+  itemSchema: S.t<Internal.effectCacheItem>,
   items: array<Internal.effectCacheItem>,
   shouldInitialize: bool,
 }
@@ -112,7 +121,7 @@ type storage = {
   getRollbackData: (
     ~entityConfig: Internal.entityConfig,
     ~rollbackTargetCheckpointId: Internal.checkpointId,
-  ) => promise<(array<{"id": string}>, array<unknown>)>,
+  ) => promise<(array<string>, array<unknown>)>,
   // Write batch to storage
   writeBatch: (
     ~batch: Batch.t,