envio 3.9.0 → 3.10.0

package/src/sources/SourceManager.res.mjs

@@ -4,6 +4,7 @@ import * as Utils from "../Utils.res.mjs";
 import * as Source from "./Source.res.mjs";
 import * as Logging from "../Logging.res.mjs";
 import * as FetchState from "../FetchState.res.mjs";
+import * as HeightFeed from "./HeightFeed.res.mjs";
 import * as Performance from "../bindings/Performance.res.mjs";
 import * as ErrorHandling from "../ErrorHandling.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
@@ -13,16 +14,16 @@ import * as Primitive_float from "@rescript/runtime/lib/es6/Primitive_float.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 recordRequestStats(sourceState, requestStats) {
+function recordStatsInto(aggregates, requestStats) {
   requestStats.forEach(param => {
     let seconds = param.seconds;
     let method = param.method;
-    let agg = sourceState.requestStats[method];
+    let agg = aggregates[method];
     if (agg !== undefined) {
       agg.count = agg.count + 1 | 0;
       agg.seconds = agg.seconds + seconds;
     } else {
-      sourceState.requestStats[method] = {
+      aggregates[method] = {
         count: 1,
         seconds: seconds
       };
@@ -54,11 +55,28 @@ function getRequestStatSamples(sourceManager) {
 function getSourceHeightSamples(sourceManager) {
   let samples = [];
   sourceManager.sourcesState.forEach(sourceState => {
-    if (sourceState.knownHeight > 0) {
+    let knownHeight = HeightFeed.knownHeight(sourceState.feed);
+    if (knownHeight > 0) {
       samples.push({
         sourceName: sourceState.source.name,
         chainId: sourceState.source.chainId,
-        height: sourceState.knownHeight
+        height: knownHeight
+      });
+      return;
+    }
+  });
+  return samples;
+}
+
+function getHeightStreamSamples(sourceManager) {
+  let samples = [];
+  sourceManager.sourcesState.forEach(sourceState => {
+    let stream = HeightFeed.sample(sourceState.feed);
+    if (stream !== undefined) {
+      samples.push({
+        sourceName: sourceState.source.name,
+        chainId: sourceState.source.chainId,
+        stream: stream
       });
       return;
     }
@@ -252,15 +270,16 @@ function make(sources, isRealtime, newBlockStallTimeoutOpt, newBlockStallTimeout
   let source = sources.find(source => getSourceRole(source.sourceFor, isRealtime, hasRealtime) === "Primary");
   let initialActiveSource = source !== undefined ? source : Stdlib_JsError.throwWithMessage("Invalid configuration, no data-source for historical sync provided");
   return {
-    sourcesState: sources.map(source => ({
-      source: source,
-      knownHeight: 0,
-      unsubscribe: undefined,
-      pendingHeightResolvers: [],
-      disabled: false,
-      lastFailedAt: undefined,
-      requestStats: {}
-    })),
+    sourcesState: sources.map(source => {
+      let requestStats = {};
+      return {
+        source: source,
+        feed: HeightFeed.make(source, stats => recordStatsInto(requestStats, stats), getHeightRetryInterval),
+        disabled: false,
+        lastFailedAt: undefined,
+        requestStats: requestStats
+      };
+    }),
     statusStart: Performance.now(),
     status: "Idle",
     idleSeconds: 0,
@@ -270,7 +289,6 @@ function make(sources, isRealtime, newBlockStallTimeoutOpt, newBlockStallTimeout
     newBlockStallTimeoutRealtime: newBlockStallTimeoutRealtime,
     stalledPollingInterval: stalledPollingInterval,
     reducedPollingInterval: reducedPollingInterval,
-    getHeightRetryInterval: getHeightRetryInterval,
     activeSource: initialActiveSource,
     waitingForNewBlockStateId: undefined,
     waitingLogged: false,
@@ -345,10 +363,7 @@ function disableSource(sourceManager, sourceState) {
     return false;
   }
   sourceState.disabled = true;
-  let unsubscribe = sourceState.unsubscribe;
-  if (unsubscribe !== undefined) {
-    unsubscribe();
-  }
+  HeightFeed.stop(sourceState.feed);
   if (sourceState.source.sourceFor === "Realtime") {
     let hasOtherRealtime = sourceManager.sourcesState.some(s => {
       if (s !== sourceState && !s.disabled) {
@@ -362,105 +377,6 @@ function disableSource(sourceManager, sourceState) {
   return true;
 }
 
-async function getSourceNewHeight(sourceManager, sourceState, knownHeight, stallTimeout, isRealtime, status, logger, reducedPolling) {
-  let source = sourceState.source;
-  let initialHeight = sourceState.knownHeight;
-  let newHeight = {
-    contents: initialHeight
-  };
-  let retry = 0;
-  while (newHeight.contents <= knownHeight && status.contents !== "Done") {
-    let match = sourceState.unsubscribe;
-    if (match !== undefined) {
-      let subscriptionPromise = new Promise((resolve, _reject) => {
-        sourceState.pendingHeightResolvers.push(resolve);
-      });
-      let half = stallTimeout / 2 | 0;
-      let pollingFallback = Utils.delay(half + (Math.random() * half | 0) | 0).then(async () => {
-        Logging.childTrace(logger, {
-          msg: "onHeight subscription stale, switching to polling fallback",
-          source: source.name,
-          chainId: source.chainId
-        });
-        let h = initialHeight;
-        while (h <= knownHeight && newHeight.contents <= initialHeight) {
-          try {
-            let res = await source.getHeightOrThrow();
-            recordRequestStats(sourceState, res.requestStats);
-            h = res.height;
-          } 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 {
-        let res = await source.getHeightOrThrow();
-        recordRequestStats(sourceState, res.requestStats);
-        let height$1 = res.height;
-        newHeight.contents = height$1;
-        if (height$1 <= knownHeight) {
-          retry = 0;
-          let createSubscription = source.createHeightSubscription;
-          let exit = 0;
-          if (createSubscription !== undefined && isRealtime) {
-            let unsubscribe = createSubscription(newHeight => {
-              if (newHeight <= sourceState.knownHeight) {
-                return recordRequestStats(sourceState, [{
-                    method: "heightPushIgnored",
-                    seconds: 0
-                  }]);
-              }
-              recordRequestStats(sourceState, [{
-                  method: "heightPush",
-                  seconds: 0
-                }]);
-              sourceState.knownHeight = newHeight;
-              let resolvers = sourceState.pendingHeightResolvers;
-              sourceState.pendingHeightResolvers = [];
-              resolvers.forEach(resolve => resolve(newHeight));
-            });
-            sourceState.unsubscribe = unsubscribe;
-          } else {
-            exit = 1;
-          }
-          if (exit === 1) {
-            let pollingInterval = reducedPolling ? sourceManager.reducedPollingInterval : (
-                status.contents === "Stalled" ? sourceManager.stalledPollingInterval : source.pollingInterval
-              );
-            await Utils.delay(pollingInterval);
-          }
-        }
-      } 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 ` + retryInterval.toString() + `ms.`,
-          source: source.name,
-          err: Utils.prettifyExn(exn)
-        });
-        retry = retry + 1 | 0;
-        await Utils.delay(retryInterval);
-      }
-    }
-  };
-  if (newHeight.contents > sourceState.knownHeight) {
-    sourceState.knownHeight = newHeight.contents;
-  }
-  return newHeight.contents;
-}
-
 function compareByOldestFailure(a, b) {
   let match = a.lastFailedAt;
   let match$1 = b.lastFailedAt;
@@ -536,10 +452,6 @@ function getNextSource(sourceManager, isRealtime, excludedSources) {
   }
 }
 
-function retryBackoffMillis(retry) {
-  return Primitive_float.min(100 * 2 ** retry, 60000) | 0;
-}
-
 async function backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, minBackoffMillisOpt, excludedSources) {
   let minBackoffMillis = minBackoffMillisOpt !== undefined ? minBackoffMillisOpt : 0;
   let switchedToWorkingSource;
@@ -568,7 +480,7 @@ async function backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime,
 }
 
 async function retryBehindHead(sourceManager, sourceState, retry, isRealtime, logger, blockNumber, method, err, excludedSources) {
-  let backoffMillis = retryBackoffMillis(retry);
+  let backoffMillis = Utils.expBackoff(100, retry, 60000);
   let log = retry >= 4 ? Logging.childWarn : Logging.childTrace;
   log(logger, {
     msg: `Block #` + blockNumber.toString() + ` is not available on the ` + sourceState.source.name + ` source yet. Instances of a load-balanced backend drift slightly around the head, so this is expected - indexing continues after an automatic retry.`,
@@ -581,7 +493,7 @@ async function retryBehindHead(sourceManager, sourceState, retry, isRealtime, lo
 }
 
 async function retryInconsistentResponse(sourceManager, sourceState, retry, isRealtime, logger, method, err, excludedSources) {
-  let backoffMillis = retryBackoffMillis(retry);
+  let backoffMillis = Utils.expBackoff(100, retry, 60000);
   let msg = `Received a partial indicator of a possible reorg from the ` + sourceState.source.name + ` source while fetching ` + method + `. Retrying the request to better identify whether a reorg happened.`;
   let match = retry >= 13 ? [
       Logging.childError,
@@ -601,7 +513,7 @@ async function retryInconsistentResponse(sourceManager, sourceState, retry, isRe
   return await backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, 50, excludedSources);
 }
 
-async function waitForNewBlock(sourceManager, knownHeight, isRealtime, reducedPolling) {
+function waitForNewBlock(sourceManager, knownHeight, isRealtime, reducedPolling) {
   let sourcesState = sourceManager.sourcesState;
   let logger = Logging.createChild({
     chainId: sourceManager.activeSource.chainId,
@@ -612,48 +524,112 @@ async function waitForNewBlock(sourceManager, knownHeight, isRealtime, reducedPo
     sourceManager.waitingLogged = true;
   }
   let mainSources = getNextSources(sourceManager, isRealtime, undefined);
-  let status = {
-    contents: "Active"
+  let stalled = {
+    contents: false
   };
   let stallTimeout = reducedPolling ? (sourceManager.reducedPollingInterval << 1) : (
       isRealtime ? sourceManager.newBlockStallTimeoutRealtime : sourceManager.newBlockStallTimeout
     );
-  let match = await Promise.race(mainSources.map(async sourceState => [
-    sourceState.source,
-    await getSourceNewHeight(sourceManager, sourceState, knownHeight, stallTimeout, isRealtime, status, logger, reducedPolling)
-  ]).concat([Utils.delay(stallTimeout).then(() => {
-      let fallbackSources = [];
-      sourcesState.forEach(sourceState => {
-        if (!sourceState.disabled && !mainSources.includes(sourceState) && Stdlib_Option.isSome(getSourceRole(sourceState.source.sourceFor, isRealtime, sourceManager.hasRealtime))) {
-          fallbackSources.push(sourceState);
+  return new Promise((resolve, _reject) => {
+    let watched = [];
+    let pokeTimeoutId = {
+      contents: undefined
+    };
+    let stallTimeoutId = {
+      contents: undefined
+    };
+    let cleanup = () => {
+      watched.forEach(subscription => subscription.unsubscribe());
+      Utils.$$Array.clearInPlace(watched);
+      Utils.clearTimeoutRef(pokeTimeoutId);
+      Utils.clearTimeoutRef(stallTimeoutId);
+    };
+    let settled = {
+      contents: false
+    };
+    let watch = (sourceState, withStream) => {
+      if (settled.contents) {
+        return;
+      }
+      if (withStream) {
+        HeightFeed.enableStream(sourceState.feed);
+      }
+      let subscription = HeightFeed.onHeightAbove(sourceState.feed, knownHeight, () => {
+        if (reducedPolling) {
+          return sourceManager.reducedPollingInterval;
+        } else if (stalled.contents) {
+          return sourceManager.stalledPollingInterval;
+        } else {
+          return sourceState.source.pollingInterval;
+        }
+      }, height => {
+        let source = sourceState.source;
+        if (settled.contents) {
           return;
         }
+        settled.contents = true;
+        cleanup();
+        sourceManager.activeSource = source;
+        let log = stalled.contents ? Logging.childInfo : Logging.childTrace;
+        log(logger, {
+          msg: `New blocks successfully found.`,
+          source: source.name,
+          newBlockHeight: height
+        });
+        sourceManager.waitingLogged = false;
+        resolve(height);
       });
-      if (status.contents !== "Done") {
-        status.contents = "Stalled";
+      if (settled.contents) {
+        return subscription.unsubscribe();
+      } else {
+        watched.push(subscription);
+        return;
+      }
+    };
+    mainSources.forEach(sourceState => watch(sourceState, isRealtime));
+    if (settled.contents) {
+      return;
+    }
+    let armPokeTimeout = () => {
+      pokeTimeoutId.contents = Primitive_option.some(setTimeout(() => {
+        pokeTimeoutId.contents = undefined;
+        if (!settled.contents) {
+          watched.forEach(subscription => subscription.distrustStream());
+        }
+        if (!settled.contents) {
+          return armPokeTimeout();
+        }
+      }, Utils.jitter(stallTimeout)));
+    };
+    let armStallTimeout = () => {
+      stallTimeoutId.contents = Primitive_option.some(setTimeout(() => {
+        stallTimeoutId.contents = undefined;
+        if (settled.contents) {
+          return;
+        }
+        stalled.contents = true;
+        let fallbackSources = [];
+        sourcesState.forEach(sourceState => {
+          if (!sourceState.disabled && !mainSources.includes(sourceState) && Stdlib_Option.isSome(getSourceRole(sourceState.source.sourceFor, isRealtime, sourceManager.hasRealtime))) {
+            fallbackSources.push(sourceState);
+            return;
+          }
+        });
         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, isRealtime, status, logger, reducedPolling)
-      ]));
-    })]));
-  let newBlockHeight = match[1];
-  let source = match[0];
-  sourceManager.activeSource = source;
-  let log = status.contents === "Stalled" ? Logging.childInfo : Logging.childTrace;
-  log(logger, {
-    msg: `New blocks successfully found.`,
-    source: source.name,
-    newBlockHeight: newBlockHeight
+        fallbackSources.forEach(sourceState => watch(sourceState, false));
+        if (!settled.contents) {
+          watched.forEach(subscription => subscription.distrustStream());
+          return;
+        }
+      }, stallTimeout));
+    };
+    armPokeTimeout();
+    armStallTimeout();
   });
-  sourceManager.waitingLogged = false;
-  status.contents = "Done";
-  return newBlockHeight;
 }
 
 async function executeQuery(sourceManager, query, knownHeight, isRealtime) {
@@ -699,22 +675,20 @@ async function executeQuery(sourceManager, query, knownHeight, isRealtime) {
     });
     try {
       let response = await source.getItemsOrThrow(query.fromBlock, toBlock, query.addresses, knownHeight, query.partitionId, FetchState.narrowSelectionToRange(query.selection, toBlock), query.itemsTarget, retry, logger$2);
-      recordRequestStats(sourceState, response.requestStats);
+      recordStatsInto(sourceState.requestStats, response.requestStats);
       validateResponseBlockStore("getItems", response.blockStore, undefined);
       sourceState.lastFailedAt = undefined;
-      if (response.knownHeight > sourceState.knownHeight) {
-        sourceState.knownHeight = response.knownHeight;
-      }
+      HeightFeed.recordHeight(sourceState.feed, response.knownHeight);
       responseRef = response;
     } catch (raw_err) {
       let err = Primitive_exceptions.internalToException(raw_err);
       if (err.RE_EXN_ID === Source.RateLimited) {
         let match = err._1;
-        recordRequestStats(sourceState, match.requestStats);
+        recordStatsInto(sourceState.requestStats, match.requestStats);
         await waitForRateLimitReset(sourceManager, match.resetMs, retry, logger$2);
         retryRef = retryRef + 1 | 0;
       } else if (err.RE_EXN_ID === Source.SourceBehindHead) {
-        recordRequestStats(sourceState, err.requestStats);
+        recordStatsInto(sourceState.requestStats, err.requestStats);
         await retryBehindHead(sourceManager, sourceState, retry, isRealtime, logger$2, err.blockNumber, "getItems", err, excludedSourcesRef);
         retryRef = retryRef + 1 | 0;
       } else if (err.RE_EXN_ID === Source.InconsistentResponse) {
@@ -831,7 +805,7 @@ async function getBlockHashes(sourceManager, blockNumbers, isRealtime) {
     });
     try {
       let res = await source.getBlockHashes(blockNumbers, logger$1);
-      recordRequestStats(sourceState, res.requestStats);
+      recordStatsInto(sourceState.requestStats, res.requestStats);
       let data = res.result;
       if (data.TAG === "Ok") {
         let data$1 = data._0;
@@ -845,18 +819,18 @@ async function getBlockHashes(sourceManager, blockNumbers, isRealtime) {
       let err = Primitive_exceptions.internalToException(raw_err);
       if (err.RE_EXN_ID === Source.RateLimited) {
         let match = err._1;
-        recordRequestStats(sourceState, match.requestStats);
+        recordStatsInto(sourceState.requestStats, match.requestStats);
         await waitForRateLimitReset(sourceManager, match.resetMs, retry, logger$1);
         retryRef = retryRef + 1 | 0;
       } else if (err.RE_EXN_ID === Source.SourceBehindHead) {
-        recordRequestStats(sourceState, err.requestStats);
+        recordStatsInto(sourceState.requestStats, err.requestStats);
         await retryBehindHead(sourceManager, sourceState, retry, isRealtime, logger$1, err.blockNumber, "getBlockHashes", err, undefined);
         retryRef = retryRef + 1 | 0;
       } else if (err.RE_EXN_ID === Source.InconsistentResponse) {
         await retryInconsistentResponse(sourceManager, sourceState, retry, isRealtime, logger$1, "getBlockHashes", err, undefined);
         retryRef = retryRef + 1 | 0;
       } else {
-        let backoffMillis = retryBackoffMillis(retry);
+        let backoffMillis = Utils.expBackoff(100, retry, 60000);
         let log = retry >= 4 ? Logging.childWarn : Logging.childTrace;
         log(logger$1, {
           msg: "Failed to fetch block hashes. Retrying.",
@@ -878,6 +852,7 @@ export {
   getActiveSource,
   getRequestStatSamples,
   getSourceHeightSamples,
+  getHeightStreamSamples,
   idleSeconds,
   waitingForNewBlockSeconds,
   queryingSeconds,

package/src/sources/SourceManager.resi

@@ -39,6 +39,14 @@ type sourceHeightSample = {
 
 let getSourceHeightSamples: t => array<sourceHeightSample>
 
+type heightStreamSample = {
+  sourceName: string,
+  chainId: ChainId.t,
+  stream: HeightFeed.streamSample,
+}
+
+let getHeightStreamSamples: t => array<heightStreamSample>
+
 let idleSeconds: t => float
 let waitingForNewBlockSeconds: t => float
 let queryingSeconds: t => float

package/src/sources/Svm.res

@@ -52,6 +52,8 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   blockTimestampName: "time",
   blockHashName: "hash",
   onBlockMethodName: "onSlot",
+  contractNoun: "program",
+  eventNoun: "instruction",
   // SVM filter shape: `{slot: {_gte?, _lte?, _every?}}`.
   // Inner range chunk parsed by `blockRangeSchema` in `Main.res`.
   onBlockFilterSchema: S.object(s => s.field("slot", S.option(S.unknown))),

package/src/sources/Svm.res.mjs

@@ -59,6 +59,8 @@ function make(logger) {
     blockTimestampName: "time",
     blockHashName: "hash",
     onBlockMethodName: "onSlot",
+    contractNoun: "program",
+    eventNoun: "instruction",
     onBlockFilterSchema: S$RescriptSchema.object(s => s.f("slot", S$RescriptSchema.option(S$RescriptSchema.unknown))),
     onEventBlockFilterSchema: S$RescriptSchema.object(param => {}),
     logger: logger,