envio 3.2.1 → 3.3.0-alpha.0

package/src/UserContext.res

@@ -1,7 +1,7 @@
 type contextParams = {
   item: Internal.item,
   checkpointId: Internal.checkpointId,
-  inMemoryStore: InMemoryStore.t,
+  indexerState: IndexerState.t,
   loadManager: LoadManager.t,
   persistence: Persistence.t,
   isPreload: bool,
@@ -22,7 +22,8 @@ Utils.Object.defineProperty(
   {
     // Wrap with toMethod so `this` binds to the EffectContext instance.
     get: Utils.toMethod(() => {
-      (paramsByThis->Utils.WeakMap.unsafeGet(%raw(`this`))).item->Logging.getUserLogger
+      let params = paramsByThis->Utils.WeakMap.unsafeGet(%raw(`this`))
+      Ecosystem.getItemUserLogger(params.item, ~ecosystem=params.config.ecosystem)
     }),
   },
 )
@@ -60,9 +61,10 @@ let initEffect = (params: contextParams) => {
       ~persistence=params.persistence,
       ~effect,
       ~effectArgs,
-      ~inMemoryStore=params.inMemoryStore,
+      ~indexerState=params.indexerState,
       ~shouldGroup=params.isPreload,
       ~item=params.item,
+      ~ecosystem=params.config.ecosystem,
     )
   }
   callEffect
@@ -82,9 +84,10 @@ let getWhereHandler = (params: entityContextParams, filter: dict<dict<unknown>>)
       ~loadManager=params.loadManager,
       ~persistence=params.persistence,
       ~entityConfig,
-      ~inMemoryStore=params.inMemoryStore,
+      ~indexerState=params.indexerState,
       ~shouldGroup=params.isPreload,
       ~item=params.item,
+      ~ecosystem=params.config.ecosystem,
       ~filter,
     )
 
@@ -121,10 +124,10 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
     let set = params.isPreload
       ? noopSet
       : (entity: Internal.entity) => {
-          params.inMemoryStore
+          params.indexerState
           ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig)
           ->InMemoryTable.Entity.set(
-            ~committedCheckpointId=params.inMemoryStore.committedCheckpointId,
+            ~committedCheckpointId=params.indexerState->IndexerState.committedCheckpointId,
             Set({
               entityId: entity.id,
               checkpointId: params.checkpointId,
@@ -146,9 +149,10 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
               ~loadManager=params.loadManager,
               ~persistence=params.persistence,
               ~entityConfig=params.entityConfig,
-              ~inMemoryStore=params.inMemoryStore,
+              ~indexerState=params.indexerState,
               ~shouldGroup=params.isPreload,
               ~item=params.item,
+              ~ecosystem=params.config.ecosystem,
               ~entityId,
             )
         )->(Utils.magic: (string => promise<option<Internal.entity>>) => unknown)
@@ -177,9 +181,10 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
               ~loadManager=params.loadManager,
               ~persistence=params.persistence,
               ~entityConfig=params.entityConfig,
-              ~inMemoryStore=params.inMemoryStore,
+              ~indexerState=params.indexerState,
               ~shouldGroup=params.isPreload,
               ~item=params.item,
+              ~ecosystem=params.config.ecosystem,
               ~entityId,
             )->Promise.thenResolve(entity => {
               switch entity {
@@ -206,9 +211,10 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
               ~loadManager=params.loadManager,
               ~persistence=params.persistence,
               ~entityConfig=params.entityConfig,
-              ~inMemoryStore=params.inMemoryStore,
+              ~indexerState=params.indexerState,
               ~shouldGroup=params.isPreload,
               ~item=params.item,
+              ~ecosystem=params.config.ecosystem,
               ~entityId=entity.id,
             )->Promise.thenResolve(storageEntity => {
               switch storageEntity {
@@ -227,10 +233,10 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
         noopDeleteUnsafe
       } else {
         entityId => {
-          params.inMemoryStore
+          params.indexerState
           ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig)
           ->InMemoryTable.Entity.set(
-            ~committedCheckpointId=params.inMemoryStore.committedCheckpointId,
+            ~committedCheckpointId=params.indexerState->IndexerState.committedCheckpointId,
             Delete({
               entityId,
               checkpointId: params.checkpointId,
@@ -250,13 +256,17 @@ let handlerTraps: Utils.Proxy.traps<contextParams> = {
     if params.isResolved {
       Utils.Error.make(
         `Impossible to access context.${prop} after the handler is resolved. Make sure you didn't miss an await in the handler.`,
-      )->ErrorHandling.mkLogAndRaise(~logger=params.item->Logging.getItemLogger)
+      )->ErrorHandling.mkLogAndRaise(
+        ~logger=Ecosystem.getItemLogger(params.item, ~ecosystem=params.config.ecosystem),
+      )
     }
     switch prop {
     | "log" =>
-      (params.isPreload ? Logging.noopLogger : params.item->Logging.getUserLogger)->(
-        Utils.magic: Envio.logger => unknown
-      )
+      (
+        params.isPreload
+          ? Logging.noopLogger
+          : Ecosystem.getItemUserLogger(params.item, ~ecosystem=params.config.ecosystem)
+      )->(Utils.magic: Envio.logger => unknown)
 
     | "effect" =>
       initEffect((params :> contextParams))->(
@@ -277,7 +287,7 @@ let handlerTraps: Utils.Proxy.traps<contextParams> = {
         {
           item: params.item,
           isPreload: params.isPreload,
-          inMemoryStore: params.inMemoryStore,
+          indexerState: params.indexerState,
           loadManager: params.loadManager,
           persistence: params.persistence,
           checkpointId: params.checkpointId,
@@ -300,101 +310,3 @@ let handlerTraps: Utils.Proxy.traps<contextParams> = {
 let getHandlerContext = (params: contextParams): Internal.handlerContext => {
   params->Utils.Proxy.make(handlerTraps)->(Utils.magic: contextParams => Internal.handlerContext)
 }
-
-// Contract register context creation
-type contractRegisterParams = {
-  item: Internal.item,
-  onRegister: (~item: Internal.item, ~contractAddress: Address.t, ~contractName: string) => unit,
-  config: Config.t,
-  mutable isResolved: bool,
-}
-
-// Helper to create a validated add function for contract registration.
-// The isResolved check has to live inside the returned closure (not just in the
-// outer proxy trap) because users can capture `const add = context.chain.X.add`
-// before awaiting — a later call would otherwise bypass the resolved guard.
-let makeAddFunction = (~params: contractRegisterParams, ~contractName: string): (
-  Address.t => unit
-) => {
-  (contractAddress: Address.t) => {
-    if params.isResolved {
-      Utils.Error.make(`Impossible to access context.chain after the contract register is resolved. Make sure you didn't miss an await in the handler.`)->ErrorHandling.mkLogAndRaise(
-        ~logger=params.item->Logging.getItemLogger,
-      )
-    }
-    let validatedAddress = if params.config.ecosystem.name === Evm {
-      // The value is passed from the user-land,
-      // so we need to validate and checksum/lowercase the address.
-      if params.config.lowercaseAddresses {
-        contractAddress->Address.Evm.fromAddressLowercaseOrThrow
-      } else {
-        contractAddress->Address.Evm.fromAddressOrThrow
-      }
-    } else {
-      // TODO: Ideally we should do the same for other ecosystems
-      contractAddress
-    }
-
-    params.onRegister(~item=params.item, ~contractAddress=validatedAddress, ~contractName)
-  }
-}
-
-// Chain proxy for contractRegister context: context.chain.ContractName.add(address)
-let contractRegisterChainTraps: Utils.Proxy.traps<contractRegisterParams> = {
-  get: (~target as params, ~prop: unknown) => {
-    let prop = prop->(Utils.magic: unknown => string)
-    switch prop {
-    | "id" =>
-      let eventItem = params.item->Internal.castUnsafeEventItem
-      eventItem.chain->ChainMap.Chain.toChainId->(Utils.magic: int => unknown)
-    | _ =>
-      // Look up the contract name directly in config contracts across all chains.
-      let contractName = prop
-      let isValidContract =
-        params.config.chainMap
-        ->ChainMap.values
-        ->Array.some(chain => chain.contracts->Array.some(c => c.name === contractName))
-      if isValidContract {
-        let addFn = makeAddFunction(~params, ~contractName)
-        {"add": addFn}->(Utils.magic: {"add": Address.t => unit} => unknown)
-      } else {
-        JsError.throwWithMessage(
-          `Invalid contract name '${prop}' on context.chain. ${EntityFilter.codegenHelpMessage}`,
-        )
-      }
-    }
-  },
-}
-
-let contractRegisterTraps: Utils.Proxy.traps<contractRegisterParams> = {
-  get: (~target as params, ~prop: unknown) => {
-    let prop = prop->(Utils.magic: unknown => string)
-    if params.isResolved {
-      Utils.Error.make(
-        `Impossible to access context.${prop} after the contract register is resolved. Make sure you didn't miss an await in the handler.`,
-      )->ErrorHandling.mkLogAndRaise(~logger=params.item->Logging.getItemLogger)
-    }
-    switch prop {
-    | "log" => params.item->Logging.getUserLogger->(Utils.magic: Envio.logger => unknown)
-    | "chain" =>
-      params
-      ->Utils.Proxy.make(contractRegisterChainTraps)
-      ->(Utils.magic: contractRegisterParams => unknown)
-    | _ =>
-      JsError.throwWithMessage(
-        `Invalid context access by '${prop}' property. Use context.chain.ContractName.add(address) to register contracts. ${EntityFilter.codegenHelpMessage}`,
-      )
-    }
-  },
-}
-
-let getContractRegisterContext = (params: contractRegisterParams) => {
-  params
-  ->Utils.Proxy.make(contractRegisterTraps)
-  ->(Utils.magic: contractRegisterParams => Internal.contractRegisterContext)
-}
-
-let getContractRegisterArgs = (params: contractRegisterParams): Internal.contractRegisterArgs => {
-  event: (params.item->Internal.castUnsafeEventItem).event,
-  context: getContractRegisterContext(params),
-}

package/src/UserContext.res.mjs

@@ -1,12 +1,12 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
-import * as Address from "./Address.res.mjs";
 import * as Logging from "./Logging.res.mjs";
-import * as ChainMap from "./ChainMap.res.mjs";
 import * as Internal from "./Internal.res.mjs";
+import * as Ecosystem from "./Ecosystem.res.mjs";
 import * as LoadLayer from "./LoadLayer.res.mjs";
 import * as EntityFilter from "./db/EntityFilter.res.mjs";
+import * as IndexerState from "./IndexerState.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryStore from "./InMemoryStore.res.mjs";
 import * as InMemoryTable from "./InMemoryTable.res.mjs";
@@ -20,7 +20,8 @@ let effectContextPrototype = (Object.create(null));
 
 Object.defineProperty(effectContextPrototype, "log", {
   get: function () {
-    return Logging.getUserLogger(paramsByThis.get(this).item);
+    let params = paramsByThis.get(this);
+    return Ecosystem.getItemUserLogger(params.item, params.config.ecosystem);
   }
 });
 
@@ -43,7 +44,7 @@ function initEffect(params) {
       cacheKey: effectArgs_cacheKey,
       checkpointId: effectArgs_checkpointId
     };
-    return LoadLayer.loadEffect(params.loadManager, params.persistence, effect, effectArgs, params.inMemoryStore, params.isPreload, params.item);
+    return LoadLayer.loadEffect(params.loadManager, params.persistence, effect, effectArgs, params.indexerState, params.isPreload, params.item, params.config.ecosystem);
   };
   return callEffect;
 }
@@ -52,9 +53,9 @@ function getWhereHandler(params, filter) {
   let entityConfig = params.entityConfig;
   let filters = EntityFilter.parseGetWhereOrThrow(filter, entityConfig.name, entityConfig.table);
   if (filters.length !== 1) {
-    return Promise.all(filters.map(filter => LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, params.inMemoryStore, params.isPreload, params.item, filter))).then(results => results.flat());
+    return Promise.all(filters.map(filter => LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, filter))).then(results => results.flat());
   } else {
-    return LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, params.inMemoryStore, params.isPreload, params.item, filters[0]);
+    return LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, filters[0]);
   }
 }
 
@@ -72,7 +73,7 @@ function throwClickHouseReadOnly(entityConfig, op) {
 
 let entityTraps_get = (params, prop) => {
   let isClickHouseOnly = !params.entityConfig.storage.postgres;
-  let set = params.isPreload ? noopSet : entity => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.inMemoryStore, params.entityConfig), params.inMemoryStore.committedCheckpointId, {
+  let set = params.isPreload ? noopSet : entity => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig), IndexerState.committedCheckpointId(params.indexerState), {
       type: "SET",
       entityId: entity.id,
       entity: entity,
@@ -83,7 +84,7 @@ let entityTraps_get = (params, prop) => {
       if (params.isPreload) {
         return noopDeleteUnsafe;
       } else {
-        return entityId => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.inMemoryStore, params.entityConfig), params.inMemoryStore.committedCheckpointId, {
+        return entityId => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig), IndexerState.committedCheckpointId(params.indexerState), {
           type: "DELETE",
           entityId: entityId,
           checkpointId: params.checkpointId
@@ -93,13 +94,13 @@ let entityTraps_get = (params, prop) => {
       if (isClickHouseOnly) {
         return _entityId => throwClickHouseReadOnly(params.entityConfig, "get");
       } else {
-        return entityId => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.inMemoryStore, params.isPreload, params.item, entityId);
+        return entityId => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, entityId);
       }
     case "getOrCreate" :
       if (isClickHouseOnly) {
         return _entity => throwClickHouseReadOnly(params.entityConfig, "getOrCreate");
       } else {
-        return entity => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.inMemoryStore, params.isPreload, params.item, entity.id).then(storageEntity => {
+        return entity => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, entity.id).then(storageEntity => {
           if (storageEntity !== undefined) {
             return storageEntity;
           } else {
@@ -112,7 +113,7 @@ let entityTraps_get = (params, prop) => {
       if (isClickHouseOnly) {
         return (_entityId, param) => throwClickHouseReadOnly(params.entityConfig, "getOrThrow");
       } else {
-        return (entityId, message) => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.inMemoryStore, params.isPreload, params.item, entityId).then(entity => {
+        return (entityId, message) => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, entityId).then(entity => {
           if (entity !== undefined) {
             return entity;
           } else {
@@ -139,7 +140,7 @@ let entityTraps = {
 
 let handlerTraps_get = (params, prop) => {
   if (params.isResolved) {
-    ErrorHandling.mkLogAndRaise(Logging.getItemLogger(params.item), undefined, new Error(`Impossible to access context.` + prop + ` after the handler is resolved. Make sure you didn't miss an await in the handler.`));
+    ErrorHandling.mkLogAndRaise(Ecosystem.getItemLogger(params.item, params.config.ecosystem), undefined, new Error(`Impossible to access context.` + prop + ` after the handler is resolved. Make sure you didn't miss an await in the handler.`));
   }
   switch (prop) {
     case "chain" :
@@ -153,7 +154,7 @@ let handlerTraps_get = (params, prop) => {
       if (params.isPreload) {
         return Logging.noopLogger;
       } else {
-        return Logging.getUserLogger(params.item);
+        return Ecosystem.getItemUserLogger(params.item, params.config.ecosystem);
       }
     default:
       let entityConfig = params.config.userEntitiesByName[prop];
@@ -161,7 +162,7 @@ let handlerTraps_get = (params, prop) => {
         return new Proxy({
           item: params.item,
           checkpointId: params.checkpointId,
-          inMemoryStore: params.inMemoryStore,
+          indexerState: params.indexerState,
           loadManager: params.loadManager,
           persistence: params.persistence,
           isPreload: params.isPreload,
@@ -184,65 +185,6 @@ function getHandlerContext(params) {
   return new Proxy(params, handlerTraps);
 }
 
-function makeAddFunction(params, contractName) {
-  return contractAddress => {
-    if (params.isResolved) {
-      ErrorHandling.mkLogAndRaise(Logging.getItemLogger(params.item), undefined, new Error(`Impossible to access context.chain after the contract register is resolved. Make sure you didn't miss an await in the handler.`));
-    }
-    let validatedAddress = params.config.ecosystem.name === "evm" ? (
-        params.config.lowercaseAddresses ? Address.Evm.fromAddressLowercaseOrThrow(contractAddress) : Address.Evm.fromAddressOrThrow(contractAddress)
-      ) : contractAddress;
-    params.onRegister(params.item, validatedAddress, contractName);
-  };
-}
-
-let contractRegisterChainTraps_get = (params, prop) => {
-  if (prop === "id") {
-    return params.item.chain;
-  }
-  let isValidContract = ChainMap.values(params.config.chainMap).some(chain => chain.contracts.some(c => c.name === prop));
-  if (isValidContract) {
-    return {
-      add: makeAddFunction(params, prop)
-    };
-  } else {
-    return Stdlib_JsError.throwWithMessage(`Invalid contract name '` + prop + `' on context.chain. ` + EntityFilter.codegenHelpMessage);
-  }
-};
-
-let contractRegisterChainTraps = {
-  get: contractRegisterChainTraps_get
-};
-
-let contractRegisterTraps_get = (params, prop) => {
-  if (params.isResolved) {
-    ErrorHandling.mkLogAndRaise(Logging.getItemLogger(params.item), undefined, new Error(`Impossible to access context.` + prop + ` after the contract register is resolved. Make sure you didn't miss an await in the handler.`));
-  }
-  switch (prop) {
-    case "chain" :
-      return new Proxy(params, contractRegisterChainTraps);
-    case "log" :
-      return Logging.getUserLogger(params.item);
-    default:
-      return Stdlib_JsError.throwWithMessage(`Invalid context access by '` + prop + `' property. Use context.chain.ContractName.add(address) to register contracts. ` + EntityFilter.codegenHelpMessage);
-  }
-};
-
-let contractRegisterTraps = {
-  get: contractRegisterTraps_get
-};
-
-function getContractRegisterContext(params) {
-  return new Proxy(params, contractRegisterTraps);
-}
-
-function getContractRegisterArgs(params) {
-  return {
-    event: params.item.event,
-    context: new Proxy(params, contractRegisterTraps)
-  };
-}
-
 export {
   paramsByThis,
   effectContextPrototype,
@@ -254,10 +196,5 @@ export {
   entityTraps,
   handlerTraps,
   getHandlerContext,
-  makeAddFunction,
-  contractRegisterChainTraps,
-  contractRegisterTraps,
-  getContractRegisterContext,
-  getContractRegisterArgs,
 }
 /* paramsByThis Not a pure module */

package/src/Writing.res

@@ -0,0 +1,242 @@
+// The write loop: drains the processed-batch queue and staged chain metadata to
+// storage off the processing path. A peer to ChainFetching/BatchProcessing/
+// Rollback, but data-driven — `schedule` kicks a single write fiber whenever
+// there's pending work, and processing waits on it through awaitCapacity/flush.
+// State mutations go through IndexerState's domain operations.
+
+// Max uncommitted entity/effect changes plus unwritten batch items before
+// processing must wait for the cycle to free capacity.
+let keepLatestChangesLimit = Env.inMemoryObjectsTarget
+
+let getChangesCount = (state: IndexerState.t) => {
+  let total = ref(0.)
+  state
+  ->IndexerState.allEntities
+  ->Array.forEach(entityConfig => {
+    total := total.contents +. (state->InMemoryStore.getInMemTable(~entityConfig)).changesCount
+  })
+  state
+  ->IndexerState.effects
+  ->Utils.Dict.forEach(inMemTable => {
+    total := total.contents +. inMemTable.changesCount
+  })
+  state
+  ->IndexerState.processedBatches
+  ->Array.forEach(batch => {
+    total := total.contents +. batch.totalBatchSize->Int.toFloat
+  })
+  total.contents
+}
+
+let waitForCommit = (state: IndexerState.t): promise<unit> =>
+  Promise.make((resolve, _) => {
+    state->IndexerState.addCommitWaiter(resolve)
+  })
+
+// Captures the cache:true outputs to persist. The dict is left intact — entries
+// stay warm and are reclaimed later by dropCommittedEffects once committed.
+let snapshotEffects = (state: IndexerState.t, ~cache): array<Persistence.updatedEffectCache> => {
+  let acc = []
+  state
+  ->IndexerState.effects
+  ->Utils.Dict.forEach(inMemTable => {
+    let {idsToStore, dict, effect, invalidationsCount} = inMemTable
+    switch idsToStore {
+    | [] => ()
+    | ids =>
+      let items = ids->Array.filterMap((id): option<Internal.effectCacheItem> =>
+        switch dict->Dict.getUnsafe(id) {
+        | Set({entity: output}) => Some({id, output})
+        | Delete(_) => None
+        }
+      )
+      let effectName = effect.name
+      let effectCacheRecord = switch cache->Utils.Dict.dangerouslyGetNonOption(effectName) {
+      | Some(c) => c
+      | None =>
+        let c: Persistence.effectCacheRecord = {effectName, count: 0}
+        cache->Dict.set(effectName, c)
+        c
+      }
+      let shouldInitialize = effectCacheRecord.count === 0
+      effectCacheRecord.count = effectCacheRecord.count + items->Array.length - invalidationsCount
+      Prometheus.EffectCacheCount.set(~count=effectCacheRecord.count, ~effectName)
+      acc->Array.push(({effect, items, shouldInitialize}: Persistence.updatedEffectCache))->ignore
+    }
+    inMemTable.idsToStore = []
+    inMemTable.invalidationsCount = 0
+  })
+  acc
+}
+
+let runOneWrite = async (state: IndexerState.t) => {
+  let persistence = state->IndexerState.persistence
+  let config = state->IndexerState.config
+  let cache = switch persistence.storageStatus {
+  | Unknown
+  | Initializing(_) =>
+    JsError.throwWithMessage(`Failed to access the indexer storage. The Persistence layer is not initialized.`)
+  | Ready({cache}) => cache
+  }
+
+  // Snapshot before the await: the batch write reads this later, in-transaction.
+  let chainMetaData = state->IndexerState.takeChainMetaSnapshot
+
+  switch state->IndexerState.processedBatches {
+  | [] =>
+    // Metadata only: a cheap upsert, still serialized by the single write loop.
+    switch chainMetaData {
+    | Some(chainsData) =>
+      await persistence.storage.setChainMeta(chainsData)->Utils.Promise.ignoreValue
+    | None => ()
+    }
+  | _ =>
+    let committedCheckpointId = state->IndexerState.committedCheckpointId
+    let batch = state->IndexerState.drainBatchRun
+    // The run's last checkpoint; entity changes above it stay queued for the next write.
+    let upToCheckpointId = switch batch.checkpointIds->Utils.Array.last {
+    | Some(checkpointId) => checkpointId
+    | None => committedCheckpointId
+    }
+
+    let rollback = state->IndexerState.takeRollback
+
+    let updatedEntities = persistence.allEntities->Array.filterMap(entityConfig => {
+      let table = state->InMemoryStore.getInMemTable(~entityConfig)
+      let changes =
+        table->InMemoryTable.Entity.snapshotChanges(~committedCheckpointId, ~upToCheckpointId)
+      if changes->Utils.Array.isEmpty {
+        None
+      } else {
+        Some(({entityConfig, changes}: Persistence.updatedEntity))
+      }
+    })
+    let updatedEffectsCache = snapshotEffects(state, ~cache)
+
+    await persistence.storage.writeBatch(
+      ~batch,
+      ~rollback,
+      ~isInReorgThreshold=batch.isInReorgThreshold,
+      ~config,
+      ~allEntities=persistence.allEntities,
+      ~updatedEntities,
+      ~updatedEffectsCache,
+      ~chainMetaData,
+    )
+
+    state->IndexerState.markCommitted(~upToCheckpointId)
+
+    switch rollback {
+    | Some({progressBlockNumberByChainId}) if RollbackCommit.callbacks->Utils.Array.notEmpty =>
+      await RollbackCommit.fire(~progressBlockNumberByChainId)
+    | _ => ()
+    }
+  }
+}
+
+let hasPendingWrite = (state: IndexerState.t) =>
+  state->IndexerState.processedBatches->Utils.Array.notEmpty || state->IndexerState.chainMetaDirty
+
+let runWriteLoop = async (state: IndexerState.t) => {
+  while state->hasPendingWrite && !(state->IndexerState.hasFailedWrite) {
+    try {
+      await runOneWrite(state)
+      state->IndexerState.wakeCommitWaiters
+    } catch {
+    | exn => state->IndexerState.recordWriteFailure(exn)
+    }
+  }
+  state->IndexerState.endWriteFiber
+  state->IndexerState.wakeCommitWaiters
+}
+
+// Kicks the single write fiber if there's pending work and one isn't running.
+let schedule = (state: IndexerState.t) =>
+  if (
+    state->IndexerState.writeFiber->Option.isNone &&
+    !(state->IndexerState.hasFailedWrite) &&
+    state->hasPendingWrite
+  ) {
+    state->IndexerState.beginWriteFiber(runWriteLoop(state))
+  }
+
+// Stages chain metadata and throttles a metadata-only write when no batches flow.
+let setChainMeta = (state: IndexerState.t, chainsData: dict<InternalTable.Chains.metaFields>) => {
+  state->IndexerState.stageChainMeta(chainsData)
+  if state->IndexerState.chainMetaDirty {
+    state
+    ->IndexerState.chainMetaThrottler
+    ->Throttler.schedule(() => {
+      state->schedule
+      Promise.resolve()
+    })
+  }
+}
+
+// Queues a processed batch and kicks the cycle. Returns immediately; the write
+// happens off the processing path.
+let commitBatch = (state: IndexerState.t, ~batch: Batch.t) => {
+  state->IndexerState.queueProcessedBatch(~batch)
+  state->schedule
+}
+
+// Drops committed entity and effect entries across all tables. With
+// keepLoadedFromDb, entries seeded from a db read are spared.
+let dropCommitted = (state: IndexerState.t, ~keepLoadedFromDb) => {
+  let committedCheckpointId = state->IndexerState.committedCheckpointId
+  state
+  ->IndexerState.allEntities
+  ->Array.forEach(entityConfig =>
+    state
+    ->InMemoryStore.getInMemTable(~entityConfig)
+    ->InMemoryTable.Entity.dropCommittedChanges(~committedCheckpointId, ~keepLoadedFromDb)
+  )
+  state
+  ->IndexerState.effects
+  ->Utils.Dict.forEach(inMemTable =>
+    inMemTable->InMemoryStore.dropCommittedEffects(~committedCheckpointId, ~keepLoadedFromDb)
+  )
+}
+
+// Blocks until the store holds fewer than keepLatestChangesLimit changes,
+// freeing committed changes first and awaiting commits as a last resort.
+let rec awaitCapacity = async (state: IndexerState.t) => {
+  // After a failed write nothing will free capacity, so bail instead of waiting
+  // on a commit that won't come (the error already went to onError).
+  if !(state->IndexerState.hasFailedWrite) && state->getChangesCount >= keepLatestChangesLimit {
+    // Drop committed writes first, sparing db-loaded entries (explicitly
+    // requested, so likelier to be read again).
+    state->dropCommitted(~keepLoadedFromDb=true)
+
+    // Still over: drop the db-loaded entries too.
+    if state->getChangesCount >= keepLatestChangesLimit {
+      state->dropCommitted(~keepLoadedFromDb=false)
+    }
+
+    // Still over: what's left is uncommitted. Only wait if a queued batch can
+    // free it; otherwise (e.g. a large rollback diff with no batch) waiting
+    // would deadlock, so let processing proceed.
+    if (
+      state->getChangesCount >= keepLatestChangesLimit &&
+        state->IndexerState.processedBatches->Utils.Array.notEmpty
+    ) {
+      state->schedule
+      await state->waitForCommit
+      await state->awaitCapacity
+    }
+  }
+}
+
+// Awaits until everything processed is persisted. On a failed write we stop
+// draining (onError already surfaced it) rather than throw.
+let rec flush = async (state: IndexerState.t) => {
+  if !(state->IndexerState.hasFailedWrite) {
+    state->schedule
+    switch state->IndexerState.writeFiber {
+    | Some(fiber) =>
+      await fiber
+      await state->flush
+    | None => ()
+    }
+  }
+}