envio 3.6.1 → 3.7.0-subgraph

package/src/PgStorage.res

@@ -630,14 +630,19 @@ let classifyWriteError = (~specificError: ref<option<exn>>, ~table: Table.table,
   }
 }
 
-// WeakMap for caching table batch set queries
-let setQueryCache = Utils.WeakMap.make()
+// Batch set queries, cached per table. The query text bakes in the schema and
+// the chain-id mode, so the cache belongs to the storage instance those came
+// from — `make` creates one and threads it down. A process-wide cache would
+// hand a second storage the first one's schema.
+let makeSetQueryCache = () => Utils.WeakMap.make()
+
 let setOrThrow = async (
   sql,
   ~items,
   ~table: Table.table,
   ~itemSchema,
   ~pgSchema,
+  ~setQueryCache,
   ~chainIdMode: ChainId.mode=Int32,
 ) => {
   if items->Array.length === 0 {
@@ -953,6 +958,7 @@ let rec writeBatch = async (
   ~config: Config.t,
   ~allEntities: array<Internal.entityConfig>,
   ~setEffectCacheOrThrow,
+  ~setQueryCache,
   ~updatedEffectsCache,
   ~updatedEntities: array<Persistence.updatedEntity>,
   ~sinkPromise: option<promise<option<exn>>>,
@@ -973,11 +979,8 @@ let rec writeBatch = async (
       let rows = batch.items->Array.filterMap(item =>
         switch item {
         | Internal.Event(_) =>
-          let coordinate = `${item
-            ->Internal.getItemChainId
-            ->ChainId.toString}-${item
-            ->Internal.getItemBlockNumber
-            ->Int.toString}-${item->Internal.getItemLogIndex->Int.toString}`
+          let eventItem = item->Internal.castUnsafeEventItem
+          let coordinate = `${eventItem.chainId->ChainId.toString}-${eventItem.blockNumber->Int.toString}-${eventItem.logIndex->Int.toString}`
           if seenLogCoordinates->Utils.Set.has(coordinate) {
             None
           } else {
@@ -1006,6 +1009,7 @@ let rec writeBatch = async (
             ~itemSchema=InternalTable.RawEvents.schema,
             ~pgSchema,
             ~chainIdMode,
+            ~setQueryCache,
           )
         }, ~items=rawEvents)
       } catch {
@@ -1161,6 +1165,7 @@ let rec writeBatch = async (
                   ~table=entityHistory.table,
                   ~pgSchema,
                   ~chainIdMode,
+                  ~setQueryCache,
                 ),
               )
               ->ignore
@@ -1178,6 +1183,7 @@ let rec writeBatch = async (
                 ~itemSchema=entityConfig->getRowSchema,
                 ~pgSchema,
                 ~chainIdMode,
+                ~setQueryCache,
               ),
             )
           }
@@ -1340,6 +1346,7 @@ let rec writeBatch = async (
       ~escapeTables,
       ~batch,
       ~pgSchema,
+      ~setQueryCache,
       ~rollback,
       ~isInReorgThreshold,
       ~config,
@@ -1483,6 +1490,7 @@ let make = (
   let storageName = "postgres"
 
   let indexManager = IndexManager.make()
+  let setQueryCache = makeSetQueryCache()
 
   let loadCatalogRows = (sql, ~indexName=?) =>
     sql
@@ -2064,6 +2072,8 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::${addrChai
       ~table,
       ~itemSchema=itemSchema->S.toUnknown,
       ~pgSchema,
+      ~setQueryCache,
+      ~chainIdMode,
     )
   }
 
@@ -2298,7 +2308,12 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::${addrChai
       }
     })
 
-    (removals, restoredEntitiesResult)
+    (
+      removals,
+      restoredEntitiesResult
+      ->S.parseOrThrow(entityConfig.table->Table.pgRowsSchema)
+      ->(Utils.magic: array<unknown> => array<Internal.entity>),
+    )
   }
 
   let writeBatchMethod = async (
@@ -2347,6 +2362,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::${addrChai
       sql,
       ~batch,
       ~pgSchema,
+      ~setQueryCache,
       ~rollback,
       ~isInReorgThreshold,
       ~config,

package/src/PgStorage.res.mjs

@@ -471,9 +471,11 @@ function classifyWriteError(specificError, table, exn) {
   }
 }
 
-let setQueryCache = new WeakMap();
+function makeSetQueryCache() {
+  return new WeakMap();
+}
 
-async function setOrThrow(sql, items, table, itemSchema, pgSchema, chainIdModeOpt) {
+async function setOrThrow(sql, items, table, itemSchema, pgSchema, setQueryCache, chainIdModeOpt) {
   let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
   if (items.length === 0) {
     return;
@@ -656,7 +658,7 @@ function executeSet(sql, items, dbFunction) {
   }
 }
 
-async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, chainMetaData, escapeTables) {
+async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, setQueryCache, updatedEffectsCache, updatedEntities, sinkPromise, chainMetaData, escapeTables) {
   try {
     let chainIdMode = config.chainIdMode;
     let shouldSaveHistory = Config.shouldSaveHistory(config, isInReorgThreshold);
@@ -670,7 +672,7 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
         if (item.kind !== 0) {
           return;
         }
-        let coordinate = ChainId.toString(Internal.getItemChainId(item)) + `-` + item.blockNumber.toString() + `-` + item.logIndex.toString();
+        let coordinate = ChainId.toString(item.chainId) + `-` + item.blockNumber.toString() + `-` + item.logIndex.toString();
         if (seenLogCoordinates.has(coordinate)) {
           return;
         } else {
@@ -687,7 +689,7 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
     }
     let setRawEvents = async sql => {
       try {
-        return await executeSet(sql, rawEvents, (sql, items) => setOrThrow(sql, items, InternalTable.RawEvents.table, InternalTable.RawEvents.schema, pgSchema, chainIdMode));
+        return await executeSet(sql, rawEvents, (sql, items) => setOrThrow(sql, items, InternalTable.RawEvents.table, InternalTable.RawEvents.schema, pgSchema, setQueryCache, chainIdMode));
       } catch (raw_exn) {
         let exn = Primitive_exceptions.internalToException(raw_exn);
         return classifyWriteError(specificError, InternalTable.RawEvents.table, exn);
@@ -791,14 +793,14 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
                 }));
               }
               let entityHistory = getEntityHistory(entityConfig);
-              promises.push(setOrThrow(sql, batchSetUpdates, entityHistory.table, entityHistory.setChangeSchema, pgSchema, chainIdMode));
+              promises.push(setOrThrow(sql, batchSetUpdates, entityHistory.table, entityHistory.setChangeSchema, pgSchema, setQueryCache, chainIdMode));
             }
           }
           if (Utils.$$Array.notEmpty(entitiesToSet)) {
             if (shouldRemoveInvalidUtf8) {
               removeInvalidUtf8InPlace(entitiesToSet);
             }
-            promises.push(setOrThrow(sql, entitiesToSet, entityConfig.table, getRowSchema(entityConfig), pgSchema, chainIdMode));
+            promises.push(setOrThrow(sql, entitiesToSet, entityConfig.table, getRowSchema(entityConfig), pgSchema, setQueryCache, chainIdMode));
           }
           if (Utils.$$Array.notEmpty(idsToDelete)) {
             promises.push(deleteByIdsOrThrow(sql, pgSchema, idsToDelete, entityConfig.table, Primitive_option.some(scopeChainId)));
@@ -870,7 +872,7 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
     if (exn$1.RE_EXN_ID === PgEncodingError) {
       let escapeTables$1 = escapeTables !== undefined ? Primitive_option.valFromOption(escapeTables) : new Set();
       escapeTables$1.add(exn$1.table);
-      return await writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, chainMetaData, Primitive_option.some(escapeTables$1));
+      return await writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, setQueryCache, updatedEffectsCache, updatedEntities, sinkPromise, chainMetaData, Primitive_option.some(escapeTables$1));
     }
     throw exn$1;
   }
@@ -954,6 +956,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
   let cacheDirPath = Path.resolve(".envio", "cache");
   let storageName = "postgres";
   let indexManager = IndexManager.make();
+  let setQueryCache = new WeakMap();
   let loadCatalogRows = (sql, indexName) => sql.unsafe(IndexCatalog.makeQuery(pgSchema, indexName)).then(rows => S$RescriptSchema.parseOrThrow(rows, IndexCatalog.rowsSchema));
   let refreshIndexCatalog = async () => {
     let rows = await loadCatalogRows(sql, undefined);
@@ -1325,7 +1328,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::` + addrCh
       msg: `Committed ` + missing.length.toString() + ` schema indexes and the ready timestamp in ` + formatSeconds(timeRef) + `s.`
     });
   };
-  let setOrThrow$1 = (items, table, itemSchema) => setOrThrow(sql, items, table, itemSchema, pgSchema, undefined);
+  let setOrThrow$1 = (items, table, itemSchema) => setOrThrow(sql, items, table, itemSchema, pgSchema, setQueryCache, chainIdMode);
   let setEffectCacheOrThrow = async (table, itemSchema, items, initialize) => {
     if (initialize) {
       await sql.unsafe(makeCreateTableQuery(table, pgSchema, false, undefined));
@@ -1461,7 +1464,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::` + addrCh
     });
     return [
       removals,
-      restoredEntitiesResult
+      S$RescriptSchema.parseOrThrow(restoredEntitiesResult, Table.pgRowsSchema(entityConfig.table))
     ];
   };
   let writeBatchMethod = async (batch, rollback, isInReorgThreshold, config, allEntities, updatedEffectsCache, updatedEntities, chainMetaData, onWrite) => {
@@ -1487,7 +1490,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::` + addrCh
       sinkPromise = undefined;
     }
     let primaryTimerRef = Performance.now();
-    await writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, pgUpdates, sinkPromise, chainMetaData, undefined);
+    await writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, setQueryCache, updatedEffectsCache, pgUpdates, sinkPromise, chainMetaData, undefined);
     return onWrite(storageName, Performance.secondsSince(primaryTimerRef));
   };
   let close = () => sql.end();
@@ -1590,7 +1593,7 @@ export {
   pgErrorMessageSchema,
   PgEncodingError,
   classifyWriteError,
-  setQueryCache,
+  makeSetQueryCache,
   setOrThrow,
   makeSchemaTableNamesQuery,
   makeEffectCacheTableNamesQuery,

package/src/ReorgDetection.res

@@ -1,17 +1,8 @@
-type blockDataWithTimestamp = {
-  blockHash: string,
-  blockNumber: int,
-  blockTimestamp: int,
-}
-
 type blockData = {
-  // Block hash is used for actual comparison to test for reorg
   blockHash: string,
   blockNumber: int,
 }
 
-external generalizeBlockDataWithTimestamp: blockDataWithTimestamp => blockData = "%identity"
-
 type reorgDetected = {
   scannedBlock: blockData,
   receivedBlock: blockData,
@@ -30,216 +21,3 @@ let reorgDetectedToLogParams = (reorgDetected: reorgDetected, ~shouldRollbackOnR
 }
 
 type reorgResult = NoReorg | ReorgDetected(reorgDetected)
-
-type t = {
-  // Whether to rollback on reorg
-  // Even if it's disabled, we still track reorgs checkpoints in memory
-  // and log when we detect an unhandled reorg
-  shouldRollbackOnReorg: bool,
-  // Number of blocks behind head, we want to keep track
-  // as a threshold for reorgs. If for eg. this is 200,
-  // it means we are accounting for reorgs up to 200 blocks
-  // behind the head
-  maxReorgDepth: int,
-  // A hash map of recent blockdata by block number to make comparison checks
-  // for reorgs.
-  dataByBlockNumber: dict<blockData>,
-}
-
-let make = (
-  ~chainReorgCheckpoints: array<Internal.reorgCheckpoint>,
-  ~maxReorgDepth,
-  ~shouldRollbackOnReorg,
-) => {
-  let dataByBlockNumber = Dict.make()
-
-  chainReorgCheckpoints->Array.forEach(block => {
-    dataByBlockNumber->Utils.Dict.setByInt(
-      block.blockNumber,
-      {
-        blockHash: block.blockHash,
-        blockNumber: block.blockNumber,
-      },
-    )
-  })
-
-  {
-    shouldRollbackOnReorg,
-    maxReorgDepth,
-    dataByBlockNumber,
-  }
-}
-
-let getDataByBlockNumberCopyInThreshold = ({dataByBlockNumber, maxReorgDepth}: t, ~knownHeight) => {
-  // Js engine automatically orders numeric object keys
-  let ascBlockNumberKeys = dataByBlockNumber->Dict.keysToArray
-  let thresholdBlockNumber = knownHeight - maxReorgDepth
-
-  let copy = Dict.make()
-
-  for idx in 0 to ascBlockNumberKeys->Array.length - 1 {
-    let blockNumberKey = ascBlockNumberKeys->Array.getUnsafe(idx)
-    let scannedBlock = dataByBlockNumber->Dict.getUnsafe(blockNumberKey)
-    let isInReorgThreshold = scannedBlock.blockNumber >= thresholdBlockNumber
-    if isInReorgThreshold {
-      copy->Dict.set(blockNumberKey, scannedBlock)
-    }
-  }
-
-  copy
-}
-
-/** Registers observed (blockNumber, blockHash) pairs from a range fetch, prunes
- * unneeded data, and returns the updated state.
- *
- * Iterates the provided block hashes, skips entries outside the reorg threshold,
- * and compares each one against the previously scanned data. Returns on the first
- * mismatch as `ReorgDetected`.
- *
- * Resets internal state if shouldRollbackOnReorg is false (detect-only mode).
- */
-let registerReorgGuard = (
-  {maxReorgDepth, shouldRollbackOnReorg} as self: t,
-  ~blockHashes: array<blockData>,
-  ~knownHeight,
-) => {
-  let dataByBlockNumberCopyInThreshold = self->getDataByBlockNumberCopyInThreshold(~knownHeight)
-  let thresholdBlockNumber = knownHeight - maxReorgDepth
-
-  let maybeReorgDetected = ref(None)
-  let idx = ref(0)
-  while maybeReorgDetected.contents === None && idx.contents < blockHashes->Array.length {
-    let receivedBlock = blockHashes->Array.getUnsafe(idx.contents)
-    if receivedBlock.blockNumber >= thresholdBlockNumber {
-      let key = receivedBlock.blockNumber->Int.toString
-      // The working copy contains both previously scanned blocks AND blocks
-      // already written by earlier iterations of this same call, so a duplicate
-      // block number with a mismatching hash inside `blockHashes` itself is
-      // flagged as a reorg.
-      switch dataByBlockNumberCopyInThreshold->Utils.Dict.dangerouslyGetNonOption(key) {
-      | Some(scannedBlock) if scannedBlock.blockHash !== receivedBlock.blockHash =>
-        maybeReorgDetected := Some({receivedBlock, scannedBlock})
-      | _ => dataByBlockNumberCopyInThreshold->Dict.set(key, receivedBlock)
-      }
-    }
-    idx := idx.contents + 1
-  }
-
-  switch maybeReorgDetected.contents {
-  | Some(reorgDetected) => (
-      shouldRollbackOnReorg
-        ? self
-        : make(~chainReorgCheckpoints=[], ~maxReorgDepth, ~shouldRollbackOnReorg),
-      ReorgDetected(reorgDetected),
-    )
-  | None => (
-      {
-        maxReorgDepth,
-        dataByBlockNumber: dataByBlockNumberCopyInThreshold,
-        shouldRollbackOnReorg,
-      },
-      NoReorg,
-    )
-  }
-}
-
-/**
-Returns the latest block number which matches block number and hashes in the provided array
-If it doesn't exist in the reorg threshold it returns NotFound
-*/
-let getLatestValidScannedBlock = (
-  reorgDetection: t,
-  ~blockNumbersAndHashes: array<blockDataWithTimestamp>,
-) => {
-  let verifiedDataByBlockNumber = Dict.make()
-  for idx in 0 to blockNumbersAndHashes->Array.length - 1 {
-    let blockData = blockNumbersAndHashes->Array.getUnsafe(idx)
-    verifiedDataByBlockNumber->Dict.set(blockData.blockNumber->Int.toString, blockData)
-  }
-  // Js engine automatically orders numeric object keys
-  let ascBlockNumberKeys = verifiedDataByBlockNumber->Dict.keysToArray
-
-  let getPrevScannedBlockNumber = idx =>
-    ascBlockNumberKeys
-    ->Array.get(idx - 1)
-    ->Option.map(key => {
-      (verifiedDataByBlockNumber->Dict.getUnsafe(key)).blockNumber
-    })
-
-  let rec loop = idx => {
-    switch ascBlockNumberKeys->Array.get(idx) {
-    | Some(blockNumberKey) =>
-      switch reorgDetection.dataByBlockNumber->Utils.Dict.dangerouslyGetNonOption(blockNumberKey) {
-      | Some(scannedBlock)
-        if (verifiedDataByBlockNumber->Dict.getUnsafe(blockNumberKey)).blockHash ===
-          scannedBlock.blockHash =>
-        loop(idx + 1)
-      | _ => getPrevScannedBlockNumber(idx)
-      }
-    | None => getPrevScannedBlockNumber(idx)
-    }
-  }
-  loop(0)
-}
-
-/**
-  Return a BlockNumbersAndHashes.t rolled back to where blockData is less
-  than the provided blockNumber
-  */
-let rollbackToValidBlockNumber = (
-  {dataByBlockNumber, maxReorgDepth, shouldRollbackOnReorg}: t,
-  ~blockNumber: int,
-) => {
-  // Js engine automatically orders numeric object keys
-  let ascBlockNumberKeys = dataByBlockNumber->Dict.keysToArray
-
-  let newDataByBlockNumber = Dict.make()
-
-  let rec loop = idx => {
-    switch ascBlockNumberKeys->Array.get(idx) {
-    | Some(blockNumberKey) => {
-        let scannedBlock = dataByBlockNumber->Dict.getUnsafe(blockNumberKey)
-        let shouldKeep = scannedBlock.blockNumber <= blockNumber
-        if shouldKeep {
-          newDataByBlockNumber->Dict.set(blockNumberKey, scannedBlock)
-          loop(idx + 1)
-        } else {
-          ()
-        }
-      }
-    | None => ()
-    }
-  }
-  loop(0)
-
-  {
-    maxReorgDepth,
-    dataByBlockNumber: newDataByBlockNumber,
-    shouldRollbackOnReorg,
-  }
-}
-
-let getThresholdBlockNumbersBelowBlock = (self: t, ~blockNumber: int, ~knownHeight) => {
-  let arr = []
-
-  // Js engine automatically orders numeric object keys
-  let ascBlockNumberKeys = self.dataByBlockNumber->Dict.keysToArray
-  let thresholdBlockNumber = knownHeight - self.maxReorgDepth
-
-  for idx in 0 to ascBlockNumberKeys->Array.length - 1 {
-    let blockNumberKey = ascBlockNumberKeys->Array.getUnsafe(idx)
-    let scannedBlock = self.dataByBlockNumber->Dict.getUnsafe(blockNumberKey)
-    let isInReorgThreshold = scannedBlock.blockNumber >= thresholdBlockNumber
-    if isInReorgThreshold && scannedBlock.blockNumber < blockNumber {
-      arr->Array.push(scannedBlock.blockNumber)
-    }
-  }
-  arr
-}
-
-let getHashByBlockNumber = (reorgDetection: t, ~blockNumber) => {
-  switch reorgDetection.dataByBlockNumber->Utils.Dict.dangerouslyGetByIntNonOption(blockNumber) {
-  | Some(v) => Null.Value(v.blockHash)
-  | None => Null.Null
-  }
-}

package/src/ReorgDetection.res.mjs

@@ -1,6 +1,5 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 
 function reorgDetectedToLogParams(reorgDetected, shouldRollbackOnReorg) {
   let scannedBlock = reorgDetected.scannedBlock;
@@ -14,169 +13,7 @@ function reorgDetectedToLogParams(reorgDetected, shouldRollbackOnReorg) {
   };
 }
 
-function make(chainReorgCheckpoints, maxReorgDepth, shouldRollbackOnReorg) {
-  let dataByBlockNumber = {};
-  chainReorgCheckpoints.forEach(block => {
-    dataByBlockNumber[block.block_number] = {
-      blockHash: block.block_hash,
-      blockNumber: block.block_number
-    };
-  });
-  return {
-    shouldRollbackOnReorg: shouldRollbackOnReorg,
-    maxReorgDepth: maxReorgDepth,
-    dataByBlockNumber: dataByBlockNumber
-  };
-}
-
-function getDataByBlockNumberCopyInThreshold(param, knownHeight) {
-  let dataByBlockNumber = param.dataByBlockNumber;
-  let ascBlockNumberKeys = Object.keys(dataByBlockNumber);
-  let thresholdBlockNumber = knownHeight - param.maxReorgDepth | 0;
-  let copy = {};
-  for (let idx = 0, idx_finish = ascBlockNumberKeys.length; idx < idx_finish; ++idx) {
-    let blockNumberKey = ascBlockNumberKeys[idx];
-    let scannedBlock = dataByBlockNumber[blockNumberKey];
-    let isInReorgThreshold = scannedBlock.blockNumber >= thresholdBlockNumber;
-    if (isInReorgThreshold) {
-      copy[blockNumberKey] = scannedBlock;
-    }
-  }
-  return copy;
-}
-
-function registerReorgGuard(self, blockHashes, knownHeight) {
-  let maxReorgDepth = self.maxReorgDepth;
-  let shouldRollbackOnReorg = self.shouldRollbackOnReorg;
-  let dataByBlockNumberCopyInThreshold = getDataByBlockNumberCopyInThreshold(self, knownHeight);
-  let thresholdBlockNumber = knownHeight - maxReorgDepth | 0;
-  let maybeReorgDetected;
-  let idx = 0;
-  while (maybeReorgDetected === undefined && idx < blockHashes.length) {
-    let receivedBlock = blockHashes[idx];
-    if (receivedBlock.blockNumber >= thresholdBlockNumber) {
-      let key = receivedBlock.blockNumber.toString();
-      let scannedBlock = dataByBlockNumberCopyInThreshold[key];
-      if (scannedBlock !== undefined && scannedBlock.blockHash !== receivedBlock.blockHash) {
-        maybeReorgDetected = {
-          scannedBlock: scannedBlock,
-          receivedBlock: receivedBlock
-        };
-      } else {
-        dataByBlockNumberCopyInThreshold[key] = receivedBlock;
-      }
-    }
-    idx = idx + 1 | 0;
-  };
-  let reorgDetected = maybeReorgDetected;
-  if (reorgDetected !== undefined) {
-    return [
-      shouldRollbackOnReorg ? self : make([], maxReorgDepth, shouldRollbackOnReorg),
-      {
-        TAG: "ReorgDetected",
-        _0: reorgDetected
-      }
-    ];
-  } else {
-    return [
-      {
-        shouldRollbackOnReorg: shouldRollbackOnReorg,
-        maxReorgDepth: maxReorgDepth,
-        dataByBlockNumber: dataByBlockNumberCopyInThreshold
-      },
-      "NoReorg"
-    ];
-  }
-}
-
-function getLatestValidScannedBlock(reorgDetection, blockNumbersAndHashes) {
-  let verifiedDataByBlockNumber = {};
-  for (let idx = 0, idx_finish = blockNumbersAndHashes.length; idx < idx_finish; ++idx) {
-    let blockData = blockNumbersAndHashes[idx];
-    verifiedDataByBlockNumber[blockData.blockNumber.toString()] = blockData;
-  }
-  let ascBlockNumberKeys = Object.keys(verifiedDataByBlockNumber);
-  let getPrevScannedBlockNumber = idx => Stdlib_Option.map(ascBlockNumberKeys[idx - 1 | 0], key => verifiedDataByBlockNumber[key].blockNumber);
-  let _idx = 0;
-  while (true) {
-    let idx$1 = _idx;
-    let blockNumberKey = ascBlockNumberKeys[idx$1];
-    if (blockNumberKey === undefined) {
-      return getPrevScannedBlockNumber(idx$1);
-    }
-    let scannedBlock = reorgDetection.dataByBlockNumber[blockNumberKey];
-    if (scannedBlock === undefined) {
-      return getPrevScannedBlockNumber(idx$1);
-    }
-    if (verifiedDataByBlockNumber[blockNumberKey].blockHash !== scannedBlock.blockHash) {
-      return getPrevScannedBlockNumber(idx$1);
-    }
-    _idx = idx$1 + 1 | 0;
-    continue;
-  };
-}
-
-function rollbackToValidBlockNumber(param, blockNumber) {
-  let dataByBlockNumber = param.dataByBlockNumber;
-  let ascBlockNumberKeys = Object.keys(dataByBlockNumber);
-  let newDataByBlockNumber = {};
-  let loop = _idx => {
-    while (true) {
-      let idx = _idx;
-      let blockNumberKey = ascBlockNumberKeys[idx];
-      if (blockNumberKey === undefined) {
-        return;
-      }
-      let scannedBlock = dataByBlockNumber[blockNumberKey];
-      let shouldKeep = scannedBlock.blockNumber <= blockNumber;
-      if (!shouldKeep) {
-        return;
-      }
-      newDataByBlockNumber[blockNumberKey] = scannedBlock;
-      _idx = idx + 1 | 0;
-      continue;
-    };
-  };
-  loop(0);
-  return {
-    shouldRollbackOnReorg: param.shouldRollbackOnReorg,
-    maxReorgDepth: param.maxReorgDepth,
-    dataByBlockNumber: newDataByBlockNumber
-  };
-}
-
-function getThresholdBlockNumbersBelowBlock(self, blockNumber, knownHeight) {
-  let arr = [];
-  let ascBlockNumberKeys = Object.keys(self.dataByBlockNumber);
-  let thresholdBlockNumber = knownHeight - self.maxReorgDepth | 0;
-  for (let idx = 0, idx_finish = ascBlockNumberKeys.length; idx < idx_finish; ++idx) {
-    let blockNumberKey = ascBlockNumberKeys[idx];
-    let scannedBlock = self.dataByBlockNumber[blockNumberKey];
-    let isInReorgThreshold = scannedBlock.blockNumber >= thresholdBlockNumber;
-    if (isInReorgThreshold && scannedBlock.blockNumber < blockNumber) {
-      arr.push(scannedBlock.blockNumber);
-    }
-  }
-  return arr;
-}
-
-function getHashByBlockNumber(reorgDetection, blockNumber) {
-  let v = reorgDetection.dataByBlockNumber[blockNumber];
-  if (v !== undefined) {
-    return v.blockHash;
-  } else {
-    return null;
-  }
-}
-
 export {
   reorgDetectedToLogParams,
-  make,
-  getDataByBlockNumberCopyInThreshold,
-  registerReorgGuard,
-  getLatestValidScannedBlock,
-  rollbackToValidBlockNumber,
-  getThresholdBlockNumbersBelowBlock,
-  getHashByBlockNumber,
 }
 /* No side effect */

package/src/Rollback.res

@@ -10,27 +10,29 @@ let getLastKnownValidBlock = async (
   ~reorgBlockNumber: int,
   ~isRealtime: bool,
 ) => {
-  // Don't include the reorg block itself — different source instances
+  // Before the search, not after: it re-fetches the scanned hashes through the
+  // sources, and a source answering from a cache it filled on the orphaned
+  // chain would confirm blocks that no longer exist - stopping the rollback
+  // short of the real fork.
+  chainState->ChainState.sourceManager->SourceManager.onReorg
+
+  // Don't include the reorg block itself - different source instances
   // may have mismatching hashes at the head, so we always rollback
   // the block where we detected the reorg.
   let scannedBlockNumbers =
-    chainState
-    ->ChainState.reorgDetection
-    ->ReorgDetection.getThresholdBlockNumbersBelowBlock(
-      ~blockNumber=reorgBlockNumber,
-      ~knownHeight=chainState->ChainState.knownHeight,
-    )
+    chainState->ChainState.getReorgThresholdBlockNumbersBelow(~blockNumber=reorgBlockNumber)
 
   switch scannedBlockNumbers {
   | [] => chainState->ChainState.getHighestBlockBelowThreshold
   | _ => {
-      let blockNumbersAndHashes = await chainState
+      let blockStore = await chainState
       ->ChainState.sourceManager
       ->SourceManager.getBlockHashes(~blockNumbers=scannedBlockNumbers, ~isRealtime)
 
-      switch chainState
-      ->ChainState.reorgDetection
-      ->ReorgDetection.getLatestValidScannedBlock(~blockNumbersAndHashes) {
+      switch chainState->ChainState.getLatestValidScannedBlock(
+        ~blockStore,
+        ~blockNumbers=scannedBlockNumbers,
+      ) {
       | Some(blockNumber) => blockNumber
       | None => chainState->ChainState.getHighestBlockBelowThreshold
       }
@@ -54,15 +56,12 @@ let rec rollback = async (
       let chainState = state->IndexerState.getChainState(~chainId)
 
       state->IndexerState.enterFindingReorgDepth
+
       let rollbackTargetBlockNumber = await chainState->getLastKnownValidBlock(
         ~reorgBlockNumber,
         ~isRealtime=state->IndexerState.isRealtime,
       )
 
-      chainState
-      ->ChainState.sourceManager
-      ->SourceManager.onReorg(~rollbackTargetBlock=rollbackTargetBlockNumber)
-
       state->IndexerState.foundReorgDepth(~chainId, ~rollbackTargetBlockNumber)
       // Rendezvous with the processing loop: whichever of {depth found, loop
       // idle} happens last triggers the rollback; the earlier one finds the