envio 3.1.0-rc.1 → 3.1.0

package/src/InMemoryStore.res

@@ -21,36 +21,91 @@ module EntityTables = {
 }
 
 type effectCacheInMemTable = {
-  idsToStore: array<string>,
+  // 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,
-  dict: dict<Internal.effectOutput>,
+  // 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 = {
   allEntities: array<Internal.entityConfig>,
-  mutable rawEvents: array<InternalTable.RawEvents.t>,
   mutable entities: dict<InMemoryTable.Entity.t>,
   mutable effects: dict<effectCacheInMemTable>,
   mutable rollback: option<Persistence.rollback>,
+  // Last checkpoint persisted to the db.
   mutable committedCheckpointId: Internal.checkpointId,
+  // Processing frontier; runs ahead of committedCheckpointId while writes lag.
+  mutable processedCheckpointId: Internal.checkpointId,
+  // Processed but unwritten. The cycle drains them, splitting each write at a
+  // change in isInReorgThreshold so it never mixes history-saving modes.
+  mutable processedBatches: array<Batch.t>,
+  // The single in-flight write loop, None when idle.
+  mutable writeFiber: option<promise<unit>>,
+  // Set once a write throws, to stop the loop. The error itself goes to onError.
+  mutable hasFailedWrite: bool,
+  // Called once on a write failure; the caller decides what to do (exit).
+  onError: exn => unit,
+  // Resolved after every commit so capacity/flush waiters can re-evaluate.
+  mutable commitWaiters: array<unit => unit>,
+  persistence: Persistence.t,
+  config: Config.t,
+  // Latest metadata staged per chain; used to skip unchanged restages.
+  mutable chainMeta: dict<InternalTable.Chains.metaFields>,
+  // Set on a real change. Folded into a batch write, else flushed on the throttle.
+  mutable chainMetaDirty: bool,
+  // Throttles metadata-only writes when no batches flow.
+  chainMetaThrottler: Throttler.t,
 }
 
 let make = (
   ~entities: array<Internal.entityConfig>,
   ~committedCheckpointId=Internal.initialCheckpointId,
+  ~persistence: Persistence.t,
+  ~config: Config.t,
+  ~onError: exn => unit,
 ): t => {
-  allEntities: entities,
-  rawEvents: [],
-  entities: EntityTables.make(entities),
-  effects: Dict.make(),
-  rollback: None,
-  committedCheckpointId,
+  let chainMetaThrottler = {
+    let intervalMillis = Env.ThrottleWrites.chainMetadataIntervalMillis
+    Throttler.make(
+      ~intervalMillis,
+      ~logger=Logging.createChild(
+        ~params={
+          "context": "Throttler for chain metadata writes",
+          "intervalMillis": intervalMillis,
+        },
+      ),
+    )
+  }
+
+  {
+    allEntities: entities,
+    entities: EntityTables.make(entities),
+    effects: Dict.make(),
+    rollback: None,
+    committedCheckpointId,
+    processedCheckpointId: committedCheckpointId,
+    processedBatches: [],
+    writeFiber: None,
+    hasFailedWrite: false,
+    onError,
+    commitWaiters: [],
+    persistence,
+    config,
+    chainMeta: Dict.make(),
+    chainMetaDirty: false,
+    chainMetaThrottler,
+  }
 }
 
-// Once the store holds this many entities across all tables, we drop them
-// after a batch write so it doesn't grow unbounded on long running indexers.
-let keepLatestChangesLimit = 50_000.
+// Max uncommitted entity/effect changes plus unwritten batch items before
+// processing must wait for the cycle to free capacity.
+let keepLatestChangesLimit = Env.inMemoryObjectsTarget
 
 let getEffectInMemTable = (inMemoryStore: t, ~effect: Internal.effect) => {
   let key = effect.name
@@ -60,6 +115,7 @@ let getEffectInMemTable = (inMemoryStore: t, ~effect: Internal.effect) => {
     let table = {
       idsToStore: [],
       dict: Dict.make(),
+      changesCount: 0.,
       invalidationsCount: 0,
       effect,
     }
@@ -68,6 +124,64 @@ let getEffectInMemTable = (inMemoryStore: t, ~effect: Internal.effect) => {
   }
 }
 
+let getEffectOutput = (inMemTable: effectCacheInMemTable, key) =>
+  switch inMemTable.dict->Utils.Dict.dangerouslyGetNonOption(key) {
+  | Some(Set({entity: output})) => Some(output)
+  | Some(Delete(_)) | None => None
+  }
+
+// Records a handler output. Persisted on the next write only when shouldCache;
+// otherwise kept in memory (re-run on a later miss) but never written to the db.
+let setEffectOutput = (
+  inMemTable: effectCacheInMemTable,
+  ~checkpointId,
+  ~cacheKey,
+  ~output,
+  ~shouldCache,
+) => {
+  switch inMemTable.dict->Utils.Dict.dangerouslyGetNonOption(cacheKey) {
+  | Some(_) => ()
+  | None => inMemTable.changesCount = inMemTable.changesCount +. 1.
+  }
+  inMemTable.dict->Dict.set(cacheKey, Set({entityId: cacheKey, entity: output, checkpointId}))
+  if shouldCache {
+    inMemTable.idsToStore->Array.push(cacheKey)->ignore
+  }
+}
+
+// Seeds an entry from a db read. Stamped with loadedFromDbCheckpointId so it's
+// always droppable (re-readable from the db) and never re-persisted.
+let initEffectOutputFromDb = (inMemTable: effectCacheInMemTable, ~cacheKey, ~output) =>
+  if inMemTable.dict->Utils.Dict.dangerouslyGetNonOption(cacheKey)->Option.isNone {
+    inMemTable.changesCount = inMemTable.changesCount +. 1.
+    inMemTable.dict->Dict.set(
+      cacheKey,
+      Set({entityId: cacheKey, entity: output, checkpointId: Internal.loadedFromDbCheckpointId}),
+    )
+  }
+
+// Frees committed entries (re-readable from the db, or re-runnable for
+// cache:false). Uncommitted entries stay warm. With keepLoadedFromDb, entries
+// seeded from a db read are spared. Mirrors entity dropCommittedChanges.
+let dropCommittedEffects = (
+  inMemTable: effectCacheInMemTable,
+  ~committedCheckpointId,
+  ~keepLoadedFromDb,
+) => {
+  let keysToDelete = []
+  inMemTable.dict->Utils.Dict.forEachWithKey((change, key) => {
+    let checkpointId = change->Change.getCheckpointId
+    if (
+      !(checkpointId > committedCheckpointId) &&
+      !(keepLoadedFromDb && checkpointId == Internal.loadedFromDbCheckpointId)
+    ) {
+      keysToDelete->Array.push(key)
+    }
+  })
+  keysToDelete->Array.forEach(key => inMemTable.dict->Utils.Dict.deleteInPlace(key))
+  inMemTable.changesCount = inMemTable.changesCount -. keysToDelete->Array.length->Int.toFloat
+}
+
 let getInMemTable = (
   inMemoryStore: t,
   ~entityConfig: Internal.entityConfig,
@@ -77,139 +191,323 @@ let getInMemTable = (
 
 let isRollingBack = (inMemoryStore: t) => inMemoryStore.rollback !== None
 
-let writeBatch = async (
-  inMemoryStore: t,
-  ~persistence: Persistence.t,
-  ~batch,
-  ~config,
-  ~isInReorgThreshold,
-) =>
-  switch persistence.storageStatus {
+let getChangesCount = (inMemoryStore: t) => {
+  let total = ref(0.)
+  inMemoryStore.allEntities->Array.forEach(entityConfig => {
+    total := total.contents +. (inMemoryStore->getInMemTable(~entityConfig)).changesCount
+  })
+  inMemoryStore.effects->Utils.Dict.forEach(inMemTable => {
+    total := total.contents +. inMemTable.changesCount
+  })
+  inMemoryStore.processedBatches->Array.forEach(batch => {
+    total := total.contents +. batch.totalBatchSize->Int.toFloat
+  })
+  total.contents
+}
+
+let wakeCommitWaiters = (inMemoryStore: t) => {
+  let waiters = inMemoryStore.commitWaiters
+  inMemoryStore.commitWaiters = []
+  waiters->Array.forEach(resolve => resolve())
+}
+
+let waitForCommit = (inMemoryStore: t): promise<unit> =>
+  Promise.make((resolve, _) => {
+    inMemoryStore.commitWaiters->Array.push(resolve)->ignore
+  })
+
+// Merges the leading run of batches sharing isInReorgThreshold into one batch;
+// the rest stay queued for the next write. Caller guarantees processedBatches
+// is non-empty.
+let drainBatchRun = (inMemoryStore: t): Batch.t => {
+  let all = inMemoryStore.processedBatches
+  let isInReorgThreshold = (all->Array.getUnsafe(0)).isInReorgThreshold
+
+  let rest = []
+  let progressedChainsById = Dict.make()
+  let totalBatchSize = ref(0)
+  let items = []
+  let checkpointIds = []
+  let checkpointChainIds = []
+  let checkpointBlockNumbers = []
+  let checkpointBlockHashes = []
+  let checkpointEventsProcessed = []
+  all->Array.forEach(batch => {
+    // Once one batch lands in rest, all later ones follow it, preserving order.
+    if rest->Utils.Array.isEmpty && batch.isInReorgThreshold == isInReorgThreshold {
+      batch.progressedChainsById->Utils.Dict.forEachWithKey((chainAfterBatch, key) =>
+        progressedChainsById->Dict.set(key, chainAfterBatch)
+      )
+      totalBatchSize := totalBatchSize.contents + batch.totalBatchSize
+      items->Array.pushMany(batch.items)
+      checkpointIds->Array.pushMany(batch.checkpointIds)
+      checkpointChainIds->Array.pushMany(batch.checkpointChainIds)
+      checkpointBlockNumbers->Array.pushMany(batch.checkpointBlockNumbers)
+      checkpointBlockHashes->Array.pushMany(batch.checkpointBlockHashes)
+      checkpointEventsProcessed->Array.pushMany(batch.checkpointEventsProcessed)
+    } else {
+      rest->Array.push(batch)
+    }
+  })
+  inMemoryStore.processedBatches = rest
+
+  {
+    totalBatchSize: totalBatchSize.contents,
+    items,
+    progressedChainsById,
+    isInReorgThreshold,
+    checkpointIds,
+    checkpointChainIds,
+    checkpointBlockNumbers,
+    checkpointBlockHashes,
+    checkpointEventsProcessed,
+  }
+}
+
+// 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 = (inMemoryStore: t, ~cache): array<Persistence.updatedEffectCache> => {
+  let acc = []
+  inMemoryStore.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 (inMemoryStore: t, ~persistence: Persistence.t, ~config) => {
+  let cache = switch persistence.storageStatus {
   | Unknown
   | Initializing(_) =>
     JsError.throwWithMessage(`Failed to access the indexer storage. The Persistence layer is not initialized.`)
-  | Ready({cache}) =>
+  | Ready({cache}) => cache
+  }
+
+  // Copy before the await: the batch write reads this later, in-transaction. A
+  // restage during the write re-dirties the flag and is rewritten next iteration.
+  let chainMetaData = if inMemoryStore.chainMetaDirty {
+    inMemoryStore.chainMetaDirty = false
+    Some(inMemoryStore.chainMeta->Utils.Dict.shallowCopy)
+  } else {
+    None
+  }
+
+  switch inMemoryStore.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 = inMemoryStore.committedCheckpointId
-    // Decide before the keepMap below trims prevEntityChanges from changesCount,
-    // so the signal still reflects every change currently held in memory.
-    let keepLatestChanges = {
-      let totalChanges = ref(0.)
-      persistence.allEntities->Array.forEach(entityConfig => {
-        totalChanges :=
-          totalChanges.contents +. (inMemoryStore->getInMemTable(~entityConfig)).changesCount
-      })
-      totalChanges.contents < keepLatestChangesLimit
+    let batch = inMemoryStore->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 = inMemoryStore.rollback
+    inMemoryStore.rollback = None
+
     let updatedEntities = persistence.allEntities->Array.filterMap(entityConfig => {
       let table = inMemoryStore->getInMemTable(~entityConfig)
-
-      // The reset below drops prevEntityChanges and we reuse the array as the
-      // write buffer here, so drop it from the count before appending to it.
-      table.changesCount = table.changesCount -. table.prevEntityChanges->Array.length->Int.toFloat
-      let changes = table.prevEntityChanges
-      table.latestEntityChangeById->Utils.Dict.forEach(change =>
-        if change->Change.getCheckpointId > committedCheckpointId {
-          changes->Array.push(change)
-        }
-      )
+      let changes =
+        table->InMemoryTable.Entity.snapshotChanges(~committedCheckpointId, ~upToCheckpointId)
       if changes->Utils.Array.isEmpty {
         None
       } else {
         Some(({entityConfig, changes}: Persistence.updatedEntity))
       }
     })
+    let updatedEffectsCache = snapshotEffects(inMemoryStore, ~cache)
+
     await persistence.storage.writeBatch(
       ~batch,
-      ~rawEvents=inMemoryStore.rawEvents,
-      ~rollback=inMemoryStore.rollback,
-      ~isInReorgThreshold,
+      ~rollback,
+      ~isInReorgThreshold=batch.isInReorgThreshold,
       ~config,
       ~allEntities=persistence.allEntities,
       ~updatedEntities,
-      ~updatedEffectsCache={
-        let acc = []
-        inMemoryStore.effects->Utils.Dict.forEach(inMemTable => {
-          let {idsToStore, dict, effect, invalidationsCount} = inMemTable
-          switch idsToStore {
-          | [] => ()
-          | ids =>
-            let items = ids->Array.map((id): Internal.effectCacheItem => {
-              id,
-              output: dict->Dict.getUnsafe(id),
-            })
-            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
-          }
-        })
-        acc
-      },
+      ~updatedEffectsCache,
+      ~chainMetaData,
     )
 
-    inMemoryStore.rawEvents = []
-    inMemoryStore.effects = Dict.make()
-    inMemoryStore.rollback = None
-    inMemoryStore.committedCheckpointId = switch batch.checkpointIds->Utils.Array.last {
-    | Some(checkpointId) => checkpointId
-    | None => committedCheckpointId
+    inMemoryStore.committedCheckpointId = upToCheckpointId
+
+    switch rollback {
+    | Some({progressBlockNumberByChainId}) if RollbackCommit.callbacks->Utils.Array.notEmpty =>
+      await RollbackCommit.fire(~progressBlockNumberByChainId)
+    | _ => ()
     }
-    if keepLatestChanges {
-      persistence.allEntities->Array.forEach(entityConfig => {
-        let table = inMemoryStore->getInMemTable(~entityConfig)
-        inMemoryStore.entities->Dict.set(
-          (entityConfig.name :> string),
-          table->InMemoryTable.Entity.resetButKeepLatestChanges,
-        )
-      })
-    } else {
-      // Over the limit: drop everything written in a batch and keep only the
-      // entities loaded from the db, so the next batch can still read them
-      // without hitting the database.
-      let loadedFromDbCount = ref(0.)
-      let resetTables = persistence.allEntities->Array.map(entityConfig => {
-        let resetTable =
-          inMemoryStore
-          ->getInMemTable(~entityConfig)
-          ->InMemoryTable.Entity.resetButKeepLoadedFromDbChanges
-        loadedFromDbCount := loadedFromDbCount.contents +. resetTable.changesCount
-        resetTable
-      })
-      // Even the loaded-from-db entities alone exceed the limit, so there's no
-      // point keeping them around - drop everything.
-      let dropEverything = loadedFromDbCount.contents >= keepLatestChangesLimit
-      persistence.allEntities->Array.forEachWithIndex((entityConfig, idx) => {
-        inMemoryStore.entities->Dict.set(
-          (entityConfig.name :> string),
-          dropEverything ? InMemoryTable.Entity.make() : resetTables->Array.getUnsafe(idx),
-        )
-      })
+  }
+}
+
+let hasPendingWrite = (inMemoryStore: t) =>
+  inMemoryStore.processedBatches->Utils.Array.notEmpty || inMemoryStore.chainMetaDirty
+
+let runWriteLoop = async (inMemoryStore: t) => {
+  while inMemoryStore->hasPendingWrite && !inMemoryStore.hasFailedWrite {
+    try {
+      await runOneWrite(
+        inMemoryStore,
+        ~persistence=inMemoryStore.persistence,
+        ~config=inMemoryStore.config,
+      )
+      inMemoryStore->wakeCommitWaiters
+    } catch {
+    | exn =>
+      inMemoryStore.hasFailedWrite = true
+      inMemoryStore.onError(exn)
+    }
+  }
+  inMemoryStore.writeFiber = None
+  inMemoryStore->wakeCommitWaiters
+}
+
+let kick = (inMemoryStore: t) =>
+  if (
+    inMemoryStore.writeFiber->Option.isNone &&
+    !inMemoryStore.hasFailedWrite &&
+    inMemoryStore->hasPendingWrite
+  ) {
+    inMemoryStore.writeFiber = Some(runWriteLoop(inMemoryStore))
+  }
+
+let metaFieldsEqual = (a: InternalTable.Chains.metaFields, b: InternalTable.Chains.metaFields) =>
+  a.firstEventBlockNumber == b.firstEventBlockNumber &&
+  a.latestFetchedBlockNumber == b.latestFetchedBlockNumber &&
+  a.isHyperSync == b.isHyperSync &&
+  // Date is boxed; compare epoch ms.
+  a.timestampCaughtUpToHeadOrEndblock->Null.toOption->Option.map(Date.getTime) ==
+    b.timestampCaughtUpToHeadOrEndblock->Null.toOption->Option.map(Date.getTime)
+
+// Stages chain metadata, dirtying only on a real change so restages are no-ops.
+let setChainMeta = (inMemoryStore: t, chainsData: dict<InternalTable.Chains.metaFields>) => {
+  chainsData->Utils.Dict.forEachWithKey((meta, chainId) => {
+    let changed = switch inMemoryStore.chainMeta->Utils.Dict.dangerouslyGetNonOption(chainId) {
+    | Some(prev) => !metaFieldsEqual(meta, prev)
+    | None => true
+    }
+    if changed {
+      inMemoryStore.chainMeta->Dict.set(chainId, meta)
+      inMemoryStore.chainMetaDirty = true
     }
+  })
+  if inMemoryStore.chainMetaDirty {
+    inMemoryStore.chainMetaThrottler->Throttler.schedule(() => {
+      inMemoryStore->kick
+      Promise.resolve()
+    })
+  }
+}
+
+// Queues a processed batch and kicks the cycle. Returns immediately; the write
+// happens off the processing path.
+let commitBatch = (inMemoryStore: t, ~batch: Batch.t) => {
+  inMemoryStore.processedBatches->Array.push(batch)->ignore
+  switch batch.checkpointIds->Utils.Array.last {
+  | Some(checkpointId) => inMemoryStore.processedCheckpointId = checkpointId
+  | None => ()
   }
+  inMemoryStore->kick
+}
+
+// Drops committed entity and effect entries across all tables. With
+// keepLoadedFromDb, entries seeded from a db read are spared.
+let dropCommitted = (inMemoryStore: t, ~keepLoadedFromDb) => {
+  let committedCheckpointId = inMemoryStore.committedCheckpointId
+  inMemoryStore.allEntities->Array.forEach(entityConfig =>
+    inMemoryStore
+    ->getInMemTable(~entityConfig)
+    ->InMemoryTable.Entity.dropCommittedChanges(~committedCheckpointId, ~keepLoadedFromDb)
+  )
+  inMemoryStore.effects->Utils.Dict.forEach(inMemTable =>
+    inMemTable->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 (inMemoryStore: 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 !inMemoryStore.hasFailedWrite && inMemoryStore->getChangesCount >= keepLatestChangesLimit {
+    // Drop committed writes first, sparing db-loaded entries (explicitly
+    // requested, so likelier to be read again).
+    inMemoryStore->dropCommitted(~keepLoadedFromDb=true)
+
+    // Still over: drop the db-loaded entries too.
+    if inMemoryStore->getChangesCount >= keepLatestChangesLimit {
+      inMemoryStore->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 (
+      inMemoryStore->getChangesCount >= keepLatestChangesLimit &&
+        inMemoryStore.processedBatches->Utils.Array.notEmpty
+    ) {
+      inMemoryStore->kick
+      await inMemoryStore->waitForCommit
+      await inMemoryStore->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 (inMemoryStore: t) => {
+  if !inMemoryStore.hasFailedWrite {
+    inMemoryStore->kick
+    switch inMemoryStore.writeFiber {
+    | Some(fiber) =>
+      await fiber
+      await inMemoryStore->flush
+    | None => ()
+    }
+  }
+}
 
 let prepareRollbackDiff = async (
   inMemoryStore: t,
   ~persistence: Persistence.t,
   ~rollbackTargetCheckpointId,
   ~rollbackDiffCheckpointId,
+  ~progressBlockNumberByChainId,
 ) => {
-  inMemoryStore.rawEvents = []
   inMemoryStore.entities = EntityTables.make(inMemoryStore.allEntities)
   inMemoryStore.effects = Dict.make()
   inMemoryStore.rollback = Some({
     targetCheckpointId: rollbackTargetCheckpointId,
     diffCheckpointId: rollbackDiffCheckpointId,
+    progressBlockNumberByChainId,
   })
 
   let deletedEntities = Dict.make()