envio 2.31.1-rc.0 → 2.32.0-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.31.1-rc.0",
+  "version": "v2.32.0-alpha.0",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
   "main": "./index.js",
@@ -25,10 +25,10 @@
   },
   "homepage": "https://envio.dev",
   "optionalDependencies": {
-    "envio-linux-x64": "v2.31.1-rc.0",
-    "envio-linux-arm64": "v2.31.1-rc.0",
-    "envio-darwin-x64": "v2.31.1-rc.0",
-    "envio-darwin-arm64": "v2.31.1-rc.0"
+    "envio-linux-x64": "v2.32.0-alpha.0",
+    "envio-linux-arm64": "v2.32.0-alpha.0",
+    "envio-darwin-x64": "v2.32.0-alpha.0",
+    "envio-darwin-arm64": "v2.32.0-alpha.0"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.6",

package/src/Batch.res

@@ -528,3 +528,23 @@ let findFirstEventBlockNumber = (batch: t, ~chainId) => {
   }
   result.contents
 }
+
+let findLastEventItem = (batch: t, ~chainId) => {
+  let idx = ref(batch.items->Array.length - 1)
+  let result = ref(None)
+  while idx.contents >= 0 && result.contents === None {
+    let item = batch.items->Array.getUnsafe(idx.contents)
+    switch item {
+    | Internal.Event(_) as eventItem => {
+        let eventItem = eventItem->Internal.castUnsafeEventItem
+        if eventItem.chain->ChainMap.Chain.toChainId === chainId {
+          result := Some(eventItem)
+        } else {
+          idx := idx.contents - 1
+        }
+      }
+    | Internal.Block(_) => idx := idx.contents - 1
+    }
+  }
+  result.contents
+}

package/src/Batch.res.js

@@ -361,6 +361,20 @@ function findFirstEventBlockNumber(batch, chainId) {
   return result;
 }
 
+function findLastEventItem(batch, chainId) {
+  var idx = batch.items.length - 1;
+  var result;
+  while(idx >= 0 && result === undefined) {
+    var item = batch.items[idx];
+    if (item.kind === 0 && item.chain === chainId) {
+      result = item;
+    } else {
+      idx = idx - 1;
+    }
+  };
+  return result;
+}
+
 exports.getOrderedNextChain = getOrderedNextChain;
 exports.immutableEmptyBatchSizePerChain = immutableEmptyBatchSizePerChain;
 exports.hasOrderedReadyItem = hasOrderedReadyItem;
@@ -372,4 +386,5 @@ exports.prepareOrderedBatch = prepareOrderedBatch;
 exports.prepareUnorderedBatch = prepareUnorderedBatch;
 exports.make = make;
 exports.findFirstEventBlockNumber = findFirstEventBlockNumber;
+exports.findLastEventItem = findLastEventItem;
 /* Utils Not a pure module */

package/src/Envio.res

@@ -68,7 +68,8 @@ let experimental_createEffect = (
         Internal.effectOutput,
       >
     ),
-    callsCount: 0,
+    activeCallsCount: 0,
+    prevCallStartTimerRef: %raw(`null`),
     // This is the way to make the createEffect API
     // work without the need for users to call S.schema themselves,
     // but simply pass the desired object/tuple/etc.

package/src/Envio.res.js

@@ -33,7 +33,8 @@ function experimental_createEffect(options, handler) {
           input: S$RescriptSchema.schema(function (param) {
                 return options.input;
               }),
-          callsCount: 0
+          activeCallsCount: 0,
+          prevCallStartTimerRef: null
         };
 }
 

package/src/Internal.res

@@ -299,7 +299,9 @@ type effect = {
   cache: option<effectCacheMeta>,
   output: S.t<effectOutput>,
   input: S.t<effectInput>,
-  mutable callsCount: int,
+  // The number of functions that are currently running.
+  mutable activeCallsCount: int,
+  mutable prevCallStartTimerRef: Hrtime.timeRef,
 }
 let cacheTablePrefix = "envio_effect_"
 let cacheOutputSchema = S.json(~validate=false)->(Utils.magic: S.t<Js.Json.t> => S.t<effectOutput>)

package/src/Persistence.res

@@ -34,7 +34,7 @@ type initialState = {
   reorgCheckpoints: array<Internal.reorgCheckpoint>,
 }
 
-type operator = [#">" | #"="]
+type operator = [#">" | #"=" | #"<"]
 
 type storage = {
   // Should return true if we already have persisted data

package/src/Prometheus.res

@@ -580,20 +580,46 @@ module ProgressBatchCount = {
   }
 }
 
+module ProgressLatency = {
+  let gauge = SafeGauge.makeOrThrow(
+    ~name="envio_progress_latency",
+    ~help="The latency in milliseconds between the latest processed event creation and the time it was written to storage.",
+    ~labelSchema=chainIdLabelsSchema,
+  )
+
+  let set = (~latencyMs, ~chainId) => {
+    gauge->SafeGauge.handleInt(~labels=chainId, ~value=latencyMs)
+  }
+}
+
 let effectLabelsSchema = S.object(s => {
   s.field("effect", S.string)
 })
 
-module EffectCallsCount = {
-  let gauge = SafeGauge.makeOrThrow(
+module EffectCalls = {
+  let timeCounter = SafeCounter.makeOrThrow(
+    ~name="envio_effect_calls_time",
+    ~help="Processing time taken to call the Effect function. (milliseconds)",
+    ~labelSchema=effectLabelsSchema,
+  )
+
+  let sumTimeCounter = SafeCounter.makeOrThrow(
+    ~name="envio_effect_calls_sum_time",
+    ~help="Cumulative time spent calling the Effect function during the indexing process. (milliseconds)",
+    ~labelSchema=effectLabelsSchema,
+  )
+
+  let totalCallsCount = SafeCounter.makeOrThrow(
     ~name="envio_effect_calls_count",
-    ~help="The number of calls to the effect. Including both handler execution and cache hits.",
+    ~help="Cumulative number of resolved Effect function calls during the indexing process.",
     ~labelSchema=effectLabelsSchema,
   )
 
-  let set = (~callsCount, ~effectName) => {
-    gauge->SafeGauge.handleInt(~labels=effectName, ~value=callsCount)
-  }
+  let activeCallsCount = SafeGauge.makeOrThrow(
+    ~name="envio_effect_active_calls_count",
+    ~help="The number of Effect function calls that are currently running.",
+    ~labelSchema=effectLabelsSchema,
+  )
 }
 
 module EffectCacheCount = {
@@ -629,8 +655,8 @@ module StorageLoad = {
     ~labelSchema=operationLabelsSchema,
   )
 
-  let totalTimeCounter = SafeCounter.makeOrThrow(
-    ~name="envio_storage_load_total_time",
+  let sumTimeCounter = SafeCounter.makeOrThrow(
+    ~name="envio_storage_load_sum_time",
     ~help="Cumulative time spent loading data from storage during the indexing process. (milliseconds)",
     ~labelSchema=operationLabelsSchema,
   )
@@ -686,7 +712,7 @@ module StorageLoad = {
       )
       operations->Utils.Dict.deleteInPlace(operation)
     }
-    totalTimeCounter->SafeCounter.handleInt(
+    sumTimeCounter->SafeCounter.handleInt(
       ~labels={operation},
       ~value=timerRef->Hrtime.timeSince->Hrtime.toMillis->Hrtime.intFromMillis,
     )

package/src/Prometheus.res.js

@@ -688,19 +688,34 @@ var ProgressBatchCount = {
   increment: increment$5
 };
 
+var gauge$20 = makeOrThrow$1("envio_progress_latency", "The latency in milliseconds between the latest processed event creation and the time it was written to storage.", chainIdLabelsSchema);
+
+function set$19(latencyMs, chainId) {
+  handleInt$1(gauge$20, chainId, latencyMs);
+}
+
+var ProgressLatency = {
+  gauge: gauge$20,
+  set: set$19
+};
+
 var effectLabelsSchema = S$RescriptSchema.object(function (s) {
       return s.f("effect", S$RescriptSchema.string);
     });
 
-var gauge$20 = makeOrThrow$1("envio_effect_calls_count", "The number of calls to the effect. Including both handler execution and cache hits.", effectLabelsSchema);
+var timeCounter$2 = makeOrThrow("envio_effect_calls_time", "Processing time taken to call the Effect function. (milliseconds)", effectLabelsSchema);
 
-function set$19(callsCount, effectName) {
-  handleInt$1(gauge$20, effectName, callsCount);
-}
+var sumTimeCounter = makeOrThrow("envio_effect_calls_sum_time", "Cumulative time spent calling the Effect function during the indexing process. (milliseconds)", effectLabelsSchema);
 
-var EffectCallsCount = {
-  gauge: gauge$20,
-  set: set$19
+var totalCallsCount = makeOrThrow("envio_effect_calls_count", "Cumulative number of resolved Effect function calls during the indexing process.", effectLabelsSchema);
+
+var activeCallsCount = makeOrThrow$1("envio_effect_active_calls_count", "The number of Effect function calls that are currently running.", effectLabelsSchema);
+
+var EffectCalls = {
+  timeCounter: timeCounter$2,
+  sumTimeCounter: sumTimeCounter,
+  totalCallsCount: totalCallsCount,
+  activeCallsCount: activeCallsCount
 };
 
 var gauge$21 = makeOrThrow$1("envio_effect_cache_count", "The number of items in the effect cache.", effectLabelsSchema);
@@ -729,9 +744,9 @@ var operationLabelsSchema = S$RescriptSchema.object(function (s) {
       return s.f("operation", S$RescriptSchema.string);
     });
 
-var timeCounter$2 = makeOrThrow("envio_storage_load_time", "Processing time taken to load data from storage. (milliseconds)", operationLabelsSchema);
+var timeCounter$3 = makeOrThrow("envio_storage_load_time", "Processing time taken to load data from storage. (milliseconds)", operationLabelsSchema);
 
-var totalTimeCounter = makeOrThrow("envio_storage_load_total_time", "Cumulative time spent loading data from storage during the indexing process. (milliseconds)", operationLabelsSchema);
+var sumTimeCounter$1 = makeOrThrow("envio_storage_load_sum_time", "Cumulative time spent loading data from storage during the indexing process. (milliseconds)", operationLabelsSchema);
 
 var counter$7 = makeOrThrow("envio_storage_load_count", "Cumulative number of successful storage load operations during the indexing process.", operationLabelsSchema);
 
@@ -758,10 +773,10 @@ function endOperation(timerRef, operation, whereSize, size) {
   var operationRef = operations[operation];
   operationRef.pendingCount = operationRef.pendingCount - 1 | 0;
   if (operationRef.pendingCount === 0) {
-    handleInt(timeCounter$2, operation, Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(operationRef.timerRef))));
+    handleInt(timeCounter$3, operation, Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(operationRef.timerRef))));
     Utils.Dict.deleteInPlace(operations, operation);
   }
-  handleInt(totalTimeCounter, operation, Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(timerRef))));
+  handleInt(sumTimeCounter$1, operation, Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(timerRef))));
   increment(counter$7, operation);
   handleInt(whereSizeCounter, operation, whereSize);
   handleInt(sizeCounter, operation, size);
@@ -769,8 +784,8 @@ function endOperation(timerRef, operation, whereSize, size) {
 
 var StorageLoad = {
   operationLabelsSchema: operationLabelsSchema,
-  timeCounter: timeCounter$2,
-  totalTimeCounter: totalTimeCounter,
+  timeCounter: timeCounter$3,
+  sumTimeCounter: sumTimeCounter$1,
   counter: counter$7,
   whereSizeCounter: whereSizeCounter,
   sizeCounter: sizeCounter,
@@ -824,8 +839,9 @@ exports.ProcessingMaxBatchSize = ProcessingMaxBatchSize;
 exports.ProgressBlockNumber = ProgressBlockNumber;
 exports.ProgressEventsCount = ProgressEventsCount;
 exports.ProgressBatchCount = ProgressBatchCount;
+exports.ProgressLatency = ProgressLatency;
 exports.effectLabelsSchema = effectLabelsSchema;
-exports.EffectCallsCount = EffectCallsCount;
+exports.EffectCalls = EffectCalls;
 exports.EffectCacheCount = EffectCacheCount;
 exports.EffectCacheInvalidationsCount = EffectCacheInvalidationsCount;
 exports.StorageLoad = StorageLoad;

package/src/ReorgDetection.res

@@ -188,19 +188,16 @@ Returns the latest block number which matches block number and hashes in the pro
 If it doesn't exist in the reorg threshold it returns NotFound
 */
 let getLatestValidScannedBlock = (
-  self: t,
+  reorgDetection: t,
   ~blockNumbersAndHashes: array<blockDataWithTimestamp>,
-  ~currentBlockHeight,
 ) => {
   let verifiedDataByBlockNumber = Js.Dict.empty()
   for idx in 0 to blockNumbersAndHashes->Array.length - 1 {
     let blockData = blockNumbersAndHashes->Array.getUnsafe(idx)
     verifiedDataByBlockNumber->Js.Dict.set(blockData.blockNumber->Int.toString, blockData)
   }
-
-  let dataByBlockNumber = self->getDataByBlockNumberCopyInThreshold(~currentBlockHeight)
   // Js engine automatically orders numeric object keys
-  let ascBlockNumberKeys = dataByBlockNumber->Js.Dict.keys
+  let ascBlockNumberKeys = verifiedDataByBlockNumber->Js.Dict.keys
 
   let getPrevScannedBlockNumber = idx =>
     ascBlockNumberKeys
@@ -216,15 +213,10 @@ let getLatestValidScannedBlock = (
   let rec loop = idx => {
     switch ascBlockNumberKeys->Belt.Array.get(idx) {
     | Some(blockNumberKey) =>
-      let scannedBlock = dataByBlockNumber->Js.Dict.unsafeGet(blockNumberKey)
-      switch verifiedDataByBlockNumber->Utils.Dict.dangerouslyGetNonOption(blockNumberKey) {
-      | None =>
-        Js.Exn.raiseError(
-          `Unexpected case. Couldn't find verified hash for block number ${blockNumberKey}`,
-        )
-      | Some(verifiedBlockData) if verifiedBlockData.blockHash === scannedBlock.blockHash =>
-        loop(idx + 1)
-      | Some(_) => getPrevScannedBlockNumber(idx)
+      let scannedBlock = reorgDetection.dataByBlockNumber->Js.Dict.unsafeGet(blockNumberKey)
+      switch verifiedDataByBlockNumber->Js.Dict.unsafeGet(blockNumberKey) {
+      | verifiedBlockData if verifiedBlockData.blockHash === scannedBlock.blockHash => loop(idx + 1)
+      | _ => getPrevScannedBlockNumber(idx)
       }
     | None => getPrevScannedBlockNumber(idx)
     }

package/src/ReorgDetection.res.js

@@ -1,7 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 'use strict';
 
-var Js_exn = require("rescript/lib/js/js_exn.js");
 var Belt_Array = require("rescript/lib/js/belt_Array.js");
 var Belt_Option = require("rescript/lib/js/belt_Option.js");
 
@@ -108,14 +107,13 @@ function registerReorgGuard(self, reorgGuard, currentBlockHeight) {
   }
 }
 
-function getLatestValidScannedBlock(self, blockNumbersAndHashes, currentBlockHeight) {
+function getLatestValidScannedBlock(reorgDetection, blockNumbersAndHashes) {
   var verifiedDataByBlockNumber = {};
   for(var idx = 0 ,idx_finish = blockNumbersAndHashes.length; idx < idx_finish; ++idx){
     var blockData = blockNumbersAndHashes[idx];
     verifiedDataByBlockNumber[String(blockData.blockNumber)] = blockData;
   }
-  var dataByBlockNumber = getDataByBlockNumberCopyInThreshold(self, currentBlockHeight);
-  var ascBlockNumberKeys = Object.keys(dataByBlockNumber);
+  var ascBlockNumberKeys = Object.keys(verifiedDataByBlockNumber);
   var getPrevScannedBlockNumber = function (idx) {
     return Belt_Option.flatMap(Belt_Array.get(ascBlockNumberKeys, idx - 1 | 0), (function (key) {
                   var v = verifiedDataByBlockNumber[key];
@@ -132,11 +130,8 @@ function getLatestValidScannedBlock(self, blockNumbersAndHashes, currentBlockHei
     if (blockNumberKey === undefined) {
       return getPrevScannedBlockNumber(idx$1);
     }
-    var scannedBlock = dataByBlockNumber[blockNumberKey];
+    var scannedBlock = reorgDetection.dataByBlockNumber[blockNumberKey];
     var verifiedBlockData = verifiedDataByBlockNumber[blockNumberKey];
-    if (verifiedBlockData === undefined) {
-      return Js_exn.raiseError("Unexpected case. Couldn't find verified hash for block number " + blockNumberKey);
-    }
     if (verifiedBlockData.blockHash !== scannedBlock.blockHash) {
       return getPrevScannedBlockNumber(idx$1);
     }

package/src/sources/HyperFuelSource.res

@@ -258,14 +258,10 @@ let make = ({chain, endpointUrl}: options): t => {
                 backoffMillis,
               })
             | UnexpectedMissingParams({missingParams}) =>
-              WithBackoff({
-                message: `Received page response with invalid data. Attempt a retry. Missing params: ${missingParams->Js.Array2.joinWith(
-                    ",",
+              ImpossibleForTheQuery({
+                message: `Source returned invalid data with missing required fields: ${missingParams->Js.Array2.joinWith(
+                    ", ",
                   )}`,
-                backoffMillis: switch retry {
-                | 0 => 1000
-                | _ => 4000 * retry
-                },
               })
             },
           }),

package/src/sources/HyperFuelSource.res.js

@@ -213,9 +213,8 @@ function make(param) {
           };
         } else {
           tmp = {
-            TAG: "WithBackoff",
-            message: "Received page response with invalid data. Attempt a retry. Missing params: " + error$1.missingParams.join(","),
-            backoffMillis: retry !== 0 ? Math.imul(4000, retry) : 1000
+            TAG: "ImpossibleForTheQuery",
+            message: "Source returned invalid data with missing required fields: " + error$1.missingParams.join(", ")
           };
         }
         throw {

package/src/sources/HyperSyncSource.res

@@ -288,14 +288,10 @@ let make = (
                 backoffMillis,
               })
             | UnexpectedMissingParams({missingParams}) =>
-              WithBackoff({
-                message: `Received page response with invalid data. Attempt a retry. Missing params: ${missingParams->Js.Array2.joinWith(
-                    ",",
+              ImpossibleForTheQuery({
+                message: `Source returned invalid data with missing required fields: ${missingParams->Js.Array2.joinWith(
+                    ", ",
                   )}`,
-                backoffMillis: switch retry {
-                | 0 => 1000
-                | _ => 4000 * retry
-                },
               })
             },
           }),

package/src/sources/HyperSyncSource.res.js

@@ -214,9 +214,8 @@ function make(param) {
           };
         } else {
           tmp = {
-            TAG: "WithBackoff",
-            message: "Received page response with invalid data. Attempt a retry. Missing params: " + error$1.missingParams.join(","),
-            backoffMillis: retry !== 0 ? Math.imul(4000, retry) : 1000
+            TAG: "ImpossibleForTheQuery",
+            message: "Source returned invalid data with missing required fields: " + error$1.missingParams.join(", ")
           };
         }
         throw {

package/src/sources/RpcSource.res

@@ -675,11 +675,12 @@ let make = (
       | exn =>
         raise(
           Source.GetItemsError(
-            FailedParsingItems({
-              message: "Failed to parse events using hypersync client decoder. Please double-check your ABI.",
+            FailedGettingItems({
               exn,
-              blockNumber: fromBlock,
-              logIndex: 0,
+              attemptedToBlock: toBlock,
+              retry: ImpossibleForTheQuery({
+                message: "Failed to parse events using hypersync client decoder. Please double-check your ABI.",
+              }),
             }),
           ),
         )
@@ -809,11 +810,12 @@ let make = (
                 | exn =>
                   raise(
                     Source.GetItemsError(
-                      FailedParsingItems({
-                        message: "Failed to parse event with viem, please double-check your ABI.",
+                      FailedGettingItems({
                         exn,
-                        blockNumber,
-                        logIndex,
+                        attemptedToBlock: toBlock,
+                        retry: ImpossibleForTheQuery({
+                          message: `Failed to parse event with viem, please double-check your ABI. Block number: ${blockNumber->Int.toString}, log index: ${logIndex->Int.toString}`,
+                        }),
                       }),
                     ),
                   )

package/src/sources/RpcSource.res.js

@@ -632,11 +632,13 @@ function make(param) {
         throw {
               RE_EXN_ID: Source.GetItemsError,
               _1: {
-                TAG: "FailedParsingItems",
+                TAG: "FailedGettingItems",
                 exn: exn,
-                blockNumber: fromBlock,
-                logIndex: 0,
-                message: "Failed to parse events using hypersync client decoder. Please double-check your ABI."
+                attemptedToBlock: toBlock$1,
+                retry: {
+                  TAG: "ImpossibleForTheQuery",
+                  message: "Failed to parse events using hypersync client decoder. Please double-check your ABI."
+                }
               },
               Error: new Error()
             };
@@ -732,11 +734,13 @@ function make(param) {
                                     throw {
                                           RE_EXN_ID: Source.GetItemsError,
                                           _1: {
-                                            TAG: "FailedParsingItems",
+                                            TAG: "FailedGettingItems",
                                             exn: exn$1,
-                                            blockNumber: blockNumber,
-                                            logIndex: logIndex,
-                                            message: "Failed to parse event with viem, please double-check your ABI."
+                                            attemptedToBlock: toBlock$1,
+                                            retry: {
+                                              TAG: "ImpossibleForTheQuery",
+                                              message: "Failed to parse event with viem, please double-check your ABI. Block number: " + String(blockNumber) + ", log index: " + String(logIndex)
+                                            }
                                           },
                                           Error: new Error()
                                         };

package/src/sources/Source.res

@@ -23,11 +23,11 @@ type blockRangeFetchResponse = {
 type getItemsRetry =
   | WithSuggestedToBlock({toBlock: int})
   | WithBackoff({message: string, backoffMillis: int})
+  | ImpossibleForTheQuery({message: string})
 
 type getItemsError =
   | UnsupportedSelection({message: string})
   | FailedGettingFieldSelection({exn: exn, blockNumber: int, logIndex: int, message: string})
-  | FailedParsingItems({exn: exn, blockNumber: int, logIndex: int, message: string})
   | FailedGettingItems({exn: exn, attemptedToBlock: int, retry: getItemsRetry})
 
 exception GetItemsError(getItemsError)

package/src/sources/SourceManager.res

@@ -304,6 +304,7 @@ let getNextSyncSource = (
   sourceManager,
   // This is needed to include the Fallback source to rotation
   ~initialSource,
+  ~currentSource,
   // 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
@@ -315,7 +316,7 @@ let getNextSyncSource = (
   let hasActive = ref(false)
 
   sourceManager.sources->Utils.Set.forEach(source => {
-    if source === sourceManager.activeSource {
+    if source === currentSource {
       hasActive := true
     } else if (
       switch source.sourceFor {
@@ -332,7 +333,7 @@ let getNextSyncSource = (
   | None =>
     switch before->Array.get(0) {
     | Some(s) => s
-    | None => sourceManager.activeSource
+    | None => currentSource
     }
   }
 }
@@ -349,9 +350,11 @@ 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 shouldUpdateActiveSource = ref(false)
 
   while responseRef.contents->Option.isNone {
-    let source = sourceManager.activeSource
+    let source = sourceRef.contents
     let toBlock = toBlockRef.contents
     let retry = retryRef.contents
 
@@ -391,9 +394,8 @@ let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~currentBl
     | Source.GetItemsError(error) =>
       switch error {
       | UnsupportedSelection(_)
-      | FailedGettingFieldSelection(_)
-      | FailedParsingItems(_) => {
-          let nextSource = sourceManager->getNextSyncSource(~initialSource)
+      | FailedGettingFieldSelection(_) => {
+          let nextSource = sourceManager->getNextSyncSource(~initialSource, ~currentSource=source)
 
           // These errors are impossible to recover, so we delete the source
           // from sourceManager so it's not attempted anymore
@@ -404,8 +406,7 @@ let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~currentBl
           if notAlreadyDeleted {
             switch error {
             | UnsupportedSelection({message}) => logger->Logging.childError(message)
-            | FailedGettingFieldSelection({exn, message, blockNumber, logIndex})
-            | FailedParsingItems({exn, message, blockNumber, logIndex}) =>
+            | FailedGettingFieldSelection({exn, message, blockNumber, logIndex}) =>
               logger->Logging.childError({
                 "msg": message,
                 "err": exn->Utils.prettifyExn,
@@ -426,7 +427,8 @@ let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~currentBl
               "msg": "Switching to another data-source",
               "source": nextSource.name,
             })
-            sourceManager.activeSource = nextSource
+            sourceRef := nextSource
+            shouldUpdateActiveSource := true
             retryRef := 0
           }
         }
@@ -438,6 +440,33 @@ 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,
+            ~attemptFallbacks=true,
+          )
+
+        let hasAnotherSource = nextSource !== initialSource
+
+        logger->Logging.childWarn({
+          "msg": message ++ (hasAnotherSource ? " - Attempting to another source" : ""),
+          "toBlock": attemptedToBlock,
+          "err": exn->Utils.prettifyExn,
+        })
+
+        if !hasAnotherSource {
+          %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.",
+          )
+        } else {
+          sourceRef := nextSource
+          shouldUpdateActiveSource := false
+          retryRef := 0
+        }
+
       | FailedGettingItems({exn, attemptedToBlock, retry: WithBackoff({message, backoffMillis})}) =>
         // Starting from the 11th failure (retry=10)
         // include fallback sources for switch
@@ -454,7 +483,11 @@ let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~currentBl
         | _ =>
           // Then try to switch every second failure
           if retry->mod(2) === 0 {
-            sourceManager->getNextSyncSource(~initialSource, ~attemptFallbacks)
+            sourceManager->getNextSyncSource(
+              ~initialSource,
+              ~attemptFallbacks,
+              ~currentSource=source,
+            )
           } else {
             source
           }
@@ -476,16 +509,22 @@ let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~currentBl
             "msg": "Switching to another data-source",
             "source": nextSource.name,
           })
-          sourceManager.activeSource = nextSource
+          sourceRef := nextSource
+          shouldUpdateActiveSource := true
         } else {
           await Utils.delay(Pervasives.min(backoffMillis, 60_000))
         }
         retryRef := retryRef.contents + 1
       }
+
     // TODO: Handle more error cases and hang/retry instead of throwing
     | exn => exn->ErrorHandling.mkLogAndRaise(~logger, ~msg="Failed to fetch block Range")
     }
   }
 
+  if shouldUpdateActiveSource.contents {
+    sourceManager.activeSource = sourceRef.contents
+  }
+
   responseRef.contents->Option.getUnsafe
 }

package/src/sources/SourceManager.res.js

@@ -203,7 +203,7 @@ async function waitForNewBlock(sourceManager, currentBlockHeight) {
   return newBlockHeight;
 }
 
-function getNextSyncSource(sourceManager, initialSource, attemptFallbacksOpt) {
+function getNextSyncSource(sourceManager, initialSource, currentSource, attemptFallbacksOpt) {
   var attemptFallbacks = attemptFallbacksOpt !== undefined ? attemptFallbacksOpt : false;
   var before = [];
   var after = [];
@@ -211,7 +211,7 @@ function getNextSyncSource(sourceManager, initialSource, attemptFallbacksOpt) {
     contents: false
   };
   sourceManager.sources.forEach(function (source) {
-        if (source === sourceManager.activeSource) {
+        if (source === currentSource) {
           hasActive.contents = true;
           return ;
         }
@@ -234,7 +234,7 @@ function getNextSyncSource(sourceManager, initialSource, attemptFallbacksOpt) {
   if (s$1 !== undefined) {
     return s$1;
   } else {
-    return sourceManager.activeSource;
+    return currentSource;
   }
 }
 
@@ -247,8 +247,10 @@ async function executeQuery(sourceManager, query, currentBlockHeight) {
   var responseRef;
   var retryRef = 0;
   var initialSource = sourceManager.activeSource;
+  var sourceRef = initialSource;
+  var shouldUpdateActiveSource = false;
   while(Belt_Option.isNone(responseRef)) {
-    var source = sourceManager.activeSource;
+    var source = sourceRef;
     var toBlock = toBlockRef;
     var retry = retryRef;
     var logger = Logging.createChild({
@@ -275,85 +277,117 @@ async function executeQuery(sourceManager, query, currentBlockHeight) {
       var error = Caml_js_exceptions.internalToOCamlException(raw_error);
       if (error.RE_EXN_ID === Source.GetItemsError) {
         var error$1 = error._1;
-        if (error$1.TAG === "FailedGettingItems") {
-          var match$1 = error$1.retry;
-          var attemptedToBlock = error$1.attemptedToBlock;
-          if (match$1.TAG === "WithSuggestedToBlock") {
-            var toBlock$1 = match$1.toBlock;
-            Logging.childTrace(logger, {
-                  msg: "Failed getting data for the block range. Immediately retrying with the suggested block range from response.",
-                  toBlock: attemptedToBlock,
-                  suggestedToBlock: toBlock$1
-                });
-            toBlockRef = toBlock$1;
-            retryRef = 0;
-          } else {
-            var backoffMillis = match$1.backoffMillis;
-            var attemptFallbacks = retry >= 10;
-            var nextSource = !(retry === 0 || retry === 1) && retry % 2 === 0 ? getNextSyncSource(sourceManager, initialSource, attemptFallbacks) : source;
-            var log = retry >= 4 ? Logging.childWarn : Logging.childTrace;
-            log(logger, {
-                  msg: match$1.message,
-                  toBlock: attemptedToBlock,
-                  backOffMilliseconds: backoffMillis,
-                  retry: retry,
-                  err: Utils.prettifyExn(error$1.exn)
-                });
-            var shouldSwitch = nextSource !== source;
-            if (shouldSwitch) {
-              Logging.childInfo(logger, {
-                    msg: "Switching to another data-source",
-                    source: nextSource.name
-                  });
-              sourceManager.activeSource = nextSource;
-            } else {
-              await Utils.delay(backoffMillis < 60000 ? backoffMillis : 60000);
-            }
-            retryRef = retryRef + 1 | 0;
-          }
-        } else {
-          var nextSource$1 = getNextSyncSource(sourceManager, initialSource, undefined);
+        var exit = 0;
+        switch (error$1.TAG) {
+          case "UnsupportedSelection" :
+          case "FailedGettingFieldSelection" :
+              exit = 1;
+              break;
+          case "FailedGettingItems" :
+              var match$1 = error$1.retry;
+              var attemptedToBlock = error$1.attemptedToBlock;
+              var exn = error$1.exn;
+              switch (match$1.TAG) {
+                case "WithSuggestedToBlock" :
+                    var toBlock$1 = match$1.toBlock;
+                    Logging.childTrace(logger, {
+                          msg: "Failed getting data for the block range. Immediately retrying with the suggested block range from response.",
+                          toBlock: attemptedToBlock,
+                          suggestedToBlock: toBlock$1
+                        });
+                    toBlockRef = toBlock$1;
+                    retryRef = 0;
+                    break;
+                case "WithBackoff" :
+                    var backoffMillis = match$1.backoffMillis;
+                    var attemptFallbacks = retry >= 10;
+                    var nextSource = !(retry === 0 || retry === 1) && retry % 2 === 0 ? getNextSyncSource(sourceManager, initialSource, source, attemptFallbacks) : source;
+                    var log = retry >= 4 ? Logging.childWarn : Logging.childTrace;
+                    log(logger, {
+                          msg: match$1.message,
+                          toBlock: attemptedToBlock,
+                          backOffMilliseconds: backoffMillis,
+                          retry: retry,
+                          err: Utils.prettifyExn(exn)
+                        });
+                    var shouldSwitch = nextSource !== source;
+                    if (shouldSwitch) {
+                      Logging.childInfo(logger, {
+                            msg: "Switching to another data-source",
+                            source: nextSource.name
+                          });
+                      sourceRef = nextSource;
+                      shouldUpdateActiveSource = true;
+                    } else {
+                      await Utils.delay(backoffMillis < 60000 ? backoffMillis : 60000);
+                    }
+                    retryRef = retryRef + 1 | 0;
+                    break;
+                case "ImpossibleForTheQuery" :
+                    var nextSource$1 = getNextSyncSource(sourceManager, initialSource, source, true);
+                    var hasAnotherSource = nextSource$1 !== initialSource;
+                    Logging.childWarn(logger, {
+                          msg: match$1.message + (
+                            hasAnotherSource ? " - Attempting to another source" : ""
+                          ),
+                          toBlock: attemptedToBlock,
+                          err: Utils.prettifyExn(exn)
+                        });
+                    if (hasAnotherSource) {
+                      sourceRef = nextSource$1;
+                      shouldUpdateActiveSource = false;
+                      retryRef = 0;
+                    } else {
+                      ErrorHandling.mkLogAndRaise(logger, "The indexer doesn't have data-sources which can continue fetching. Please, check the error logs or reach out to the Envio team.", null);
+                    }
+                    break;
+                
+              }
+              break;
+          
+        }
+        if (exit === 1) {
+          var nextSource$2 = getNextSyncSource(sourceManager, initialSource, source, undefined);
           var notAlreadyDeleted = sourceManager.sources.delete(source);
           if (notAlreadyDeleted) {
-            var exit = 0;
             switch (error$1.TAG) {
               case "UnsupportedSelection" :
                   Logging.childError(logger, error$1.message);
                   break;
               case "FailedGettingFieldSelection" :
-              case "FailedParsingItems" :
-                  exit = 1;
+                  Logging.childError(logger, {
+                        msg: error$1.message,
+                        err: Utils.prettifyExn(error$1.exn),
+                        blockNumber: error$1.blockNumber,
+                        logIndex: error$1.logIndex
+                      });
                   break;
               case "FailedGettingItems" :
                   break;
               
             }
-            if (exit === 1) {
-              Logging.childError(logger, {
-                    msg: error$1.message,
-                    err: Utils.prettifyExn(error$1.exn),
-                    blockNumber: error$1.blockNumber,
-                    logIndex: error$1.logIndex
-                  });
-            }
-            
           }
-          if (nextSource$1 === source) {
+          if (nextSource$2 === source) {
             ErrorHandling.mkLogAndRaise(logger, "The indexer doesn't have data-sources which can continue fetching. Please, check the error logs or reach out to the Envio team.", null);
           } else {
             Logging.childInfo(logger, {
                   msg: "Switching to another data-source",
-                  source: nextSource$1.name
+                  source: nextSource$2.name
                 });
-            sourceManager.activeSource = nextSource$1;
+            sourceRef = nextSource$2;
+            shouldUpdateActiveSource = true;
             retryRef = 0;
           }
         }
+        
       } else {
         ErrorHandling.mkLogAndRaise(logger, "Failed to fetch block Range", error);
       }
     }
   };
+  if (shouldUpdateActiveSource) {
+    sourceManager.activeSource = sourceRef;
+  }
   return responseRef;
 }