envio 3.6.1 → 3.7.0

package/src/sources/HyperSync.res

@@ -1,59 +1,65 @@
-let reraisIfRateLimited = exn =>
-  switch exn->JsExn.anyToExnInternal {
-  | JsExn(e) =>
-    switch e->JsExn.message {
-    | Some(msg) if msg->String.startsWith("RATE_LIMITED:") =>
-      let resetMs =
-        msg
-        ->String.slice(~start=13, ~end=msg->String.length)
-        ->Int.fromString
-        ->Option.getOr(1000)
-      throw(Source.RateLimited({resetMs: resetMs}))
-    | _ => ()
+// A napi error carries nothing but a message, so the native clients signal the
+// recoverable conditions SourceManager knows how to retry as a `PREFIX:<int>`
+// marker. Keep in sync with `request_stats.rs`.
+let rateLimitedPrefix = "RATE_LIMITED:"
+let behindHeadPrefix = "SOURCE_BEHIND_HEAD:"
+
+let markerValue = (msg, ~prefix) =>
+  msg->String.slice(~start=prefix->String.length, ~end=msg->String.length)->Int.fromString
+
+let mapNativeFailure = (failure: Source.nativeRequestFailure) => {
+  switch failure.message {
+  | Some(msg) if msg->String.startsWith(rateLimitedPrefix) =>
+    Source.RateLimited({
+      resetMs: msg->markerValue(~prefix=rateLimitedPrefix)->Option.getOr(1000),
+      requestStats: failure.requestStats,
+    })
+  | Some(msg) if msg->String.startsWith(behindHeadPrefix) =>
+    Source.SourceBehindHead({
+      blockNumber: msg->markerValue(~prefix=behindHeadPrefix)->Option.getOr(0),
+      requestStats: failure.requestStats,
+    })
+  | _ => failure.cause
+  }
+}
+
+let mapNativeFailureExn = exn => exn->Source.unpackNativeRequestFailure->mapNativeFailure
+
+// Every HyperSync client paginates block hashes in Rust and returns the page
+// store with the timings of the requests it took. A failure arrives as the
+// native envelope, which carries those same timings, so the caller records them
+// either way.
+let makeGetBlockHashes = (
+  ~query: (~blockNumbers: array<int>) => promise<(BlockStore.t, array<Source.requestStat>)>,
+) =>
+  async (~blockNumbers, ~logger as _) => {
+    let (result, requestStats) = try {
+      let (blockStore, requestStats) = await query(~blockNumbers)
+      (Ok(blockStore), requestStats)
+    } catch {
+    | exn =>
+      let failure = exn->Source.unpackNativeRequestFailure
+      (Error(failure->mapNativeFailure), failure.requestStats)
     }
+    {Source.result, requestStats}
+  }
+
+let reraiseIfRecoverable = exn =>
+  switch exn->mapNativeFailureExn {
+  | (Source.RateLimited(_) | Source.SourceBehindHead(_)) as exn => throw(exn)
   | _ => ()
   }
 
 type logsQueryPage = {
   items: array<HyperSyncClient.EventItems.item>,
-  // Headers for every returned block, deduplicated by block number.
-  blocks: array<HyperSyncClient.EventItems.blockHeader>,
   nextBlock: int,
   archiveHeight: int,
-  rollbackGuard: option<HyperSyncClient.ResponseTypes.rollbackGuard>,
   // Page store owning this page's raw transactions.
   transactionStore: TransactionStore.t,
   // Page store owning this page's raw blocks.
   blockStore: BlockStore.t,
 }
 
-type missingParams = {
-  queryName: string,
-  missingParams: array<string>,
-}
-type queryError = UnexpectedMissingParams(missingParams)
-
-exception HyperSyncQueryError(queryError)
-
-let queryErrorToExn = queryError => {
-  HyperSyncQueryError(queryError)
-}
-
-let queryErrorToMsq = (e: queryError): string => {
-  switch e {
-  | UnexpectedMissingParams({queryName, missingParams}) =>
-    `${queryName} query failed due to unexpected missing params on response:
-      ${missingParams->Array.joinUnsafe(", ")}`
-  }
-}
-
-type queryResponse<'a> = result<'a, queryError>
-let mapExn = (queryResponse: queryResponse<'a>) =>
-  switch queryResponse {
-  | Ok(v) => Ok(v)
-  | Error(err) => err->queryErrorToExn->Error
-  }
-
 module GetLogs = {
   type error =
     | UnexpectedMissingParams({missingParams: array<string>})
@@ -109,7 +115,7 @@ module GetLogs = {
     ) {
     | res => res
     | exception exn =>
-      reraisIfRateLimited(exn)
+      reraiseIfRecoverable(exn)
       switch extractMissingParams(exn) {
       | Some(missingParams) => throw(Error(UnexpectedMissingParams({missingParams: missingParams})))
       | None => throw(exn)
@@ -122,196 +128,10 @@ module GetLogs = {
 
     {
       items: res.items,
-      blocks: res.blocks,
       nextBlock: res.nextBlock,
       archiveHeight: res.archiveHeight->Option.getOr(0), //Archive Height is only None if height is 0
-      rollbackGuard: res.rollbackGuard,
       transactionStore,
       blockStore,
     }
   }
 }
-
-module BlockData = {
-  let makeRequestBody = (~fromBlock, ~toBlock): HyperSyncClient.QueryTypes.query => {
-    fromBlock,
-    toBlockExclusive: toBlock + 1,
-    fieldSelection: {
-      block: [Number, Hash, Timestamp],
-    },
-    includeAllBlocks: true,
-  }
-
-  let convertResponse = (res: HyperSyncClient.queryResponse): queryResponse<
-    array<ReorgDetection.blockDataWithTimestamp>,
-  > => {
-    res.data.blocks
-    ->Array.map(block => {
-      switch block {
-      | {number: blockNumber, hash: blockHash, timestamp: blockTimestamp} =>
-        Ok(
-          (
-            {
-              blockTimestamp,
-              blockNumber,
-              blockHash,
-            }: ReorgDetection.blockDataWithTimestamp
-          ),
-        )
-      | _ =>
-        let missingParams =
-          [
-            block.number->Utils.Option.mapNone("block.number"),
-            block.timestamp->Utils.Option.mapNone("block.timestamp"),
-            block.hash->Utils.Option.mapNone("block.hash"),
-          ]->Array.filterMap(p => p)
-
-        Error(
-          UnexpectedMissingParams({
-            queryName: "query block data HyperSync",
-            missingParams,
-          }),
-        )
-      }
-    })
-    ->Utils.Array.transposeResults
-  }
-
-  let rec queryBlockData = async (
-    ~client: HyperSyncClient.t,
-    ~fromBlock,
-    ~toBlock,
-    ~sourceName,
-    ~chainId,
-    ~logger,
-    ~requestStats: array<Source.requestStat>,
-  ): queryResponse<array<ReorgDetection.blockDataWithTimestamp>> => {
-    let body = makeRequestBody(~fromBlock, ~toBlock)
-
-    let logger = Logging.createChildFrom(
-      ~logger,
-      ~params={
-        "logType": "HyperSync get block hash query",
-        "fromBlock": fromBlock,
-        "toBlock": toBlock,
-      },
-    )
-
-    let timerRef = Performance.now()
-    let maybeSuccessfulRes = switch await client.get(~query=body) {
-    | exception exn =>
-      reraisIfRateLimited(exn)
-      None
-    | res if res.nextBlock <= fromBlock => None
-    | res => Some(res)
-    }
-    requestStats
-    ->Array.push({Source.method: "getBlockHashes", seconds: timerRef->Performance.secondsSince})
-    ->ignore
-
-    // If the block is not found, retry the query. This can occur since replicas of hypersync might not have caught up yet
-    switch maybeSuccessfulRes {
-    | None => {
-        let delayMilliseconds = 100
-        logger->Logging.childInfo(
-          `Block #${fromBlock->Int.toString} not found in HyperSync. HyperSync has multiple instances and it's possible that they drift independently slightly from the head. Indexing should continue correctly after retrying the query in ${delayMilliseconds->Int.toString}ms.`,
-        )
-        await Time.resolvePromiseAfterDelay(~delayMilliseconds)
-        await queryBlockData(
-          ~client,
-          ~fromBlock,
-          ~toBlock,
-          ~sourceName,
-          ~chainId,
-          ~logger,
-          ~requestStats,
-        )
-      }
-    | Some(res) =>
-      switch res->convertResponse {
-      | Error(_) as err => err
-      | Ok(datas) if res.nextBlock <= toBlock => {
-          let restRes = await queryBlockData(
-            ~client,
-            ~fromBlock=res.nextBlock,
-            ~toBlock,
-            ~sourceName,
-            ~chainId,
-            ~logger,
-            ~requestStats,
-          )
-          restRes->Result.map(rest => datas->Array.concat(rest))
-        }
-      | Ok(_) as ok => ok
-      }
-    }
-  }
-
-  let queryBlockDataMulti = async (
-    ~client: HyperSyncClient.t,
-    ~blockNumbers,
-    ~sourceName,
-    ~chainId,
-    ~logger,
-  ): (queryResponse<array<ReorgDetection.blockDataWithTimestamp>>, array<Source.requestStat>) => {
-    let requestStats = []
-    let result = switch blockNumbers->Array.get(0) {
-    | None => Ok([])
-    | Some(firstBlock) => {
-        let fromBlock = ref(firstBlock)
-        let toBlock = ref(firstBlock)
-        let set = Utils.Set.make()
-        for idx in 0 to blockNumbers->Array.length - 1 {
-          let blockNumber = blockNumbers->Array.getUnsafe(idx)
-          if blockNumber < fromBlock.contents {
-            fromBlock := blockNumber
-          }
-          if blockNumber > toBlock.contents {
-            toBlock := blockNumber
-          }
-          set->Utils.Set.add(blockNumber)->ignore
-        }
-        if toBlock.contents - fromBlock.contents > 1000 {
-          JsError.throwWithMessage(
-            `Invalid block data request. Range of block numbers is too large. Max range is 1000. Requested range: ${fromBlock.contents->Int.toString}-${toBlock.contents->Int.toString}`,
-          )
-        }
-        let res = await queryBlockData(
-          ~fromBlock=fromBlock.contents,
-          ~toBlock=toBlock.contents,
-          ~client,
-          ~sourceName,
-          ~chainId,
-          ~logger,
-          ~requestStats,
-        )
-        let filtered = res->Result.map(datas => {
-          datas->Array.filter(data => set->Utils.Set.delete(data.blockNumber))
-        })
-        if set->Utils.Set.size > 0 {
-          JsError.throwWithMessage(
-            `Invalid response. Failed to get block data for block numbers: ${set
-              ->Utils.Set.toArray
-              ->Array.joinUnsafe(", ")}`,
-          )
-        }
-        filtered
-      }
-    }
-    (result, requestStats)
-  }
-}
-
-let queryBlockData = (~client, ~blockNumber, ~sourceName, ~chainId, ~logger) => {
-  let requestStats = []
-  BlockData.queryBlockData(
-    ~client,
-    ~fromBlock=blockNumber,
-    ~toBlock=blockNumber,
-    ~sourceName,
-    ~chainId,
-    ~logger,
-    ~requestStats,
-  )->Promise.thenResolve(res => (res->Result.map(res => res->Array.get(0)), requestStats))
-}
-let queryBlockDataMulti = BlockData.queryBlockDataMulti

package/src/sources/HyperSync.res.mjs

@@ -1,62 +1,89 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Time from "../Time.res.mjs";
-import * as Utils from "../Utils.res.mjs";
 import * as Source from "./Source.res.mjs";
-import * as Logging from "../Logging.res.mjs";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
-import * as Performance from "../bindings/Performance.res.mjs";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
-import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-function reraisIfRateLimited(exn) {
-  let e = Primitive_exceptions.internalToException(exn);
-  if (e.RE_EXN_ID !== "JsExn") {
-    return;
-  }
-  let msg = Stdlib_JsExn.message(e._1);
-  if (msg === undefined) {
-    return;
-  }
-  if (!msg.startsWith("RATE_LIMITED:")) {
-    return;
-  }
-  let resetMs = Stdlib_Option.getOr(Stdlib_Int.fromString(msg.slice(13, msg.length), undefined), 1000);
-  throw {
-    RE_EXN_ID: Source.RateLimited,
-    resetMs: resetMs,
-    Error: new Error()
-  };
-}
+let rateLimitedPrefix = "RATE_LIMITED:";
 
-let HyperSyncQueryError = /* @__PURE__ */Primitive_exceptions.create("HyperSync.HyperSyncQueryError");
+let behindHeadPrefix = "SOURCE_BEHIND_HEAD:";
 
-function queryErrorToMsq(e) {
-  let match = e._0;
-  return match.queryName + ` query failed due to unexpected missing params on response:
-      ` + match.missingParams.join(", ");
+function markerValue(msg, prefix) {
+  return Stdlib_Int.fromString(msg.slice(prefix.length, msg.length), undefined);
 }
 
-function mapExn(queryResponse) {
-  if (queryResponse.TAG === "Ok") {
-    return {
-      TAG: "Ok",
-      _0: queryResponse._0
-    };
+function mapNativeFailure(failure) {
+  let msg = failure.message;
+  if (msg !== undefined) {
+    if (msg.startsWith(rateLimitedPrefix)) {
+      return {
+        RE_EXN_ID: Source.RateLimited,
+        _1: {
+          resetMs: Stdlib_Option.getOr(markerValue(msg, rateLimitedPrefix), 1000),
+          requestStats: failure.requestStats
+        }
+      };
+    } else if (msg.startsWith(behindHeadPrefix)) {
+      return {
+        RE_EXN_ID: Source.SourceBehindHead,
+        blockNumber: Stdlib_Option.getOr(markerValue(msg, behindHeadPrefix), 0),
+        requestStats: failure.requestStats
+      };
+    } else {
+      return failure.cause;
+    }
   } else {
+    return failure.cause;
+  }
+}
+
+function mapNativeFailureExn(exn) {
+  return mapNativeFailure(Source.unpackNativeRequestFailure(exn));
+}
+
+function makeGetBlockHashes(query) {
+  return async (blockNumbers, param) => {
+    let match;
+    try {
+      let match$1 = await query(blockNumbers);
+      match = [
+        {
+          TAG: "Ok",
+          _0: match$1[0]
+        },
+        match$1[1]
+      ];
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      let failure = Source.unpackNativeRequestFailure(exn);
+      match = [
+        {
+          TAG: "Error",
+          _0: mapNativeFailure(failure)
+        },
+        failure.requestStats
+      ];
+    }
     return {
-      TAG: "Error",
-      _0: {
-        RE_EXN_ID: HyperSyncQueryError,
-        _1: queryResponse._0
-      }
+      result: match[0],
+      requestStats: match[1]
     };
+  };
+}
+
+function reraiseIfRecoverable(exn) {
+  let exn$1 = mapNativeFailure(Source.unpackNativeRequestFailure(exn));
+  if (exn$1.RE_EXN_ID === Source.RateLimited) {
+    throw exn$1;
+  }
+  if (exn$1.RE_EXN_ID !== Source.SourceBehindHead) {
+    return;
   }
+  throw exn$1;
 }
 
 let $$Error = /* @__PURE__ */Primitive_exceptions.create("HyperSync.GetLogs.Error");
@@ -95,7 +122,7 @@ async function query(client, fromBlock, toBlock, maxNumLogs, registrationIndexes
     match = await client.getEventItems(query$1, addressSet);
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
-    reraisIfRateLimited(exn);
+    reraiseIfRecoverable(exn);
     let missingParams = extractMissingParams(exn);
     if (missingParams !== undefined) {
       throw {
@@ -119,10 +146,8 @@ async function query(client, fromBlock, toBlock, maxNumLogs, registrationIndexes
   }
   return {
     items: res.items,
-    blocks: res.blocks,
     nextBlock: res.nextBlock,
     archiveHeight: Stdlib_Option.getOr(res.archiveHeight, 0),
-    rollbackGuard: res.rollbackGuard,
     transactionStore: match[1],
     blockStore: match[2]
   };
@@ -134,153 +159,11 @@ let GetLogs = {
   query: query
 };
 
-function makeRequestBody(fromBlock, toBlock) {
-  return {
-    fromBlock: fromBlock,
-    toBlock: toBlock + 1 | 0,
-    fieldSelection: {
-      block: [
-        "Number",
-        "Hash",
-        "Timestamp"
-      ]
-    },
-    includeAllBlocks: true
-  };
-}
-
-function convertResponse(res) {
-  return Utils.$$Array.transposeResults(res.data.blocks.map(block => {
-    let blockNumber = block.number;
-    if (blockNumber !== undefined) {
-      let blockHash = block.hash;
-      if (blockHash !== undefined) {
-        let blockTimestamp = block.timestamp;
-        if (blockTimestamp !== undefined) {
-          return {
-            TAG: "Ok",
-            _0: {
-              blockHash: blockHash,
-              blockNumber: blockNumber,
-              blockTimestamp: blockTimestamp
-            }
-          };
-        }
-      }
-    }
-    let missingParams = Stdlib_Array.filterMap([
-      Utils.Option.mapNone(block.number, "block.number"),
-      Utils.Option.mapNone(block.timestamp, "block.timestamp"),
-      Utils.Option.mapNone(block.hash, "block.hash")
-    ], p => p);
-    return {
-      TAG: "Error",
-      _0: {
-        TAG: "UnexpectedMissingParams",
-        _0: {
-          queryName: "query block data HyperSync",
-          missingParams: missingParams
-        }
-      }
-    };
-  }));
-}
-
-async function queryBlockData(client, fromBlock, toBlock, sourceName, chainId, logger, requestStats) {
-  let body = makeRequestBody(fromBlock, toBlock);
-  let logger$1 = Logging.createChildFrom(logger, {
-    logType: "HyperSync get block hash query",
-    fromBlock: fromBlock,
-    toBlock: toBlock
-  });
-  let timerRef = Performance.now();
-  let maybeSuccessfulRes;
-  let exit = 0;
-  let res;
-  try {
-    res = await client.get(body);
-    exit = 1;
-  } catch (raw_exn) {
-    let exn = Primitive_exceptions.internalToException(raw_exn);
-    reraisIfRateLimited(exn);
-    maybeSuccessfulRes = undefined;
-  }
-  if (exit === 1) {
-    maybeSuccessfulRes = res.nextBlock <= fromBlock ? undefined : res;
-  }
-  requestStats.push({
-    method: "getBlockHashes",
-    seconds: Performance.secondsSince(timerRef)
-  });
-  if (maybeSuccessfulRes !== undefined) {
-    let err = convertResponse(maybeSuccessfulRes);
-    if (err.TAG !== "Ok") {
-      return err;
-    }
-    if (maybeSuccessfulRes.nextBlock > toBlock) {
-      return err;
-    }
-    let datas = err._0;
-    let restRes = await queryBlockData(client, maybeSuccessfulRes.nextBlock, toBlock, sourceName, chainId, logger$1, requestStats);
-    return Stdlib_Result.map(restRes, rest => datas.concat(rest));
-  }
-  Logging.childInfo(logger$1, `Block #` + fromBlock.toString() + ` not found in HyperSync. HyperSync has multiple instances and it's possible that they drift independently slightly from the head. Indexing should continue correctly after retrying the query in ` + (100).toString() + `ms.`);
-  await Time.resolvePromiseAfterDelay(100);
-  return await queryBlockData(client, fromBlock, toBlock, sourceName, chainId, logger$1, requestStats);
-}
-
-async function queryBlockDataMulti(client, blockNumbers, sourceName, chainId, logger) {
-  let requestStats = [];
-  let firstBlock = blockNumbers[0];
-  let result;
-  if (firstBlock !== undefined) {
-    let fromBlock = firstBlock;
-    let toBlock = firstBlock;
-    let set = new Set();
-    for (let idx = 0, idx_finish = blockNumbers.length; idx < idx_finish; ++idx) {
-      let blockNumber = blockNumbers[idx];
-      if (blockNumber < fromBlock) {
-        fromBlock = blockNumber;
-      }
-      if (blockNumber > toBlock) {
-        toBlock = blockNumber;
-      }
-      set.add(blockNumber);
-    }
-    if ((toBlock - fromBlock | 0) > 1000) {
-      Stdlib_JsError.throwWithMessage(`Invalid block data request. Range of block numbers is too large. Max range is 1000. Requested range: ` + fromBlock.toString() + `-` + toBlock.toString());
-    }
-    let res = await queryBlockData(client, fromBlock, toBlock, sourceName, chainId, logger, requestStats);
-    let filtered = Stdlib_Result.map(res, datas => datas.filter(data => set.delete(data.blockNumber)));
-    if (set.size > 0) {
-      Stdlib_JsError.throwWithMessage(`Invalid response. Failed to get block data for block numbers: ` + Array.from(set).join(", "));
-    }
-    result = filtered;
-  } else {
-    result = {
-      TAG: "Ok",
-      _0: []
-    };
-  }
-  return [
-    result,
-    requestStats
-  ];
-}
-
-function queryBlockData$1(client, blockNumber, sourceName, chainId, logger) {
-  let requestStats = [];
-  return queryBlockData(client, blockNumber, blockNumber, sourceName, chainId, logger, requestStats).then(res => [
-    Stdlib_Result.map(res, res => res[0]),
-    requestStats
-  ]);
-}
-
 export {
-  queryErrorToMsq,
+  mapNativeFailure,
+  mapNativeFailureExn,
+  reraiseIfRecoverable,
+  makeGetBlockHashes,
   GetLogs,
-  queryBlockData$1 as queryBlockData,
-  queryBlockDataMulti,
-  mapExn,
 }
-/* Time Not a pure module */
+/* Source Not a pure module */

package/src/sources/HyperSync.resi

@@ -1,23 +1,23 @@
 type logsQueryPage = {
   items: array<HyperSyncClient.EventItems.item>,
-  blocks: array<HyperSyncClient.EventItems.blockHeader>,
   nextBlock: int,
   archiveHeight: int,
-  rollbackGuard: option<HyperSyncClient.ResponseTypes.rollbackGuard>,
   transactionStore: TransactionStore.t,
   blockStore: BlockStore.t,
 }
 
-type missingParams = {
-  queryName: string,
-  missingParams: array<string>,
-}
-
-type queryError = UnexpectedMissingParams(missingParams)
-
-let queryErrorToMsq: queryError => string
+// Map a native client's `PREFIX:<int>` failure marker onto the exception
+// SourceManager retries on (`RateLimited` / `SourceBehindHead`), falling back to
+// the original cause.
+let mapNativeFailure: Source.nativeRequestFailure => exn
+let mapNativeFailureExn: exn => exn
+let reraiseIfRecoverable: exn => unit
 
-type queryResponse<'a> = result<'a, queryError>
+// Wrap a native client's paginated block-hash query as a `Source.getBlockHashes`,
+// keeping the request timings whether it succeeds or fails.
+let makeGetBlockHashes: (
+  ~query: (~blockNumbers: array<int>) => promise<(BlockStore.t, array<Source.requestStat>)>,
+) => (~blockNumbers: array<int>, ~logger: Pino.t) => promise<Source.getBlockHashesResponse>
 
 module GetLogs: {
   type error =
@@ -38,27 +38,3 @@ module GetLogs: {
     ~clientFilteredContracts: option<array<string>>,
   ) => promise<logsQueryPage>
 }
-
-let queryBlockData: (
-  ~client: HyperSyncClient.t,
-  ~blockNumber: int,
-  ~sourceName: string,
-  ~chainId: ChainId.t,
-  ~logger: Pino.t,
-) => promise<(
-  queryResponse<option<ReorgDetection.blockDataWithTimestamp>>,
-  array<Source.requestStat>,
-)>
-
-let queryBlockDataMulti: (
-  ~client: HyperSyncClient.t,
-  ~blockNumbers: array<int>,
-  ~sourceName: string,
-  ~chainId: ChainId.t,
-  ~logger: Pino.t,
-) => promise<(
-  queryResponse<array<ReorgDetection.blockDataWithTimestamp>>,
-  array<Source.requestStat>,
-)>
-
-let mapExn: queryResponse<'a> => result<'a, exn>