envio 3.3.0-alpha.1 → 3.3.0-alpha.11

package/src/sources/RpcSource.res.mjs

@@ -4,19 +4,16 @@ import * as Rpc from "./Rpc.res.mjs";
 import * as Rest from "../vendored/Rest.res.mjs";
 import * as Time from "../Time.res.mjs";
 import * as Utils from "../Utils.res.mjs";
-import * as Hrtime from "../bindings/Hrtime.res.mjs";
 import * as Source from "./Source.res.mjs";
 import * as Address from "../Address.res.mjs";
 import * as Logging from "../Logging.res.mjs";
 import * as Internal from "../Internal.res.mjs";
-import * as FetchState from "../FetchState.res.mjs";
 import * as LazyLoader from "../LazyLoader.res.mjs";
-import * as Prometheus from "../Prometheus.res.mjs";
-import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
-import * as EventRouter from "./EventRouter.res.mjs";
+import * as Performance from "../bindings/Performance.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as EvmRpcClient from "./EvmRpcClient.res.mjs";
-import * as LogSelection from "../LogSelection.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.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";
@@ -27,8 +24,6 @@ import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as RpcWebSocketHeightStream from "./RpcWebSocketHeightStream.res.mjs";
 
-let QueryTimout = /* @__PURE__ */Primitive_exceptions.create("RpcSource.QueryTimout");
-
 let TransactionDataNotFound = /* @__PURE__ */Primitive_exceptions.create("RpcSource.TransactionDataNotFound");
 
 async function getKnownRawBlock(client, blockNumber) {
@@ -49,11 +44,11 @@ function parseBlockInfo(json) {
   };
 }
 
-async function getKnownRawBlockWithBackoff(client, sourceName, chain, blockNumber, backoffMsOnFailure) {
+async function getKnownRawBlockWithBackoff(client, sourceName, chain, blockNumber, backoffMsOnFailure, recordRequest) {
   let currentBackoff = backoffMsOnFailure;
   let result;
   while (Stdlib_Option.isNone(result)) {
-    Prometheus.SourceRequestCount.increment(sourceName, chain, "eth_getBlockByNumber");
+    let timerRef = Performance.now();
     let exit = 0;
     let json;
     try {
@@ -61,6 +56,7 @@ async function getKnownRawBlockWithBackoff(client, sourceName, chain, blockNumbe
       exit = 1;
     } catch (raw_err) {
       let err = Primitive_exceptions.internalToException(raw_err);
+      recordRequest("eth_getBlockByNumber", Performance.secondsSince(timerRef));
       Logging.warn({
         err: Utils.prettifyExn(err),
         msg: `Issue while running fetching batch of events from the RPC. Will wait ` + currentBackoff.toString() + `ms and try again.`,
@@ -72,318 +68,128 @@ async function getKnownRawBlockWithBackoff(client, sourceName, chain, blockNumbe
       currentBackoff = (currentBackoff << 1);
     }
     if (exit === 1) {
+      recordRequest("eth_getBlockByNumber", Performance.secondsSince(timerRef));
       result = json;
     }
   };
   return Stdlib_Option.getOrThrow(result, undefined);
 }
 
-let suggestedRangeRegExp = /retry with the range (\d+)-(\d+)/;
-
-let blockRangeLimitRegExp = /limited to a (\d+) blocks range/;
-
-let alchemyRangeRegExp = /up to a (\d+) block range/;
-
-let cloudflareRangeRegExp = /Max range: (\d+)/;
-
-let thirdwebRangeRegExp = /Maximum allowed number of requested blocks is (\d+)/;
-
-let blockpiRangeRegExp = /limited to (\d+) block/;
-
-let baseRangeRegExp = /block range too large/;
-
-let maxAllowedBlocksRegExp = /maximum allowed is (\d+) blocks/;
-
-let blastPaidRegExp = /exceeds the range allowed for your plan \(\d+ > (\d+)\)/;
-
-let chainstackRegExp = /Block range limit exceeded./;
-
-let coinbaseRegExp = /please limit the query to at most (\d+) blocks/;
-
-let publicNodeRegExp = /maximum block range: (\d+)/;
-
-let hyperliquidRegExp = /query exceeds max block range (\d+)/;
-
-function parseMessageForBlockRange(message) {
-  let extractBlockRange = (execResult, isMaxRange) => {
-    let match = execResult.slice(1);
-    if (match.length !== 1) {
-      return;
-    }
-    let blockRangeLimit = match[0];
-    if (blockRangeLimit === undefined) {
-      return;
-    }
-    let blockRangeLimit$1 = Stdlib_Int.fromString(blockRangeLimit, undefined);
-    if (blockRangeLimit$1 !== undefined && blockRangeLimit$1 > 0) {
-      return [
-        blockRangeLimit$1,
-        isMaxRange
-      ];
-    }
-  };
-  let execResult = suggestedRangeRegExp.exec(message);
-  if (execResult == null) {
-    let execResult$1 = blockRangeLimitRegExp.exec(message);
-    if (!(execResult$1 == null)) {
-      return extractBlockRange(execResult$1, true);
-    }
-    let execResult$2 = alchemyRangeRegExp.exec(message);
-    if (!(execResult$2 == null)) {
-      return extractBlockRange(execResult$2, true);
-    }
-    let execResult$3 = cloudflareRangeRegExp.exec(message);
-    if (!(execResult$3 == null)) {
-      return extractBlockRange(execResult$3, true);
-    }
-    let execResult$4 = thirdwebRangeRegExp.exec(message);
-    if (!(execResult$4 == null)) {
-      return extractBlockRange(execResult$4, true);
-    }
-    let execResult$5 = blockpiRangeRegExp.exec(message);
-    if (!(execResult$5 == null)) {
-      return extractBlockRange(execResult$5, true);
-    }
-    let execResult$6 = maxAllowedBlocksRegExp.exec(message);
-    if (!(execResult$6 == null)) {
-      return extractBlockRange(execResult$6, true);
-    }
-    let match = baseRangeRegExp.exec(message);
-    if (!(match == null)) {
-      return [
-        2000,
-        true
-      ];
-    }
-    let execResult$7 = blastPaidRegExp.exec(message);
-    if (!(execResult$7 == null)) {
-      return extractBlockRange(execResult$7, true);
-    }
-    let match$1 = chainstackRegExp.exec(message);
-    if (!(match$1 == null)) {
-      return [
-        10000,
-        true
-      ];
-    }
-    let execResult$8 = coinbaseRegExp.exec(message);
-    if (!(execResult$8 == null)) {
-      return extractBlockRange(execResult$8, true);
-    }
-    let execResult$9 = publicNodeRegExp.exec(message);
-    if (!(execResult$9 == null)) {
-      return extractBlockRange(execResult$9, true);
-    }
-    let execResult$10 = hyperliquidRegExp.exec(message);
-    if (!(execResult$10 == null)) {
-      return extractBlockRange(execResult$10, true);
-    } else {
-      return;
-    }
+function getErrorMessage(exn) {
+  if (exn.RE_EXN_ID === Rpc.JsonRpcError) {
+    return exn._1.message;
+  }
+  if (exn.RE_EXN_ID !== "JsExn") {
+    return;
   }
-  let match$2 = execResult.slice(1);
-  if (match$2.length !== 2) {
+  let msg = Stdlib_JsExn.message(exn._1);
+  if (msg === undefined) {
     return;
   }
-  let fromBlock = match$2[0];
-  if (fromBlock === undefined) {
+  let obj;
+  try {
+    obj = Stdlib_JSON.Decode.object(JSON.parse(msg));
+  } catch (exn$1) {
     return;
   }
-  let toBlock = match$2[1];
-  if (toBlock === undefined) {
+  if (obj === undefined) {
     return;
   }
-  let match$3 = Stdlib_Int.fromString(fromBlock, undefined);
-  let match$4 = Stdlib_Int.fromString(toBlock, undefined);
-  if (match$3 !== undefined && match$4 !== undefined && match$4 >= match$3) {
-    return [
-      (match$4 - match$3 | 0) + 1 | 0,
-      false
-    ];
+  let match = obj["errorMessage"];
+  if (typeof match === "string") {
+    return match;
   }
 }
 
-function getSuggestedBlockIntervalFromExn(exn) {
-  if (exn.RE_EXN_ID === Rpc.JsonRpcError) {
-    return parseMessageForBlockRange(exn._1.message);
-  }
+function parseGetNextPageRetryError(exn) {
   if (exn.RE_EXN_ID !== "JsExn") {
     return;
   }
+  let msg = Stdlib_JsExn.message(exn._1);
+  if (msg === undefined) {
+    return;
+  }
+  let obj;
   try {
-    let message = exn._1.error.message;
-    S$RescriptSchema.assertOrThrow(message, S$RescriptSchema.string);
-    return parseMessageForBlockRange(message);
+    obj = Stdlib_JSON.Decode.object(JSON.parse(msg));
   } catch (exn$1) {
     return;
   }
-}
-
-let maxSuggestedBlockIntervalKey = "max";
-
-function getNextPage(fromBlock, toBlock, addresses, topicQuery, loadBlock, sc, client, mutSuggestedBlockIntervals, partitionId, sourceName, chainId) {
-  let queryTimoutPromise = Time.resolvePromiseAfterDelay(sc.queryTimeoutMillis).then(() => Promise.reject({
-    RE_EXN_ID: QueryTimout,
-    _1: `Query took longer than ` + (sc.queryTimeoutMillis / 1000 | 0).toString() + ` seconds`
-  }));
-  let latestFetchedBlockPromise = loadBlock(toBlock);
-  Prometheus.SourceRequestCount.increment(sourceName, chainId, "eth_getLogs");
-  let logsPromise = Rpc.getLogs(client, {
-    fromBlock: fromBlock,
-    toBlock: toBlock,
-    address: addresses,
-    topics: topicQuery
-  }).then(async logs => ({
-    logs: logs,
-    latestFetchedBlockInfo: await latestFetchedBlockPromise
-  }));
-  return Stdlib_Promise.$$catch(Promise.race([
-    queryTimoutPromise,
-    logsPromise
-  ]), err => {
-    let match = getSuggestedBlockIntervalFromExn(err);
-    if (match !== undefined) {
-      let nextBlockIntervalTry = match[0];
-      mutSuggestedBlockIntervals[match[1] ? maxSuggestedBlockIntervalKey : partitionId] = nextBlockIntervalTry;
-      throw {
-        RE_EXN_ID: Source.GetItemsError,
-        _1: {
-          TAG: "FailedGettingItems",
-          exn: err,
-          attemptedToBlock: toBlock,
-          retry: {
-            TAG: "WithSuggestedToBlock",
-            toBlock: (fromBlock + nextBlockIntervalTry | 0) - 1 | 0
+  if (obj === undefined) {
+    return;
+  }
+  let match = obj["kind"];
+  let match$1 = obj["attemptedToBlock"];
+  let match$2 = obj["retry"];
+  if (match === undefined) {
+    return;
+  }
+  if (typeof match !== "string") {
+    return;
+  }
+  if (match !== "Retry") {
+    return;
+  }
+  if (match$1 === undefined) {
+    return;
+  }
+  if (typeof match$1 !== "number") {
+    return;
+  }
+  if (match$2 === undefined) {
+    return;
+  }
+  if (typeof match$2 !== "object" || match$2 === null || Array.isArray(match$2)) {
+    return;
+  }
+  let match$3 = obj["requestStats"];
+  let requestStats = match$3 !== undefined ? (
+      Array.isArray(match$3) ? Stdlib_Array.filterMap(match$3, s => {
+          let o = Stdlib_JSON.Decode.object(s);
+          if (o === undefined) {
+            return;
           }
-        },
-        Error: new Error()
-      };
-    }
-    let executedBlockInterval = (toBlock - fromBlock | 0) + 1 | 0;
-    let nextBlockIntervalTry$1 = executedBlockInterval * sc.backoffMultiplicative | 0;
-    mutSuggestedBlockIntervals[partitionId] = nextBlockIntervalTry$1;
-    throw {
-      RE_EXN_ID: Source.GetItemsError,
-      _1: {
-        TAG: "FailedGettingItems",
-        exn: err,
-        attemptedToBlock: toBlock,
-        retry: {
-          TAG: "WithBackoff",
-          message: `Failed getting data for the block range. Will try smaller block range for the next attempt.`,
-          backoffMillis: sc.backoffMillis
-        }
-      },
-      Error: new Error()
-    };
-  });
-}
-
-function getSelectionConfig(selection, chain) {
-  let staticTopicSelections = [];
-  let dynamicEventFilters = [];
-  selection.eventConfigs.forEach(param => {
-    let s = param.getEventFiltersOrThrow(chain);
-    if (s.TAG === "Static") {
-      staticTopicSelections.push(...s._0);
-      return;
-    }
-    dynamicEventFilters.push(s._0);
-  });
-  let match = LogSelection.compressTopicSelections(staticTopicSelections);
-  let len = match.length;
-  let getLogSelectionOrThrow;
-  if (len !== 1) {
-    if (len !== 0) {
-      throw {
-        RE_EXN_ID: Source.GetItemsError,
-        _1: {
-          TAG: "UnsupportedSelection",
-          message: "RPC data-source currently supports event filters only when there's a single wildcard event. Please, create a GitHub issue if it's a blocker for you."
-        },
-        Error: new Error()
-      };
-    }
-    let len$1 = dynamicEventFilters.length;
-    if (len$1 !== 1) {
-      if (len$1 !== 0) {
-        throw {
-          RE_EXN_ID: Source.GetItemsError,
-          _1: {
-            TAG: "UnsupportedSelection",
-            message: "RPC data-source currently supports event filters only when there's a single wildcard event. Please, create a GitHub issue if it's a blocker for you."
-          },
-          Error: new Error()
-        };
-      }
-      throw {
-        RE_EXN_ID: Source.GetItemsError,
-        _1: {
-          TAG: "UnsupportedSelection",
-          message: "Invalid events configuration for the partition. Nothing to fetch. Please, report to the Envio team."
-        },
-        Error: new Error()
-      };
-    }
-    let dynamicEventFilter = dynamicEventFilters[0];
-    if (selection.eventConfigs.length === 1) {
-      let eventConfig = Utils.$$Array.firstUnsafe(selection.eventConfigs);
-      getLogSelectionOrThrow = addressesByContractName => {
-        let addresses = FetchState.addressesByContractNameGetAll(addressesByContractName);
-        let match = dynamicEventFilter(addresses);
-        if (match.length !== 1) {
-          throw {
-            RE_EXN_ID: Source.GetItemsError,
-            _1: {
-              TAG: "UnsupportedSelection",
-              message: "RPC data-source currently doesn't support an array of event filters. Please, create a GitHub issue if it's a blocker for you."
-            },
-            Error: new Error()
-          };
-        }
-        return {
-          addresses: eventConfig.isWildcard ? undefined : addresses,
-          topicQuery: Rpc.GetLogs.mapTopicQuery(match[0])
-        };
-      };
-    } else {
-      throw {
-        RE_EXN_ID: Source.GetItemsError,
-        _1: {
-          TAG: "UnsupportedSelection",
-          message: "RPC data-source currently supports event filters only when there's a single wildcard event. Please, create a GitHub issue if it's a blocker for you."
-        },
-        Error: new Error()
-      };
+          let match = o["method"];
+          let match$1 = o["seconds"];
+          if (typeof match === "string" && typeof match$1 === "number") {
+            return {
+              method: match,
+              seconds: match$1
+            };
+          }
+        }) : []
+    ) : [];
+  let match$4 = match$2["tag"];
+  let retry;
+  if (typeof match$4 === "string") {
+    switch (match$4) {
+      case "WithBackoff" :
+        let match$5 = match$2["message"];
+        let match$6 = match$2["backoffMillis"];
+        retry = typeof match$5 === "string" && typeof match$6 === "number" ? ({
+            TAG: "WithBackoff",
+            message: match$5,
+            backoffMillis: match$6 | 0
+          }) : undefined;
+        break;
+      case "WithSuggestedToBlock" :
+        let match$7 = match$2["toBlock"];
+        retry = typeof match$7 === "number" ? ({
+            TAG: "WithSuggestedToBlock",
+            toBlock: match$7 | 0
+          }) : undefined;
+        break;
+      default:
+        retry = undefined;
     }
   } else {
-    let topicSelection = match[0];
-    if (dynamicEventFilters.length !== 0) {
-      throw {
-        RE_EXN_ID: Source.GetItemsError,
-        _1: {
-          TAG: "UnsupportedSelection",
-          message: "RPC data-source currently supports event filters only when there's a single wildcard event. Please, create a GitHub issue if it's a blocker for you."
-        },
-        Error: new Error()
-      };
-    }
-    let topicQuery = Rpc.GetLogs.mapTopicQuery(topicSelection);
-    getLogSelectionOrThrow = addressesByContractName => {
-      let addresses = FetchState.addressesByContractNameGetAll(addressesByContractName);
-      return {
-        addresses: addresses.length !== 0 ? addresses : undefined,
-        topicQuery: topicQuery
-      };
-    };
+    retry = undefined;
   }
-  return {
-    getLogSelectionOrThrow: getLogSelectionOrThrow
-  };
-}
-
-function memoGetSelectionConfig(chain) {
-  return Utils.$$WeakMap.memoize(selection => getSelectionConfig(selection, chain));
+  return Stdlib_Option.map(retry, retry => [
+    match$1 | 0,
+    retry,
+    requestStats
+  ]);
 }
 
 let lowercaseAddressSchema = S$RescriptSchema.transform(S$RescriptSchema.string, param => ({
@@ -918,22 +724,35 @@ function makeThrowingGetEventTransaction(getTransactionJson, getReceiptJson, low
 }
 
 function make(param) {
+  let headers = param.headers;
   let lowercaseAddresses = param.lowercaseAddresses;
-  let allEventParams = param.allEventParams;
-  let eventRouter = param.eventRouter;
+  let onEventRegistrations = param.onEventRegistrations;
   let chain = param.chain;
   let url = param.url;
   let syncConfig = param.syncConfig;
   let host = Utils.Url.getHostFromUrl(url);
   let urlHost = host !== undefined ? host : Stdlib_JsError.throwWithMessage(`The RPC url for chain ` + chain.toString() + ` is in incorrect format. The RPC url needs to start with either http:// or https://`);
   let name = `RPC (` + urlHost + `)`;
-  let getSelectionConfig = memoGetSelectionConfig(chain);
-  let mutSuggestedBlockIntervals = {};
-  let client = Rpc.makeClient(url);
-  let rpcClient = EvmRpcClient.make(url, undefined);
+  let client = Rpc.makeClient(url, headers);
+  let rpcClient = EvmRpcClient.make(url, !lowercaseAddresses, syncConfig, undefined, headers, HyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations));
+  let pendingRequestStats = [];
+  let recordRequest = (method, seconds) => {
+    pendingRequestStats.push({
+      method: method,
+      seconds: seconds
+    });
+  };
+  let drainRequestStats = () => {
+    let stats = pendingRequestStats.slice();
+    Utils.$$Array.clearInPlace(pendingRequestStats);
+    return stats;
+  };
   let makeTransactionLoader = () => LazyLoader.make(transactionHash => {
-    Prometheus.SourceRequestCount.increment(name, chain, "eth_getTransactionByHash");
-    return Rest.fetch(Rpc.GetTransactionByHash.rawRoute, transactionHash, client);
+    let timerRef = Performance.now();
+    return Rest.fetch(Rpc.GetTransactionByHash.rawRoute, transactionHash, client).then(res => {
+      recordRequest("eth_getTransactionByHash", Performance.secondsSince(timerRef));
+      return res;
+    });
   }, (am, exn) => Logging.error({
     err: Utils.prettifyExn(exn),
     msg: `Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in ` + (am._retryDelayMillis / 1000 | 0).toString() + ` seconds. It is highly likely that your indexer isn't syncing on one or more chains currently. Also take a look at the "suggestedFix" in the metadata of this command`,
@@ -944,7 +763,7 @@ function make(param) {
       suggestedFix: "This likely means the RPC url you are using is not responding correctly. Please try another RPC endipoint."
     }
   }), undefined, undefined, undefined, undefined);
-  let makeBlockLoader = () => LazyLoader.make(blockNumber => getKnownRawBlockWithBackoff(client, name, chain, blockNumber, 1000), (am, exn) => Logging.error({
+  let makeBlockLoader = () => LazyLoader.make(blockNumber => getKnownRawBlockWithBackoff(client, name, chain, blockNumber, 1000, recordRequest), (am, exn) => Logging.error({
     err: Utils.prettifyExn(exn),
     msg: `Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in ` + (am._retryDelayMillis / 1000 | 0).toString() + ` seconds. It is highly likely that your indexer isn't syncing on one or more chains currently. Also take a look at the "suggestedFix" in the metadata of this command`,
     source: name,
@@ -955,8 +774,11 @@ function make(param) {
     }
   }), undefined, undefined, undefined, undefined);
   let makeReceiptLoader = () => LazyLoader.make(transactionHash => {
-    Prometheus.SourceRequestCount.increment(name, chain, "eth_getTransactionReceipt");
-    return Rest.fetch(Rpc.GetTransactionReceipt.rawRoute, transactionHash, client);
+    let timerRef = Performance.now();
+    return Rest.fetch(Rpc.GetTransactionReceipt.rawRoute, transactionHash, client).then(res => {
+      recordRequest("eth_getTransactionReceipt", Performance.secondsSince(timerRef));
+      return res;
+    });
   }, (am, exn) => Logging.error({
     err: Utils.prettifyExn(exn),
     msg: `Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in ` + (am._retryDelayMillis / 1000 | 0).toString() + ` seconds. It is highly likely that your indexer isn't syncing on one or more chains currently. Also take a look at the "suggestedFix" in the metadata of this command`,
@@ -998,65 +820,45 @@ function make(param) {
       Error: new Error()
     };
   }, lowercaseAddresses);
-  let convertLogToHyperSyncEvent = log => {
-    let hyperSyncLog_removed = log.removed;
-    let hyperSyncLog_logIndex = log.logIndex;
-    let hyperSyncLog_transactionIndex = log.transactionIndex;
-    let hyperSyncLog_transactionHash = log.transactionHash;
-    let hyperSyncLog_blockHash = log.blockHash;
-    let hyperSyncLog_blockNumber = log.blockNumber;
-    let hyperSyncLog_address = Primitive_option.some(log.address);
-    let hyperSyncLog_data = log.data;
-    let hyperSyncLog_topics = log.topics;
-    let hyperSyncLog = {
-      removed: hyperSyncLog_removed,
-      logIndex: hyperSyncLog_logIndex,
-      transactionIndex: hyperSyncLog_transactionIndex,
-      transactionHash: hyperSyncLog_transactionHash,
-      blockHash: hyperSyncLog_blockHash,
-      blockNumber: hyperSyncLog_blockNumber,
-      address: hyperSyncLog_address,
-      data: hyperSyncLog_data,
-      topics: hyperSyncLog_topics
-    };
-    return {
-      log: hyperSyncLog
-    };
-  };
-  let hscDecoder = {
-    contents: undefined
-  };
-  let getHscDecoder = () => {
-    let decoder = hscDecoder.contents;
-    if (decoder !== undefined) {
-      return decoder;
-    }
-    let decoder$1 = HyperSyncClient.Decoder.fromParams(allEventParams, !lowercaseAddresses);
-    hscDecoder.contents = decoder$1;
-    return decoder$1;
-  };
-  let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, indexingAddresses, knownHeight, partitionId, selection, retry, param) => {
-    let startFetchingBatchTimeRef = Hrtime.makeTimer();
-    let maxSuggestedBlockInterval = mutSuggestedBlockIntervals[maxSuggestedBlockIntervalKey];
-    let suggestedBlockInterval = maxSuggestedBlockInterval !== undefined ? maxSuggestedBlockInterval : Stdlib_Option.getOr(mutSuggestedBlockIntervals[partitionId], syncConfig.initialBlockInterval);
+  let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, param, knownHeight, partitionId, selection, param$1, retry, param$2) => {
+    let startFetchingBatchTimeRef = Performance.now();
     let toBlock$1 = toBlock !== undefined ? Primitive_int.min(toBlock, knownHeight) : knownHeight;
-    let suggestedToBlock = Primitive_int.max(Primitive_int.min((fromBlock + suggestedBlockInterval | 0) - 1 | 0, toBlock$1), fromBlock);
     let firstBlockParentPromise = fromBlock > 0 ? LazyLoader.get(blockLoader.contents, fromBlock - 1 | 0).then(json => parseBlockInfo(json)) : Promise.resolve(undefined);
-    let match = getSelectionConfig(selection);
-    let match$1 = match.getLogSelectionOrThrow(addressesByContractName);
-    let match$2 = await getNextPage(fromBlock, suggestedToBlock, match$1.addresses, match$1.topicQuery, blockNumber => LazyLoader.get(blockLoader.contents, blockNumber).then(parseBlockInfo), syncConfig, client, mutSuggestedBlockIntervals, partitionId, name, chain);
-    let latestFetchedBlockInfo = match$2.latestFetchedBlockInfo;
-    let logs = match$2.logs;
-    let executedBlockInterval = (suggestedToBlock - fromBlock | 0) + 1 | 0;
-    if (executedBlockInterval >= suggestedBlockInterval && !(maxSuggestedBlockIntervalKey in mutSuggestedBlockIntervals)) {
-      mutSuggestedBlockIntervals[partitionId] = Primitive_int.min(executedBlockInterval + syncConfig.accelerationAdditive | 0, syncConfig.intervalCeiling);
+    if (Utils.$$Array.isEmpty(selection.onEventRegistrations)) {
+      throw {
+        RE_EXN_ID: Source.GetItemsError,
+        _1: {
+          TAG: "UnsupportedSelection",
+          message: "Invalid events configuration for the partition. Nothing to fetch. Please, report to the Envio team."
+        },
+        Error: new Error()
+      };
     }
-    let hyperSyncEvents = logs.map(convertLogToHyperSyncEvent);
-    let parsedEvents;
+    let match;
     try {
-      parsedEvents = await getHscDecoder().decodeLogs(hyperSyncEvents);
+      match = await rpcClient.getNextPage({
+        fromBlock: fromBlock,
+        toBlockCeiling: toBlock$1,
+        partitionId: partitionId,
+        registrationIndexes: selection.onEventRegistrations.map(reg => reg.index),
+        addressesByContractName: addressesByContractName
+      });
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
+      let match$1 = parseGetNextPageRetryError(exn);
+      if (match$1 !== undefined) {
+        match$1[2].forEach(stat => recordRequest(stat.method, stat.seconds));
+        throw {
+          RE_EXN_ID: Source.GetItemsError,
+          _1: {
+            TAG: "FailedGettingItems",
+            exn: exn,
+            attemptedToBlock: match$1[0],
+            retry: match$1[1]
+          },
+          Error: new Error()
+        };
+      }
       throw {
         RE_EXN_ID: Source.GetItemsError,
         _1: {
@@ -1064,26 +866,22 @@ function make(param) {
           exn: exn,
           attemptedToBlock: toBlock$1,
           retry: {
-            TAG: "ImpossibleForTheQuery",
-            message: "Failed to parse events using hypersync client decoder. Please double-check your ABI."
+            TAG: "WithBackoff",
+            message: "Unexpected issue while fetching events from the RPC client. Attempt a retry.",
+            backoffMillis: retry !== 0 ? 1000 * retry | 0 : 500
           }
         },
         Error: new Error()
       };
     }
-    let parsedQueueItems = await Promise.all(Stdlib_Array.filterMap(Stdlib_Array.zip(logs, parsedEvents), param => {
-      let log = param[0];
-      let topic0 = Stdlib_Option.getOr(log.topics[0], "0x0");
-      let routedAddress = lowercaseAddresses ? Address.Evm.fromAddressLowercaseOrThrow(log.address) : Address.Evm.fromAddressOrThrow(log.address);
-      let eventConfig = EventRouter.get(eventRouter, EventRouter.getEvmEventId(topic0, log.topics.length), routedAddress, log.blockNumber, indexingAddresses);
-      if (eventConfig === undefined) {
-        return;
-      }
-      let decoded = Stdlib_Option.flatMap(Primitive_option.fromNullable(param[1]), __x => __x[eventConfig.contractName]);
-      if (decoded === undefined) {
-        return;
-      }
-      let decoded$1 = Primitive_option.valFromOption(decoded);
+    let items = match.items;
+    match.requestStats.forEach(stat => recordRequest(stat.method, stat.seconds));
+    let latestFetchedBlockInfo = await LazyLoader.get(blockLoader.contents, match.toBlock).then(parseBlockInfo);
+    let parsedQueueItems = await Promise.all(items.map(param => {
+      let decoded = param.params;
+      let log = param.log;
+      let onEventRegistration = onEventRegistrations[param.onEventRegistrationIndex];
+      let eventConfig = onEventRegistration.eventConfig;
       return (async () => {
         let match;
         try {
@@ -1125,27 +923,26 @@ function make(param) {
         let block = match[0];
         return {
           kind: 0,
-          eventConfig: eventConfig,
-          timestamp: block.timestamp,
+          onEventRegistration: onEventRegistration,
           chain: chain,
           blockNumber: block.number,
-          blockHash: block.hash,
           logIndex: log.logIndex,
+          transactionIndex: log.transactionIndex,
           payload: {
             contractName: eventConfig.contractName,
             eventName: eventConfig.name,
-            params: decoded$1,
+            params: decoded,
             chainId: chain,
-            srcAddress: routedAddress,
+            srcAddress: log.address,
             logIndex: log.logIndex,
-            transaction: match[1],
-            block: block
+            transaction: Primitive_option.some(match[1]),
+            block: Primitive_option.some(block)
           }
         };
       })();
     }));
     let optFirstBlockParent = await firstBlockParentPromise;
-    let totalTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(startFetchingBatchTimeRef));
+    let totalTimeElapsed = Performance.secondsSince(startFetchingBatchTimeRef);
     let blockHashes = [];
     let pushBlockInfo = b => {
       blockHashes.push({
@@ -1164,7 +961,8 @@ function make(param) {
     if (optFirstBlockParent !== undefined) {
       pushBlockInfo(optFirstBlockParent);
     }
-    logs.forEach(log => {
+    items.forEach(param => {
+      let log = param.log;
       blockHashes.push({
         blockHash: log.blockHash,
         blockNumber: log.blockNumber
@@ -1174,12 +972,15 @@ function make(param) {
       knownHeight: knownHeight,
       blockHashes: blockHashes,
       parsedQueueItems: parsedQueueItems,
+      transactionStore: undefined,
+      blockStore: undefined,
       fromBlockQueried: fromBlock,
       latestFetchedBlockNumber: latestFetchedBlockInfo.number,
       latestFetchedBlockTimestamp: latestFetchedBlockInfo.timestamp,
       stats: {
         "total time elapsed (s)": totalTimeElapsed
-      }
+      },
+      requestStats: drainRequestStats()
     };
   };
   let onReorg = param => {
@@ -1187,19 +988,28 @@ function make(param) {
     transactionLoader.contents = makeTransactionLoader();
     receiptLoader.contents = makeReceiptLoader();
   };
-  let getBlockHashes = (blockNumbers, _currentlyUnusedLogger) => Stdlib_Promise.$$catch(Promise.all(blockNumbers.map(blockNum => LazyLoader.get(blockLoader.contents, blockNum))).then(rawBlocks => ({
-    TAG: "Ok",
-    _0: rawBlocks.map(json => {
-      let b = parseBlockInfo(json);
-      return {
-        blockHash: b.hash,
-        blockNumber: b.number,
-        blockTimestamp: b.timestamp
-      };
-    })
-  })), exn => Promise.resolve({
-    TAG: "Error",
-    _0: exn
+  let getBlockHashes = (blockNumbers, _currentlyUnusedLogger) => Stdlib_Promise.$$catch(Promise.all(blockNumbers.map(blockNum => LazyLoader.get(blockLoader.contents, blockNum))).then(rawBlocks => {
+    let result = {
+      TAG: "Ok",
+      _0: rawBlocks.map(json => {
+        let b = parseBlockInfo(json);
+        return {
+          blockHash: b.hash,
+          blockNumber: b.number,
+          blockTimestamp: b.timestamp
+        };
+      })
+    };
+    return {
+      result: result,
+      requestStats: drainRequestStats()
+    };
+  }), exn => Promise.resolve({
+    result: {
+      TAG: "Error",
+      _0: exn
+    },
+    requestStats: drainRequestStats()
   }));
   let createHeightSubscription = Stdlib_Option.map(param.ws, wsUrl => (onHeight => RpcWebSocketHeightStream.subscribe(wsUrl, chain, onHeight)));
   return {
@@ -1210,20 +1020,19 @@ function make(param) {
     pollingInterval: syncConfig.pollingInterval,
     getBlockHashes: getBlockHashes,
     getHeightOrThrow: async () => {
-      let timerRef = Hrtime.makeTimer();
+      let timerRef = Performance.now();
       let height;
       try {
         height = await rpcClient.getHeight();
       } catch (exn) {
-        let seconds = Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef));
-        Prometheus.SourceRequestCount.increment(name, chain, "eth_blockNumber");
-        Prometheus.SourceRequestCount.addSeconds(name, chain, "eth_blockNumber", seconds);
+        recordRequest("eth_blockNumber", Performance.secondsSince(timerRef));
         throw exn;
       }
-      let seconds$1 = Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef));
-      Prometheus.SourceRequestCount.increment(name, chain, "eth_blockNumber");
-      Prometheus.SourceRequestCount.addSeconds(name, chain, "eth_blockNumber", seconds$1);
-      return height;
+      recordRequest("eth_blockNumber", Performance.secondsSince(timerRef));
+      return {
+        height: height,
+        requestStats: drainRequestStats()
+      };
     },
     getItemsOrThrow: getItemsOrThrow,
     createHeightSubscription: createHeightSubscription,
@@ -1232,16 +1041,12 @@ function make(param) {
 }
 
 export {
-  QueryTimout,
   TransactionDataNotFound,
   getKnownRawBlock,
   parseBlockInfo,
   getKnownRawBlockWithBackoff,
-  getSuggestedBlockIntervalFromExn,
-  maxSuggestedBlockIntervalKey,
-  getNextPage,
-  getSelectionConfig,
-  memoGetSelectionConfig,
+  getErrorMessage,
+  parseGetNextPageRetryError,
   lowercaseAddressSchema,
   checksumAddressSchema,
   makeBlockFieldRegistry,