envio 3.0.0-alpha.2 → 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/HyperSyncSource.res

@@ -249,7 +249,7 @@ let make = (
     ~toBlock,
     ~addressesByContractName,
     ~indexingContracts,
-    ~currentBlockHeight,
+    ~knownHeight,
     ~partitionId as _,
     ~selection,
     ~retry,
@@ -282,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 {
@@ -308,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 {
@@ -325,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
@@ -537,7 +537,7 @@ let make = (
       parsedQueueItems,
       latestFetchedBlockNumber: rangeLastBlock.blockNumber,
       stats,
-      currentBlockHeight,
+      knownHeight,
       reorgGuard,
       fromBlockQueried: fromBlock,
     }

package/src/sources/HyperSyncSource.res.mjs

@@ -179,7 +179,7 @@ function make(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);
     };
@@ -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 HyperSync 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 = pageUnsafe.rollbackGuard;
     var lastBlockQueriedPromise;
@@ -371,7 +371,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/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,

package/src/sources/Solana.res

@@ -0,0 +1,59 @@
+@get external getNumber: Internal.eventBlock => int = "height"
+@get external getTimestamp: Internal.eventBlock => int = "time"
+@get external getId: Internal.eventBlock => string = "hash"
+
+let cleanUpRawEventFieldsInPlace: Js.Json.t => unit = %raw(`fields => {
+    delete fields.hash
+    delete fields.height
+    delete fields.time
+  }`)
+
+let ecosystem: Ecosystem.t = {
+  name: Solana,
+  blockFields: ["slot"],
+  transactionFields: [],
+  blockNumberName: "height",
+  blockTimestampName: "time",
+  blockHashName: "hash",
+  getNumber,
+  getTimestamp,
+  getId,
+  cleanUpRawEventFieldsInPlace,
+}
+
+module GetFinalizedSlot = {
+  let route = Rpc.makeRpcRoute(
+    "getSlot",
+    S.tuple(s => {
+      s.tag(0, {"commitment": "finalized"})
+      ()
+    }),
+    S.int,
+  )
+}
+
+let makeRPCSource = (~chain, ~rpc: string): Source.t => {
+  let client = Rest.client(rpc)
+
+  {
+    name: "Solana",
+    sourceFor: Sync,
+    chain,
+    poweredByHyperSync: false,
+    pollingInterval: 10_000,
+    getBlockHashes: (~blockNumbers as _, ~logger as _) =>
+      Js.Exn.raiseError("Solana does not support getting block hashes"),
+    getHeightOrThrow: () => GetFinalizedSlot.route->Rest.fetch((), ~client),
+    getItemsOrThrow: (
+      ~fromBlock as _,
+      ~toBlock as _,
+      ~addressesByContractName as _,
+      ~indexingContracts as _,
+      ~knownHeight as _,
+      ~partitionId as _,
+      ~selection as _,
+      ~retry as _,
+      ~logger as _,
+    ) => Js.Exn.raiseError("Solana does not support getting items"),
+  }
+}

package/src/sources/Solana.res.mjs

@@ -0,0 +1,79 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Rpc from "./Rpc.res.mjs";
+import * as Rest from "../vendored/Rest.res.mjs";
+import * as Js_exn from "rescript/lib/es6/js_exn.js";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+var cleanUpRawEventFieldsInPlace = (fields => {
+    delete fields.hash
+    delete fields.height
+    delete fields.time
+  });
+
+var ecosystem_blockFields = ["slot"];
+
+var ecosystem_transactionFields = [];
+
+function ecosystem_getNumber(prim) {
+  return prim.height;
+}
+
+function ecosystem_getTimestamp(prim) {
+  return prim.time;
+}
+
+function ecosystem_getId(prim) {
+  return prim.hash;
+}
+
+var ecosystem = {
+  name: "solana",
+  blockFields: ecosystem_blockFields,
+  transactionFields: ecosystem_transactionFields,
+  blockNumberName: "height",
+  blockTimestampName: "time",
+  blockHashName: "hash",
+  getNumber: ecosystem_getNumber,
+  getTimestamp: ecosystem_getTimestamp,
+  getId: ecosystem_getId,
+  cleanUpRawEventFieldsInPlace: cleanUpRawEventFieldsInPlace
+};
+
+var route = Rpc.makeRpcRoute("getSlot", S$RescriptSchema.tuple(function (s) {
+          s.tag(0, {
+                commitment: "finalized"
+              });
+        }), S$RescriptSchema.$$int);
+
+var GetFinalizedSlot = {
+  route: route
+};
+
+function makeRPCSource(chain, rpc) {
+  var client = Rest.client(rpc, undefined);
+  return {
+          name: "Solana",
+          sourceFor: "Sync",
+          chain: chain,
+          poweredByHyperSync: false,
+          pollingInterval: 10000,
+          getBlockHashes: (function (param, param$1) {
+              return Js_exn.raiseError("Solana does not support getting block hashes");
+            }),
+          getHeightOrThrow: (function () {
+              return Rest.$$fetch(route, undefined, client);
+            }),
+          getItemsOrThrow: (function (param, param$1, param$2, param$3, param$4, param$5, param$6, param$7, param$8) {
+              return Js_exn.raiseError("Solana does not support getting items");
+            })
+        };
+}
+
+export {
+  cleanUpRawEventFieldsInPlace ,
+  ecosystem ,
+  GetFinalizedSlot ,
+  makeRPCSource ,
+}
+/* route Not a pure module */

package/src/sources/Source.res

@@ -11,7 +11,7 @@ type blockRangeFetchStats = {
 Thes response returned from a block range fetch
 */
 type blockRangeFetchResponse = {
-  currentBlockHeight: int,
+  knownHeight: int,
   reorgGuard: ReorgDetection.reorgGuard,
   parsedQueueItems: array<Internal.item>,
   fromBlockQueried: int,
@@ -50,7 +50,7 @@ type t = {
     ~toBlock: option<int>,
     ~addressesByContractName: dict<array<Address.t>>,
     ~indexingContracts: dict<Internal.indexingContract>,
-    ~currentBlockHeight: int,
+    ~knownHeight: int,
     ~partitionId: string,
     ~selection: FetchState.selection,
     ~retry: int,

package/src/sources/SourceManager.res

@@ -92,7 +92,6 @@ let trackNewStatus = (sourceManager: t, ~newStatus) => {
 let fetchNext = async (
   sourceManager: t,
   ~fetchState: FetchState.t,
-  ~currentBlockHeight,
   ~executeQuery,
   ~waitForNewBlock,
   ~onNewBlock,
@@ -100,13 +99,14 @@ let fetchNext = async (
 ) => {
   let {maxPartitionConcurrency} = sourceManager
 
-  switch fetchState->FetchState.getNextQuery(
+  let nextQuery = fetchState->FetchState.getNextQuery(
     ~concurrencyLimit={
       maxPartitionConcurrency - sourceManager.fetchingPartitionsCount
     },
-    ~currentBlockHeight,
     ~stateId,
-  ) {
+  )
+
+  switch nextQuery {
   | ReachedMaxConcurrency
   | NothingToQuery => ()
   | WaitingForNewBlock =>
@@ -116,12 +116,12 @@ let fetchNext = async (
     | None =>
       sourceManager->trackNewStatus(~newStatus=WaitingForNewBlock)
       sourceManager.waitingForNewBlockStateId = Some(stateId)
-      let currentBlockHeight = await waitForNewBlock(~currentBlockHeight)
+      let knownHeight = await waitForNewBlock(~knownHeight=fetchState.knownHeight)
       switch sourceManager.waitingForNewBlockStateId {
       | Some(waitingStateId) if waitingStateId === stateId => {
           sourceManager->trackNewStatus(~newStatus=Idle)
           sourceManager.waitingForNewBlockStateId = None
-          onNewBlock(~currentBlockHeight)
+          onNewBlock(~knownHeight)
         }
       | Some(_) // Don't reset it if we are waiting for another state
       | None => ()
@@ -162,14 +162,14 @@ type status = Active | Stalled | Done
 let getSourceNewHeight = async (
   sourceManager,
   ~source: Source.t,
-  ~currentBlockHeight,
+  ~knownHeight,
   ~status: ref<status>,
   ~logger,
 ) => {
   let newHeight = ref(0)
   let retry = ref(0)
 
-  while newHeight.contents <= currentBlockHeight && status.contents !== Done {
+  while newHeight.contents <= knownHeight && status.contents !== Done {
     try {
       // Use to detect if the source is taking too long to respond
       let endTimer = Prometheus.SourceGetHeightDuration.startTimer({
@@ -180,7 +180,7 @@ let getSourceNewHeight = async (
       endTimer()
 
       newHeight := height
-      if height <= currentBlockHeight {
+      if height <= knownHeight {
         retry := 0
         // Slowdown polling when the chain isn't progressing
         let pollingInterval = if status.contents === Stalled {
@@ -211,35 +211,35 @@ let getSourceNewHeight = async (
 }
 
 // Polls for a block height greater than the given block number to ensure a new block is available for indexing.
-let waitForNewBlock = async (sourceManager: t, ~currentBlockHeight) => {
+let waitForNewBlock = async (sourceManager: t, ~knownHeight) => {
   let {sources} = sourceManager
 
   let logger = Logging.createChild(
     ~params={
       "chainId": sourceManager.activeSource.chain->ChainMap.Chain.toChainId,
-      "currentBlockHeight": currentBlockHeight,
+      "knownHeight": knownHeight,
     },
   )
   logger->Logging.childTrace("Initiating check for new blocks.")
 
   // Only include Live sources if we've actually synced some blocks
-  // (currentBlockHeight > 0 means we've fetched at least one batch)
+  // (knownHeight > 0 means we've fetched at least one batch)
   // This prevents Live RPC from winning the initial height race and
   // becoming activeSource, which would bypass HyperSync's smart block detection
-  let isInitialHeightFetch = currentBlockHeight === 0
+  let isInitialHeightFetch = knownHeight === 0
 
   let syncSources = []
   let fallbackSources = []
   sources->Utils.Set.forEach(source => {
     if (
       source.sourceFor === Sync ||
-        // Include Live sources only after initial sync has started
-        // Live sources are optimized for real-time indexing with lower latency
-        (source.sourceFor === Live && !isInitialHeightFetch) ||
-        // Even if the active source is a fallback, still include
-        // it to the list. So we don't wait for a timeout again
-        // if all main sync sources are still not valid
-        source === sourceManager.activeSource
+      // Include Live sources only after initial sync has started
+      // Live sources are optimized for real-time indexing with lower latency
+      source.sourceFor === Live && !isInitialHeightFetch ||
+      // Even if the active source is a fallback, still include
+      // it to the list. So we don't wait for a timeout again
+      // if all main sync sources are still not valid
+      source === sourceManager.activeSource
     ) {
       syncSources->Array.push(source)
     } else {
@@ -252,10 +252,7 @@ let waitForNewBlock = async (sourceManager: t, ~currentBlockHeight) => {
   let (source, newBlockHeight) = await Promise.race(
     syncSources
     ->Array.map(async source => {
-      (
-        source,
-        await sourceManager->getSourceNewHeight(~source, ~currentBlockHeight, ~status, ~logger),
-      )
+      (source, await sourceManager->getSourceNewHeight(~source, ~knownHeight, ~status, ~logger))
     })
     ->Array.concat([
       Utils.delay(sourceManager.newBlockFallbackStallTimeout)->Promise.then(() => {
@@ -281,12 +278,7 @@ let waitForNewBlock = async (sourceManager: t, ~currentBlockHeight) => {
           fallbackSources->Array.map(async source => {
             (
               source,
-              await sourceManager->getSourceNewHeight(
-                ~source,
-                ~currentBlockHeight,
-                ~status,
-                ~logger,
-              ),
+              await sourceManager->getSourceNewHeight(~source, ~knownHeight, ~status, ~logger),
             )
           }),
         )
@@ -349,7 +341,7 @@ let getNextSyncSource = (
   }
 }
 
-let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~currentBlockHeight) => {
+let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~knownHeight) => {
   let toBlockRef = ref(
     switch query.target {
     | Head => None
@@ -389,7 +381,7 @@ let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~currentBl
         ~addressesByContractName=query.addressesByContractName,
         ~indexingContracts=query.indexingContracts,
         ~partitionId=query.partitionId,
-        ~currentBlockHeight,
+        ~knownHeight,
         ~selection=query.selection,
         ~retry,
         ~logger,

package/src/sources/SourceManager.res.mjs

@@ -68,10 +68,10 @@ function trackNewStatus(sourceManager, newStatus) {
   sourceManager.status = newStatus;
 }
 
-async function fetchNext(sourceManager, fetchState, currentBlockHeight, executeQuery, waitForNewBlock, onNewBlock, stateId) {
-  var queries = FetchState.getNextQuery(fetchState, sourceManager.maxPartitionConcurrency - sourceManager.fetchingPartitionsCount | 0, currentBlockHeight, stateId);
-  if (typeof queries !== "object") {
-    switch (queries) {
+async function fetchNext(sourceManager, fetchState, executeQuery, waitForNewBlock, onNewBlock, stateId) {
+  var nextQuery = FetchState.getNextQuery(fetchState, sourceManager.maxPartitionConcurrency - sourceManager.fetchingPartitionsCount | 0, stateId);
+  if (typeof nextQuery !== "object") {
+    switch (nextQuery) {
       case "WaitingForNewBlock" :
           var waitingStateId = sourceManager.waitingForNewBlockStateId;
           if (waitingStateId !== undefined && waitingStateId >= stateId) {
@@ -79,12 +79,12 @@ async function fetchNext(sourceManager, fetchState, currentBlockHeight, executeQ
           }
           trackNewStatus(sourceManager, "WaitingForNewBlock");
           sourceManager.waitingForNewBlockStateId = stateId;
-          var currentBlockHeight$1 = await waitForNewBlock(currentBlockHeight);
+          var knownHeight = await waitForNewBlock(fetchState.knownHeight);
           var waitingStateId$1 = sourceManager.waitingForNewBlockStateId;
           if (waitingStateId$1 !== undefined && waitingStateId$1 === stateId) {
             trackNewStatus(sourceManager, "Idle");
             sourceManager.waitingForNewBlockStateId = undefined;
-            return onNewBlock(currentBlockHeight$1);
+            return onNewBlock(knownHeight);
           } else {
             return ;
           }
@@ -94,12 +94,12 @@ async function fetchNext(sourceManager, fetchState, currentBlockHeight, executeQ
       
     }
   } else {
-    var queries$1 = queries._0;
-    FetchState.startFetchingQueries(fetchState, queries$1, stateId);
-    sourceManager.fetchingPartitionsCount = sourceManager.fetchingPartitionsCount + queries$1.length | 0;
+    var queries = nextQuery._0;
+    FetchState.startFetchingQueries(fetchState, queries, stateId);
+    sourceManager.fetchingPartitionsCount = sourceManager.fetchingPartitionsCount + queries.length | 0;
     Prometheus.IndexingConcurrency.set(sourceManager.fetchingPartitionsCount, sourceManager.activeSource.chain);
     trackNewStatus(sourceManager, "Querieng");
-    await Promise.all(Belt_Array.map(queries$1, (function (q) {
+    await Promise.all(Belt_Array.map(queries, (function (q) {
                 var promise = executeQuery(q);
                 promise.then(function (param) {
                       sourceManager.fetchingPartitionsCount = sourceManager.fetchingPartitionsCount - 1 | 0;
@@ -115,10 +115,10 @@ async function fetchNext(sourceManager, fetchState, currentBlockHeight, executeQ
   }
 }
 
-async function getSourceNewHeight(sourceManager, source, currentBlockHeight, status, logger) {
+async function getSourceNewHeight(sourceManager, source, knownHeight, status, logger) {
   var newHeight = 0;
   var retry = 0;
-  while(newHeight <= currentBlockHeight && status.contents !== "Done") {
+  while(newHeight <= knownHeight && status.contents !== "Done") {
     try {
       var endTimer = Prometheus.SourceGetHeightDuration.startTimer({
             source: source.name,
@@ -127,7 +127,7 @@ async function getSourceNewHeight(sourceManager, source, currentBlockHeight, sta
       var height = await source.getHeightOrThrow();
       endTimer();
       newHeight = height;
-      if (height <= currentBlockHeight) {
+      if (height <= knownHeight) {
         retry = 0;
         var pollingInterval = status.contents === "Stalled" ? sourceManager.stalledPollingInterval : source.pollingInterval;
         await Utils.delay(pollingInterval);
@@ -150,13 +150,13 @@ async function getSourceNewHeight(sourceManager, source, currentBlockHeight, sta
   return newHeight;
 }
 
-async function waitForNewBlock(sourceManager, currentBlockHeight) {
+async function waitForNewBlock(sourceManager, knownHeight) {
   var logger = Logging.createChild({
         chainId: sourceManager.activeSource.chain,
-        currentBlockHeight: currentBlockHeight
+        knownHeight: knownHeight
       });
   Logging.childTrace(logger, "Initiating check for new blocks.");
-  var isInitialHeightFetch = currentBlockHeight === 0;
+  var isInitialHeightFetch = knownHeight === 0;
   var syncSources = [];
   var fallbackSources = [];
   sourceManager.sources.forEach(function (source) {
@@ -172,7 +172,7 @@ async function waitForNewBlock(sourceManager, currentBlockHeight) {
   var match = await Promise.race(Belt_Array.concat(Belt_Array.map(syncSources, (async function (source) {
                   return [
                           source,
-                          await getSourceNewHeight(sourceManager, source, currentBlockHeight, status, logger)
+                          await getSourceNewHeight(sourceManager, source, knownHeight, status, logger)
                         ];
                 })), [Utils.delay(sourceManager.newBlockFallbackStallTimeout).then(function () {
                   if (status.contents !== "Done") {
@@ -186,7 +186,7 @@ async function waitForNewBlock(sourceManager, currentBlockHeight) {
                   return Promise.race(Belt_Array.map(fallbackSources, (async function (source) {
                                     return [
                                             source,
-                                            await getSourceNewHeight(sourceManager, source, currentBlockHeight, status, logger)
+                                            await getSourceNewHeight(sourceManager, source, knownHeight, status, logger)
                                           ];
                                   })));
                 })]));
@@ -247,7 +247,7 @@ function getNextSyncSource(sourceManager, initialSource, currentSource, attemptF
   }
 }
 
-async function executeQuery(sourceManager, query, currentBlockHeight) {
+async function executeQuery(sourceManager, query, knownHeight) {
   var match = query.target;
   var toBlockRef;
   toBlockRef = typeof match !== "object" ? undefined : (
@@ -273,7 +273,7 @@ async function executeQuery(sourceManager, query, currentBlockHeight) {
           retry: retry
         });
     try {
-      var response = await source.getItemsOrThrow(query.fromBlock, toBlock, query.addressesByContractName, query.indexingContracts, currentBlockHeight, query.partitionId, query.selection, retry, logger);
+      var response = await source.getItemsOrThrow(query.fromBlock, toBlock, query.addressesByContractName, query.indexingContracts, knownHeight, query.partitionId, query.selection, retry, logger);
       Logging.childTrace(logger, {
             msg: "Fetched block range from server",
             toBlock: response.latestFetchedBlockNumber,

package/src/sources/SourceManager.resi

@@ -13,19 +13,18 @@ let getActiveSource: t => Source.t
 let fetchNext: (
   t,
   ~fetchState: FetchState.t,
-  ~currentBlockHeight: int,
   ~executeQuery: FetchState.query => promise<unit>,
-  ~waitForNewBlock: (~currentBlockHeight: int) => promise<int>,
-  ~onNewBlock: (~currentBlockHeight: int) => unit,
+  ~waitForNewBlock: (~knownHeight: int) => promise<int>,
+  ~onNewBlock: (~knownHeight: int) => unit,
   ~stateId: int,
 ) => promise<unit>
 
-let waitForNewBlock: (t, ~currentBlockHeight: int) => promise<int>
+let waitForNewBlock: (t, ~knownHeight: int) => promise<int>
 
 let executeQuery: (
   t,
   ~query: FetchState.query,
-  ~currentBlockHeight: int,
+  ~knownHeight: int,
 ) => promise<Source.blockRangeFetchResponse>
 
 let makeGetHeightRetryInterval: (