envio 3.0.0-alpha.1 → 3.0.0-alpha.3

package/src/sources/HyperFuelSource.res.mjs

@@ -186,7 +186,7 @@ function make(param) {
   var endpointUrl = param.endpointUrl;
   var chain = param.chain;
   var getSelectionConfig = memoGetSelectionConfig(chain);
-  var getItemsOrThrow = async function (fromBlock, toBlock, addressesByContractName, indexingContracts, currentBlockHeight, param, selection, retry, logger) {
+  var getItemsOrThrow = async function (fromBlock, toBlock, addressesByContractName, indexingContracts, knownHeight, param, selection, retry, logger) {
     var mkLogAndRaise = function (extra, extra$1) {
       return ErrorHandling.mkLogAndRaise(logger, extra, extra$1);
     };
@@ -221,7 +221,7 @@ function make(param) {
               _1: {
                 TAG: "FailedGettingItems",
                 exn: null,
-                attemptedToBlock: Belt_Option.getWithDefault(toBlock, currentBlockHeight),
+                attemptedToBlock: Belt_Option.getWithDefault(toBlock, knownHeight),
                 retry: tmp
               },
               Error: new Error()
@@ -232,7 +232,7 @@ function make(param) {
             _1: {
               TAG: "FailedGettingItems",
               exn: error,
-              attemptedToBlock: Belt_Option.getWithDefault(toBlock, currentBlockHeight),
+              attemptedToBlock: Belt_Option.getWithDefault(toBlock, knownHeight),
               retry: {
                 TAG: "WithBackoff",
                 message: "Unexpected issue while fetching events from HyperFuel client. Attempt a retry.",
@@ -243,7 +243,7 @@ function make(param) {
           };
     }
     var pageFetchTime = Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(startFetchingBatchTimeRef)));
-    var currentBlockHeight$1 = pageUnsafe.archiveHeight;
+    var knownHeight$1 = pageUnsafe.archiveHeight;
     var heighestBlockQueried = pageUnsafe.nextBlock - 1 | 0;
     var match = Belt_Array.get(pageUnsafe.items, pageUnsafe.items.length - 1 | 0);
     var lastBlockQueriedPromise;
@@ -407,7 +407,7 @@ function make(param) {
       "page fetch time (ms)": stats_page$unknownfetch$unknowntime$unknown$lparms$rpar
     };
     return {
-            currentBlockHeight: currentBlockHeight$1,
+            knownHeight: knownHeight$1,
             reorgGuard: reorgGuard,
             parsedQueueItems: parsedQueueItems,
             fromBlockQueried: fromBlock,

package/src/sources/HyperSyncHeightStream.res

@@ -0,0 +1,179 @@
+/*
+Pure js implementation of the HyperSync height stream.
+*/
+
+type t = {
+  heightRef: ref<int>,
+  errorRef: ref<option<string>>,
+  timeoutIdRef: ref<Js.Global.timeoutId>,
+  eventsourceRef: ref<option<EventSource.t>>,
+}
+
+let make = (~hyperSyncUrl, ~apiToken) => {
+  /**
+  On every successful ping or height event, clear the timeout and set a new one.
+
+  if the timeout lapses, close and reconnect the EventSource.
+  */
+  let rec updateTimeoutId = (
+    ~eventsourceRef: ref<option<EventSource.t>>,
+    ~timeoutIdRef: ref<Js.Global.timeoutId>,
+    ~hyperSyncUrl,
+    ~apiToken,
+    ~heightRef: ref<int>,
+    ~errorRef: ref<option<string>>,
+  ) => {
+    timeoutIdRef.contents->Js.Global.clearTimeout
+
+    // Should receive a ping at least every 5s, so 15s is a safe margin
+    // for staleness to restart the EventSource connection
+    let staleTimeMillis = 15_000
+    let newTimeoutId = Js.Global.setTimeout(() => {
+      Logging.trace({
+        "msg": "Timeout fired for height stream",
+        "url": hyperSyncUrl,
+        "staleTimeMillis": staleTimeMillis,
+      })
+      refreshEventSource(
+        ~eventsourceRef,
+        ~hyperSyncUrl,
+        ~apiToken,
+        ~heightRef,
+        ~errorRef,
+        ~timeoutIdRef,
+      )
+    }, staleTimeMillis)
+
+    timeoutIdRef := newTimeoutId
+  }
+  and /**
+    Instantiate a new EventSource and set it to the shared refs.
+    Add the necessary event listeners, handle errors
+    and update the timeout.
+    */
+  refreshEventSource = (
+    ~eventsourceRef: ref<option<EventSource.t>>,
+    ~hyperSyncUrl,
+    ~apiToken,
+    ~heightRef: ref<int>,
+    ~errorRef: ref<option<string>>,
+    ~timeoutIdRef: ref<Js.Global.timeoutId>,
+  ) => {
+    // Close the old EventSource if it exists (on a new connection after timeout)
+    switch eventsourceRef.contents {
+    | Some(es) => es->EventSource.close
+    | None => ()
+    }
+
+    let userAgent = `hyperindex/${Utils.EnvioPackage.value.version}`
+    let es = EventSource.create(
+      ~url=`${hyperSyncUrl}/height/sse`,
+      ~options={
+        headers: Js.Dict.fromArray([
+          ("Authorization", `Bearer ${apiToken}`),
+          ("User-Agent", userAgent),
+        ]),
+      },
+    )
+
+    // Set the new EventSource to the shared ref
+    eventsourceRef := Some(es)
+    // Update the timeout in case connection goes stale
+    updateTimeoutId(~eventsourceRef, ~timeoutIdRef, ~hyperSyncUrl, ~apiToken, ~heightRef, ~errorRef)
+
+    es->EventSource.onopen(_ => {
+      Logging.trace({"msg": "SSE connection opened for height stream", "url": hyperSyncUrl})
+    })
+
+    es->EventSource.onerror(error => {
+      Logging.trace({
+        "msg": "EventSource error",
+        "error": error->Js.Exn.message,
+      })
+      // On errors, set the error ref
+      // so that getHeight can raise an error
+      errorRef :=
+        Some(error->Js.Exn.message->Belt.Option.getWithDefault("Unexpected no error.message"))
+    })
+
+    es->EventSource.addEventListener("ping", _event => {
+      // ping lets us know from the server that the connection is still alive
+      // and that the height hasn't updated for 5seconds
+      // update the timeout on each successful ping received
+      updateTimeoutId(
+        ~eventsourceRef,
+        ~timeoutIdRef,
+        ~hyperSyncUrl,
+        ~apiToken,
+        ~heightRef,
+        ~errorRef,
+      )
+      // reset the error ref, since we had a successful ping
+      errorRef := None
+    })
+
+    es->EventSource.addEventListener("height", event => {
+      switch event.data->Belt.Int.fromString {
+      | Some(height) =>
+        // On a successful height event, update the timeout
+        // and reset the error ref
+        updateTimeoutId(
+          ~eventsourceRef,
+          ~timeoutIdRef,
+          ~hyperSyncUrl,
+          ~apiToken,
+          ~heightRef,
+          ~errorRef,
+        )
+        errorRef := None
+        // Set the actual height ref
+        heightRef := height
+      | None =>
+        Logging.trace({"msg": "Height was not a number in event.data", "data": event.data})
+        errorRef := Some("Height was not a number in event.data")
+      }
+    })
+  }
+
+  // Refs used between the functions
+
+  let heightRef = ref(0)
+  let errorRef = ref(None)
+  let eventsourceRef = ref(None)
+  // Timeout doesn't do anything for initalization
+  let timeoutIdRef = ref(Js.Global.setTimeout(() => (), 0))
+  refreshEventSource(
+    ~eventsourceRef,
+    ~hyperSyncUrl,
+    ~apiToken,
+    ~heightRef,
+    ~errorRef,
+    ~timeoutIdRef,
+  )
+
+  {
+    heightRef,
+    errorRef,
+    timeoutIdRef,
+    eventsourceRef,
+  }
+}
+
+let getHeight = async (t: t) => {
+  while t.heightRef.contents == 0 && t.errorRef.contents == None {
+    // Poll internally until height is over 0
+    await Utils.delay(200)
+  }
+  switch t.errorRef.contents {
+  | None => t.heightRef.contents
+  | Some(error) => Js.Exn.raiseError(error)
+  }
+}
+
+let close = t => {
+  t.timeoutIdRef.contents->Js.Global.clearTimeout
+  switch t.eventsourceRef.contents {
+  | Some(es) => es->EventSource.close
+  | None => ()
+  }
+}

package/src/sources/HyperSyncHeightStream.res.mjs

@@ -0,0 +1,127 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "../Utils.res.mjs";
+import * as Js_exn from "rescript/lib/es6/js_exn.js";
+import * as Js_dict from "rescript/lib/es6/js_dict.js";
+import * as Logging from "../Logging.res.mjs";
+import * as Belt_Int from "rescript/lib/es6/belt_Int.js";
+import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
+import * as Caml_option from "rescript/lib/es6/caml_option.js";
+import * as Eventsource from "eventsource";
+
+function make(hyperSyncUrl, apiToken) {
+  var updateTimeoutId = function (eventsourceRef, timeoutIdRef, hyperSyncUrl, apiToken, heightRef, errorRef) {
+    clearTimeout(timeoutIdRef.contents);
+    var newTimeoutId = setTimeout((function () {
+            Logging.trace({
+                  msg: "Timeout fired for height stream",
+                  url: hyperSyncUrl,
+                  staleTimeMillis: 15000
+                });
+            refreshEventSource(eventsourceRef, hyperSyncUrl, apiToken, heightRef, errorRef, timeoutIdRef);
+          }), 15000);
+    timeoutIdRef.contents = newTimeoutId;
+  };
+  var refreshEventSource = function (eventsourceRef, hyperSyncUrl, apiToken, heightRef, errorRef, timeoutIdRef) {
+    var es = eventsourceRef.contents;
+    if (es !== undefined) {
+      Caml_option.valFromOption(es).close();
+    }
+    var userAgent = "hyperindex/" + Utils.EnvioPackage.value.version;
+    var es$1 = new Eventsource.EventSource(hyperSyncUrl + "/height/sse", {
+          headers: Js_dict.fromArray([
+                [
+                  "Authorization",
+                  "Bearer " + apiToken
+                ],
+                [
+                  "User-Agent",
+                  userAgent
+                ]
+              ])
+        });
+    eventsourceRef.contents = Caml_option.some(es$1);
+    updateTimeoutId(eventsourceRef, timeoutIdRef, hyperSyncUrl, apiToken, heightRef, errorRef);
+    es$1.onopen = (function () {
+        Logging.trace({
+              msg: "SSE connection opened for height stream",
+              url: hyperSyncUrl
+            });
+      });
+    es$1.onerror = (function (error) {
+        Logging.trace({
+              msg: "EventSource error",
+              error: error.message
+            });
+        errorRef.contents = Belt_Option.getWithDefault(error.message, "Unexpected no error.message");
+      });
+    es$1.addEventListener("ping", (function (_event) {
+            updateTimeoutId(eventsourceRef, timeoutIdRef, hyperSyncUrl, apiToken, heightRef, errorRef);
+            errorRef.contents = undefined;
+          }));
+    es$1.addEventListener("height", (function ($$event) {
+            var height = Belt_Int.fromString($$event.data);
+            if (height !== undefined) {
+              updateTimeoutId(eventsourceRef, timeoutIdRef, hyperSyncUrl, apiToken, heightRef, errorRef);
+              errorRef.contents = undefined;
+              heightRef.contents = height;
+            } else {
+              Logging.trace({
+                    msg: "Height was not a number in event.data",
+                    data: $$event.data
+                  });
+              errorRef.contents = "Height was not a number in event.data";
+            }
+          }));
+  };
+  var heightRef = {
+    contents: 0
+  };
+  var errorRef = {
+    contents: undefined
+  };
+  var eventsourceRef = {
+    contents: undefined
+  };
+  var timeoutIdRef = {
+    contents: setTimeout((function () {
+            
+          }), 0)
+  };
+  refreshEventSource(eventsourceRef, hyperSyncUrl, apiToken, heightRef, errorRef, timeoutIdRef);
+  return {
+          heightRef: heightRef,
+          errorRef: errorRef,
+          timeoutIdRef: timeoutIdRef,
+          eventsourceRef: eventsourceRef
+        };
+}
+
+async function getHeight(t) {
+  while(t.heightRef.contents === 0 && t.errorRef.contents === undefined) {
+    await Utils.delay(200);
+  };
+  var error = t.errorRef.contents;
+  if (error !== undefined) {
+    return Js_exn.raiseError(error);
+  } else {
+    return t.heightRef.contents;
+  }
+}
+
+function close(t) {
+  clearTimeout(t.timeoutIdRef.contents);
+  var es = t.eventsourceRef.contents;
+  if (es !== undefined) {
+    Caml_option.valFromOption(es).close();
+    return ;
+  }
+  
+}
+
+export {
+  make ,
+  getHeight ,
+  close ,
+}
+/* Utils Not a pure module */

package/src/sources/HyperSyncSource.res

@@ -159,63 +159,6 @@ type options = {
   enableQueryCaching: bool,
 }
 
-module HeightState: {
-  type t
-  let make: (HyperSyncClient.t, ~chainId: int) => Promise.t<t>
-  let getHeight: t => Promise.t<int>
-} = {
-  open HyperSyncClient
-  type t = {
-    heightStream: HeightStream.t,
-    mutable currentHeight: int,
-    mutable errMessage: option<string>,
-  }
-
-  let makeInternal = async (client: HyperSyncClient.t) => {
-    currentHeight: 0,
-    heightStream: await client.streamHeight(),
-    errMessage: None,
-  }
-
-  let start = async (state: t, ~chainId) => {
-    while true {
-      let height = await state.heightStream.recv()
-      switch height {
-      | Height({height}) => state.currentHeight = height
-      | Connected =>
-        Logging.trace({"msg": "HyperSync height stream is connected", "chainId": chainId})
-        state.errMessage = None
-      | Reconnecting({delayMillis, errorMsg}) =>
-        Logging.trace({
-          "msg": "HyperSync height stream is reconnecting",
-          "err": errorMsg,
-          "delayMillis": delayMillis,
-          "chainId": chainId,
-        })
-        state.errMessage = Some(errorMsg)
-      }
-    }
-  }
-
-  let make = async (client: HyperSyncClient.t, ~chainId) => {
-    let state = await makeInternal(client)
-    let _async = state->start(~chainId)
-    state
-  }
-
-  let getHeight = async (state: t) => {
-    while state.currentHeight == 0 && state.errMessage->Belt.Option.isNone {
-      // Just poll internally until its no longer 0
-      await Utils.delay(200)
-    }
-
-    switch state.errMessage {
-    | Some(errMessage) => Js.Exn.raiseError(errMessage)
-    | None => state.currentHeight
-    }
-  }
-}
-
 let make = (
   {
     contracts,
@@ -306,7 +249,7 @@ let make = (
     ~toBlock,
     ~addressesByContractName,
     ~indexingContracts,
-    ~currentBlockHeight,
+    ~knownHeight,
     ~partitionId as _,
     ~selection,
     ~retry,
@@ -339,7 +282,7 @@ let make = (
         Source.GetItemsError(
           Source.FailedGettingItems({
             exn: %raw(`null`),
-            attemptedToBlock: toBlock->Option.getWithDefault(currentBlockHeight),
+            attemptedToBlock: toBlock->Option.getWithDefault(knownHeight),
             retry: switch error {
             | WrongInstance =>
               let backoffMillis = switch retry {
@@ -365,7 +308,7 @@ let make = (
         Source.GetItemsError(
           Source.FailedGettingItems({
             exn,
-            attemptedToBlock: toBlock->Option.getWithDefault(currentBlockHeight),
+            attemptedToBlock: toBlock->Option.getWithDefault(knownHeight),
             retry: WithBackoff({
               message: `Unexpected issue while fetching events from HyperSync client. Attempt a retry.`,
               backoffMillis: switch retry {
@@ -382,7 +325,7 @@ let make = (
       startFetchingBatchTimeRef->Hrtime.timeSince->Hrtime.toMillis->Hrtime.intFromMillis
 
     //set height and next from block
-    let currentBlockHeight = pageUnsafe.archiveHeight
+    let knownHeight = pageUnsafe.archiveHeight
 
     //The heighest (biggest) blocknumber that was accounted for in
     //Our query. Not necessarily the blocknumber of the last log returned
@@ -594,7 +537,7 @@ let make = (
       parsedQueueItems,
       latestFetchedBlockNumber: rangeLastBlock.blockNumber,
       stats,
-      currentBlockHeight,
+      knownHeight,
       reorgGuard,
       fromBlockQueried: fromBlock,
     }
@@ -610,7 +553,7 @@ let make = (
 
   let malformedTokenMessage = `Your token is malformed. For more info: https://docs.envio.dev/docs/HyperSync/api-tokens.`
 
-  let heightStatePromise = HeightState.make(client, ~chainId=chain->ChainMap.Chain.toChainId)
+  let heightStream = HyperSyncHeightStream.make(~hyperSyncUrl=endpointUrl, ~apiToken)
 
   {
     name,
@@ -620,8 +563,7 @@ let make = (
     poweredByHyperSync: true,
     getBlockHashes,
     getHeightOrThrow: async () => {
-      let heightState = await heightStatePromise
-      try await heightState->HeightState.getHeight catch {
+      try await heightStream->HyperSyncHeightStream.getHeight catch {
       | Js.Exn.Error(exn)
         if exn
         ->Js.Exn.message

package/src/sources/HyperSyncSource.res.mjs

@@ -16,6 +16,7 @@ import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
 import * as HyperSyncClient from "./HyperSyncClient.res.mjs";
 import * as Caml_splice_call from "rescript/lib/es6/caml_splice_call.js";
 import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as HyperSyncHeightStream from "./HyperSyncHeightStream.res.mjs";
 
 function getSelectionConfig(selection, chain) {
   var nonOptionalBlockFieldNames = new Set();
@@ -120,62 +121,7 @@ function memoGetSelectionConfig(chain) {
   };
 }
 
-async function makeInternal(client) {
-  return {
-          heightStream: await client.streamHeight(),
-          currentHeight: 0,
-          errMessage: undefined
-        };
-}
-
-async function start(state, chainId) {
-  while(true) {
-    var height = await state.heightStream.recv();
-    if (typeof height !== "object") {
-      Logging.trace({
-            msg: "HyperSync height stream is connected",
-            chainId: chainId
-          });
-      state.errMessage = undefined;
-    } else if (height.type === "Height") {
-      state.currentHeight = height.height;
-    } else {
-      var errorMsg = height.errorMsg;
-      Logging.trace({
-            msg: "HyperSync height stream is reconnecting",
-            err: errorMsg,
-            delayMillis: height.delayMillis,
-            chainId: chainId
-          });
-      state.errMessage = errorMsg;
-    }
-  };
-}
-
-async function make(client, chainId) {
-  var state = await makeInternal(client);
-  start(state, chainId);
-  return state;
-}
-
-async function getHeight(state) {
-  while(state.currentHeight === 0 && Belt_Option.isNone(state.errMessage)) {
-    await Utils.delay(200);
-  };
-  var errMessage = state.errMessage;
-  if (errMessage !== undefined) {
-    return Js_exn.raiseError(errMessage);
-  } else {
-    return state.currentHeight;
-  }
-}
-
-var HeightState = {
-  make: make,
-  getHeight: getHeight
-};
-
-function make$1(param) {
+function make(param) {
   var lowercaseAddresses = param.lowercaseAddresses;
   var eventRouter = param.eventRouter;
   var shouldUseHypersyncClientDecoder = param.shouldUseHypersyncClientDecoder;
@@ -233,7 +179,7 @@ function make$1(param) {
   Belt_Array.forEach(param.contracts, (function (contract) {
           contractNameAbiMapping[contract.name] = contract.abi;
         }));
-  var getItemsOrThrow = async function (fromBlock, toBlock, addressesByContractName, indexingContracts, currentBlockHeight, param, selection, retry, logger) {
+  var getItemsOrThrow = async function (fromBlock, toBlock, addressesByContractName, indexingContracts, knownHeight, param, selection, retry, logger) {
     var mkLogAndRaise = function (extra, extra$1) {
       return ErrorHandling.mkLogAndRaise(logger, extra, extra$1);
     };
@@ -275,7 +221,7 @@ function make$1(param) {
               _1: {
                 TAG: "FailedGettingItems",
                 exn: null,
-                attemptedToBlock: Belt_Option.getWithDefault(toBlock, currentBlockHeight),
+                attemptedToBlock: Belt_Option.getWithDefault(toBlock, knownHeight),
                 retry: tmp
               },
               Error: new Error()
@@ -286,7 +232,7 @@ function make$1(param) {
             _1: {
               TAG: "FailedGettingItems",
               exn: error,
-              attemptedToBlock: Belt_Option.getWithDefault(toBlock, currentBlockHeight),
+              attemptedToBlock: Belt_Option.getWithDefault(toBlock, knownHeight),
               retry: {
                 TAG: "WithBackoff",
                 message: "Unexpected issue while fetching events from HyperSync client. Attempt a retry.",
@@ -297,7 +243,7 @@ function make$1(param) {
           };
     }
     var pageFetchTime = Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(startFetchingBatchTimeRef)));
-    var currentBlockHeight$1 = pageUnsafe.archiveHeight;
+    var knownHeight$1 = pageUnsafe.archiveHeight;
     var heighestBlockQueried = pageUnsafe.nextBlock - 1 | 0;
     var match = pageUnsafe.rollbackGuard;
     var lastBlockQueriedPromise;
@@ -425,7 +371,7 @@ function make$1(param) {
       "page fetch time (ms)": stats_page$unknownfetch$unknowntime$unknown$lparms$rpar
     };
     return {
-            currentBlockHeight: currentBlockHeight$1,
+            knownHeight: knownHeight$1,
             reorgGuard: reorgGuard,
             parsedQueueItems: parsedQueueItems,
             fromBlockQueried: fromBlock,
@@ -437,7 +383,7 @@ function make$1(param) {
   var getBlockHashes = function (blockNumbers, logger) {
     return HyperSync.queryBlockDataMulti(endpointUrl, apiToken, blockNumbers, logger).then(HyperSync.mapExn);
   };
-  var heightStatePromise = make(client, chain);
+  var heightStream = HyperSyncHeightStream.make(endpointUrl, apiToken);
   return {
           name: "HyperSync",
           sourceFor: "Sync",
@@ -446,9 +392,8 @@ function make$1(param) {
           pollingInterval: 32,
           getBlockHashes: getBlockHashes,
           getHeightOrThrow: (async function () {
-              var heightState = await heightStatePromise;
               try {
-                return await getHeight(heightState);
+                return await HyperSyncHeightStream.getHeight(heightStream);
               }
               catch (raw_exn){
                 var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
@@ -472,7 +417,6 @@ function make$1(param) {
 export {
   getSelectionConfig ,
   memoGetSelectionConfig ,
-  HeightState ,
-  make$1 as make,
+  make ,
 }
 /* Viem Not a pure module */

package/src/sources/RpcSource.res

@@ -601,7 +601,7 @@ let make = (
     ~toBlock,
     ~addressesByContractName,
     ~indexingContracts,
-    ~currentBlockHeight,
+    ~knownHeight,
     ~partitionId,
     ~selection: FetchState.selection,
     ~retry as _,
@@ -621,8 +621,8 @@ let make = (
 
     // Always have a toBlock for an RPC worker
     let toBlock = switch toBlock {
-    | Some(toBlock) => Pervasives.min(toBlock, currentBlockHeight)
-    | None => currentBlockHeight
+    | Some(toBlock) => Pervasives.min(toBlock, knownHeight)
+    | None => knownHeight
     }
 
     let suggestedToBlock = Pervasives.min(fromBlock + suggestedBlockInterval - 1, toBlock)
@@ -874,7 +874,7 @@ let make = (
       stats: {
         totalTimeElapsed: totalTimeElapsed,
       },
-      currentBlockHeight,
+      knownHeight,
       reorgGuard,
       fromBlockQueried: fromBlock,
     }

package/src/sources/RpcSource.res.mjs

@@ -604,11 +604,11 @@ function make(param) {
       return HyperSyncClient.Decoder.fromSignatures(allEventSignatures);
     }
   };
-  var getItemsOrThrow = async function (fromBlock, toBlock, addressesByContractName, indexingContracts, currentBlockHeight, partitionId, selection, param, param$1) {
+  var getItemsOrThrow = async function (fromBlock, toBlock, addressesByContractName, indexingContracts, knownHeight, partitionId, selection, param, param$1) {
     var startFetchingBatchTimeRef = Hrtime.makeTimer();
     var maxSuggestedBlockInterval = mutSuggestedBlockIntervals[maxSuggestedBlockIntervalKey];
     var suggestedBlockInterval = maxSuggestedBlockInterval !== undefined ? maxSuggestedBlockInterval : Belt_Option.getWithDefault(mutSuggestedBlockIntervals[partitionId], syncConfig.initialBlockInterval);
-    var toBlock$1 = toBlock !== undefined && toBlock < currentBlockHeight ? toBlock : currentBlockHeight;
+    var toBlock$1 = toBlock !== undefined && toBlock < knownHeight ? toBlock : knownHeight;
     var suggestedToBlock = Caml.int_max(Caml.int_min((fromBlock + suggestedBlockInterval | 0) - 1 | 0, toBlock$1), fromBlock);
     var firstBlockParentPromise = fromBlock > 0 ? LazyLoader.get(blockLoader.contents, fromBlock - 1 | 0).then(function (res) {
             return res;
@@ -785,7 +785,7 @@ function make(param) {
       prevRangeLastBlock: reorgGuard_prevRangeLastBlock
     };
     return {
-            currentBlockHeight: currentBlockHeight,
+            knownHeight: knownHeight,
             reorgGuard: reorgGuard,
             parsedQueueItems: parsedQueueItems,
             fromBlockQueried: fromBlock,