envio 3.6.1 → 3.7.0-svm-alpha.1

package/index.d.ts

@@ -725,17 +725,188 @@ export type FuelOnEventWhere<Params, ContractName extends string> =
 type _ProjectEvmEvent = EvmEvent extends EventLike ? EvmEvent : never;
 type _ProjectFuelEvent = FuelEvent extends EventLike ? FuelEvent : never;
 
+// ============== EVM inline field selection ==============
+
+/** Marks a block/transaction field the registration doesn't select. Reading such
+ * a field is a type error; the message names the field and where to add it. */
+export type FieldNotSelected<Message extends string> = { readonly __fieldNotSelected: Message };
+
+/** Every EVM block field, with the type it has once selected. Declared by hand
+ * so the `fields` option types work in a project that never ran codegen; kept
+ * in sync with the config-parsing enums by a test in `codegen_templates.rs`. */
+export type EvmAllBlockFields = {
+  readonly number: number;
+  readonly timestamp: number;
+  readonly hash: string;
+  readonly parentHash: string;
+  readonly nonce: bigint | undefined;
+  readonly sha3Uncles: string;
+  readonly logsBloom: string;
+  readonly transactionsRoot: string;
+  readonly stateRoot: string;
+  readonly receiptsRoot: string;
+  readonly miner: Address;
+  readonly difficulty: bigint | undefined;
+  readonly totalDifficulty: bigint | undefined;
+  readonly extraData: string;
+  readonly size: bigint;
+  readonly gasLimit: bigint;
+  readonly gasUsed: bigint;
+  readonly uncles: readonly string[] | undefined;
+  readonly baseFeePerGas: bigint | undefined;
+  readonly blobGasUsed: bigint | undefined;
+  readonly excessBlobGas: bigint | undefined;
+  readonly parentBeaconBlockRoot: string | undefined;
+  readonly withdrawalsRoot: string | undefined;
+  readonly l1BlockNumber: number | undefined;
+  readonly sendCount: string | undefined;
+  readonly sendRoot: string | undefined;
+  readonly mixHash: string | undefined;
+};
+
+export type EvmAllTransactionFields = {
+  readonly transactionIndex: number;
+  readonly hash: string;
+  readonly from: Address | undefined;
+  readonly to: Address | undefined;
+  readonly gas: bigint;
+  readonly gasPrice: bigint | undefined;
+  readonly maxPriorityFeePerGas: bigint | undefined;
+  readonly maxFeePerGas: bigint | undefined;
+  readonly cumulativeGasUsed: bigint;
+  readonly effectiveGasPrice: bigint;
+  readonly gasUsed: bigint;
+  readonly input: string;
+  readonly nonce: bigint;
+  readonly value: bigint;
+  readonly v: string | undefined;
+  readonly r: string | undefined;
+  readonly s: string | undefined;
+  readonly contractAddress: Address | undefined;
+  readonly logsBloom: string;
+  readonly root: string | undefined;
+  readonly status: number | undefined;
+  readonly yParity: string | undefined;
+  readonly accessList: readonly unknown[] | undefined;
+  readonly maxFeePerBlobGas: bigint | undefined;
+  readonly blobVersionedHashes: readonly string[] | undefined;
+  readonly type: number | undefined;
+  readonly l1Fee: bigint | undefined;
+  readonly l1GasPrice: bigint | undefined;
+  readonly l1GasUsed: bigint | undefined;
+  readonly l1FeeScalar: number | undefined;
+  readonly gasUsedForL1: bigint | undefined;
+  readonly authorizationList: readonly unknown[] | undefined;
+};
+
+export type EvmBlockFieldName = keyof EvmAllBlockFields & string;
+export type EvmTransactionFieldName = keyof EvmAllTransactionFields & string;
+
+/** The `fields` option of `indexer.onEvent` / `indexer.contractRegister`.
+ * Names the block and transaction fields this registration reads. Replaces
+ * `field_selection` from `config.yaml` for this registration — fields selected
+ * there but not listed here are not readable. */
+export type EvmFieldsSelection = {
+  readonly block?: readonly EvmBlockFieldName[];
+  readonly transaction?: readonly EvmTransactionFieldName[];
+};
+
+/** Included in every inline selection without being listed. `block.number` is
+ * the item's own key, so it costs nothing extra. */
+type EvmAlwaysSelectedBlockField = "number";
+
+type EvmSelectedFields<All, Selected extends string, Knob extends string> = {
+  readonly [K in keyof All]: K extends Selected
+    ? All[K]
+    : FieldNotSelected<`Field '${K &
+        string}' is not selected for this handler. Add it to fields.${Knob} in the registration options.`>;
+};
+
+/** Field names listed under `Knob`, or `never` when the key is absent or lists
+ * nothing. Reads the value through `EvmListedArray` for the same reason that
+ * type exists: an optional property doesn't satisfy a `Record<Knob, _>`
+ * conditional, which would type every listed field as unselected for a
+ * selection whose keys are optional. Element access rather than `infer`, which
+ * falls back to its `string` constraint on an absent key — naming every field
+ * as selected. */
+type EvmListedFields<Fields, Knob extends keyof EvmFieldsSelection> = NonNullable<
+  EvmListedArray<Fields, Knob>
+>[number] &
+  string;
+
+/** The value listed under `Knob`, keeping optional keys (which a `Record<Knob, _>`
+ * conditional would miss, since an optional property doesn't satisfy a required
+ * one). `never` when the key is absent from the selection entirely. */
+type EvmListedArray<Fields, Knob extends keyof EvmFieldsSelection> = Fields[Knob &
+  keyof Fields];
+
+/** True for an unbounded `T[]` / `readonly T[]`, false for a literal tuple —
+ * and false for an absent key, so a selection that names only one knob passes. */
+type IsWidenedArray<T> = [NonNullable<T>] extends [never]
+  ? false
+  : [NonNullable<T>] extends [readonly unknown[]]
+    ? number extends NonNullable<T>["length"]
+      ? true
+      : false
+    : false;
+
+/** Rejected in place of the `fields` option when a selection isn't written as a
+ * literal. Reading it as an array type would only tell us the field union, not
+ * which fields this registration listed, so every field would type as selected
+ * while the runtime selected a subset. */
+export type EvmFieldsMustBeLiteral<Knob extends string> = {
+  readonly __fieldsMustBeLiteral: `fields.${Knob} must be a literal array, so its element types name the selected fields. Write it inline, or annotate the variable with 'as const' instead of a field-name array type.`;
+};
+
+/** `unknown` (a no-op intersection) when every listed selection is a literal
+ * array, otherwise the branded type that rejects the option. */
+type EvmFieldsLiteralCheck<Fields> = [Fields] extends [undefined]
+  ? unknown
+  : IsWidenedArray<EvmListedArray<Fields, "block">> extends true
+    ? EvmFieldsMustBeLiteral<"block">
+    : IsWidenedArray<EvmListedArray<Fields, "transaction">> extends true
+      ? EvmFieldsMustBeLiteral<"transaction">
+      : unknown;
+
+/** Rebinds an event's `block`/`transaction` to an inline `fields` selection.
+ * With no `fields` option the event type passes through, so the `config.yaml`
+ * `field_selection` path is unaffected. */
+export type EvmEventWithFields<Event, Fields> = [Fields] extends [EvmFieldsSelection]
+  ? Omit<Event, "block" | "transaction"> & {
+      readonly block: EvmSelectedFields<
+        EvmAllBlockFields,
+        EvmAlwaysSelectedBlockField | EvmListedFields<Fields, "block">,
+        "block"
+      >;
+      readonly transaction: EvmSelectedFields<
+        EvmAllTransactionFields,
+        EvmListedFields<Fields, "transaction">,
+        "transaction"
+      >;
+    }
+  : Event;
+
 /** Options for registering an EVM onEvent handler. Contract and event literal names are derived from the Event type.
  * The conditional `Event extends EventLike` distributes over union members so that each member's
  * contractName/eventName pair is constrained together — preventing invalid cross-member pairings.
  * The `Params` generic carries the indexed-parameter shape (looked up via `EvmEventFilters[C][E]["params"]`
  * by callers) so the `where` option enforces the same per-event narrowing as the inline handler signature. */
-export type EvmOnEventOptions<Event extends EventLike = _ProjectEvmEvent, Params = {}> = Event extends EventLike
+export type EvmOnEventOptions<
+  Event extends EventLike = _ProjectEvmEvent,
+  Params = {},
+  Fields extends EvmFieldsSelection | undefined = undefined,
+> = Event extends EventLike
   ? {
       readonly contract: Event["contractName"];
       readonly event: Event["eventName"];
       readonly wildcard?: boolean;
       readonly where?: EvmOnEventWhere<Params, Event["contractName"] & string>;
+      /** Pass the selection's literal type as the `Fields` generic to get the
+       * same narrowing `indexer.onEvent` infers from the call site. Defaults to
+       * no selection: `EvmFieldsSelection` names no fields in particular, so an
+       * options value declared without the generic would carry a selection
+       * `onEvent` can only reject. */
+      readonly fields?: Fields & EvmFieldsLiteralCheck<Fields>;
     }
   : never;
 
@@ -749,7 +920,8 @@ export type EvmOnEventHandler<
 export type EvmContractRegisterOptions<
   Event extends EventLike = _ProjectEvmEvent,
   Params = {},
-> = EvmOnEventOptions<Event, Params>;
+  Fields extends EvmFieldsSelection | undefined = undefined,
+> = EvmOnEventOptions<Event, Params, Fields>;
 
 /** Handler function for an EVM contractRegister registration. */
 export type EvmContractRegisterHandler<
@@ -1029,10 +1201,18 @@ export type SvmInstructionBlock = {
 export type SvmTokenBalance = {
   readonly account?: string;
   readonly mint?: string;
+  /** Owner at the end of the transaction, falling back to the owner on entry
+   * when the account was closed during it. Pre and post owners differ only
+   * when a `SetAuthority(AccountOwner)` runs mid-transaction. */
   readonly owner?: string;
-  /** u64 decimal string. Cast with BigInt(...) for arithmetic. */
-  readonly preAmount?: string;
-  readonly postAmount?: string;
+  /** Mint decimals, for scaling the raw amounts below. */
+  readonly decimals?: number;
+  /** Raw amount in base units before the transaction. Absent when the token
+   * account was created during it. */
+  readonly preAmount?: bigint;
+  /** Raw amount in base units after the transaction. Absent when the token
+   * account was closed during it. */
+  readonly postAmount?: bigint;
 };
 
 export type SvmLog = {
@@ -1181,7 +1361,8 @@ type EvmEcosystem<Config extends IndexerConfigTypes = GlobalConfig> =
                 /** Register an event handler. */
                 readonly onEvent: <
                   C extends keyof Contracts & string,
-                  E extends keyof Contracts[C] & string
+                  E extends keyof Contracts[C] & string,
+                  const F extends EvmFieldsSelection | undefined
                 >(
                   options: {
                     readonly contract: C;
@@ -1195,13 +1376,17 @@ type EvmEcosystem<Config extends IndexerConfigTypes = GlobalConfig> =
                         : {},
                       C
                     >;
+                    /** Block and transaction fields this handler reads. Replaces
+                     * `field_selection` from `config.yaml` for this registration. */
+                    readonly fields?: F & EvmFieldsLiteralCheck<F>;
                   },
-                  handler: EvmOnEventHandler<Contracts[C][E], EvmOnEventContext<Config>>
+                  handler: EvmOnEventHandler<EvmEventWithFields<Contracts[C][E], F>, EvmOnEventContext<Config>>
                 ) => void;
                 /** Register a contract register handler for dynamic contract indexing. */
                 readonly contractRegister: <
                   C extends keyof Contracts & string,
-                  E extends keyof Contracts[C] & string
+                  E extends keyof Contracts[C] & string,
+                  const F extends EvmFieldsSelection | undefined
                 >(
                   options: {
                     readonly contract: C;
@@ -1215,8 +1400,11 @@ type EvmEcosystem<Config extends IndexerConfigTypes = GlobalConfig> =
                         : {},
                       C
                     >;
+                    /** Block and transaction fields this handler reads. Replaces
+                     * `field_selection` from `config.yaml` for this registration. */
+                    readonly fields?: F & EvmFieldsLiteralCheck<F>;
                   },
-                  handler: EvmContractRegisterHandler<Contracts[C][E], EvmContractRegisterContext<Config>>
+                  handler: EvmContractRegisterHandler<EvmEventWithFields<Contracts[C][E], F>, EvmContractRegisterContext<Config>>
                 ) => void;
               }
             : {})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.6.1",
+  "version": "3.7.0-svm-alpha.1",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -69,10 +69,10 @@
     "tsx": "4.21.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.6.1",
-    "envio-linux-x64-musl": "3.6.1",
-    "envio-linux-arm64": "3.6.1",
-    "envio-darwin-x64": "3.6.1",
-    "envio-darwin-arm64": "3.6.1"
+    "envio-linux-x64": "3.7.0-svm-alpha.1",
+    "envio-linux-x64-musl": "3.7.0-svm-alpha.1",
+    "envio-linux-arm64": "3.7.0-svm-alpha.1",
+    "envio-darwin-x64": "3.7.0-svm-alpha.1",
+    "envio-darwin-arm64": "3.7.0-svm-alpha.1"
   }
 }

package/src/Batch.res

@@ -10,9 +10,20 @@ type chainAfterBatch = {
   isProgressAtHeadWhenBatchCreated: bool,
 }
 
+// A per-chain snapshot of the scanned block hashes still inside the reorg
+// threshold, taken when the batch is assembled. Immutable for the batch's
+// lifetime, unlike the live block store it is read from - so checkpoint hashes
+// can't shift under a concurrent store mutation. `blockNumbers` is ascending;
+// `hashByBlockNumber` is keyed by block number.
+type reorgHashSnapshot = {
+  blockNumbers: array<int>,
+  hashByBlockNumber: dict<string>,
+}
+
 type chainBeforeBatch = {
   fetchState: FetchState.t,
-  reorgDetection: ReorgDetection.t,
+  scannedHashes: reorgHashSnapshot,
+  shouldRollbackOnReorg: bool,
   progressBlockNumber: int,
   sourceBlockNumber: int,
   totalEventsProcessed: float,
@@ -107,10 +118,7 @@ let getProgressedChainsById = {
         )
       } {
       | Some(progressedChain) =>
-        progressedChainsById->ChainId.Dict.set(
-          chainBeforeBatch.fetchState.chainId,
-          progressedChain,
-        )
+        progressedChainsById->ChainId.Dict.set(chainBeforeBatch.fetchState.chainId, progressedChain)
       | None => ()
       }
     })
@@ -119,10 +127,27 @@ let getProgressedChainsById = {
   }
 }
 
+// Index of the first entry of an ascending array strictly above `blockNumber`,
+// or the array length when there is none.
+let seekFirstAbove = (blockNumbers: array<int>, blockNumber) => {
+  let low = ref(0)
+  let high = ref(blockNumbers->Array.length)
+  while low.contents < high.contents {
+    let mid = (low.contents + high.contents) / 2
+    if blockNumbers->Array.getUnsafe(mid) > blockNumber {
+      high := mid
+    } else {
+      low := mid + 1
+    }
+  }
+  low.contents
+}
+
 @inline
 let addReorgCheckpoints = (
   ~prevCheckpointId,
-  ~reorgDetection: ReorgDetection.t,
+  ~scannedHashes: reorgHashSnapshot,
+  ~shouldRollbackOnReorg,
   ~fromBlockExclusive,
   ~toBlockExclusive,
   ~chainId,
@@ -132,23 +157,30 @@ let addReorgCheckpoints = (
   ~mutCheckpointBlockHashes,
   ~mutCheckpointEventsProcessed,
 ) => {
-  if (
-    reorgDetection.shouldRollbackOnReorg && !(reorgDetection.dataByBlockNumber->Utils.Dict.isEmpty)
-  ) {
+  if shouldRollbackOnReorg {
     let prevCheckpointId = ref(prevCheckpointId)
-    for blockNumber in fromBlockExclusive + 1 to toBlockExclusive - 1 {
-      switch reorgDetection->ReorgDetection.getHashByBlockNumber(~blockNumber) {
-      | Null.Value(hash) =>
-        let checkpointId = prevCheckpointId.contents->BigInt.add(1n)
-        prevCheckpointId := checkpointId
-
-        mutCheckpointIds->Array.push(checkpointId)
-        mutCheckpointChainIds->Array.push(chainId)
-        mutCheckpointBlockNumbers->Array.push(blockNumber)
-        mutCheckpointBlockHashes->Array.push(Null.Value(hash))
-        mutCheckpointEventsProcessed->Array.push(0)
-      | Null.Null => ()
-      }
+    // The snapshot already holds only in-threshold scanned hashes, ascending,
+    // so seeking to the gap's lower bound gives the gap checkpoints without
+    // rescanning the whole snapshot for every gap in the batch.
+    let blockNumbers = scannedHashes.blockNumbers
+    let length = blockNumbers->Array.length
+    let idx = ref(blockNumbers->seekFirstAbove(fromBlockExclusive))
+    while idx.contents < length && blockNumbers->Array.getUnsafe(idx.contents) < toBlockExclusive {
+      let blockNumber = blockNumbers->Array.getUnsafe(idx.contents)
+      let hash =
+        scannedHashes.hashByBlockNumber
+        ->Utils.Dict.dangerouslyGetByIntNonOption(blockNumber)
+        ->Option.getUnsafe
+      let checkpointId = prevCheckpointId.contents->BigInt.add(1n)
+      prevCheckpointId := checkpointId
+
+      mutCheckpointIds->Array.push(checkpointId)
+      mutCheckpointChainIds->Array.push(chainId)
+      mutCheckpointBlockNumbers->Array.push(blockNumber)
+      mutCheckpointBlockHashes->Array.push(Null.Value(hash))
+      mutCheckpointEventsProcessed->Array.push(0)
+
+      idx := idx.contents + 1
     }
     prevCheckpointId.contents
   } else {
@@ -209,7 +241,8 @@ let prepareBatch = (
           prevCheckpointId :=
             addReorgCheckpoints(
               ~chainId=fetchState.chainId,
-              ~reorgDetection=chainBeforeBatch.reorgDetection,
+              ~scannedHashes=chainBeforeBatch.scannedHashes,
+              ~shouldRollbackOnReorg=chainBeforeBatch.shouldRollbackOnReorg,
               ~prevCheckpointId=prevCheckpointId.contents,
               ~fromBlockExclusive=prevBlockNumber.contents,
               ~toBlockExclusive=blockNumber,
@@ -227,7 +260,12 @@ let prepareBatch = (
           checkpointBlockNumbers->Array.push(blockNumber)->ignore
           checkpointBlockHashes
           ->Array.push(
-            chainBeforeBatch.reorgDetection->ReorgDetection.getHashByBlockNumber(~blockNumber),
+            switch chainBeforeBatch.scannedHashes.hashByBlockNumber->Utils.Dict.dangerouslyGetByIntNonOption(
+              blockNumber,
+            ) {
+            | Some(hash) => Null.Value(hash)
+            | None => Null.Null
+            },
           )
           ->ignore
           checkpointEventsProcessed->Array.push(1)->ignore
@@ -254,7 +292,8 @@ let prepareBatch = (
     prevCheckpointId :=
       addReorgCheckpoints(
         ~chainId=fetchState.chainId,
-        ~reorgDetection=chainBeforeBatch.reorgDetection,
+        ~scannedHashes=chainBeforeBatch.scannedHashes,
+        ~shouldRollbackOnReorg=chainBeforeBatch.shouldRollbackOnReorg,
         ~prevCheckpointId=prevCheckpointId.contents,
         ~fromBlockExclusive=prevBlockNumber.contents,
         ~toBlockExclusive=progressBlockNumberAfterBatch + 1, // Make it inclusive

package/src/Batch.res.mjs

@@ -1,9 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Utils from "./Utils.res.mjs";
 import * as ChainId from "./ChainId.res.mjs";
 import * as FetchState from "./FetchState.res.mjs";
-import * as ReorgDetection from "./ReorgDetection.res.mjs";
 
 function getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, fetchStateAfterBatch, batchSize) {
   if (chainBeforeBatch.progressBlockNumber < progressBlockNumberAfterBatch) {
@@ -40,23 +38,40 @@ function getProgressedChainsById(chainsBeforeBatch, batchSizePerChain, progressB
   return progressedChainsById;
 }
 
-function addReorgCheckpoints(prevCheckpointId, reorgDetection, fromBlockExclusive, toBlockExclusive, chainId, mutCheckpointIds, mutCheckpointChainIds, mutCheckpointBlockNumbers, mutCheckpointBlockHashes, mutCheckpointEventsProcessed) {
-  if (!(reorgDetection.shouldRollbackOnReorg && !Utils.Dict.isEmpty(reorgDetection.dataByBlockNumber))) {
+function seekFirstAbove(blockNumbers, blockNumber) {
+  let low = 0;
+  let high = blockNumbers.length;
+  while (low < high) {
+    let mid = (low + high) / 2 | 0;
+    if (blockNumbers[mid] > blockNumber) {
+      high = mid;
+    } else {
+      low = mid + 1;
+    }
+  };
+  return low;
+}
+
+function addReorgCheckpoints(prevCheckpointId, scannedHashes, shouldRollbackOnReorg, fromBlockExclusive, toBlockExclusive, chainId, mutCheckpointIds, mutCheckpointChainIds, mutCheckpointBlockNumbers, mutCheckpointBlockHashes, mutCheckpointEventsProcessed) {
+  if (!shouldRollbackOnReorg) {
     return prevCheckpointId;
   }
   let prevCheckpointId$1 = prevCheckpointId;
-  for (let blockNumber = fromBlockExclusive + 1, blockNumber_finish = toBlockExclusive - 1; blockNumber <= blockNumber_finish; ++blockNumber) {
-    let hash = ReorgDetection.getHashByBlockNumber(reorgDetection, blockNumber);
-    if (hash !== null) {
-      let checkpointId = prevCheckpointId$1 + 1n;
-      prevCheckpointId$1 = checkpointId;
-      mutCheckpointIds.push(checkpointId);
-      mutCheckpointChainIds.push(chainId);
-      mutCheckpointBlockNumbers.push(blockNumber);
-      mutCheckpointBlockHashes.push(hash);
-      mutCheckpointEventsProcessed.push(0);
-    }
-  }
+  let blockNumbers = scannedHashes.blockNumbers;
+  let length = blockNumbers.length;
+  let idx = seekFirstAbove(blockNumbers, fromBlockExclusive);
+  while (idx < length && blockNumbers[idx] < toBlockExclusive) {
+    let blockNumber = blockNumbers[idx];
+    let hash = scannedHashes.hashByBlockNumber[blockNumber];
+    let checkpointId = prevCheckpointId$1 + 1n;
+    prevCheckpointId$1 = checkpointId;
+    mutCheckpointIds.push(checkpointId);
+    mutCheckpointChainIds.push(chainId);
+    mutCheckpointBlockNumbers.push(blockNumber);
+    mutCheckpointBlockHashes.push(hash);
+    mutCheckpointEventsProcessed.push(0);
+    idx = idx + 1;
+  };
   return prevCheckpointId$1;
 }
 
@@ -86,23 +101,26 @@ function prepareBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSizeTarge
         if (blockNumber !== prevBlockNumber) {
           let chainId = fetchState.chainId;
           let fromBlockExclusive = prevBlockNumber;
-          let reorgDetection = chainBeforeBatch.reorgDetection;
+          let scannedHashes = chainBeforeBatch.scannedHashes;
           let prevCheckpointId$1 = prevCheckpointId;
           let tmp;
-          if (reorgDetection.shouldRollbackOnReorg && !Utils.Dict.isEmpty(reorgDetection.dataByBlockNumber)) {
+          if (chainBeforeBatch.shouldRollbackOnReorg) {
             let prevCheckpointId$2 = prevCheckpointId$1;
-            for (let blockNumber$1 = fromBlockExclusive + 1, blockNumber_finish = blockNumber - 1; blockNumber$1 <= blockNumber_finish; ++blockNumber$1) {
-              let hash = ReorgDetection.getHashByBlockNumber(reorgDetection, blockNumber$1);
-              if (hash !== null) {
-                let checkpointId = prevCheckpointId$2 + 1n;
-                prevCheckpointId$2 = checkpointId;
-                checkpointIds.push(checkpointId);
-                checkpointChainIds.push(chainId);
-                checkpointBlockNumbers.push(blockNumber$1);
-                checkpointBlockHashes.push(hash);
-                checkpointEventsProcessed.push(0);
-              }
-            }
+            let blockNumbers = scannedHashes.blockNumbers;
+            let length = blockNumbers.length;
+            let idx$1 = seekFirstAbove(blockNumbers, fromBlockExclusive);
+            while (idx$1 < length && blockNumbers[idx$1] < blockNumber) {
+              let blockNumber$1 = blockNumbers[idx$1];
+              let hash = scannedHashes.hashByBlockNumber[blockNumber$1];
+              let checkpointId = prevCheckpointId$2 + 1n;
+              prevCheckpointId$2 = checkpointId;
+              checkpointIds.push(checkpointId);
+              checkpointChainIds.push(chainId);
+              checkpointBlockNumbers.push(blockNumber$1);
+              checkpointBlockHashes.push(hash);
+              checkpointEventsProcessed.push(0);
+              idx$1 = idx$1 + 1;
+            };
             tmp = prevCheckpointId$2;
           } else {
             tmp = prevCheckpointId$1;
@@ -112,7 +130,8 @@ function prepareBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSizeTarge
           checkpointIds.push(checkpointId$1);
           checkpointChainIds.push(fetchState.chainId);
           checkpointBlockNumbers.push(blockNumber);
-          checkpointBlockHashes.push(ReorgDetection.getHashByBlockNumber(chainBeforeBatch.reorgDetection, blockNumber));
+          let hash$1 = chainBeforeBatch.scannedHashes.hashByBlockNumber[blockNumber];
+          checkpointBlockHashes.push(hash$1 !== undefined ? hash$1 : null);
           checkpointEventsProcessed.push(1);
           prevBlockNumber = blockNumber;
           prevCheckpointId = checkpointId$1;
@@ -129,23 +148,26 @@ function prepareBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSizeTarge
     let chainId$1 = fetchState.chainId;
     let toBlockExclusive = progressBlockNumberAfterBatch + 1;
     let fromBlockExclusive$1 = prevBlockNumber;
-    let reorgDetection$1 = chainBeforeBatch.reorgDetection;
+    let scannedHashes$1 = chainBeforeBatch.scannedHashes;
     let prevCheckpointId$3 = prevCheckpointId;
     let tmp$1;
-    if (reorgDetection$1.shouldRollbackOnReorg && !Utils.Dict.isEmpty(reorgDetection$1.dataByBlockNumber)) {
+    if (chainBeforeBatch.shouldRollbackOnReorg) {
       let prevCheckpointId$4 = prevCheckpointId$3;
-      for (let blockNumber$2 = fromBlockExclusive$1 + 1, blockNumber_finish$1 = toBlockExclusive - 1; blockNumber$2 <= blockNumber_finish$1; ++blockNumber$2) {
-        let hash$1 = ReorgDetection.getHashByBlockNumber(reorgDetection$1, blockNumber$2);
-        if (hash$1 !== null) {
-          let checkpointId$2 = prevCheckpointId$4 + 1n;
-          prevCheckpointId$4 = checkpointId$2;
-          checkpointIds.push(checkpointId$2);
-          checkpointChainIds.push(chainId$1);
-          checkpointBlockNumbers.push(blockNumber$2);
-          checkpointBlockHashes.push(hash$1);
-          checkpointEventsProcessed.push(0);
-        }
-      }
+      let blockNumbers$1 = scannedHashes$1.blockNumbers;
+      let length$1 = blockNumbers$1.length;
+      let idx$2 = seekFirstAbove(blockNumbers$1, fromBlockExclusive$1);
+      while (idx$2 < length$1 && blockNumbers$1[idx$2] < toBlockExclusive) {
+        let blockNumber$2 = blockNumbers$1[idx$2];
+        let hash$2 = scannedHashes$1.hashByBlockNumber[blockNumber$2];
+        let checkpointId$2 = prevCheckpointId$4 + 1n;
+        prevCheckpointId$4 = checkpointId$2;
+        checkpointIds.push(checkpointId$2);
+        checkpointChainIds.push(chainId$1);
+        checkpointBlockNumbers.push(blockNumber$2);
+        checkpointBlockHashes.push(hash$2);
+        checkpointEventsProcessed.push(0);
+        idx$2 = idx$2 + 1;
+      };
       tmp$1 = prevCheckpointId$4;
     } else {
       tmp$1 = prevCheckpointId$3;
@@ -200,10 +222,11 @@ function findLastEventItem(batch, chainId) {
 
 export {
   getProgressedChainsById,
+  seekFirstAbove,
   addReorgCheckpoints,
   prepareBatch,
   make,
   findFirstEventBlockNumber,
   findLastEventItem,
 }
-/* Utils Not a pure module */
+/* ChainId Not a pure module */