envio 3.0.0-alpha.21 → 3.0.0-alpha.22

package/src/sources/SourceManager.res.mjs

@@ -1,18 +1,17 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Caml from "rescript/lib/es6/caml.js";
 import * as Utils from "../Utils.res.mjs";
 import * as Hrtime from "../bindings/Hrtime.res.mjs";
-import * as Js_exn from "rescript/lib/es6/js_exn.js";
 import * as Source from "./Source.res.mjs";
 import * as Logging from "../Logging.res.mjs";
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
 import * as FetchState from "../FetchState.res.mjs";
 import * as Prometheus from "../Prometheus.res.mjs";
-import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
-import * as Caml_option from "rescript/lib/es6/caml_option.js";
 import * as ErrorHandling from "../ErrorHandling.res.mjs";
-import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 function getActiveSource(sourceManager) {
   return sourceManager.activeSource;
@@ -22,92 +21,85 @@ function getSourceRole(sourceFor, isLive, hasLive) {
   if (isLive) {
     switch (sourceFor) {
       case "Sync" :
-          if (hasLive) {
-            return "Secondary";
-          } else {
-            return "Primary";
-          }
-      case "Fallback" :
+        if (hasLive) {
           return "Secondary";
-      case "Live" :
+        } else {
           return "Primary";
-      
+        }
+      case "Fallback" :
+        return "Secondary";
+      case "Live" :
+        return "Primary";
     }
   } else {
     switch (sourceFor) {
       case "Sync" :
-          return "Primary";
+        return "Primary";
       case "Fallback" :
-          return "Secondary";
+        return "Secondary";
       case "Live" :
-          return ;
-      
+        return;
     }
   }
 }
 
 function makeGetHeightRetryInterval(initialRetryInterval, backoffMultiplicative, maxRetryInterval) {
-  return function (retry) {
-    var backoff = retry === 0 ? 1 : Math.imul(retry, backoffMultiplicative);
-    return Caml.int_min(Math.imul(initialRetryInterval, backoff), maxRetryInterval);
+  return retry => {
+    let backoff = retry === 0 ? 1 : retry * backoffMultiplicative | 0;
+    return Primitive_int.min(initialRetryInterval * backoff | 0, maxRetryInterval);
   };
 }
 
-function make(sources, maxPartitionConcurrency, isLive, newBlockStallTimeoutOpt, newBlockStallTimeoutLiveOpt, stalledPollingIntervalOpt, recoveryTimeoutOpt, getHeightRetryIntervalOpt) {
-  var newBlockStallTimeout = newBlockStallTimeoutOpt !== undefined ? newBlockStallTimeoutOpt : 60000;
-  var newBlockStallTimeoutLive = newBlockStallTimeoutLiveOpt !== undefined ? newBlockStallTimeoutLiveOpt : 20000;
-  var stalledPollingInterval = stalledPollingIntervalOpt !== undefined ? stalledPollingIntervalOpt : 5000;
-  var recoveryTimeout = recoveryTimeoutOpt !== undefined ? recoveryTimeoutOpt : 60000.0;
-  var getHeightRetryInterval = getHeightRetryIntervalOpt !== undefined ? getHeightRetryIntervalOpt : makeGetHeightRetryInterval(1000, 2, 60000);
-  var hasLive = sources.some(function (s) {
-        return s.sourceFor === "Live";
-      });
-  var source = sources.find(function (source) {
-        return getSourceRole(source.sourceFor, isLive, hasLive) === "Primary";
-      });
-  var initialActiveSource = source !== undefined ? source : Js_exn.raiseError("Invalid configuration, no data-source for historical sync provided");
+function make(sources, maxPartitionConcurrency, isLive, newBlockStallTimeoutOpt, newBlockStallTimeoutLiveOpt, stalledPollingIntervalOpt, reducedPollingIntervalOpt, recoveryTimeoutOpt, getHeightRetryIntervalOpt) {
+  let newBlockStallTimeout = newBlockStallTimeoutOpt !== undefined ? newBlockStallTimeoutOpt : 60000;
+  let newBlockStallTimeoutLive = newBlockStallTimeoutLiveOpt !== undefined ? newBlockStallTimeoutLiveOpt : 20000;
+  let stalledPollingInterval = stalledPollingIntervalOpt !== undefined ? stalledPollingIntervalOpt : 5000;
+  let reducedPollingInterval = reducedPollingIntervalOpt !== undefined ? reducedPollingIntervalOpt : 60000;
+  let recoveryTimeout = recoveryTimeoutOpt !== undefined ? recoveryTimeoutOpt : 60000.0;
+  let getHeightRetryInterval = getHeightRetryIntervalOpt !== undefined ? getHeightRetryIntervalOpt : makeGetHeightRetryInterval(1000, 2, 60000);
+  let hasLive = sources.some(s => s.sourceFor === "Live");
+  let source = sources.find(source => getSourceRole(source.sourceFor, isLive, hasLive) === "Primary");
+  let initialActiveSource = source !== undefined ? source : Stdlib_JsError.throwWithMessage("Invalid configuration, no data-source for historical sync provided");
   Prometheus.IndexingMaxConcurrency.set(maxPartitionConcurrency, initialActiveSource.chain);
   Prometheus.IndexingConcurrency.set(0, initialActiveSource.chain);
   return {
-          sourcesState: Belt_Array.map(sources, (function (source) {
-                  return {
-                          source: source,
-                          knownHeight: 0,
-                          unsubscribe: undefined,
-                          pendingHeightResolvers: [],
-                          disabled: false,
-                          lastFailedAt: undefined
-                        };
-                })),
-          statusStart: Hrtime.makeTimer(),
-          status: "Idle",
-          maxPartitionConcurrency: maxPartitionConcurrency,
-          newBlockStallTimeout: newBlockStallTimeout,
-          newBlockStallTimeoutLive: newBlockStallTimeoutLive,
-          stalledPollingInterval: stalledPollingInterval,
-          getHeightRetryInterval: getHeightRetryInterval,
-          activeSource: initialActiveSource,
-          waitingForNewBlockStateId: undefined,
-          fetchingPartitionsCount: 0,
-          recoveryTimeout: recoveryTimeout,
-          hasLive: hasLive
-        };
+    sourcesState: sources.map(source => ({
+      source: source,
+      knownHeight: 0,
+      unsubscribe: undefined,
+      pendingHeightResolvers: [],
+      disabled: false,
+      lastFailedAt: undefined
+    })),
+    statusStart: Hrtime.makeTimer(),
+    status: "Idle",
+    maxPartitionConcurrency: maxPartitionConcurrency,
+    newBlockStallTimeout: newBlockStallTimeout,
+    newBlockStallTimeoutLive: newBlockStallTimeoutLive,
+    stalledPollingInterval: stalledPollingInterval,
+    reducedPollingInterval: reducedPollingInterval,
+    getHeightRetryInterval: getHeightRetryInterval,
+    activeSource: initialActiveSource,
+    waitingForNewBlockStateId: undefined,
+    fetchingPartitionsCount: 0,
+    recoveryTimeout: recoveryTimeout,
+    hasLive: hasLive
+  };
 }
 
 function trackNewStatus(sourceManager, newStatus) {
-  var match = sourceManager.status;
-  var promCounter;
+  let match = sourceManager.status;
+  let promCounter;
   switch (match) {
     case "Idle" :
-        promCounter = Prometheus.IndexingIdleTime.counter;
-        break;
+      promCounter = Prometheus.IndexingIdleTime.counter;
+      break;
     case "WaitingForNewBlock" :
-        promCounter = Prometheus.IndexingSourceWaitingTime.counter;
-        break;
+      promCounter = Prometheus.IndexingSourceWaitingTime.counter;
+      break;
     case "Querieng" :
-        promCounter = Prometheus.IndexingQueryTime.counter;
-        break;
-    
+      promCounter = Prometheus.IndexingQueryTime.counter;
+      break;
   }
   Prometheus.SafeCounter.handleFloat(promCounter, sourceManager.activeSource.chain, Hrtime.toSecondsFloat(Hrtime.timeSince(sourceManager.statusStart)));
   sourceManager.statusStart = Hrtime.makeTimer();
@@ -115,49 +107,47 @@ function trackNewStatus(sourceManager, newStatus) {
 }
 
 async function fetchNext(sourceManager, fetchState, executeQuery, waitForNewBlock, onNewBlock, stateId) {
-  var nextQuery = FetchState.getNextQuery(fetchState, sourceManager.maxPartitionConcurrency - sourceManager.fetchingPartitionsCount | 0);
+  let nextQuery = FetchState.getNextQuery(fetchState, sourceManager.maxPartitionConcurrency - sourceManager.fetchingPartitionsCount | 0);
   if (typeof nextQuery !== "object") {
     switch (nextQuery) {
       case "WaitingForNewBlock" :
-          var waitingStateId = sourceManager.waitingForNewBlockStateId;
-          if (waitingStateId !== undefined && waitingStateId >= stateId) {
-            return ;
-          }
-          trackNewStatus(sourceManager, "WaitingForNewBlock");
-          sourceManager.waitingForNewBlockStateId = stateId;
-          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(knownHeight);
-          } else {
-            return ;
-          }
+        let waitingStateId = sourceManager.waitingForNewBlockStateId;
+        if (waitingStateId !== undefined && waitingStateId >= stateId) {
+          return;
+        }
+        trackNewStatus(sourceManager, "WaitingForNewBlock");
+        sourceManager.waitingForNewBlockStateId = stateId;
+        let knownHeight = await waitForNewBlock(fetchState.knownHeight);
+        let waitingStateId$1 = sourceManager.waitingForNewBlockStateId;
+        if (waitingStateId$1 !== undefined && waitingStateId$1 === stateId) {
+          trackNewStatus(sourceManager, "Idle");
+          sourceManager.waitingForNewBlockStateId = undefined;
+          return onNewBlock(knownHeight);
+        } else {
+          return;
+        }
       case "ReachedMaxConcurrency" :
       case "NothingToQuery" :
-          return ;
-      
+        return;
     }
   } else {
-    var queries = nextQuery._0;
+    let queries = nextQuery._0;
     FetchState.startFetchingQueries(fetchState, queries);
     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, (function (q) {
-                var promise = executeQuery(q);
-                promise.then(function (param) {
-                      sourceManager.fetchingPartitionsCount = sourceManager.fetchingPartitionsCount - 1 | 0;
-                      Prometheus.IndexingConcurrency.set(sourceManager.fetchingPartitionsCount, sourceManager.activeSource.chain);
-                      if (sourceManager.fetchingPartitionsCount === 0) {
-                        return trackNewStatus(sourceManager, "Idle");
-                      }
-                      
-                    });
-                return promise;
-              })));
-    return ;
+    await Promise.all(queries.map(q => {
+      let promise = executeQuery(q);
+      promise.then(param => {
+        sourceManager.fetchingPartitionsCount = sourceManager.fetchingPartitionsCount - 1 | 0;
+        Prometheus.IndexingConcurrency.set(sourceManager.fetchingPartitionsCount, sourceManager.activeSource.chain);
+        if (sourceManager.fetchingPartitionsCount === 0) {
+          return trackNewStatus(sourceManager, "Idle");
+        }
+      });
+      return promise;
+    }));
+    return;
   }
 }
 
@@ -166,102 +156,96 @@ function disableSource(sourceManager, sourceState) {
     return false;
   }
   sourceState.disabled = true;
-  var unsubscribe = sourceState.unsubscribe;
+  let unsubscribe = sourceState.unsubscribe;
   if (unsubscribe !== undefined) {
     unsubscribe();
   }
   if (sourceState.source.sourceFor === "Live") {
-    var hasOtherLive = sourceManager.sourcesState.some(function (s) {
-          if (s !== sourceState && !s.disabled) {
-            return s.source.sourceFor === "Live";
-          } else {
-            return false;
-          }
-        });
+    let hasOtherLive = sourceManager.sourcesState.some(s => {
+      if (s !== sourceState && !s.disabled) {
+        return s.source.sourceFor === "Live";
+      } else {
+        return false;
+      }
+    });
     sourceManager.hasLive = hasOtherLive;
   }
   return true;
 }
 
-async function getSourceNewHeight(sourceManager, sourceState, knownHeight, stallTimeout, isLive, status, logger) {
-  var source = sourceState.source;
-  var initialHeight = sourceState.knownHeight;
-  var newHeight = {
+async function getSourceNewHeight(sourceManager, sourceState, knownHeight, stallTimeout, isLive, status, logger, reducedPolling) {
+  let source = sourceState.source;
+  let initialHeight = sourceState.knownHeight;
+  let newHeight = {
     contents: initialHeight
   };
-  var retry = 0;
-  while(newHeight.contents <= knownHeight && status.contents !== "Done") {
-    var match = sourceState.unsubscribe;
+  let retry = 0;
+  while (newHeight.contents <= knownHeight && status.contents !== "Done") {
+    let match = sourceState.unsubscribe;
     if (match !== undefined) {
-      var subscriptionPromise = new Promise((function (resolve, _reject) {
-              sourceState.pendingHeightResolvers.push(resolve);
-            }));
-      var pollingFallback = Utils.delay(stallTimeout / 2 | 0).then(async function () {
-            Logging.childTrace(logger, {
-                  msg: "onHeight subscription stale, switching to polling fallback",
-                  source: source.name,
-                  chainId: source.chain
-                });
-            var h = initialHeight;
-            while(h <= knownHeight && newHeight.contents <= initialHeight) {
-              try {
-                h = await source.getHeightOrThrow();
-              }
-              catch (exn){
-                
-              }
-              if (h <= knownHeight && newHeight.contents <= initialHeight) {
-                await Utils.delay(source.pollingInterval);
-              }
-              
-            };
-            return h;
-          });
-      var height = await Promise.race([
-            subscriptionPromise,
-            pollingFallback
-          ]);
+      let subscriptionPromise = new Promise((resolve, _reject) => {
+        sourceState.pendingHeightResolvers.push(resolve);
+      });
+      let pollingFallback = Utils.delay(stallTimeout / 2 | 0).then(async () => {
+        Logging.childTrace(logger, {
+          msg: "onHeight subscription stale, switching to polling fallback",
+          source: source.name,
+          chainId: source.chain
+        });
+        let h = initialHeight;
+        while (h <= knownHeight && newHeight.contents <= initialHeight) {
+          try {
+            h = await source.getHeightOrThrow();
+          } catch (exn) {
+            
+          }
+          if (h <= knownHeight && newHeight.contents <= initialHeight) {
+            await Utils.delay(source.pollingInterval);
+          }
+        };
+        return h;
+      });
+      let height = await Promise.race([
+        subscriptionPromise,
+        pollingFallback
+      ]);
       if (height > initialHeight) {
         newHeight.contents = height;
       }
-      
     } else {
       try {
-        var height$1 = await source.getHeightOrThrow();
+        let height$1 = await source.getHeightOrThrow();
         newHeight.contents = height$1;
         if (height$1 <= knownHeight) {
           retry = 0;
-          var createSubscription = source.createHeightSubscription;
-          var exit = 0;
+          let createSubscription = source.createHeightSubscription;
+          let exit = 0;
           if (createSubscription !== undefined && isLive) {
-            var unsubscribe = createSubscription(function (newHeight) {
-                  sourceState.knownHeight = newHeight;
-                  var resolvers = sourceState.pendingHeightResolvers;
-                  sourceState.pendingHeightResolvers = [];
-                  Belt_Array.forEach(resolvers, (function (resolve) {
-                          resolve(newHeight);
-                        }));
-                });
+            let unsubscribe = createSubscription(newHeight => {
+              sourceState.knownHeight = newHeight;
+              let resolvers = sourceState.pendingHeightResolvers;
+              sourceState.pendingHeightResolvers = [];
+              resolvers.forEach(resolve => resolve(newHeight));
+            });
             sourceState.unsubscribe = unsubscribe;
           } else {
             exit = 1;
           }
           if (exit === 1) {
-            var pollingInterval = status.contents === "Stalled" ? sourceManager.stalledPollingInterval : source.pollingInterval;
+            let pollingInterval = reducedPolling ? sourceManager.reducedPollingInterval : (
+                status.contents === "Stalled" ? sourceManager.stalledPollingInterval : source.pollingInterval
+              );
             await Utils.delay(pollingInterval);
           }
-          
         }
-        
-      }
-      catch (raw_exn){
-        var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-        var retryInterval = sourceManager.getHeightRetryInterval(retry);
+      } catch (raw_exn) {
+        let exn = Primitive_exceptions.internalToException(raw_exn);
+        let retryInterval = sourceManager.getHeightRetryInterval(retry);
         Logging.childTrace(logger, {
-              msg: "Height retrieval from " + source.name + " source failed. Retrying in " + String(retryInterval) + "ms.",
-              source: source.name,
-              err: Utils.prettifyExn(exn)
-            });
+          msg: `Height retrieval from ` + source.name + ` source failed. Retrying in ` + retryInterval.toString() + `ms.`,
+          source: source.name,
+          err: Utils.prettifyExn(exn)
+        });
         retry = retry + 1 | 0;
         await Utils.delay(retryInterval);
       }
@@ -274,8 +258,8 @@ async function getSourceNewHeight(sourceManager, sourceState, knownHeight, stall
 }
 
 function compareByOldestFailure(a, b) {
-  var match = a.lastFailedAt;
-  var match$1 = b.lastFailedAt;
+  let match = a.lastFailedAt;
+  let match$1 = b.lastFailedAt;
   if (match !== undefined) {
     if (match$1 !== undefined) {
       if (match < match$1) {
@@ -296,276 +280,261 @@ function compareByOldestFailure(a, b) {
 }
 
 function getNextSources(sourceManager, isLive, excludedSources) {
-  var now = Date.now();
-  var workingPrimarySources = [];
-  var allPrimarySources = [];
-  var workingSecondarySources = [];
-  for(var i = 0 ,i_finish = sourceManager.sourcesState.length; i < i_finish; ++i){
-    var sourceState = sourceManager.sourcesState[i];
+  let now = Date.now();
+  let workingPrimarySources = [];
+  let allPrimarySources = [];
+  let workingSecondarySources = [];
+  for (let i = 0, i_finish = sourceManager.sourcesState.length; i < i_finish; ++i) {
+    let sourceState = sourceManager.sourcesState[i];
     if (!sourceState.disabled) {
-      var isExcluded = excludedSources !== undefined ? Caml_option.valFromOption(excludedSources).has(sourceState) : false;
+      let isExcluded = excludedSources !== undefined ? Primitive_option.valFromOption(excludedSources).has(sourceState) : false;
       if (!isExcluded) {
-        var failedAt = sourceState.lastFailedAt;
-        var isWorking = failedAt !== undefined ? now - failedAt >= sourceManager.recoveryTimeout : true;
-        var match = getSourceRole(sourceState.source.sourceFor, isLive, sourceManager.hasLive);
+        let failedAt = sourceState.lastFailedAt;
+        let isWorking = failedAt !== undefined ? now - failedAt >= sourceManager.recoveryTimeout : true;
+        let match = getSourceRole(sourceState.source.sourceFor, isLive, sourceManager.hasLive);
         if (match !== undefined) {
           if (match === "Primary") {
             allPrimarySources.push(sourceState);
             if (isWorking) {
               workingPrimarySources.push(sourceState);
             }
-            
           } else if (isWorking) {
             workingSecondarySources.push(sourceState);
           }
-          
         }
-        
       }
-      
     }
-    
   }
   if (workingPrimarySources.length !== 0) {
     return workingPrimarySources;
   } else if (workingSecondarySources.length !== 0) {
     return workingSecondarySources;
   } else {
-    return allPrimarySources.sort(compareByOldestFailure);
+    allPrimarySources.sort(compareByOldestFailure);
+    return allPrimarySources;
   }
 }
 
 function getNextSource(sourceManager, isLive, excludedSources) {
-  var sources = getNextSources(sourceManager, isLive, excludedSources);
-  var first = Belt_Array.get(sources, 0);
+  let sources = getNextSources(sourceManager, isLive, excludedSources);
+  let first = sources[0];
   if (first === undefined) {
-    return ;
+    return;
   }
   if (first.source === sourceManager.activeSource) {
     return first;
   }
-  var result = sources.find(function (s) {
-        return s.source === sourceManager.activeSource;
-      });
+  let result = sources.find(s => s.source === sourceManager.activeSource);
   if (result !== undefined) {
-    if (result === undefined) {
-      return ;
-    } else {
-      return Caml_option.some(result);
-    }
+    return result;
   } else {
-    return Belt_Array.get(sources, 0);
+    return sources[0];
   }
 }
 
-async function waitForNewBlock(sourceManager, knownHeight, isLive) {
-  var sourcesState = sourceManager.sourcesState;
-  var logger = Logging.createChild({
-        chainId: sourceManager.activeSource.chain,
-        knownHeight: knownHeight
-      });
-  Logging.childTrace(logger, "Initiating check for new blocks.");
-  var mainSources = getNextSources(sourceManager, isLive, undefined);
-  var status = {
+async function waitForNewBlock(sourceManager, knownHeight, isLive, reducedPolling) {
+  let sourcesState = sourceManager.sourcesState;
+  let logger = Logging.createChild({
+    chainId: sourceManager.activeSource.chain,
+    knownHeight: knownHeight
+  });
+  if (reducedPolling) {
+    Logging.childTrace(logger, `Waiting for new blocks with reduced polling (` + (sourceManager.reducedPollingInterval / 1000 | 0).toString() + `s). Chain is caught up, waiting for other chains to backfill.`);
+  } else {
+    Logging.childTrace(logger, "Initiating check for new blocks.");
+  }
+  let mainSources = getNextSources(sourceManager, isLive, undefined);
+  let status = {
     contents: "Active"
   };
-  var stallTimeout = isLive ? sourceManager.newBlockStallTimeoutLive : sourceManager.newBlockStallTimeout;
-  var match = await Promise.race(Belt_Array.concat(Belt_Array.map(mainSources, (async function (sourceState) {
-                  return [
-                          sourceState.source,
-                          await getSourceNewHeight(sourceManager, sourceState, knownHeight, stallTimeout, isLive, status, logger)
-                        ];
-                })), [Utils.delay(stallTimeout).then(function () {
-                  var fallbackSources = [];
-                  Belt_Array.forEach(sourcesState, (function (sourceState) {
-                          if (!mainSources.includes(sourceState) && Belt_Option.isSome(getSourceRole(sourceState.source.sourceFor, isLive, sourceManager.hasLive))) {
-                            fallbackSources.push(sourceState);
-                            return ;
-                          }
-                          
-                        }));
-                  if (status.contents !== "Done") {
-                    status.contents = "Stalled";
-                    if (fallbackSources.length !== 0) {
-                      Logging.childWarn(logger, "No new blocks detected within " + String(stallTimeout / 1000 | 0) + "s. Continuing polling with secondary RPC sources from the configuration.");
-                    } else {
-                      Logging.childWarn(logger, "No new blocks detected within " + String(stallTimeout / 1000 | 0) + "s. Polling will continue at a reduced rate. For better reliability, refer to our RPC fallback guide: https://docs.envio.dev/docs/HyperIndex/rpc-sync");
-                    }
-                  }
-                  return Promise.race(Belt_Array.map(fallbackSources, (async function (sourceState) {
-                                    return [
-                                            sourceState.source,
-                                            await getSourceNewHeight(sourceManager, sourceState, knownHeight, stallTimeout, isLive, status, logger)
-                                          ];
-                                  })));
-                })]));
-  var newBlockHeight = match[1];
-  var source = match[0];
+  let stallTimeout = reducedPolling ? (sourceManager.reducedPollingInterval << 1) : (
+      isLive ? sourceManager.newBlockStallTimeoutLive : sourceManager.newBlockStallTimeout
+    );
+  let match = await Promise.race(mainSources.map(async sourceState => [
+    sourceState.source,
+    await getSourceNewHeight(sourceManager, sourceState, knownHeight, stallTimeout, isLive, status, logger, reducedPolling)
+  ]).concat([Utils.delay(stallTimeout).then(() => {
+      let fallbackSources = [];
+      sourcesState.forEach(sourceState => {
+        if (!mainSources.includes(sourceState) && Stdlib_Option.isSome(getSourceRole(sourceState.source.sourceFor, isLive, sourceManager.hasLive))) {
+          fallbackSources.push(sourceState);
+          return;
+        }
+      });
+      if (status.contents !== "Done") {
+        status.contents = "Stalled";
+        if (fallbackSources.length !== 0) {
+          Logging.childWarn(logger, `No new blocks detected within ` + (stallTimeout / 1000 | 0).toString() + `s. Continuing polling with secondary RPC sources from the configuration.`);
+        } else {
+          Logging.childWarn(logger, `No new blocks detected within ` + (stallTimeout / 1000 | 0).toString() + `s. Polling will continue at a reduced rate. For better reliability, refer to our RPC fallback guide: https://docs.envio.dev/docs/HyperIndex/rpc-sync`);
+        }
+      }
+      return Promise.race(fallbackSources.map(async sourceState => [
+        sourceState.source,
+        await getSourceNewHeight(sourceManager, sourceState, knownHeight, stallTimeout, isLive, status, logger, reducedPolling)
+      ]));
+    })]));
+  let newBlockHeight = match[1];
+  let source = match[0];
   sourceManager.activeSource = source;
-  var log = status.contents === "Stalled" ? Logging.childInfo : Logging.childTrace;
+  let log = status.contents === "Stalled" ? Logging.childInfo : Logging.childTrace;
   log(logger, {
-        msg: "New blocks successfully found.",
-        source: source.name,
-        newBlockHeight: newBlockHeight
-      });
+    msg: `New blocks successfully found.`,
+    source: source.name,
+    newBlockHeight: newBlockHeight
+  });
   status.contents = "Done";
   return newBlockHeight;
 }
 
 async function executeQuery(sourceManager, query, knownHeight, isLive) {
-  var excludedSourcesRef;
-  var toBlockRef = query.toBlock;
-  var responseRef;
-  var retryRef = 0;
-  while(Belt_Option.isNone(responseRef)) {
-    var s = getNextSource(sourceManager, isLive, excludedSourcesRef);
-    var sourceState;
+  let excludedSourcesRef;
+  let toBlockRef = query.toBlock;
+  let responseRef;
+  let retryRef = 0;
+  while (Stdlib_Option.isNone(responseRef)) {
+    let s = getNextSource(sourceManager, isLive, excludedSourcesRef);
+    let sourceState;
     if (s !== undefined) {
       if (s.source !== sourceManager.activeSource) {
-        var logger = Logging.createChild({
-              chainId: sourceManager.activeSource.chain
-            });
+        let logger = Logging.createChild({
+          chainId: sourceManager.activeSource.chain
+        });
         Logging.childInfo(logger, {
-              msg: "Switching data-source",
-              source: s.source.name,
-              previousSource: sourceManager.activeSource.name,
-              fromBlock: query.fromBlock
-            });
+          msg: "Switching data-source",
+          source: s.source.name,
+          previousSource: sourceManager.activeSource.name,
+          fromBlock: query.fromBlock
+        });
       }
       sourceState = s;
     } else {
-      var logger$1 = Logging.createChild({
-            chainId: sourceManager.activeSource.chain
-          });
+      let logger$1 = Logging.createChild({
+        chainId: sourceManager.activeSource.chain
+      });
       sourceState = ErrorHandling.mkLogAndRaise(logger$1, "The indexer doesn't have data-sources which can continue fetching. Please, check the error logs or reach out to the Envio team.", null);
     }
     sourceManager.activeSource = sourceState.source;
-    var source = sourceState.source;
-    var toBlock = toBlockRef;
-    var retry = retryRef;
-    var logger$2 = Logging.createChild({
-          chainId: source.chain,
-          logType: "Block Range Query",
-          partitionId: query.partitionId,
-          source: source.name,
-          fromBlock: query.fromBlock,
-          toBlock: toBlock,
-          addresses: FetchState.addressesByContractNameCount(query.addressesByContractName),
-          retry: retry
-        });
+    let source = sourceState.source;
+    let toBlock = toBlockRef;
+    let retry = retryRef;
+    let logger$2 = Logging.createChild({
+      chainId: source.chain,
+      logType: "Block Range Query",
+      partitionId: query.partitionId,
+      source: source.name,
+      fromBlock: query.fromBlock,
+      toBlock: toBlock,
+      addresses: FetchState.addressesByContractNameCount(query.addressesByContractName),
+      retry: retry
+    });
     try {
-      var response = await source.getItemsOrThrow(query.fromBlock, toBlock, query.addressesByContractName, query.indexingContracts, knownHeight, query.partitionId, query.selection, retry, logger$2);
+      let response = await source.getItemsOrThrow(query.fromBlock, toBlock, query.addressesByContractName, query.indexingAddresses, knownHeight, query.partitionId, query.selection, retry, logger$2);
       Logging.childTrace(logger$2, {
-            msg: "Fetched block range from server",
-            toBlock: response.latestFetchedBlockNumber,
-            numEvents: response.parsedQueueItems.length,
-            stats: response.stats
-          });
+        msg: "Fetched block range from server",
+        toBlock: response.latestFetchedBlockNumber,
+        numEvents: response.parsedQueueItems.length,
+        stats: response.stats
+      });
       sourceState.lastFailedAt = undefined;
       responseRef = response;
-    }
-    catch (raw_error){
-      var error = Caml_js_exceptions.internalToOCamlException(raw_error);
+    } catch (raw_error) {
+      let error = Primitive_exceptions.internalToException(raw_error);
       if (error.RE_EXN_ID === Source.GetItemsError) {
-        var error$1 = error._1;
-        var exit = 0;
+        let error$1 = error._1;
+        let exit = 0;
         switch (error$1.TAG) {
           case "UnsupportedSelection" :
           case "FailedGettingFieldSelection" :
-              exit = 1;
-              break;
+            exit = 1;
+            break;
           case "FailedGettingItems" :
-              var match = error$1.retry;
-              var attemptedToBlock = error$1.attemptedToBlock;
-              var exn = error$1.exn;
-              switch (match.TAG) {
-                case "WithSuggestedToBlock" :
-                    var toBlock$1 = match.toBlock;
-                    Logging.childTrace(logger$2, {
-                          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.backoffMillis;
-                    var log = retry >= 4 ? Logging.childWarn : Logging.childTrace;
-                    log(logger$2, {
-                          msg: match.message,
-                          toBlock: attemptedToBlock,
-                          backOffMilliseconds: backoffMillis,
-                          retry: retry,
-                          err: Utils.prettifyExn(exn)
-                        });
-                    var shouldSwitch = retry === 0 || retry === 1 ? false : retry % 2 === 0;
-                    if (shouldSwitch) {
-                      var now = Date.now();
-                      sourceState.lastFailedAt = now;
-                      var nextSource = getNextSource(sourceManager, isLive, excludedSourcesRef);
-                      var hasWorkingAlternative;
-                      if (nextSource !== undefined) {
-                        var failedAt = nextSource.lastFailedAt;
-                        hasWorkingAlternative = failedAt !== undefined ? now - failedAt >= sourceManager.recoveryTimeout : true;
-                      } else {
-                        hasWorkingAlternative = false;
-                      }
-                      if (!hasWorkingAlternative) {
-                        await Utils.delay(backoffMillis < 60000 ? backoffMillis : 60000);
-                      }
-                      
-                    } else {
-                      await Utils.delay(backoffMillis < 60000 ? backoffMillis : 60000);
-                    }
-                    retryRef = retryRef + 1 | 0;
-                    break;
-                case "ImpossibleForTheQuery" :
-                    var s$1 = excludedSourcesRef;
-                    var excludedSources;
-                    if (s$1 !== undefined) {
-                      excludedSources = Caml_option.valFromOption(s$1);
-                    } else {
-                      var s$2 = new Set();
-                      excludedSourcesRef = Caml_option.some(s$2);
-                      excludedSources = s$2;
-                    }
-                    excludedSources.add(sourceState);
-                    Logging.childWarn(logger$2, {
-                          msg: match.message + " - Attempting another source",
-                          toBlock: attemptedToBlock,
-                          err: Utils.prettifyExn(exn)
-                        });
-                    retryRef = 0;
-                    break;
-                
-              }
-              break;
-          
+            let match = error$1.retry;
+            let attemptedToBlock = error$1.attemptedToBlock;
+            let exn = error$1.exn;
+            switch (match.TAG) {
+              case "WithSuggestedToBlock" :
+                let toBlock$1 = match.toBlock;
+                Logging.childTrace(logger$2, {
+                  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" :
+                let backoffMillis = match.backoffMillis;
+                let log = retry >= 4 ? Logging.childWarn : Logging.childTrace;
+                log(logger$2, {
+                  msg: match.message,
+                  toBlock: attemptedToBlock,
+                  backOffMilliseconds: backoffMillis,
+                  retry: retry,
+                  err: Utils.prettifyExn(exn)
+                });
+                let shouldSwitch = retry !== 0 && retry !== 1 ? retry % 2 === 0 : false;
+                if (shouldSwitch) {
+                  let now = Date.now();
+                  sourceState.lastFailedAt = now;
+                  let nextSource = getNextSource(sourceManager, isLive, excludedSourcesRef);
+                  let hasWorkingAlternative;
+                  if (nextSource !== undefined) {
+                    let failedAt = nextSource.lastFailedAt;
+                    hasWorkingAlternative = failedAt !== undefined ? now - failedAt >= sourceManager.recoveryTimeout : true;
+                  } else {
+                    hasWorkingAlternative = false;
+                  }
+                  if (!hasWorkingAlternative) {
+                    await Utils.delay(Primitive_int.min(backoffMillis, 60000));
+                  }
+                } else {
+                  await Utils.delay(Primitive_int.min(backoffMillis, 60000));
+                }
+                retryRef = retryRef + 1 | 0;
+                break;
+              case "ImpossibleForTheQuery" :
+                let s$1 = excludedSourcesRef;
+                let excludedSources;
+                if (s$1 !== undefined) {
+                  excludedSources = Primitive_option.valFromOption(s$1);
+                } else {
+                  let s$2 = new Set();
+                  excludedSourcesRef = Primitive_option.some(s$2);
+                  excludedSources = s$2;
+                }
+                excludedSources.add(sourceState);
+                Logging.childWarn(logger$2, {
+                  msg: match.message + " - Attempting another source",
+                  toBlock: attemptedToBlock,
+                  err: Utils.prettifyExn(exn)
+                });
+                retryRef = 0;
+                break;
+            }
+            break;
         }
         if (exit === 1) {
-          var notAlreadyDisabled = disableSource(sourceManager, sourceState);
+          let notAlreadyDisabled = disableSource(sourceManager, sourceState);
           if (notAlreadyDisabled) {
             switch (error$1.TAG) {
               case "UnsupportedSelection" :
-                  Logging.childError(logger$2, error$1.message);
-                  break;
+                Logging.childError(logger$2, error$1.message);
+                break;
               case "FailedGettingFieldSelection" :
-                  Logging.childError(logger$2, {
-                        msg: error$1.message,
-                        err: Utils.prettifyExn(error$1.exn),
-                        blockNumber: error$1.blockNumber,
-                        logIndex: error$1.logIndex
-                      });
-                  break;
+                Logging.childError(logger$2, {
+                  msg: error$1.message,
+                  err: Utils.prettifyExn(error$1.exn),
+                  blockNumber: error$1.blockNumber,
+                  logIndex: error$1.logIndex
+                });
+                break;
               case "FailedGettingItems" :
-                  break;
-              
+                break;
             }
           }
           retryRef = 0;
         }
-        
       } else {
         ErrorHandling.mkLogAndRaise(logger$2, "Failed to fetch block Range", error);
       }
@@ -575,12 +544,12 @@ async function executeQuery(sourceManager, query, knownHeight, isLive) {
 }
 
 export {
-  getSourceRole ,
-  make ,
-  getActiveSource ,
-  fetchNext ,
-  waitForNewBlock ,
-  executeQuery ,
-  makeGetHeightRetryInterval ,
+  getSourceRole,
+  make,
+  getActiveSource,
+  fetchNext,
+  waitForNewBlock,
+  executeQuery,
+  makeGetHeightRetryInterval,
 }
 /* Utils Not a pure module */