envio 3.2.1 → 3.3.0-alpha.1

package/src/CrossChainState.res.mjs

@@ -0,0 +1,221 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Env from "./Env.res.mjs";
+import * as Batch from "./Batch.res.mjs";
+import * as Utils from "./Utils.res.mjs";
+import * as Logging from "./Logging.res.mjs";
+import * as ChainMap from "./ChainMap.res.mjs";
+import * as ChainState from "./ChainState.res.mjs";
+import * as FetchState from "./FetchState.res.mjs";
+import * as Prometheus from "./Prometheus.res.mjs";
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Primitive_float from "@rescript/runtime/lib/es6/Primitive_float.js";
+import * as SafeCheckpointTracking from "./SafeCheckpointTracking.res.mjs";
+
+function calculateTargetBufferSize() {
+  if (Env.targetBufferSize !== undefined) {
+    return Env.targetBufferSize;
+  } else {
+    return 100000;
+  }
+}
+
+function make(chainStates, isInReorgThreshold, isRealtime, targetBufferSizeOpt) {
+  let targetBufferSize = targetBufferSizeOpt !== undefined ? targetBufferSizeOpt : (
+      Env.targetBufferSize !== undefined ? Env.targetBufferSize : 100000
+    );
+  let crossChainState = {
+    chainStates: chainStates,
+    chainIds: Object.values(chainStates).map(cs => ChainState.chainConfig(cs).id),
+    isRealtime: isRealtime,
+    isInReorgThreshold: isInReorgThreshold,
+    targetBufferSize: targetBufferSize
+  };
+  Prometheus.IndexingTargetBufferSize.set(targetBufferSize);
+  return crossChainState;
+}
+
+function chainStates(crossChainState) {
+  return crossChainState.chainStates;
+}
+
+function isRealtime(crossChainState) {
+  return crossChainState.isRealtime;
+}
+
+function isInReorgThreshold(crossChainState) {
+  return crossChainState.isInReorgThreshold;
+}
+
+function totalReadyCount(crossChainState) {
+  let total = 0;
+  for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
+    let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
+    total = total + FetchState.bufferReadyCount(ChainState.fetchState(cs)) | 0;
+  }
+  return total;
+}
+
+function nextItemIsNone(crossChainState) {
+  return !Batch.hasReadyItem(Object.values(crossChainState.chainStates).map(ChainState.fetchState));
+}
+
+function getSafeCheckpointId(crossChainState) {
+  let result;
+  for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
+    let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
+    let safeCheckpointTracking = ChainState.safeCheckpointTracking(cs);
+    if (safeCheckpointTracking !== undefined) {
+      let safeCheckpointId = SafeCheckpointTracking.getSafeCheckpointId(safeCheckpointTracking, ChainState.fetchState(cs).knownHeight);
+      let current = result;
+      if (!(current !== undefined && safeCheckpointId >= current)) {
+        result = safeCheckpointId;
+      }
+    }
+  }
+  let id = result;
+  if (id !== undefined && id > 0n) {
+    return id;
+  }
+}
+
+function createBatch(crossChainState, processedCheckpointId, batchSizeTarget, isRollback) {
+  return Batch.make(processedCheckpointId + (
+    isRollback ? 1n : 0n
+  ), Utils.Dict.mapValues(crossChainState.chainStates, cs => ({
+    fetchState: ChainState.fetchState(cs),
+    reorgDetection: ChainState.reorgDetection(cs),
+    progressBlockNumber: ChainState.committedProgressBlockNumber(cs),
+    sourceBlockNumber: ChainState.fetchState(cs).knownHeight,
+    totalEventsProcessed: ChainState.numEventsProcessed(cs),
+    chainConfig: ChainState.chainConfig(cs)
+  })), batchSizeTarget, crossChainState.isInReorgThreshold);
+}
+
+function enterReorgThreshold(crossChainState) {
+  Logging.info("Reorg threshold reached");
+  Prometheus.ReorgThreshold.set(true);
+  for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
+    ChainState.enterReorgThreshold(crossChainState.chainStates[crossChainState.chainIds[i]]);
+  }
+  crossChainState.isInReorgThreshold = true;
+}
+
+function applyBatchProgress(crossChainState, batch) {
+  let chainIds = crossChainState.chainIds;
+  let everyChainCaughtUp = true;
+  for (let i = 0, i_finish = chainIds.length; i < i_finish; ++i) {
+    let cs = crossChainState.chainStates[chainIds[i]];
+    ChainState.applyBatchProgress(cs, batch);
+    if (!(ChainState.hasProcessedToEndblock(cs) || ChainState.isProgressAtHead(cs))) {
+      everyChainCaughtUp = false;
+    }
+  }
+  let indexerCaughtUp = nextItemIsNone(crossChainState) && everyChainCaughtUp;
+  let allChainsReady = true;
+  for (let i$1 = 0, i_finish$1 = chainIds.length; i$1 < i_finish$1; ++i$1) {
+    let cs$1 = crossChainState.chainStates[chainIds[i$1]];
+    if (indexerCaughtUp) {
+      ChainState.markReady(cs$1);
+    }
+    if (!ChainState.isReady(cs$1)) {
+      allChainsReady = false;
+    }
+  }
+  if (allChainsReady) {
+    Prometheus.ProgressReady.setAllReady();
+  }
+  crossChainState.isRealtime = crossChainState.isRealtime || allChainsReady;
+}
+
+function priorityOrder(crossChainState) {
+  return Object.values(crossChainState.chainStates).toSorted((a, b) => Primitive_float.compare(FetchState.getProgressPercentage(ChainState.fetchState(a)), FetchState.getProgressPercentage(ChainState.fetchState(b))));
+}
+
+function totalReservedSize(crossChainState) {
+  let total = 0;
+  for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
+    let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
+    total = total + ChainState.pendingBudget(cs);
+  }
+  return total;
+}
+
+function compareByProgress(a, b) {
+  return Primitive_float.compare(a.progress, b.progress);
+}
+
+async function checkAndFetch(crossChainState, dispatchChain) {
+  let remaining = Primitive_int.max(0, (crossChainState.targetBufferSize - totalReadyCount(crossChainState) | 0) - (totalReservedSize(crossChainState) | 0) | 0);
+  let chainIds = crossChainState.chainIds;
+  let actionByChain = {};
+  let candidates = [];
+  for (let i = 0, i_finish = chainIds.length; i < i_finish; ++i) {
+    let chainId = chainIds[i];
+    let cs = crossChainState.chainStates[chainId];
+    let fetchState = ChainState.fetchState(cs);
+    let action = FetchState.getNextQuery(fetchState, remaining, ChainState.pendingBudget(cs));
+    if (typeof action !== "object") {
+      actionByChain[chainId] = action;
+    } else {
+      actionByChain[chainId] = "NothingToQuery";
+      action._0.forEach(query => {
+        query.chainId = chainId;
+        query.progress = FetchState.getProgressPercentageAt(fetchState, query.fromBlock);
+        candidates.push(query);
+      });
+    }
+  }
+  candidates.sort(compareByProgress);
+  let admittedByChain = {};
+  let running = 0;
+  let idx = 0;
+  while (running < remaining && idx < candidates.length) {
+    let query = candidates[idx];
+    Utils.Dict.push(admittedByChain, query.chainId.toString(), query);
+    running = running + query.estResponseSize;
+    idx = idx + 1 | 0;
+  };
+  Stdlib_Dict.forEachWithKey(admittedByChain, (queries, chainId) => {
+    actionByChain[chainId] = {
+      TAG: "Ready",
+      _0: queries
+    };
+    let chainId$1 = Stdlib_Int.fromString(chainId, undefined);
+    ChainState.startFetchingQueries(crossChainState.chainStates[chainId$1], queries);
+  });
+  let promises = [];
+  for (let i$1 = 0, i_finish$1 = chainIds.length; i$1 < i_finish$1; ++i$1) {
+    let chainId$1 = chainIds[i$1];
+    let action$1 = actionByChain[chainId$1];
+    if (action$1 !== undefined) {
+      let exit = 0;
+      if (typeof action$1 === "object" || action$1 === "WaitingForNewBlock") {
+        exit = 1;
+      }
+      if (exit === 1) {
+        let chain = ChainMap.Chain.makeUnsafe(chainId$1);
+        promises.push(dispatchChain(chain, action$1));
+      }
+    }
+  }
+  await Promise.all(promises);
+}
+
+export {
+  calculateTargetBufferSize,
+  make,
+  chainStates,
+  isRealtime,
+  isInReorgThreshold,
+  nextItemIsNone,
+  getSafeCheckpointId,
+  createBatch,
+  enterReorgThreshold,
+  applyBatchProgress,
+  priorityOrder,
+  checkAndFetch,
+}
+/* Env Not a pure module */

package/src/CrossChainState.resi

@@ -0,0 +1,39 @@
+// Whole-indexer view over every chain's ChainState. `t` is opaque: other modules
+// read it through the accessors and change it only through the transitions here.
+
+type t
+
+let calculateTargetBufferSize: unit => int
+
+let make: (
+  ~chainStates: dict<ChainState.t>,
+  ~isInReorgThreshold: bool,
+  ~isRealtime: bool,
+  ~targetBufferSize: int=?,
+) => t
+
+// Accessors.
+let chainStates: t => dict<ChainState.t>
+let isRealtime: t => bool
+let isInReorgThreshold: t => bool
+
+// Derived (pure).
+let nextItemIsNone: t => bool
+let getSafeCheckpointId: t => option<Internal.checkpointId>
+
+// Cross-chain transitions.
+let createBatch: (
+  t,
+  ~processedCheckpointId: Internal.checkpointId,
+  ~batchSizeTarget: int,
+  ~isRollback: bool,
+) => Batch.t
+let enterReorgThreshold: t => unit
+let applyBatchProgress: (t, ~batch: Batch.t) => unit
+
+// Fetch control.
+let priorityOrder: t => array<ChainState.t>
+let checkAndFetch: (
+  t,
+  ~dispatchChain: (~chain: ChainMap.Chain.t, ~action: FetchState.nextQuery) => promise<unit>,
+) => promise<unit>

package/src/Ecosystem.res

@@ -29,8 +29,66 @@ type t = {
       `LogSelection.res`. SVM does not support event handlers, so its
       schema always surfaces `None`. */
   onEventBlockFilterSchema: S.t<option<unknown>>,
+  /** Base logger injected at construction. Used to build per-item child
+      loggers (see `getItemLogger`). */
+  logger: Pino.t,
+  /** Materialise the user-facing event handed to handlers and contract
+      registration from an item's opaque payload. */
+  toEvent: Internal.eventItem => Internal.event,
+  /** Build the per-item child logger for an event item, with
+      ecosystem-specific log fields (EVM/Fuel: contract/event/address; SVM:
+      program/instruction/programId). Closes over the injected logger. */
+  toEventLogger: Internal.eventItem => Pino.t,
+  /** Build a raw event row for the `raw_events` table. Unsupported on SVM,
+      where the implementation throws. */
+  toRawEvent: Internal.eventItem => Internal.rawEvent,
 }
 
+// The materialised event and the child logger are both memoised on the item
+// object (an item is processed across preload + execution passes, and logged
+// from several places). Hidden keys mirror each other.
+let getItemEvent = {
+  let cacheKey = "_event"
+  (item: Internal.item, ~ecosystem: t): Internal.event => {
+    let cache = item->(Utils.magic: Internal.item => dict<Internal.event>)
+    switch cache->Utils.Dict.dangerouslyGetNonOption(cacheKey) {
+    | Some(event) => event
+    | None =>
+      let event = ecosystem.toEvent(item->Internal.castUnsafeEventItem)
+      cache->Dict.set(cacheKey, event)
+      event
+    }
+  }
+}
+
+let getItemLogger = {
+  let cacheKey = "_logger"
+  (item: Internal.item, ~ecosystem: t): Pino.t => {
+    let cache = item->(Utils.magic: Internal.item => dict<Pino.t>)
+    switch cache->Utils.Dict.dangerouslyGetNonOption(cacheKey) {
+    | Some(logger) => logger
+    | None =>
+      let logger = switch item {
+      | Internal.Event(_) => ecosystem.toEventLogger(item->Internal.castUnsafeEventItem)
+      | Block({blockNumber, onBlockConfig}) =>
+        Logging.createChildFrom(
+          ~logger=ecosystem.logger,
+          ~params={
+            "onBlock": onBlockConfig.name,
+            "chainId": onBlockConfig.chainId,
+            "block": blockNumber,
+          },
+        )
+      }
+      cache->Dict.set(cacheKey, logger)
+      logger
+    }
+  }
+}
+
+let getItemUserLogger = (item: Internal.item, ~ecosystem: t): Envio.logger =>
+  getItemLogger(item, ~ecosystem)->Logging.userLogger
+
 let makeOnBlockArgs = (~blockNumber: int, ~ecosystem: t, ~context): Internal.onBlockArgs => {
   switch ecosystem.name {
   | Svm => {slot: blockNumber, context}

package/src/Ecosystem.res.mjs

@@ -1,7 +1,46 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Logging from "./Logging.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 
+let cacheKey = "_event";
+
+function getItemEvent(item, ecosystem) {
+  let event = item[cacheKey];
+  if (event !== undefined) {
+    return Primitive_option.valFromOption(event);
+  }
+  let event$1 = ecosystem.toEvent(item);
+  item[cacheKey] = event$1;
+  return event$1;
+}
+
+let cacheKey$1 = "_logger";
+
+function getItemLogger(item, ecosystem) {
+  let logger = item[cacheKey$1];
+  if (logger !== undefined) {
+    return logger;
+  }
+  let logger$1;
+  if (item.kind === 0) {
+    logger$1 = ecosystem.toEventLogger(item);
+  } else {
+    let onBlockConfig = item.onBlockConfig;
+    logger$1 = Logging.createChildFrom(ecosystem.logger, {
+      onBlock: onBlockConfig.name,
+      chainId: onBlockConfig.chainId,
+      block: item.blockNumber
+    });
+  }
+  item[cacheKey$1] = logger$1;
+  return logger$1;
+}
+
+function getItemUserLogger(item, ecosystem) {
+  return Logging.userLogger(getItemLogger(item, ecosystem));
+}
+
 function makeOnBlockArgs(blockNumber, ecosystem, context) {
   let match = ecosystem.name;
   switch (match) {
@@ -23,6 +62,9 @@ function makeOnBlockArgs(blockNumber, ecosystem, context) {
 }
 
 export {
+  getItemEvent,
+  getItemLogger,
+  getItemUserLogger,
   makeOnBlockArgs,
 }
-/* No side effect */
+/* Logging Not a pure module */

package/src/Env.res

@@ -8,8 +8,6 @@ let updateSyncTimeOnRestart =
   envSafe->EnvSafe.get("UPDATE_SYNC_TIME_ON_RESTART", S.bool, ~fallback=true)
 let targetBufferSize = envSafe->EnvSafe.get("ENVIO_INDEXING_MAX_BUFFER_SIZE", S.option(S.int))
 let maxAddrInPartition = envSafe->EnvSafe.get("MAX_PARTITION_SIZE", S.int, ~fallback=5_000)
-let maxPartitionConcurrency =
-  envSafe->EnvSafe.get("ENVIO_MAX_PARTITION_CONCURRENCY", S.int, ~fallback=10)
 
 // Target number of in-memory objects (uncommitted entity/effect changes plus
 // unwritten batch items) the store holds before processing waits for the write

package/src/Env.res.mjs

@@ -19,8 +19,6 @@ let targetBufferSize = EnvSafe.get(envSafe, "ENVIO_INDEXING_MAX_BUFFER_SIZE", S$
 
 let maxAddrInPartition = EnvSafe.get(envSafe, "MAX_PARTITION_SIZE", S$RescriptSchema.int, undefined, 5000, undefined, undefined);
 
-let maxPartitionConcurrency = EnvSafe.get(envSafe, "ENVIO_MAX_PARTITION_CONCURRENCY", S$RescriptSchema.int, undefined, 10, undefined, undefined);
-
 let inMemoryObjectsTarget = EnvSafe.get(envSafe, "ENVIO_IN_MEMORY_OBJECTS_TARGET", S$RescriptSchema.int, undefined, 100000, undefined, undefined);
 
 let serverPort = EnvSafe.get(envSafe, "ENVIO_INDEXER_PORT", S$RescriptSchema.port(S$RescriptSchema.int, undefined), undefined, EnvSafe.get(envSafe, "METRICS_PORT", S$RescriptSchema.port(S$RescriptSchema.int, undefined), undefined, 9898, undefined, undefined), undefined, undefined);
@@ -222,7 +220,6 @@ export {
   updateSyncTimeOnRestart,
   targetBufferSize,
   maxAddrInPartition,
-  maxPartitionConcurrency,
   inMemoryObjectsTarget,
   serverPort,
   tuiEnvVar,

package/src/EventConfigBuilder.res

@@ -312,7 +312,7 @@ let resolveFieldSelection = (
 // ============== Client-side address filter ==============
 
 let compileAddressFilter: string => (
-  Internal.event,
+  Internal.eventPayload,
   int,
   dict<Internal.indexingContract>,
 ) => bool = %raw(`function (body) {
@@ -339,7 +339,7 @@ let buildAddressFilterBody = (groups: array<array<string>>): option<string> => {
 }
 
 let buildAddressFilter = (groups: array<array<string>>): option<
-  (Internal.event, int, dict<Internal.indexingContract>) => bool,
+  (Internal.eventPayload, int, dict<Internal.indexingContract>) => bool,
 > => buildAddressFilterBody(groups)->Option.map(compileAddressFilter)
 
 // ============== Build complete EVM event config ==============

package/src/EventProcessing.res

@@ -1,18 +1,17 @@
-let allChainsEventsProcessedToEndblock = (chainFetchers: ChainMap.t<ChainFetcher.t>) => {
-  chainFetchers
-  ->ChainMap.values
-  ->Array.every(cf => cf->ChainFetcher.hasProcessedToEndblock)
+let allChainsEventsProcessedToEndblock = (chainStates: dict<ChainState.t>) => {
+  chainStates
+  ->Dict.valuesToArray
+  ->Array.every(cs => cs->ChainState.hasProcessedToEndblock)
 }
 
-let computeChainsState = (chainFetchers: ChainMap.t<ChainFetcher.t>): Internal.chains => {
+let computeChainsState = (chainStates: dict<ChainState.t>): Internal.chains => {
   let chains = Dict.make()
 
-  let isRealtime = chainFetchers->ChainMap.values->Array.every(cf => cf->ChainFetcher.isReady)
+  let values = chainStates->Dict.valuesToArray
+  let isRealtime = values->Array.every(cs => cs->ChainState.isReady)
 
-  chainFetchers
-  ->ChainMap.keys
-  ->Array.forEach(chain => {
-    let chainId = chain->ChainMap.Chain.toChainId
+  values->Array.forEach(cs => {
+    let chainId = (cs->ChainState.chainConfig).id
     chains->Dict.set(
       chainId->Int.toString,
       {
@@ -31,7 +30,7 @@ let runEventHandlerOrThrow = async (
   item: Internal.item,
   ~checkpointId,
   ~handler,
-  ~inMemoryStore,
+  ~indexerState,
   ~loadManager,
   ~persistence,
   ~chains: Internal.chains,
@@ -46,7 +45,7 @@ let runEventHandlerOrThrow = async (
     let contextParams: UserContext.contextParams = {
       item,
       checkpointId,
-      inMemoryStore,
+      indexerState,
       loadManager,
       persistence,
       isPreload: false,
@@ -57,7 +56,7 @@ let runEventHandlerOrThrow = async (
     await handler(
       (
         {
-          event: eventItem.event,
+          event: item->Ecosystem.getItemEvent(~ecosystem=config.ecosystem),
           context: UserContext.getHandlerContext(contextParams),
         }: Internal.handlerArgs
       ),
@@ -84,9 +83,10 @@ let runEventHandlerOrThrow = async (
 let runHandlerOrThrow = async (
   item: Internal.item,
   ~checkpointId,
-  ~inMemoryStore,
+  ~indexerState,
   ~loadManager,
-  ~ctx: Ctx.t,
+  ~persistence: Persistence.t,
+  ~config: Config.t,
   ~chains: Internal.chains,
 ) => {
   switch item {
@@ -94,19 +94,19 @@ let runHandlerOrThrow = async (
     try {
       let contextParams: UserContext.contextParams = {
         item,
-        inMemoryStore,
+        indexerState,
         loadManager,
-        persistence: ctx.persistence,
+        persistence,
         checkpointId,
         isPreload: false,
         chains,
-        config: ctx.config,
+        config,
         isResolved: false,
       }
       await handler(
         Ecosystem.makeOnBlockArgs(
           ~blockNumber,
-          ~ecosystem=ctx.config.ecosystem,
+          ~ecosystem=config.ecosystem,
           ~context=UserContext.getHandlerContext(contextParams),
         ),
       )
@@ -121,16 +121,17 @@ let runHandlerOrThrow = async (
         }),
       )
     }
-  | Event({eventConfig}) => switch eventConfig.handler {
+  | Event({eventConfig}) =>
+    switch eventConfig.handler {
     | Some(handler) =>
       await item->runEventHandlerOrThrow(
         ~handler,
         ~checkpointId,
-        ~inMemoryStore,
+        ~indexerState,
         ~loadManager,
-        ~persistence=ctx.persistence,
+        ~persistence,
         ~chains,
-        ~config=ctx.config,
+        ~config,
       )
     | None => ()
     }
@@ -142,7 +143,7 @@ let preloadBatchOrThrow = async (
   ~loadManager,
   ~persistence,
   ~config: Config.t,
-  ~inMemoryStore,
+  ~indexerState,
   ~chains: Internal.chains,
 ) => {
   // On the first run of loaders, we don't care about the result,
@@ -160,7 +161,7 @@ let preloadBatchOrThrow = async (
     for idx in 0 to checkpointEventsProcessed - 1 {
       let item = batch.items->Array.getUnsafe(itemIdx.contents + idx)
       switch item {
-      | Event({eventConfig: {handler, contractName, name: eventName}, event}) =>
+      | Event({eventConfig: {handler, contractName, name: eventName}}) =>
         switch handler {
         | None => ()
         | Some(handler) =>
@@ -171,10 +172,10 @@ let preloadBatchOrThrow = async (
             )
             promises->Array.push(
               handler({
-                event,
+                event: item->Ecosystem.getItemEvent(~ecosystem=config.ecosystem),
                 context: UserContext.getHandlerContext({
                   item,
-                  inMemoryStore,
+                  indexerState,
                   loadManager,
                   persistence,
                   checkpointId,
@@ -208,7 +209,7 @@ let preloadBatchOrThrow = async (
                 ~ecosystem=config.ecosystem,
                 ~context=UserContext.getHandlerContext({
                   item,
-                  inMemoryStore,
+                  indexerState,
                   loadManager,
                   persistence,
                   checkpointId,
@@ -234,9 +235,10 @@ let preloadBatchOrThrow = async (
 
 let runBatchHandlersOrThrow = async (
   batch: Batch.t,
-  ~inMemoryStore,
+  ~indexerState,
   ~loadManager,
-  ~ctx,
+  ~persistence,
+  ~config,
   ~chains: Internal.chains,
 ) => {
   let itemIdx = ref(0)
@@ -248,7 +250,15 @@ let runBatchHandlersOrThrow = async (
     for idx in 0 to checkpointEventsProcessed - 1 {
       let item = batch.items->Array.getUnsafe(itemIdx.contents + idx)
 
-      await runHandlerOrThrow(item, ~checkpointId, ~inMemoryStore, ~loadManager, ~ctx, ~chains)
+      await runHandlerOrThrow(
+        item,
+        ~checkpointId,
+        ~indexerState,
+        ~loadManager,
+        ~persistence,
+        ~config,
+        ~chains,
+      )
     }
     itemIdx := itemIdx.contents + checkpointEventsProcessed
   }
@@ -273,14 +283,15 @@ type logPartitionInfo = {
 
 let processEventBatch = async (
   ~batch: Batch.t,
-  ~inMemoryStore: InMemoryStore.t,
+  ~indexerState: IndexerState.t,
   ~loadManager,
-  ~ctx: Ctx.t,
-  ~chainFetchers: ChainMap.t<ChainFetcher.t>,
+  ~persistence: Persistence.t,
+  ~config: Config.t,
+  ~chainStates: dict<ChainState.t>,
 ) => {
   let totalBatchSize = batch.totalBatchSize
   // Compute chains state for this batch
-  let chains: Internal.chains = chainFetchers->computeChainsState
+  let chains: Internal.chains = chainStates->computeChainsState
 
   let logger = Logging.getLogger()
   logger->Logging.childTrace({
@@ -296,29 +307,29 @@ let processEventBatch = async (
 
   try {
     // Backpressure: keep processing within keepLatestChangesLimit of the cycle.
-    await inMemoryStore->InMemoryStore.awaitCapacity
+    await indexerState->Writing.awaitCapacity
 
     let timeRef = Hrtime.makeTimer()
 
     if batch.items->Utils.Array.notEmpty {
-      await batch->preloadBatchOrThrow(
-        ~loadManager,
-        ~persistence=ctx.persistence,
-        ~inMemoryStore,
-        ~chains,
-        ~config=ctx.config,
-      )
+      await batch->preloadBatchOrThrow(~loadManager, ~persistence, ~indexerState, ~chains, ~config)
     }
 
     let elapsedTimeAfterLoaders = timeRef->Hrtime.timeSince->Hrtime.toSecondsFloat
 
     if batch.items->Utils.Array.notEmpty {
-      await batch->runBatchHandlersOrThrow(~inMemoryStore, ~loadManager, ~ctx, ~chains)
+      await batch->runBatchHandlersOrThrow(
+        ~indexerState,
+        ~loadManager,
+        ~persistence,
+        ~config,
+        ~chains,
+      )
     }
 
     let elapsedTimeAfterProcessing = timeRef->Hrtime.timeSince->Hrtime.toSecondsFloat
 
-    inMemoryStore->InMemoryStore.commitBatch(~batch)
+    indexerState->Writing.commitBatch(~batch)
 
     let loaderDuration = elapsedTimeAfterLoaders
     let handlerDuration = elapsedTimeAfterProcessing -. loaderDuration
@@ -329,7 +340,10 @@ let processEventBatch = async (
     reason->ErrorHandling.make(~msg=message, ~logger)->Error
   | ProcessingError({message, exn, item}) =>
     exn
-    ->ErrorHandling.make(~msg=message, ~logger=item->Logging.getItemLogger)
+    ->ErrorHandling.make(
+      ~msg=message,
+      ~logger=Ecosystem.getItemLogger(item, ~ecosystem=config.ecosystem),
+    )
     ->Error
   | exn => exn->ErrorHandling.make(~msg="Failed processing batch", ~logger)->Error
   }