envio 3.6.1 → 3.7.0-subgraph

package/src/ChainState.res

@@ -9,7 +9,7 @@ type t = {
   mutable fetchState: FetchState.t,
   // The chain-wide address index, kept in Rust. Not `mutable`: registration and
   // rollback mutate it in place, so the handle is stable across fetchState
-  // versions — and it's the same handle this chain's source clients hold.
+  // versions - and it's the same handle this chain's source clients hold.
   addressStore: AddressStore.t,
   sourceManager: SourceManager.t,
   chainConfig: Config.chain,
@@ -18,7 +18,7 @@ type t = {
   mutable committedProgressBlockNumber: int,
   // Progress of the batch currently being processed. The buffer is consumed at
   // batch creation (see advanceAfterBatch), so this runs ahead of
-  // committedProgressBlockNumber until the batch commits — it's the true lower
+  // committedProgressBlockNumber until the batch commits - it's the true lower
   // boundary of the remaining buffer's block span.
   mutable processingBlockNumber: int,
   mutable numEventsProcessed: float,
@@ -35,8 +35,12 @@ type t = {
   // Empty in the default cross-chain mode, where every entity's table lives on
   // the indexer instead.
   mutable entities: EntityTables.t,
-  mutable reorgDetection: ReorgDetection.t,
   mutable safeCheckpointTracking: option<SafeCheckpointTracking.t>,
+  // Reorg handling knobs, mirrored from the chain/indexer config: hashes are
+  // compared for blocks within `maxReorgDepth` of the known height, and a
+  // detected reorg either rolls back or is only logged.
+  shouldRollbackOnReorg: bool,
+  maxReorgDepth: int,
   // Holds this chain's transactions (kept in Rust) keyed by (blockNumber,
   // transactionIndex). Fetch responses merge their page in; entries are pruned
   // as the chain progresses and dropped above the target on rollback.
@@ -90,9 +94,10 @@ let make = (
   ~onEventRegistrations=[],
   ~addressStore: AddressStore.t,
   ~sourceManager: SourceManager.t,
-  ~reorgDetection: ReorgDetection.t,
   ~committedProgressBlockNumber: int,
   ~safeCheckpointTracking=None,
+  ~shouldRollbackOnReorg,
+  ~maxReorgDepth,
   ~numEventsProcessed=0.,
   ~timestampCaughtUpToHeadOrEndblock=None,
   ~isProgressAtHead=false,
@@ -119,8 +124,9 @@ let make = (
     numEventsProcessed,
     pendingBudget: 0.,
     chainDensity,
-    reorgDetection,
     safeCheckpointTracking,
+    shouldRollbackOnReorg,
+    maxReorgDepth,
     transactionStore,
     blockStore,
     reorgThresholdReadyTolerance,
@@ -211,14 +217,17 @@ let makeInternal = (
     ~knownHeight,
     ~chainId=chainConfig.id,
     // FIXME: Shouldn't set with full history
+    // The resumed depth, not the config one: the pre-threshold lag must match
+    // the window reorg detection compares, or a reduced config depth would let
+    // fetching enter the stored rollback window without history.
     ~blockLag=Pervasives.max(
-      !config.shouldRollbackOnReorg || isInReorgThreshold ? 0 : chainConfig.maxReorgDepth,
+      !config.shouldRollbackOnReorg || isInReorgThreshold ? 0 : maxReorgDepth,
       chainConfig.blockLag,
     ),
     ~onBlockRegistrations,
     ~firstEventBlock,
     // Fuel and SVM route through the address store like EVM does, so the
-    // client-side path works for them — but their address counts are nowhere
+    // client-side path works for them - but their address counts are nowhere
     // near the threshold, so switching would only trade a server-side filter
     // that costs nothing today for an over-fetch. Keep them server-side until a
     // chain actually needs it.
@@ -293,14 +302,41 @@ let makeInternal = (
       ]
     }
   | Config.SimulateSourceConfig({items, endBlock}) => [
-      SimulateSource.make(~items, ~endBlock, ~chainId, ~addressStore),
+      SimulateSource.make(
+        ~items,
+        ~endBlock,
+        ~chainId,
+        ~addressStore,
+        ~ecosystem=config.ecosystem.name,
+      ),
     ]
   // For tests: use ready-to-use sources directly
   | Config.CustomSources(sources) => sources
   }
 
+  let blockStore = BlockStore.make(
+    ~ecosystem=config.ecosystem.name,
+    ~shouldChecksum=!lowercaseAddresses,
+  )
+
+  // Seed the stored reorg checkpoints (hash-only rows) so detection resumes
+  // against the hashes scanned before the restart.
+  if chainReorgCheckpoints->Utils.Array.notEmpty {
+    let seedPage = BlockStore.fromJs(
+      chainReorgCheckpoints->Array.map((cp): BlockStore.inputBlock => {
+        blockNumber: cp.blockNumber,
+        blockHash: cp.blockHash,
+      }),
+      ~ecosystem=config.ecosystem.name,
+      ~shouldChecksum=!lowercaseAddresses,
+    )
+    blockStore
+    ->BlockStore.merge(seedPage, ~fromBlock=0, ~reportOnly=false)
+    ->ignore
+  }
+
   // Seed chain density from whatever progress this chain already has (from a
-  // resumed DB state, or 0 on a fresh chain) — refined per-batch afterwards.
+  // resumed DB state, or 0 on a fresh chain) - refined per-batch afterwards.
   let chainDensity = switch fetchState.firstEventBlock {
   | Some(firstEventBlock) if progressBlockNumber > firstEventBlock && numEventsProcessed > 0. =>
     Some(numEventsProcessed /. (progressBlockNumber - firstEventBlock)->Int.toFloat)
@@ -313,11 +349,8 @@ let makeInternal = (
     ~onEventRegistrations,
     ~addressStore,
     ~sourceManager=SourceManager.make(~sources, ~isRealtime, ~reducedPollingInterval?),
-    ~reorgDetection=ReorgDetection.make(
-      ~chainReorgCheckpoints,
-      ~maxReorgDepth,
-      ~shouldRollbackOnReorg=config.shouldRollbackOnReorg,
-    ),
+    ~shouldRollbackOnReorg=config.shouldRollbackOnReorg,
+    ~maxReorgDepth,
     ~safeCheckpointTracking=SafeCheckpointTracking.make(
       ~maxReorgDepth,
       ~shouldRollbackOnReorg=config.shouldRollbackOnReorg,
@@ -332,10 +365,7 @@ let makeInternal = (
       ~shouldChecksum=!lowercaseAddresses,
     ),
     ~chainDensity,
-    ~blockStore=BlockStore.make(
-      ~ecosystem=config.ecosystem.name,
-      ~shouldChecksum=!lowercaseAddresses,
-    ),
+    ~blockStore,
     ~reorgThresholdReadyTolerance=config.reorgThresholdReadyTolerance,
     ~logger,
   )
@@ -415,6 +445,7 @@ let makeFromDbState = (
 // --- Read accessors. ---
 
 let logger = (cs: t) => cs.logger
+let blockStore = (cs: t) => cs.blockStore
 let entities = (cs: t) => cs.entities
 
 // Rollback discards every uncommitted change, so this chain's partition is
@@ -422,7 +453,20 @@ let entities = (cs: t) => cs.entities
 let resetEntities = (cs: t, ~perChainEntities) => cs.entities = EntityTables.make(perChainEntities)
 let sourceManager = (cs: t) => cs.sourceManager
 let chainConfig = (cs: t) => cs.chainConfig
-let reorgDetection = (cs: t) => cs.reorgDetection
+let shouldRollbackOnReorg = (cs: t) => cs.shouldRollbackOnReorg
+// Reorg-scan reads over the block store, for the rollback flow: the scanned
+// block numbers still inside the reorg threshold, and the highest of them whose
+// re-fetched hash still matches.
+let getReorgThresholdBlockNumbersBelow = (cs: t, ~blockNumber) =>
+  cs.blockStore->BlockStore.getHashedBlockNumbers(
+    ~fromBlock=Pervasives.max(cs.fetchState.knownHeight - cs.maxReorgDepth, 0),
+    ~belowBlock=blockNumber,
+  )
+
+let getLatestValidScannedBlock = (cs: t, ~blockStore: BlockStore.t, ~blockNumbers: array<int>) =>
+  cs.blockStore
+  ->BlockStore.latestValidBlockFromStore(blockStore, blockNumbers)
+  ->Null.toOption
 let safeCheckpointTracking = (cs: t) => cs.safeCheckpointTracking
 let isProgressAtHead = (cs: t) => cs.isProgressAtHead
 let committedProgressBlockNumber = (cs: t) => cs.committedProgressBlockNumber
@@ -512,7 +556,7 @@ let fetchCeiling = (cs: t) => {
   }
 }
 
-// Events/block over the ready part of the buffer — a live signal that reacts
+// Events/block over the ready part of the buffer - a live signal that reacts
 // to what fetching just found, unlike the processing EMA which only moves as
 // batches commit.
 let readyBufferDensity = (cs: t) => {
@@ -527,7 +571,7 @@ let readyBufferDensity = (cs: t) => {
 
 // Density used for query sizing: the higher of the processing EMA and the
 // ready-buffer density, so a stale-low EMA can't undersize queries while the
-// buffer proves the range is dense. None means the chain is cold — no density
+// buffer proves the range is dense. None means the chain is cold - no density
 // signal at all.
 let effectiveDensity = (cs: t) =>
   switch (cs.chainDensity, cs->readyBufferDensity) {
@@ -551,7 +595,7 @@ let targetBlock = (cs: t, ~chainTargetItems: float) => {
   | Some(density) if density > 0. =>
     // Decided by comparison so no unbounded value is ever converted to int:
     // at low densities chainTargetItems /. density exceeds the int range, and
-    // truncating it wraps negative — the target collapses below the frontier
+    // truncating it wraps negative - the target collapses below the frontier
     // and the chain stops querying. The division only runs when its result is
     // provably below the ceiling-bounded range.
     if density *. (fetchCeiling - bufferBlockNumber)->Int.toFloat <= chainTargetItems {
@@ -565,7 +609,7 @@ let targetBlock = (cs: t, ~chainTargetItems: float) => {
 
 // Block range that cross-chain progress alignment maps fractions over: from
 // the chain's startBlock to the last block it can fetch right now. The lower
-// bound is deliberately static — anchoring it at firstEventBlock would make
+// bound is deliberately static - anchoring it at firstEventBlock would make
 // two chains sitting at the same block read different progress fractions
 // depending on whether each has discovered its first event yet, so the
 // anchor's line could map below a follower's own frontier and stall it.
@@ -576,7 +620,7 @@ let progressRange = (cs: t) => {
 
 // A degenerate range (chain already at or past its last block) maps to 1 so it
 // never constrains the other chains. Clamped at 0 for the initial -1 fetch
-// frontier — the only possible blockNumber below the range's lower bound.
+// frontier - the only possible blockNumber below the range's lower bound.
 let progressAtBlock = (cs: t, ~blockNumber) => {
   let (lower, upper) = cs->progressRange
   upper <= lower
@@ -592,7 +636,7 @@ let blockAtProgress = (cs: t, ~progress) => {
   lower + Math.ceil(progress *. (upper - lower)->Int.toFloat)->Float.toInt
 }
 
-// The fetch frontier as a fraction of the alignable range — what the
+// The fetch frontier as a fraction of the alignable range - what the
 // cross-chain waterfall aligns other chains against. Based on blocks actually
 // fetched, so it holds up even while this chain's queries are in flight.
 let frontierProgress = (cs: t) =>
@@ -611,7 +655,7 @@ let getNextQuery = (cs: t, ~chainTargetItems: float, ~maxTargetBlock=?) => {
   | None => chainTargetBlock
   }
   // When the target block is clamped (head/endBlock/cross-chain alignment) a
-  // known-density chain can't use the whole handed budget — cap the fresh part
+  // known-density chain can't use the whole handed budget - cap the fresh part
   // at what the clamped range actually costs (in-flight reservations stay on
   // top: they're already accounted and shouldn't crowd out new partitions), so
   // the waterfall's leftover flows to the next chain in the same tick instead
@@ -676,7 +720,7 @@ let isDurablyCaughtUp = (cs: t) => {
 }
 
 let getHighestBlockBelowThreshold = (cs: t): int => {
-  let highestBlockBelowThreshold = cs.fetchState.knownHeight - cs.chainConfig.maxReorgDepth
+  let highestBlockBelowThreshold = cs.fetchState.knownHeight - cs.maxReorgDepth
   highestBlockBelowThreshold < 0 ? 0 : highestBlockBelowThreshold
 }
 
@@ -685,7 +729,7 @@ let isActivelyIndexing = (cs: t) => cs.fetchState->FetchState.isActivelyIndexing
 // True once the fetch frontier has reached the head/endBlock for this chain.
 let isFetchingAtHead = (cs: t) => cs.fetchState->FetchState.isFetchingAtHead
 
-// Reached head on a chain with no configured endBlock — used by auto-exit to
+// Reached head on a chain with no configured endBlock - used by auto-exit to
 // detect that no events were found in the start..head range.
 let isAtHeadWithoutEndBlock = (cs: t) =>
   cs.isProgressAtHead && cs.fetchState.endBlock->Option.isNone
@@ -713,12 +757,7 @@ type blockGroups = {
 // same batch independently. Items already arrive in (blockNumber, logIndex)
 // order, so a (blockNumber, transactionIndex) run and a blockNumber-only run
 // each stay adjacent; every item is checked against both, in the same pass.
-// `includeBlocks` skips the block side entirely for Fuel, which carries the
-// block inline and has no store.
-let groupBatchItems = (items: array<Internal.item>, ~includeBlocks: bool): (
-  transactionGroups,
-  blockGroups,
-) => {
+let groupBatchItems = (items: array<Internal.item>): (transactionGroups, blockGroups) => {
   let txBlockNumbers = []
   let transactionIndices = []
   let transactionMasks = []
@@ -739,7 +778,7 @@ let groupBatchItems = (items: array<Internal.item>, ~includeBlocks: bool): (
       | Some(_) => () // RPC/simulate/Fuel carry the transaction inline.
       | None =>
         let {transactionIndex} = eventItem
-        let mask = eventItem.onEventRegistration.eventConfig.transactionFieldMask
+        let mask = eventItem.onEventRegistration.fieldSelection.transactionMask
         if mask != 0. {
           anyTransactionFieldSelected := true
         }
@@ -762,27 +801,25 @@ let groupBatchItems = (items: array<Internal.item>, ~includeBlocks: bool): (
         }
       }
 
-      if includeBlocks {
-        switch eventItem.payload->Internal.getPayloadBlock->Nullable.toOption {
-        | Some(_) => () // RPC/simulate/Fuel carry the block inline.
-        | None =>
-          let mask = eventItem.onEventRegistration.eventConfig.blockFieldMask
-          let last = blockItemGroups->Array.length - 1
-          if last >= 0 && blockBlockNumbers->Array.getUnsafe(last) == blockNumber {
-            blockItemGroups->Array.getUnsafe(last)->Array.push(eventItem)
-            blockMasks->Array.setUnsafe(
-              last,
-              FieldMask.orMask(blockMasks->Array.getUnsafe(last), mask),
-            )
-          } else {
-            blockBlockNumbers->Array.push(blockNumber)
-            blockMasks->Array.push(mask)
-            blockItemGroups->Array.push([eventItem])
-          }
+      switch eventItem.payload->Internal.getPayloadBlock->Nullable.toOption {
+      | Some(_) => () // RPC/simulate carry the block inline.
+      | None =>
+        let mask = eventItem.onEventRegistration.fieldSelection.blockMask
+        let last = blockItemGroups->Array.length - 1
+        if last >= 0 && blockBlockNumbers->Array.getUnsafe(last) == blockNumber {
+          blockItemGroups->Array.getUnsafe(last)->Array.push(eventItem)
+          blockMasks->Array.setUnsafe(
+            last,
+            FieldMask.orMask(blockMasks->Array.getUnsafe(last), mask),
+          )
+        } else {
+          blockBlockNumbers->Array.push(blockNumber)
+          blockMasks->Array.push(mask)
+          blockItemGroups->Array.push([eventItem])
         }
       }
     // onBlock items build their block from the handler's own block number, not
-    // from the stores — which is what lets the sources keep only the blocks and
+    // from the stores - which is what lets the sources keep only the blocks and
     // transactions an event item references.
     | Internal.Block(_) => ()
     }
@@ -801,8 +838,8 @@ let groupBatchItems = (items: array<Internal.item>, ~includeBlocks: bool): (
 }
 
 // Materialise a `TransactionStore` against precomputed groups (see
-// `groupBatchItems`). Store-backed items always get a transaction object — the
-// selected fields, or `{}` when nothing was selected — so `event.transaction`
+// `groupBatchItems`). Store-backed items always get a transaction object - the
+// selected fields, or `{}` when nothing was selected - so `event.transaction`
 // is never `undefined` (matching the inline sources).
 let applyTransactionGroups = async (store: TransactionStore.t, g: transactionGroups) => {
   if g.payloadGroups->Utils.Array.notEmpty {
@@ -838,45 +875,34 @@ let applyBlockGroups = async (store: BlockStore.t, g: blockGroups) => {
   }
 }
 
-let includeBlocksForEcosystem = (ecosystem: Ecosystem.name) =>
-  switch ecosystem {
-  | Evm | Svm => true
-  | Fuel => false
-  }
-
 // Materialise the chain stores' selected transaction and block fields onto a
 // batch's items at batch prep (the persistent-store path). A single pass over
 // `items` (`groupBatchItems`) builds both stores' selection masks before the
 // two independent materialize calls run concurrently.
-let materializeBatchItems = async (cs: t, ~items: array<Internal.item>, ~ecosystem) => {
-  let (txGroups, blockGroups) =
-    items->groupBatchItems(~includeBlocks=ecosystem->includeBlocksForEcosystem)
+let materializeBatchItems = async (cs: t, ~items: array<Internal.item>) => {
+  let (txGroups, blockGroups) = items->groupBatchItems
   let _ = await Promise.all2((
     cs.transactionStore->applyTransactionGroups(txGroups),
     cs.blockStore->applyBlockGroups(blockGroups),
   ))
 }
 
-// Materialise a fetch-response page's transactions and blocks onto its items
-// before contract-register handlers read them. `None` pages (RPC/Fuel/Simulate
-// keep them inline) are a no-op.
+// Materialise a fetch-response's transactions and blocks onto its items before
+// contract-register handlers read them. Transactions come from the response's
+// page (`None` when kept inline); blocks come from the chain store, which the
+// response's page was already merged into by `registerReorgGuard`.
 let materializePageItems = async (
   ~items: array<Internal.item>,
   ~transactionStore: option<TransactionStore.t>,
-  ~blockStore: option<BlockStore.t>,
-  ~ecosystem,
+  ~blockStore: BlockStore.t,
 ) => {
-  let (txGroups, blockGroups) =
-    items->groupBatchItems(~includeBlocks=ecosystem->includeBlocksForEcosystem)
+  let (txGroups, blockGroups) = items->groupBatchItems
   let _ = await Promise.all2((
     switch transactionStore {
     | Some(store) => store->applyTransactionGroups(txGroups)
     | None => Promise.resolve()
     },
-    switch blockStore {
-    | Some(store) => store->applyBlockGroups(blockGroups)
-    | None => Promise.resolve()
-    },
+    blockStore->applyBlockGroups(blockGroups),
   ))
 }
 
@@ -885,21 +911,17 @@ let handleQueryResult = (
   ~query: FetchState.query,
   ~newItems,
   ~newRegistrations,
-  ~latestFetchedBlock: FetchState.blockNumberAndTimestamp,
+  ~latestFetchedBlock: int,
   ~knownHeight,
   ~transactionStore as txPage: option<TransactionStore.t>,
-  ~blockStore as blockPage: option<BlockStore.t>,
 ) => {
-  // Merge this response's pages into the chain stores in lockstep with appending
-  // its items to the buffer. Inline sources contribute no page.
+  // Merge this response's transaction page into the chain store in lockstep
+  // with appending its items to the buffer. Inline sources contribute no page;
+  // the block page was already merged by `registerReorgGuard`.
   switch txPage {
   | Some(page) => cs.transactionStore->TransactionStore.merge(page)
   | None => ()
   }
-  switch blockPage {
-  | Some(page) => cs.blockStore->BlockStore.merge(page)
-  | None => ()
-  }
 
   let fs = switch newRegistrations {
   | [] => cs.fetchState
@@ -908,9 +930,9 @@ let handleQueryResult = (
       ~addressStore=cs.addressStore,
       // This response is applied below, after the addresses land. It was routed
       // before they existed, so whatever it claims has to be inside the
-      // catch-up range — and an unbounded query can reach past the height that
+      // catch-up range - and an unbounded query can reach past the height that
       // was known when it went out.
-      ~claimCeiling=Pervasives.max(knownHeight, latestFetchedBlock.blockNumber),
+      ~claimCeiling=Pervasives.max(knownHeight, latestFetchedBlock),
       newRegistrations,
     )
   }
@@ -924,15 +946,25 @@ let handleQueryResult = (
   cs.pendingBudget = Pervasives.max(0., cs.pendingBudget -. query.itemsEst->Int.toFloat)
 }
 
-// Run reorg detection against a fetch response and commit the updated guard.
-// Returns the result so the caller can decide whether to roll back; on the
-// rollback path registerReorgGuard returns the guard unchanged, so committing
-// here is a no-op there.
-let registerReorgGuard = (cs: t, ~blockHashes, ~knownHeight): ReorgDetection.reorgResult => {
-  let (updatedReorgDetection, reorgResult) =
-    cs.reorgDetection->ReorgDetection.registerReorgGuard(~blockHashes, ~knownHeight)
-  cs.reorgDetection = updatedReorgDetection
-  reorgResult
+// Run reorg detection against a fetch response by merging its block-store page
+// into the chain store: hashes of blocks inside the reorg threshold are
+// compared on the way. On a mismatch with rollback enabled the page is
+// discarded (the stored hashes stay for the rollback comparison); in
+// detect-only mode the page still merges, so the overwritten hash doesn't
+// re-report on every response.
+let registerReorgGuard = (cs: t, ~blockStore, ~knownHeight): ReorgDetection.reorgResult => {
+  switch cs.blockStore->BlockStore.merge(
+    blockStore,
+    ~fromBlock=Pervasives.max(knownHeight - cs.maxReorgDepth, 0),
+    ~reportOnly=!cs.shouldRollbackOnReorg,
+  ) {
+  | Null.Null => NoReorg
+  | Null.Value({blockNumber, storedHash, receivedHash}) =>
+    ReorgDetected({
+      scannedBlock: {blockNumber, blockHash: storedHash},
+      receivedBlock: {blockNumber, blockHash: receivedHash},
+    })
+  }
 }
 
 // Prepare for a reorg rollback: restore the events-processed counter to its
@@ -1008,14 +1040,28 @@ let toMetrics = (cs: t): Metrics.chainMetrics => {
   rollbackTargetBlock: cs.rollbackTargetBlock,
 }
 
-// Snapshot the inputs a batch build needs from this chain.
+// Snapshot the inputs a batch build needs from this chain, including an
+// immutable copy of the scanned in-threshold block hashes so the batch never
+// reads the live store mid-build.
 let toChainBeforeBatch = (cs: t): Batch.chainBeforeBatch => {
-  fetchState: cs.fetchState,
-  progressBlockNumber: cs.committedProgressBlockNumber,
-  totalEventsProcessed: cs.numEventsProcessed,
-  sourceBlockNumber: cs.fetchState.knownHeight,
-  reorgDetection: cs.reorgDetection,
-  chainConfig: cs.chainConfig,
+  let {blockNumbers, hashes} =
+    cs.blockStore->BlockStore.getHashes(
+      ~fromBlock=Pervasives.max(cs.fetchState.knownHeight - cs.maxReorgDepth, 0),
+      ~belowBlock=cs.fetchState.knownHeight + 1,
+    )
+  let hashByBlockNumber = Dict.make()
+  blockNumbers->Array.forEachWithIndex((blockNumber, idx) =>
+    hashByBlockNumber->Utils.Dict.setByInt(blockNumber, hashes->Array.getUnsafe(idx))
+  )
+  {
+    fetchState: cs.fetchState,
+    progressBlockNumber: cs.committedProgressBlockNumber,
+    totalEventsProcessed: cs.numEventsProcessed,
+    sourceBlockNumber: cs.fetchState.knownHeight,
+    scannedHashes: {blockNumbers, hashByBlockNumber},
+    shouldRollbackOnReorg: cs.shouldRollbackOnReorg,
+    chainConfig: cs.chainConfig,
+  }
 }
 
 // Whether the chain's post-batch fetch frontier is ready to cross into the reorg
@@ -1057,7 +1103,7 @@ let applyBatchProgress = (cs: t, ~batch: Batch.t, ~blockTimestampName: string) =
   | Some(chainAfterBatch) => {
       // Calculate and set latency metrics. The payload block is materialised or
       // inline by processing time; its timestamp may still be absent (e.g. an
-      // SVM slot with no block row) — the metric is skipped then.
+      // SVM slot with no block row) - the metric is skipped then.
       switch batch
       ->Batch.findLastEventItem(~chainId)
       ->Option.flatMap(eventItem =>
@@ -1088,13 +1134,13 @@ let applyBatchProgress = (cs: t, ~batch: Batch.t, ~blockTimestampName: string) =
       }
 
       // Chain-wide density update: seed with the batch's own events/block on
-      // the first update, then blend weighted by the batch's block span — a
+      // the first update, then blend weighted by the batch's block span - a
       // few sparse/dense blocks barely nudge the estimate, while a
       // window-sized batch replaces it.
       let deltaBlocks = chainAfterBatch.progressBlockNumber - cs.committedProgressBlockNumber
       if deltaBlocks > 0 {
         let deltaEvents = chainAfterBatch.totalEventsProcessed -. cs.numEventsProcessed
-        // Don't seed a density before the first event is seen — a progress-only
+        // Don't seed a density before the first event is seen - a progress-only
         // batch would otherwise set it to 0, matching the resume-seed guard.
         switch (cs.chainDensity, deltaEvents > 0.) {
         | (None, false) => ()
@@ -1122,7 +1168,12 @@ let applyBatchProgress = (cs: t, ~batch: Batch.t, ~blockTimestampName: string) =
       cs.numEventsProcessed = chainAfterBatch.totalEventsProcessed
       // Processed blocks' transactions and blocks are no longer needed.
       cs.transactionStore->TransactionStore.prune(chainAfterBatch.progressBlockNumber)
-      cs.blockStore->BlockStore.prune(chainAfterBatch.progressBlockNumber)
+      // Processed blocks' other fields are dropped, but hashes still inside the
+      // reorg threshold stay for reorg detection.
+      cs.blockStore->BlockStore.prune(
+        chainAfterBatch.progressBlockNumber,
+        ~keepHashesFrom=cs.fetchState.knownHeight - cs.maxReorgDepth,
+      )
       cs.isProgressAtHead = cs.isProgressAtHead || chainAfterBatch.isProgressAtHeadWhenBatchCreated
       switch cs.safeCheckpointTracking {
       | Some(safeCheckpointTracking) =>
@@ -1154,10 +1205,10 @@ let markReady = (cs: t, ~readyAt) =>
   }
 
 // Roll a chain back to a reorg target. With a progress diff, restore fetch/
-// safe-checkpoint/progress state to `newProgressBlockNumber`; the reorg chain
-// additionally rewinds its reorg-detection guard. A reorg chain with no diff
-// entry still rewinds guard + fetch state to the target — otherwise the stale
-// block hash stays in the guard and re-triggers the same reorg.
+// safe-checkpoint/progress state to `newProgressBlockNumber`. A reorg chain
+// with no diff entry still rewinds fetch state + stores to the target -
+// otherwise the stale block hash stays in the store and re-triggers the same
+// reorg.
 let rollback = (
   cs: t,
   ~newProgressBlockNumber,
@@ -1175,12 +1226,6 @@ let rollback = (
         ~message="Missing events-processed diff for rolled-back chain",
       )
 
-    if isReorgChain {
-      cs.reorgDetection =
-        cs.reorgDetection->ReorgDetection.rollbackToValidBlockNumber(
-          ~blockNumber=rollbackTargetBlockNumber,
-        )
-    }
     switch cs.safeCheckpointTracking {
     | Some(safeCheckpointTracking) =>
       cs.safeCheckpointTracking = Some(
@@ -1202,10 +1247,6 @@ let rollback = (
     cs.numEventsProcessed = newTotalEventsProcessed
   | None =>
     if isReorgChain {
-      cs.reorgDetection =
-        cs.reorgDetection->ReorgDetection.rollbackToValidBlockNumber(
-          ~blockNumber=rollbackTargetBlockNumber,
-        )
       cs.fetchState =
         cs.fetchState->FetchState.rollback(
           ~addressStore=cs.addressStore,