envio 3.0.0-alpha.2 → 3.0.0-alpha.4

package/src/sources/RpcSource.res

@@ -503,10 +503,12 @@ let make = (
 
   let mutSuggestedBlockIntervals = Js.Dict.empty()
 
+  let client = Rest.client(url)
+
   let makeTransactionLoader = () =>
     LazyLoader.make(
       ~loaderFn=transactionHash =>
-        provider->Ethers.JsonRpcProvider.getTransaction(~transactionHash),
+        Rpc.GetTransactionByHash.route->Rest.fetch(transactionHash, ~client),
       ~onError=(am, ~exn) => {
         Logging.error({
           "err": exn->Utils.prettifyExn,
@@ -560,7 +562,12 @@ let make = (
   )
   let getEventTransactionOrThrow = makeThrowingGetEventTransaction(
     ~getTransactionFields=Ethers.JsonRpcProvider.makeGetTransactionFields(
-      ~getTransactionByHash=LazyLoader.get(transactionLoader.contents, _),
+      ~getTransactionByHash=async transactionHash => {
+        switch await transactionLoader.contents->LazyLoader.get(transactionHash) {
+        | Some(tx) => tx
+        | None => Js.Exn.raiseError(`Transaction not found for hash: ${transactionHash}`)
+        }
+      },
       ~lowercaseAddresses,
     ),
   )
@@ -601,7 +608,7 @@ let make = (
     ~toBlock,
     ~addressesByContractName,
     ~indexingContracts,
-    ~currentBlockHeight,
+    ~knownHeight,
     ~partitionId,
     ~selection: FetchState.selection,
     ~retry as _,
@@ -621,8 +628,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 +881,7 @@ let make = (
       stats: {
         totalTimeElapsed: totalTimeElapsed,
       },
-      currentBlockHeight,
+      knownHeight,
       reorgGuard,
       fromBlockQueried: fromBlock,
     }
@@ -902,8 +909,6 @@ let make = (
     ->Promise.catch(exn => exn->Error->Promise.resolve)
   }
 
-  let client = Rest.client(url)
-
   {
     name,
     sourceFor,

package/src/sources/RpcSource.res.mjs

@@ -518,9 +518,10 @@ function make(param) {
   var provider = Ethers.JsonRpcProvider.make(url, chain);
   var getSelectionConfig = memoGetSelectionConfig(chain);
   var mutSuggestedBlockIntervals = {};
+  var client = Rest.client(url, undefined);
   var makeTransactionLoader = function () {
     return LazyLoader.make((function (transactionHash) {
-                  return provider.getTransaction(transactionHash);
+                  return Rest.$$fetch(Rpc.GetTransactionByHash.route, transactionHash, client);
                 }), (function (am, exn) {
                   Logging.error({
                         err: Utils.prettifyExn(exn),
@@ -559,8 +560,13 @@ function make(param) {
   var getEventBlockOrThrow = makeThrowingGetEventBlock(function (blockNumber) {
         return LazyLoader.get(blockLoader.contents, blockNumber);
       });
-  var getEventTransactionOrThrow = makeThrowingGetEventTransaction(Ethers.JsonRpcProvider.makeGetTransactionFields((function (__x) {
-              return LazyLoader.get(transactionLoader.contents, __x);
+  var getEventTransactionOrThrow = makeThrowingGetEventTransaction(Ethers.JsonRpcProvider.makeGetTransactionFields((async function (transactionHash) {
+              var tx = await LazyLoader.get(transactionLoader.contents, transactionHash);
+              if (tx !== undefined) {
+                return tx;
+              } else {
+                return Js_exn.raiseError("Transaction not found for hash: " + transactionHash);
+              }
             }), lowercaseAddresses));
   var contractNameAbiMapping = {};
   Belt_Array.forEach(param.contracts, (function (contract) {
@@ -604,11 +610,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 +791,7 @@ function make(param) {
       prevRangeLastBlock: reorgGuard_prevRangeLastBlock
     };
     return {
-            currentBlockHeight: currentBlockHeight,
+            knownHeight: knownHeight,
             reorgGuard: reorgGuard,
             parsedQueueItems: parsedQueueItems,
             fromBlockQueried: fromBlock,
@@ -819,7 +825,6 @@ function make(param) {
                             });
                 }));
   };
-  var client = Rest.client(url, undefined);
   return {
           name: name,
           sourceFor: param.sourceFor,

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,10 +50,11 @@ 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,
     ~logger: Pino.t,
   ) => promise<blockRangeFetchResponse>,
+  createHeightSubscription?: (~onHeight: int => unit) => unit => unit,
 }

package/src/sources/SourceManager.res

@@ -2,13 +2,21 @@ open Belt
 
 type sourceManagerStatus = Idle | WaitingForNewBlock | Querieng
 
+type sourceState = {
+  source: Source.t,
+  mutable knownHeight: int,
+  mutable unsubscribe: option<unit => unit>,
+  mutable pendingHeightResolvers: array<int => unit>,
+  mutable disabled: bool,
+}
+
 // Ideally the ChainFetcher name suits this better
 // But currently the ChainFetcher module is immutable
 // and handles both processing and fetching.
 // So this module is to encapsulate the fetching logic only
 // with a mutable state for easier reasoning and testing.
 type t = {
-  sources: Utils.Set.t<Source.t>,
+  sourcesState: array<sourceState>,
   mutable statusStart: Hrtime.timeRef,
   mutable status: sourceManagerStatus,
   maxPartitionConcurrency: int,
@@ -63,7 +71,13 @@ let make = (
   )
   {
     maxPartitionConcurrency,
-    sources: Utils.Set.fromArray(sources),
+    sourcesState: sources->Array.map(source => {
+      source,
+      knownHeight: 0,
+      unsubscribe: None,
+      pendingHeightResolvers: [],
+      disabled: false,
+    }),
     activeSource: initialActiveSource,
     waitingForNewBlockStateId: None,
     fetchingPartitionsCount: 0,
@@ -92,7 +106,6 @@ let trackNewStatus = (sourceManager: t, ~newStatus) => {
 let fetchNext = async (
   sourceManager: t,
   ~fetchState: FetchState.t,
-  ~currentBlockHeight,
   ~executeQuery,
   ~waitForNewBlock,
   ~onNewBlock,
@@ -100,13 +113,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 +130,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 => ()
@@ -159,91 +173,144 @@ let fetchNext = async (
 
 type status = Active | Stalled | Done
 
+let disableSource = (sourceState: sourceState) => {
+  if !sourceState.disabled {
+    sourceState.disabled = true
+    switch sourceState.unsubscribe {
+    | Some(unsubscribe) => unsubscribe()
+    | None => ()
+    }
+    true
+  } else {
+    false
+  }
+}
+
 let getSourceNewHeight = async (
   sourceManager,
-  ~source: Source.t,
-  ~currentBlockHeight,
+  ~sourceState: sourceState,
+  ~knownHeight,
   ~status: ref<status>,
   ~logger,
 ) => {
-  let newHeight = ref(0)
+  let source = sourceState.source
+  let initialHeight = sourceState.knownHeight
+  let newHeight = ref(initialHeight)
   let retry = ref(0)
 
-  while newHeight.contents <= currentBlockHeight && status.contents !== Done {
-    try {
-      // Use to detect if the source is taking too long to respond
-      let endTimer = Prometheus.SourceGetHeightDuration.startTimer({
-        "source": source.name,
-        "chainId": source.chain->ChainMap.Chain.toChainId,
+  while newHeight.contents <= knownHeight && status.contents !== Done {
+    // If subscription exists, wait for next height event
+    switch sourceState.unsubscribe {
+    | Some(_) =>
+      let height = await Promise.make((resolve, _reject) => {
+        sourceState.pendingHeightResolvers->Array.push(resolve)
       })
-      let height = await source.getHeightOrThrow()
-      endTimer()
-
-      newHeight := height
-      if height <= currentBlockHeight {
-        retry := 0
-        // Slowdown polling when the chain isn't progressing
-        let pollingInterval = if status.contents === Stalled {
-          sourceManager.stalledPollingInterval
-        } else {
-          source.pollingInterval
+
+      // Only accept heights greater than initialHeight
+      if height > initialHeight {
+        newHeight := height
+      }
+    | None =>
+      // No subscription, use REST polling
+      try {
+        // Use to detect if the source is taking too long to respond
+        let endTimer = Prometheus.SourceGetHeightDuration.startTimer({
+          "source": source.name,
+          "chainId": source.chain->ChainMap.Chain.toChainId,
+        })
+        let height = await source.getHeightOrThrow()
+        endTimer()
+
+        newHeight := height
+        if height <= knownHeight {
+          retry := 0
+
+          // If createHeightSubscription is available and height hasn't changed,
+          // create subscription instead of polling
+          switch source.createHeightSubscription {
+          | Some(createSubscription) =>
+            let unsubscribe = createSubscription(~onHeight=newHeight => {
+              sourceState.knownHeight = newHeight
+              // Resolve all pending height resolvers
+              let resolvers = sourceState.pendingHeightResolvers
+              sourceState.pendingHeightResolvers = []
+              resolvers->Array.forEach(resolve => resolve(newHeight))
+            })
+            sourceState.unsubscribe = Some(unsubscribe)
+          | None =>
+            // Slowdown polling when the chain isn't progressing
+            let pollingInterval = if status.contents === Stalled {
+              sourceManager.stalledPollingInterval
+            } else {
+              source.pollingInterval
+            }
+            await Utils.delay(pollingInterval)
+          }
         }
-        await Utils.delay(pollingInterval)
+      } catch {
+      | exn =>
+        let retryInterval = sourceManager.getHeightRetryInterval(~retry=retry.contents)
+        logger->Logging.childTrace({
+          "msg": `Height retrieval from ${source.name} source failed. Retrying in ${retryInterval->Int.toString}ms.`,
+          "source": source.name,
+          "err": exn->Utils.prettifyExn,
+        })
+        retry := retry.contents + 1
+        await Utils.delay(retryInterval)
       }
-    } catch {
-    | exn =>
-      let retryInterval = sourceManager.getHeightRetryInterval(~retry=retry.contents)
-      logger->Logging.childTrace({
-        "msg": `Height retrieval from ${source.name} source failed. Retrying in ${retryInterval->Int.toString}ms.`,
-        "source": source.name,
-        "err": exn->Utils.prettifyExn,
-      })
-      retry := retry.contents + 1
-      await Utils.delay(retryInterval)
     }
   }
-  Prometheus.SourceHeight.set(
-    ~sourceName=source.name,
-    ~chainId=source.chain->ChainMap.Chain.toChainId,
-    ~blockNumber=newHeight.contents,
-  )
+
+  // Update Prometheus only if height increased
+  if newHeight.contents > initialHeight {
+    Prometheus.SourceHeight.set(
+      ~sourceName=source.name,
+      ~chainId=source.chain->ChainMap.Chain.toChainId,
+      ~blockNumber=newHeight.contents,
+    )
+  }
+
   newHeight.contents
 }
 
 // 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 {sources} = sourceManager
+let waitForNewBlock = async (sourceManager: t, ~knownHeight) => {
+  let {sourcesState} = 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 (
+  sourcesState->Array.forEach(sourceState => {
+    let source = sourceState.source
+    if sourceState.disabled {
+      // Skip disabled sources
+      ()
+    } else 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)
+      syncSources->Array.push(sourceState)
     } else {
-      fallbackSources->Array.push(source)
+      fallbackSources->Array.push(sourceState)
     }
   })
 
@@ -251,10 +318,10 @@ let waitForNewBlock = async (sourceManager: t, ~currentBlockHeight) => {
 
   let (source, newBlockHeight) = await Promise.race(
     syncSources
-    ->Array.map(async source => {
+    ->Array.map(async sourceState => {
       (
-        source,
-        await sourceManager->getSourceNewHeight(~source, ~currentBlockHeight, ~status, ~logger),
+        sourceState.source,
+        await sourceManager->getSourceNewHeight(~sourceState, ~knownHeight, ~status, ~logger),
       )
     })
     ->Array.concat([
@@ -278,15 +345,10 @@ let waitForNewBlock = async (sourceManager: t, ~currentBlockHeight) => {
         // Promise.race will be forever pending if fallbackSources is empty
         // which is good for this use case
         Promise.race(
-          fallbackSources->Array.map(async source => {
+          fallbackSources->Array.map(async sourceState => {
             (
-              source,
-              await sourceManager->getSourceNewHeight(
-                ~source,
-                ~currentBlockHeight,
-                ~status,
-                ~logger,
-              ),
+              sourceState.source,
+              await sourceManager->getSourceNewHeight(~sourceState, ~knownHeight, ~status, ~logger),
             )
           }),
         )
@@ -309,11 +371,11 @@ let waitForNewBlock = async (sourceManager: t, ~currentBlockHeight) => {
   newBlockHeight
 }
 
-let getNextSyncSource = (
+let getNextSyncSourceState = (
   sourceManager,
   // This is needed to include the Fallback source to rotation
-  ~initialSource,
-  ~currentSource,
+  ~initialSourceState: sourceState,
+  ~currentSourceState: sourceState,
   // After multiple failures start returning fallback sources as well
   // But don't try it when main sync sources fail because of invalid configuration
   // note: The logic might be changed in the future
@@ -324,18 +386,23 @@ let getNextSyncSource = (
 
   let hasActive = ref(false)
 
-  sourceManager.sources->Utils.Set.forEach(source => {
-    if source === currentSource {
+  sourceManager.sourcesState->Array.forEach(sourceState => {
+    let source = sourceState.source
+
+    // Skip disabled sources
+    if sourceState.disabled {
+      ()
+    } else if sourceState === currentSourceState {
       hasActive := true
     } else if (
       switch source.sourceFor {
       | Sync => true
       // Live sources should NOT be used for historical sync rotation
       // They are only meant for real-time indexing once synced
-      | Live | Fallback => attemptFallbacks || source === initialSource
+      | Live | Fallback => attemptFallbacks || sourceState === initialSourceState
       }
     ) {
-      (hasActive.contents ? after : before)->Array.push(source)
+      (hasActive.contents ? after : before)->Array.push(sourceState)
     }
   })
 
@@ -344,12 +411,12 @@ let getNextSyncSource = (
   | None =>
     switch before->Array.get(0) {
     | Some(s) => s
-    | None => currentSource
+    | None => currentSourceState
     }
   }
 }
 
-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
@@ -360,12 +427,16 @@ let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~currentBl
   )
   let responseRef = ref(None)
   let retryRef = ref(0)
-  let initialSource = sourceManager.activeSource
-  let sourceRef = ref(initialSource)
+  let initialSourceState =
+    sourceManager.sourcesState
+    ->Js.Array2.find(s => s.source === sourceManager.activeSource)
+    ->Option.getUnsafe
+  let sourceStateRef = ref(initialSourceState)
   let shouldUpdateActiveSource = ref(false)
 
   while responseRef.contents->Option.isNone {
-    let source = sourceRef.contents
+    let sourceState = sourceStateRef.contents
+    let source = sourceState.source
     let toBlock = toBlockRef.contents
     let retry = retryRef.contents
 
@@ -389,7 +460,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,
@@ -406,15 +477,19 @@ let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~currentBl
       switch error {
       | UnsupportedSelection(_)
       | FailedGettingFieldSelection(_) => {
-          let nextSource = sourceManager->getNextSyncSource(~initialSource, ~currentSource=source)
+          let nextSourceState =
+            sourceManager->getNextSyncSourceState(
+              ~initialSourceState,
+              ~currentSourceState=sourceState,
+            )
 
-          // These errors are impossible to recover, so we delete the source
-          // from sourceManager so it's not attempted anymore
-          let notAlreadyDeleted = sourceManager.sources->Utils.Set.delete(source)
+          // These errors are impossible to recover, so we disable the source
+          // so it's not attempted anymore
+          let notAlreadyDisabled = disableSource(sourceState)
 
           // In case there are multiple partitions
           // failing at the same time. Log only once
-          if notAlreadyDeleted {
+          if notAlreadyDisabled {
             switch error {
             | UnsupportedSelection({message}) => logger->Logging.childError(message)
             | FailedGettingFieldSelection({exn, message, blockNumber, logIndex}) =>
@@ -428,7 +503,7 @@ let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~currentBl
             }
           }
 
-          if nextSource === source {
+          if nextSourceState === sourceState {
             %raw(`null`)->ErrorHandling.mkLogAndRaise(
               ~logger,
               ~msg="The indexer doesn't have data-sources which can continue fetching. Please, check the error logs or reach out to the Envio team.",
@@ -436,9 +511,9 @@ let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~currentBl
           } else {
             logger->Logging.childInfo({
               "msg": "Switching to another data-source",
-              "source": nextSource.name,
+              "source": nextSourceState.source.name,
             })
-            sourceRef := nextSource
+            sourceStateRef := nextSourceState
             shouldUpdateActiveSource := true
             retryRef := 0
           }
@@ -452,14 +527,14 @@ let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~currentBl
         toBlockRef := Some(toBlock)
         retryRef := 0
       | FailedGettingItems({exn, attemptedToBlock, retry: ImpossibleForTheQuery({message})}) =>
-        let nextSource =
-          sourceManager->getNextSyncSource(
-            ~initialSource,
-            ~currentSource=source,
+        let nextSourceState =
+          sourceManager->getNextSyncSourceState(
+            ~initialSourceState,
+            ~currentSourceState=sourceState,
             ~attemptFallbacks=true,
           )
 
-        let hasAnotherSource = nextSource !== initialSource
+        let hasAnotherSource = nextSourceState !== initialSourceState
 
         logger->Logging.childWarn({
           "msg": message ++ (hasAnotherSource ? " - Attempting to another source" : ""),
@@ -473,7 +548,7 @@ let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~currentBl
             ~msg="The indexer doesn't have data-sources which can continue fetching. Please, check the error logs or reach out to the Envio team.",
           )
         } else {
-          sourceRef := nextSource
+          sourceStateRef := nextSourceState
           shouldUpdateActiveSource := false
           retryRef := 0
         }
@@ -488,19 +563,19 @@ let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~currentBl
         // just keep the value high
         let attemptFallbacks = retry >= 10
 
-        let nextSource = switch retry {
+        let nextSourceState = switch retry {
         // Don't attempt a switch on first two failure
-        | 0 | 1 => source
+        | 0 | 1 => sourceState
         | _ =>
           // Then try to switch every second failure
           if retry->mod(2) === 0 {
-            sourceManager->getNextSyncSource(
-              ~initialSource,
+            sourceManager->getNextSyncSourceState(
+              ~initialSourceState,
               ~attemptFallbacks,
-              ~currentSource=source,
+              ~currentSourceState=sourceState,
             )
           } else {
-            source
+            sourceState
           }
         }
 
@@ -514,13 +589,13 @@ let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~currentBl
           "err": exn->Utils.prettifyExn,
         })
 
-        let shouldSwitch = nextSource !== source
+        let shouldSwitch = nextSourceState !== sourceState
         if shouldSwitch {
           logger->Logging.childInfo({
             "msg": "Switching to another data-source",
-            "source": nextSource.name,
+            "source": nextSourceState.source.name,
           })
-          sourceRef := nextSource
+          sourceStateRef := nextSourceState
           shouldUpdateActiveSource := true
         } else {
           await Utils.delay(Pervasives.min(backoffMillis, 60_000))
@@ -534,7 +609,7 @@ let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~currentBl
   }
 
   if shouldUpdateActiveSource.contents {
-    sourceManager.activeSource = sourceRef.contents
+    sourceManager.activeSource = sourceStateRef.contents.source
   }
 
   responseRef.contents->Option.getUnsafe