envio 3.0.2 → 3.1.0-rc.1

package/src/sources/HyperFuelSource.res

@@ -225,7 +225,6 @@ let make = ({chain, endpointUrl}: options): t => {
     ~retry,
     ~logger,
   ) => {
-    let mkLogAndRaise = ErrorHandling.mkLogAndRaise(~logger, ...)
     let totalTimeRef = Hrtime.makeTimer()
 
     let selectionConfig = getSelectionConfig(selection)
@@ -299,55 +298,6 @@ let make = ({chain, endpointUrl}: options): t => {
     //In the query
     let heighestBlockQueried = pageUnsafe.nextBlock - 1
 
-    let lastBlockQueriedPromise = // switch pageUnsafe.rollbackGuard {
-    // //In the case a rollbackGuard is returned (this only happens at the head for unconfirmed blocks)
-    // //use these values
-    // | Some({blockNumber, timestamp, hash}) =>
-    //   {
-    //     ReorgDetection.blockNumber,
-    //     blockTimestamp: timestamp,
-    //     blockHash: hash,
-    //   }->Promise.resolve
-    // | None =>
-    //The optional block and timestamp of the last item returned by the query
-    //(Optional in the case that there are no logs returned in the query)
-    switch pageUnsafe.items->Belt.Array.get(pageUnsafe.items->Belt.Array.length - 1) {
-    | Some({block}) if block.height == heighestBlockQueried =>
-      //If the last log item in the current page is equal to the
-      //heighest block acounted for in the query. Simply return this
-      //value without making an extra query
-
-      (
-        {
-          blockNumber: block.height,
-          blockTimestamp: block.time,
-          blockHash: block.id,
-        }: ReorgDetection.blockDataWithTimestamp
-      )->Promise.resolve
-    //If it does not match it means that there were no matching logs in the last
-    //block so we should fetch the block data
-    | Some(_)
-    | None =>
-      //If there were no logs at all in the current page query then fetch the
-      //timestamp of the heighest block accounted for
-      HyperFuel.queryBlockData(~serverUrl=endpointUrl, ~blockNumber=heighestBlockQueried, ~logger)
-      ->Promise.thenResolve(res => {
-        switch res {
-        | Some(blockData) => blockData
-        | None =>
-          mkLogAndRaise(
-            Not_found,
-            ~msg=`Failure, blockData for block ${heighestBlockQueried->Int.toString} unexpectedly returned None`,
-          )
-        }
-      })
-      ->Promise.catch(exn => {
-        exn->mkLogAndRaise(
-          ~msg=`Failed to query blockData for block ${heighestBlockQueried->Int.toString}`,
-        )
-      })
-    }
-
     let parsingTimeRef = Hrtime.makeTimer()
 
     let parsedQueueItems = pageUnsafe.items->Array.map(item => {
@@ -463,11 +413,18 @@ let make = ({chain, endpointUrl}: options): t => {
 
     let parsingTimeElapsed = parsingTimeRef->Hrtime.timeSince->Hrtime.toSecondsFloat
 
-    let rangeLastBlock = await lastBlockQueriedPromise
+    // Fuel never rolls back on reorg, so block hashes here are purely informational
+    // for detect-only logging via ReorgDetection.
+    let blockHashes = pageUnsafe.items->Array.map(({block}) => {
+      ReorgDetection.blockNumber: block.height,
+      blockHash: block.id,
+    })
 
-    let reorgGuard: ReorgDetection.reorgGuard = {
-      rangeLastBlock: rangeLastBlock->ReorgDetection.generalizeBlockDataWithTimestamp,
-      prevRangeLastBlock: None,
+    let latestFetchedBlockTimestamp = switch pageUnsafe.items->Belt.Array.get(
+      pageUnsafe.items->Belt.Array.length - 1,
+    ) {
+    | Some({block}) if block.height == heighestBlockQueried => block.time
+    | _ => 0
     }
 
     let totalTimeElapsed = totalTimeRef->Hrtime.timeSince->Hrtime.toSecondsFloat
@@ -479,12 +436,12 @@ let make = ({chain, endpointUrl}: options): t => {
     }
 
     {
-      latestFetchedBlockTimestamp: rangeLastBlock.blockTimestamp,
+      latestFetchedBlockTimestamp,
       parsedQueueItems,
-      latestFetchedBlockNumber: rangeLastBlock.blockNumber,
+      latestFetchedBlockNumber: heighestBlockQueried,
       stats,
       knownHeight,
-      reorgGuard,
+      blockHashes,
       fromBlockQueried: fromBlock,
     }
   }
@@ -492,7 +449,7 @@ let make = ({chain, endpointUrl}: options): t => {
   let getBlockHashes = (~blockNumbers as _, ~logger as _) =>
     JsError.throwWithMessage("HyperFuel does not support getting block hashes")
 
-  let jsonApiClient = Rest.client(endpointUrl)
+  let jsonApiClient = EnvioApiClient.make(endpointUrl)
 
   {
     name,

package/src/sources/HyperFuelSource.res.mjs

@@ -11,8 +11,8 @@ import * as Prometheus from "../Prometheus.res.mjs";
 import * as EventRouter from "./EventRouter.res.mjs";
 import * as ErrorHandling from "../ErrorHandling.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as EnvioApiClient from "./EnvioApiClient.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
-import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 let EventRoutingFailed = /* @__PURE__ */Primitive_exceptions.create("HyperFuelSource.EventRoutingFailed");
@@ -182,7 +182,6 @@ function make(param) {
   let name = "HyperFuel";
   let getSelectionConfig = memoGetSelectionConfig(chain);
   let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, indexingAddresses, knownHeight, param, selection, retry, logger) => {
-    let mkLogAndRaise = (extra, extra$1) => ErrorHandling.mkLogAndRaise(logger, extra, extra$1);
     let totalTimeRef = Hrtime.makeTimer();
     let selectionConfig = getSelectionConfig(selection);
     let recieptsSelection = selectionConfig.getRecieptsSelection(addressesByContractName);
@@ -238,34 +237,6 @@ function make(param) {
     let pageFetchTime = Hrtime.toSecondsFloat(Hrtime.timeSince(startFetchingBatchTimeRef));
     let knownHeight$1 = pageUnsafe.archiveHeight;
     let heighestBlockQueried = pageUnsafe.nextBlock - 1 | 0;
-    let match = Belt_Array.get(pageUnsafe.items, pageUnsafe.items.length - 1 | 0);
-    let lastBlockQueriedPromise;
-    let exit = 0;
-    if (match !== undefined) {
-      let block = match.block;
-      if (block.height === heighestBlockQueried) {
-        lastBlockQueriedPromise = Promise.resolve({
-          blockHash: block.id,
-          blockNumber: block.height,
-          blockTimestamp: block.time
-        });
-      } else {
-        exit = 1;
-      }
-    } else {
-      exit = 1;
-    }
-    if (exit === 1) {
-      lastBlockQueriedPromise = Stdlib_Promise.$$catch(HyperFuel.queryBlockData(endpointUrl, heighestBlockQueried, logger).then(res => {
-        if (res !== undefined) {
-          return res;
-        } else {
-          return mkLogAndRaise(`Failure, blockData for block ` + heighestBlockQueried.toString() + ` unexpectedly returned None`, {
-            RE_EXN_ID: "Not_found"
-          });
-        }
-      }), exn => mkLogAndRaise(`Failed to query blockData for block ` + heighestBlockQueried.toString(), exn));
-    }
     let parsingTimeRef = Hrtime.makeTimer();
     let parsedQueueItems = pageUnsafe.items.map(item => {
       let block = item.block;
@@ -383,11 +354,21 @@ function make(param) {
       };
     });
     let parsingTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(parsingTimeRef));
-    let rangeLastBlock = await lastBlockQueriedPromise;
-    let reorgGuard = {
-      rangeLastBlock: rangeLastBlock,
-      prevRangeLastBlock: undefined
-    };
+    let blockHashes = pageUnsafe.items.map(param => {
+      let block = param.block;
+      return {
+        blockHash: block.id,
+        blockNumber: block.height
+      };
+    });
+    let match = Belt_Array.get(pageUnsafe.items, pageUnsafe.items.length - 1 | 0);
+    let latestFetchedBlockTimestamp;
+    if (match !== undefined) {
+      let block = match.block;
+      latestFetchedBlockTimestamp = block.height === heighestBlockQueried ? block.time : 0;
+    } else {
+      latestFetchedBlockTimestamp = 0;
+    }
     let totalTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(totalTimeRef));
     let stats_parsing$unknowntime$unknown$lpars$rpar = parsingTimeElapsed;
     let stats_page$unknownfetch$unknowntime$unknown$lpars$rpar = pageFetchTime;
@@ -398,16 +379,16 @@ function make(param) {
     };
     return {
       knownHeight: knownHeight$1,
-      reorgGuard: reorgGuard,
+      blockHashes: blockHashes,
       parsedQueueItems: parsedQueueItems,
       fromBlockQueried: fromBlock,
-      latestFetchedBlockNumber: rangeLastBlock.blockNumber,
-      latestFetchedBlockTimestamp: rangeLastBlock.blockTimestamp,
+      latestFetchedBlockNumber: heighestBlockQueried,
+      latestFetchedBlockTimestamp: latestFetchedBlockTimestamp,
       stats: stats
     };
   };
   let getBlockHashes = (param, param$1) => Stdlib_JsError.throwWithMessage("HyperFuel does not support getting block hashes");
-  let jsonApiClient = Rest.client(endpointUrl, undefined);
+  let jsonApiClient = EnvioApiClient.make(endpointUrl);
   return {
     name: name,
     sourceFor: "Sync",

package/src/sources/HyperSync.res

@@ -1,30 +1,26 @@
-module Log = {
-  type t = {
-    address: Address.t,
-    data: string,
-    topics: array<EvmTypes.Hex.t>,
-    logIndex: int,
+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}))
+    | _ => ()
+    }
+  | _ => ()
   }
 
-  let fieldNames = ["address", "data", "topics", "logIndex"]
-}
-
-type hyperSyncPage<'item> = {
-  items: array<'item>,
+type logsQueryPage = {
+  items: array<HyperSyncClient.EventItems.item>,
   nextBlock: int,
   archiveHeight: int,
   rollbackGuard: option<HyperSyncClient.ResponseTypes.rollbackGuard>,
-  events: array<HyperSyncClient.ResponseTypes.event>,
 }
 
-type logsQueryPageItem = {
-  log: Log.t,
-  block: HyperSyncClient.ResponseTypes.block,
-  transaction: Internal.eventTransaction,
-}
-
-type logsQueryPage = hyperSyncPage<logsQueryPageItem>
-
 type missingParams = {
   queryName: string,
   missingParams: array<string>,
@@ -74,94 +70,37 @@ module GetLogs = {
     fieldSelection,
   }
 
-  @inline
-  let addMissingParams = (acc, fieldNames, returnedObj, ~prefix) => {
-    if fieldNames->Utils.Array.notEmpty {
-      if !(returnedObj->Obj.magic) {
-        acc->Array.push(prefix)->ignore
-      } else {
-        for idx in 0 to fieldNames->Array.length - 1 {
-          let fieldName = fieldNames->Array.getUnsafe(idx)
-          switch returnedObj
-          ->(Utils.magic: 'a => dict<unknown>)
-          ->Utils.Dict.dangerouslyGetNonOption(fieldName) {
-          | Some(_) => ()
-          | None => acc->Array.push(prefix ++ "." ++ fieldName)->ignore
-          }
+  // Rust encodes structured failures as a JSON payload in the napi error's
+  // message: `{"kind":"MissingFields","fields":["block.timestamp", ...]}`.
+  // JSON.parse + shape check is the recovery protocol — no string-grepping
+  // on anyhow's Debug format.
+  let extractMissingParams = (exn: exn): option<array<string>> => {
+    let message = switch exn {
+    | JsExn(jsExn) => jsExn->JsExn.message
+    | _ => None
+    }
+    switch message {
+    | None => None
+    | Some(msg) =>
+      switch msg->JSON.parseOrThrow->JSON.Decode.object {
+      | exception _ => None
+      | None => None
+      | Some(obj) =>
+        switch (obj->Dict.get("kind"), obj->Dict.get("fields")) {
+        | (Some(String("MissingFields")), Some(Array(fields))) =>
+          Some(fields->Array.filterMap(JSON.Decode.string))
+        | _ => None
         }
       }
     }
   }
 
-  //Note this function can throw an error
-  let convertEvent = (
-    event: HyperSyncClient.ResponseTypes.event,
-    ~nonOptionalBlockFieldNames,
-    ~nonOptionalTransactionFieldNames,
-  ): logsQueryPageItem => {
-    let missingParams = []
-    missingParams->addMissingParams(Log.fieldNames, event.log, ~prefix="log")
-    missingParams->addMissingParams(nonOptionalBlockFieldNames, event.block, ~prefix="block")
-    missingParams->addMissingParams(
-      nonOptionalTransactionFieldNames,
-      event.transaction,
-      ~prefix="transaction",
-    )
-    if missingParams->Array.length > 0 {
-      throw(Error(UnexpectedMissingParams({missingParams: missingParams})))
-    }
-
-    //Topics can be nullable and still need to be filtered
-    let logUnsanitized: Log.t = event.log->(Utils.magic: HyperSyncClient.ResponseTypes.log => Log.t)
-    let topics = event.log.topics->Option.getUnsafe->Array.filterMap(Nullable.toOption)
-    let address = event.log.address->Option.getUnsafe
-    let log = {
-      ...logUnsanitized,
-      topics,
-      address,
-    }
-
-    {
-      log,
-      block: event.block->(
-        Utils.magic: option<
-          HyperSyncClient.ResponseTypes.block,
-        > => HyperSyncClient.ResponseTypes.block
-      ),
-      transaction: event.transaction->(
-        Utils.magic: option<HyperSyncClient.ResponseTypes.transaction> => Internal.eventTransaction
-      ),
-    }
-  }
-
-  let convertResponse = (
-    res: HyperSyncClient.ResponseTypes.eventResponse,
-    ~nonOptionalBlockFieldNames,
-    ~nonOptionalTransactionFieldNames,
-  ): logsQueryPage => {
-    let {nextBlock, archiveHeight, rollbackGuard} = res
-    let items =
-      res.data->Array.map(item =>
-        item->convertEvent(~nonOptionalBlockFieldNames, ~nonOptionalTransactionFieldNames)
-      )
-    let page: logsQueryPage = {
-      items,
-      nextBlock,
-      archiveHeight: archiveHeight->Option.getOr(0), //Archive Height is only None if height is 0
-      events: res.data,
-      rollbackGuard,
-    }
-    page
-  }
-
   let query = async (
     ~client: HyperSyncClient.t,
     ~fromBlock,
     ~toBlock,
     ~logSelections: array<LogSelection.t>,
     ~fieldSelection,
-    ~nonOptionalBlockFieldNames,
-    ~nonOptionalTransactionFieldNames,
   ): logsQueryPage => {
     let addressesWithTopics = logSelections->Array.flatMap(({addresses, topicSelections}) =>
       topicSelections->Array.map(({topic0, topic1, topic2, topic3}) => {
@@ -182,13 +121,26 @@ module GetLogs = {
       ~fieldSelection,
     )
 
-    let res = await client.getEvents(~query)
+    let res = switch await client.getEventItems(~query) {
+    | res => res
+    | exception exn =>
+      reraisIfRateLimited(exn)
+      switch extractMissingParams(exn) {
+      | Some(missingParams) => throw(Error(UnexpectedMissingParams({missingParams: missingParams})))
+      | None => throw(exn)
+      }
+    }
     if res.nextBlock <= fromBlock {
       // Might happen when /height response was from another instance of HyperSync
       throw(Error(WrongInstance))
     }
 
-    res->convertResponse(~nonOptionalBlockFieldNames, ~nonOptionalTransactionFieldNames)
+    {
+      items: res.items,
+      nextBlock: res.nextBlock,
+      archiveHeight: res.archiveHeight->Option.getOr(0), //Archive Height is only None if height is 0
+      rollbackGuard: res.rollbackGuard,
+    }
   }
 }
 
@@ -258,7 +210,9 @@ module BlockData = {
 
     Prometheus.SourceRequestCount.increment(~sourceName, ~chainId, ~method="getBlockHashes")
     let maybeSuccessfulRes = switch await client.get(~query=body) {
-    | exception _ => None
+    | exception exn =>
+      reraisIfRateLimited(exn)
+      None
     | res if res.nextBlock <= fromBlock => None
     | res => Some(res)
     }

package/src/sources/HyperSync.res.mjs

@@ -2,22 +2,38 @@
 
 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 Prometheus from "../Prometheus.res.mjs";
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+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 HyperSyncClient from "./HyperSyncClient.res.mjs";
-import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-let fieldNames = [
-  "address",
-  "data",
-  "topics",
-  "logIndex"
-];
+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 HyperSyncQueryError = /* @__PURE__ */Primitive_exceptions.create("HyperSync.HyperSyncQueryError");
 
@@ -55,7 +71,28 @@ function makeRequestBody(fromBlock, toBlockInclusive, addressesWithTopics, field
   };
 }
 
-async function query(client, fromBlock, toBlock, logSelections, fieldSelection, nonOptionalBlockFieldNames, nonOptionalTransactionFieldNames) {
+function extractMissingParams(exn) {
+  let message = exn.RE_EXN_ID === "JsExn" ? Stdlib_JsExn.message(exn._1) : undefined;
+  if (message === undefined) {
+    return;
+  }
+  let obj;
+  try {
+    obj = Stdlib_JSON.Decode.object(JSON.parse(message));
+  } catch (exn$1) {
+    return;
+  }
+  if (obj === undefined) {
+    return;
+  }
+  let match = obj["kind"];
+  let match$1 = obj["fields"];
+  if (match === "MissingFields" && Array.isArray(match$1)) {
+    return Stdlib_Array.filterMap(match$1, Stdlib_JSON.Decode.string);
+  }
+}
+
+async function query(client, fromBlock, toBlock, logSelections, fieldSelection) {
   let addressesWithTopics = logSelections.flatMap(param => {
     let addresses = param.addresses;
     return param.topicSelections.map(param => {
@@ -64,65 +101,14 @@ async function query(client, fromBlock, toBlock, logSelections, fieldSelection,
     });
   });
   let query$1 = makeRequestBody(fromBlock, toBlock, addressesWithTopics, fieldSelection);
-  let res = await client.getEvents(query$1);
-  if (res.nextBlock <= fromBlock) {
-    throw {
-      RE_EXN_ID: $$Error,
-      _1: "WrongInstance",
-      Error: new Error()
-    };
-  }
-  let items = res.data.map(item => {
-    let missingParams = [];
-    let returnedObj = item.log;
-    if (Utils.$$Array.notEmpty(fieldNames)) {
-      if (returnedObj) {
-        for (let idx = 0, idx_finish = fieldNames.length; idx < idx_finish; ++idx) {
-          let fieldName = fieldNames[idx];
-          let match = returnedObj[fieldName];
-          if (match !== undefined) {
-            
-          } else {
-            missingParams.push("log." + fieldName);
-          }
-        }
-      } else {
-        missingParams.push("log");
-      }
-    }
-    let returnedObj$1 = item.block;
-    if (Utils.$$Array.notEmpty(nonOptionalBlockFieldNames)) {
-      if (returnedObj$1) {
-        for (let idx$1 = 0, idx_finish$1 = nonOptionalBlockFieldNames.length; idx$1 < idx_finish$1; ++idx$1) {
-          let fieldName$1 = nonOptionalBlockFieldNames[idx$1];
-          let match$1 = returnedObj$1[fieldName$1];
-          if (match$1 !== undefined) {
-            
-          } else {
-            missingParams.push("block." + fieldName$1);
-          }
-        }
-      } else {
-        missingParams.push("block");
-      }
-    }
-    let returnedObj$2 = item.transaction;
-    if (Utils.$$Array.notEmpty(nonOptionalTransactionFieldNames)) {
-      if (returnedObj$2) {
-        for (let idx$2 = 0, idx_finish$2 = nonOptionalTransactionFieldNames.length; idx$2 < idx_finish$2; ++idx$2) {
-          let fieldName$2 = nonOptionalTransactionFieldNames[idx$2];
-          let match$2 = returnedObj$2[fieldName$2];
-          if (match$2 !== undefined) {
-            
-          } else {
-            missingParams.push("transaction." + fieldName$2);
-          }
-        }
-      } else {
-        missingParams.push("transaction");
-      }
-    }
-    if (missingParams.length !== 0) {
+  let res;
+  try {
+    res = await client.getEventItems(query$1);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    reraisIfRateLimited(exn);
+    let missingParams = extractMissingParams(exn);
+    if (missingParams !== undefined) {
       throw {
         RE_EXN_ID: $$Error,
         _1: {
@@ -132,35 +118,20 @@ async function query(client, fromBlock, toBlock, logSelections, fieldSelection,
         Error: new Error()
       };
     }
-    let logUnsanitized = item.log;
-    let topics = Stdlib_Array.filterMap(item.log.topics, prim => {
-      if (prim == null) {
-        return;
-      } else {
-        return Primitive_option.some(prim);
-      }
-    });
-    let address = item.log.address;
-    let log_data = logUnsanitized.data;
-    let log_logIndex = logUnsanitized.logIndex;
-    let log = {
-      address: address,
-      data: log_data,
-      topics: topics,
-      logIndex: log_logIndex
-    };
-    return {
-      log: log,
-      block: item.block,
-      transaction: item.transaction
+    throw exn;
+  }
+  if (res.nextBlock <= fromBlock) {
+    throw {
+      RE_EXN_ID: $$Error,
+      _1: "WrongInstance",
+      Error: new Error()
     };
-  });
+  }
   return {
-    items: items,
+    items: res.items,
     nextBlock: res.nextBlock,
     archiveHeight: Stdlib_Option.getOr(res.archiveHeight, 0),
-    rollbackGuard: res.rollbackGuard,
-    events: res.data
+    rollbackGuard: res.rollbackGuard
   };
 }
 
@@ -230,7 +201,9 @@ async function queryBlockData(client, fromBlock, toBlock, sourceName, chainId, l
   try {
     res = await client.get(body);
     exit = 1;
-  } catch (exn) {
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    reraisIfRateLimited(exn);
     maybeSuccessfulRes = undefined;
   }
   if (exit === 1) {
@@ -289,15 +262,13 @@ function queryBlockData$1(client, blockNumber, sourceName, chainId, logger) {
   return queryBlockData(client, blockNumber, blockNumber, sourceName, chainId, logger).then(res => Stdlib_Result.map(res, res => res[0]));
 }
 
-let Log = {};
-
 let GetLogs = {
   $$Error: $$Error,
+  extractMissingParams: extractMissingParams,
   query: query
 };
 
 export {
-  Log,
   queryErrorToMsq,
   GetLogs,
   queryBlockData$1 as queryBlockData,

package/src/sources/HyperSync.resi

@@ -1,28 +1,10 @@
-type hyperSyncPage<'item> = {
-  items: array<'item>,
+type logsQueryPage = {
+  items: array<HyperSyncClient.EventItems.item>,
   nextBlock: int,
   archiveHeight: int,
   rollbackGuard: option<HyperSyncClient.ResponseTypes.rollbackGuard>,
-  events: array<HyperSyncClient.ResponseTypes.event>,
 }
 
-module Log: {
-  type t = {
-    address: Address.t,
-    data: string,
-    topics: array<EvmTypes.Hex.t>,
-    logIndex: int,
-  }
-}
-
-type logsQueryPageItem = {
-  log: Log.t,
-  block: HyperSyncClient.ResponseTypes.block,
-  transaction: Internal.eventTransaction,
-}
-
-type logsQueryPage = hyperSyncPage<logsQueryPageItem>
-
 type missingParams = {
   queryName: string,
   missingParams: array<string>,
@@ -41,14 +23,14 @@ module GetLogs: {
 
   exception Error(error)
 
+  let extractMissingParams: exn => option<array<string>>
+
   let query: (
     ~client: HyperSyncClient.t,
     ~fromBlock: int,
     ~toBlock: option<int>,
     ~logSelections: array<LogSelection.t>,
     ~fieldSelection: HyperSyncClient.QueryTypes.fieldSelection,
-    ~nonOptionalBlockFieldNames: array<string>,
-    ~nonOptionalTransactionFieldNames: array<string>,
   ) => promise<logsQueryPage>
 }