envio 3.3.0-alpha.4 → 3.3.0-alpha.6

package/src/sources/RpcSource.res.mjs

@@ -8,7 +8,6 @@ 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";
@@ -21,7 +20,6 @@ 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 Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
-import * as HyperSyncClient from "./HyperSyncClient.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
@@ -78,6 +76,43 @@ async function getKnownRawBlockWithBackoff(client, sourceName, chain, blockNumbe
   return Stdlib_Option.getOrThrow(result, undefined);
 }
 
+function getErrorMessage(exn) {
+  if (exn.RE_EXN_ID === Rpc.JsonRpcError) {
+    return exn._1.message;
+  }
+  if (exn.RE_EXN_ID !== "JsExn") {
+    return;
+  }
+  try {
+    let message = exn._1.error.message;
+    S$RescriptSchema.assertOrThrow(message, S$RescriptSchema.string);
+    return message;
+  } catch (exn$1) {
+    return;
+  }
+}
+
+let patterns = [
+  /more than \d+ logs/i,
+  /\d+ logs returned/i,
+  /too many logs/i,
+  /query returned more than \d+ results/i,
+  /query exceeds max results/i,
+  /response size should not/i,
+  /(backend )?response too large/i,
+  /logs matched by query exceeds limit/i,
+  /block range is too wide/i
+];
+
+function isResponseTooLargeError(exn) {
+  let message = getErrorMessage(exn);
+  if (message !== undefined) {
+    return patterns.some(re => re.test(message));
+  } else {
+    return false;
+  }
+}
+
 let suggestedRangeRegExp = /retry with the range (\d+)-(\d+)/;
 
 let blockRangeLimitRegExp = /limited to a (\d+) blocks range/;
@@ -104,281 +139,288 @@ 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;
+function getSuggestedBlockIntervalFromExn(exn) {
+  let message = getErrorMessage(exn);
+  if (message !== undefined) {
+    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;
+      }
     }
-    let blockRangeLimit = match[0];
-    if (blockRangeLimit === undefined) {
+    let match$2 = execResult.slice(1);
+    if (match$2.length !== 2) {
       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 fromBlock = match$2[0];
+    if (fromBlock === undefined) {
+      return;
     }
-    let execResult$7 = blastPaidRegExp.exec(message);
-    if (!(execResult$7 == null)) {
-      return extractBlockRange(execResult$7, true);
+    let toBlock = match$2[1];
+    if (toBlock === undefined) {
+      return;
     }
-    let match$1 = chainstackRegExp.exec(message);
-    if (!(match$1 == null)) {
+    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 [
-        10000,
-        true
+        (match$4 - match$3 | 0) + 1 | 0,
+        false
       ];
-    }
-    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;
     }
   }
-  let match$2 = execResult.slice(1);
-  if (match$2.length !== 2) {
-    return;
-  }
-  let fromBlock = match$2[0];
-  if (fromBlock === undefined) {
-    return;
-  }
-  let toBlock = match$2[1];
-  if (toBlock === 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
-    ];
-  }
 }
 
-function getSuggestedBlockIntervalFromExn(exn) {
-  if (exn.RE_EXN_ID === Rpc.JsonRpcError) {
-    return parseMessageForBlockRange(exn._1.message);
-  }
-  if (exn.RE_EXN_ID !== "JsExn") {
-    return;
-  }
-  try {
-    let message = exn._1.error.message;
-    S$RescriptSchema.assertOrThrow(message, S$RescriptSchema.string);
-    return parseMessageForBlockRange(message);
-  } catch (exn$1) {
-    return;
-  }
+let maxSuggestedBlockIntervalKey = "max";
+
+function getSourceMaxBlockInterval(mutSuggestedBlockIntervals, intervalCeiling) {
+  return Stdlib_Option.getOr(mutSuggestedBlockIntervals[maxSuggestedBlockIntervalKey], intervalCeiling);
 }
 
-let maxSuggestedBlockIntervalKey = "max";
+function mergeAndDedupItems(itemsPerSelection) {
+  let seen = new Set();
+  let merged = [];
+  itemsPerSelection.forEach(items => {
+    items.forEach(item => {
+      let key = item.log.blockNumber.toString() + `-` + item.log.logIndex.toString();
+      if (!seen.has(key)) {
+        seen.add(key);
+        merged.push(item);
+        return;
+      }
+    });
+  });
+  return merged;
+}
 
-function getNextPage(fromBlock, toBlock, addresses, topicQuery, loadBlock, sc, client, mutSuggestedBlockIntervals, partitionId, sourceName, chainId) {
+function getNextPage(fromBlock, toBlock, logSelections, loadBlock, sc, rpcClient, 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
-  }));
+  let queryLogs = param => {
+    Prometheus.SourceRequestCount.increment(sourceName, chainId, "eth_getLogs");
+    return rpcClient.getLogs({
+      fromBlock: fromBlock,
+      toBlock: toBlock,
+      addresses: param.addresses,
+      topics: param.topicQuery.map(filter => {
+        if (filter === null) {
+          return null;
+        } else if (typeof filter === "string") {
+          return [filter];
+        } else {
+          return filter;
+        }
+      })
+    });
+  };
+  let len = logSelections.length;
+  let logsPromise;
+  if (len !== 1) {
+    logsPromise = len !== 0 ? Promise.all(logSelections.map(queryLogs)).then(async itemsPerSelection => ({
+        items: mergeAndDedupItems(itemsPerSelection),
+        latestFetchedBlockInfo: await latestFetchedBlockPromise
+      })) : latestFetchedBlockPromise.then(latestFetchedBlockInfo => ({
+        items: [],
+        latestFetchedBlockInfo: latestFetchedBlockInfo
+      }));
+  } else {
+    let logSelection = logSelections[0];
+    logsPromise = queryLogs(logSelection).then(async items => ({
+      items: items,
+      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;
+    let executedBlockInterval = (toBlock - fromBlock | 0) + 1 | 0;
+    let shrunkBlockInterval = Primitive_int.max(1, executedBlockInterval * sc.backoffMultiplicative | 0);
+    let throwFailedGettingItems = retry => {
       throw {
         RE_EXN_ID: Source.GetItemsError,
         _1: {
           TAG: "FailedGettingItems",
           exn: err,
           attemptedToBlock: toBlock,
-          retry: {
-            TAG: "WithSuggestedToBlock",
-            toBlock: (fromBlock + nextBlockIntervalTry | 0) - 1 | 0
-          }
+          retry: retry
         },
         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: {
+    };
+    let throwResize = interval => throwFailedGettingItems({
+      TAG: "WithSuggestedToBlock",
+      toBlock: (fromBlock + interval | 0) - 1 | 0
+    });
+    let match = getSuggestedBlockIntervalFromExn(err);
+    if (match === undefined) {
+      if (executedBlockInterval > 1 && isResponseTooLargeError(err)) {
+        mutSuggestedBlockIntervals[partitionId] = shrunkBlockInterval;
+        return throwResize(shrunkBlockInterval);
+      } else {
+        mutSuggestedBlockIntervals[partitionId] = shrunkBlockInterval;
+        return throwFailedGettingItems({
           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()
-    };
+        });
+      }
+    }
+    let interval = match[0];
+    if (match[1]) {
+      let capped = Primitive_int.min(getSourceMaxBlockInterval(mutSuggestedBlockIntervals, sc.intervalCeiling), interval);
+      mutSuggestedBlockIntervals[maxSuggestedBlockIntervalKey] = capped;
+      return throwResize(capped);
+    }
+    mutSuggestedBlockIntervals[partitionId] = interval;
+    return throwResize(interval);
   });
 }
 
 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()
-        };
+  let evmEventConfigs = selection.eventConfigs;
+  if (Utils.$$Array.isEmpty(evmEventConfigs)) {
+    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 noAddressTopicSelections = [];
+  let staticByContract = {};
+  let dynamicByContract = {};
+  let dynamicWildcardByContract = {};
+  let contractNames = new Set();
+  evmEventConfigs.forEach(param => {
+    let contractName = param.contractName;
+    let eventFilters = param.getEventFiltersOrThrow(chain);
+    if (param.dependsOnAddresses) {
+      contractNames.add(contractName);
+      if (eventFilters.TAG === "Static") {
+        return Utils.Dict.pushMany(staticByContract, contractName, eventFilters._0);
+      } else {
+        return Utils.Dict.push(param.isWildcard ? dynamicWildcardByContract : dynamicByContract, contractName, eventFilters._0);
       }
-      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()
-          };
+    let tmp;
+    tmp = eventFilters.TAG === "Static" ? eventFilters._0 : eventFilters._0([]);
+    noAddressTopicSelections.push(...tmp);
+  });
+  let toLogSelections = (addresses, topicSelections) => LogSelection.compressTopicSelections(topicSelections).map(topicSelection => ({
+    addresses: addresses,
+    topicQuery: Rpc.GetLogs.mapTopicQuery(topicSelection)
+  }));
+  let noAddressLogSelections = toLogSelections(undefined, noAddressTopicSelections);
+  let getLogSelectionsOrThrow = contractNames.size === 0 ? param => noAddressLogSelections : addressesByContractName => {
+      let logSelections = noAddressLogSelections.slice();
+      contractNames.forEach(contractName => {
+        let addresses = addressesByContractName[contractName];
+        if (addresses === undefined) {
+          return;
         }
-        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()
-      };
-    }
-  } 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
-      };
+        if (addresses.length === 0) {
+          return;
+        }
+        let addressedTopicSelections = [];
+        let s = staticByContract[contractName];
+        if (s !== undefined) {
+          addressedTopicSelections.push(...s);
+        }
+        let fns = dynamicByContract[contractName];
+        if (fns !== undefined) {
+          fns.forEach(fn => {
+            addressedTopicSelections.push(...fn(addresses));
+          });
+        }
+        logSelections.push(...toLogSelections(addresses, addressedTopicSelections));
+        let fns$1 = dynamicWildcardByContract[contractName];
+        if (fns$1 !== undefined) {
+          logSelections.push(...toLogSelections(undefined, fns$1.flatMap(fn => fn(addresses))));
+          return;
+        }
+      });
+      return logSelections;
     };
-  }
   return {
-    getLogSelectionOrThrow: getLogSelectionOrThrow
+    getLogSelectionsOrThrow: getLogSelectionsOrThrow
   };
 }
 
@@ -918,8 +960,8 @@ 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 chain = param.chain;
   let url = param.url;
@@ -929,8 +971,8 @@ function make(param) {
   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, undefined, headers, param.allEventParams);
   let makeTransactionLoader = () => LazyLoader.make(transactionHash => {
     Prometheus.SourceRequestCount.increment(name, chain, "eth_getTransactionByHash");
     return Rest.fetch(Rpc.GetTransactionByHash.rawRoute, transactionHash, client);
@@ -998,88 +1040,31 @@ 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, contractNameByAddress, knownHeight, partitionId, selection, retry, param) => {
     let startFetchingBatchTimeRef = Performance.now();
-    let maxSuggestedBlockInterval = mutSuggestedBlockIntervals[maxSuggestedBlockIntervalKey];
-    let suggestedBlockInterval = maxSuggestedBlockInterval !== undefined ? maxSuggestedBlockInterval : Stdlib_Option.getOr(mutSuggestedBlockIntervals[partitionId], syncConfig.initialBlockInterval);
+    let sourceMaxBlockInterval = getSourceMaxBlockInterval(mutSuggestedBlockIntervals, syncConfig.intervalCeiling);
+    let suggestedBlockInterval = Primitive_int.min(Stdlib_Option.getOr(mutSuggestedBlockIntervals[partitionId], syncConfig.initialBlockInterval), sourceMaxBlockInterval);
     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 logSelections = match.getLogSelectionsOrThrow(addressesByContractName);
+    let match$1 = await getNextPage(fromBlock, suggestedToBlock, logSelections, blockNumber => LazyLoader.get(blockLoader.contents, blockNumber).then(parseBlockInfo), syncConfig, rpcClient, mutSuggestedBlockIntervals, partitionId, name, chain);
+    let latestFetchedBlockInfo = match$1.latestFetchedBlockInfo;
+    let items = match$1.items;
     let executedBlockInterval = (suggestedToBlock - fromBlock | 0) + 1 | 0;
-    if (executedBlockInterval >= suggestedBlockInterval && !(maxSuggestedBlockIntervalKey in mutSuggestedBlockIntervals)) {
-      mutSuggestedBlockIntervals[partitionId] = Primitive_int.min(executedBlockInterval + syncConfig.accelerationAdditive | 0, syncConfig.intervalCeiling);
-    }
-    let hyperSyncEvents = logs.map(convertLogToHyperSyncEvent);
-    let parsedEvents;
-    try {
-      parsedEvents = await getHscDecoder().decodeLogs(hyperSyncEvents);
-    } catch (raw_exn) {
-      let exn = Primitive_exceptions.internalToException(raw_exn);
-      throw {
-        RE_EXN_ID: Source.GetItemsError,
-        _1: {
-          TAG: "FailedGettingItems",
-          exn: exn,
-          attemptedToBlock: toBlock$1,
-          retry: {
-            TAG: "ImpossibleForTheQuery",
-            message: "Failed to parse events using hypersync client decoder. Please double-check your ABI."
-          }
-        },
-        Error: new Error()
-      };
+    if (executedBlockInterval >= suggestedBlockInterval) {
+      mutSuggestedBlockIntervals[partitionId] = Primitive_int.min(executedBlockInterval + syncConfig.accelerationAdditive | 0, sourceMaxBlockInterval);
     }
-    let parsedQueueItems = await Promise.all(Stdlib_Array.filterMap(Stdlib_Array.zip(logs, parsedEvents), param => {
-      let log = param[0];
+    let parsedQueueItems = await Promise.all(Stdlib_Array.filterMap(items, param => {
+      let log = param.log;
       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, contractNameByAddress);
       if (eventConfig === undefined) {
         return;
       }
-      let decoded = Stdlib_Option.flatMap(Primitive_option.fromNullable(param[1]), __x => __x[eventConfig.contractName]);
+      let decoded = Stdlib_Option.flatMap(Primitive_option.fromNullable(param.params), __x => __x[eventConfig.contractName]);
       if (decoded === undefined) {
         return;
       }
@@ -1165,7 +1150,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
@@ -1239,8 +1225,12 @@ export {
   getKnownRawBlock,
   parseBlockInfo,
   getKnownRawBlockWithBackoff,
+  getErrorMessage,
+  isResponseTooLargeError,
   getSuggestedBlockIntervalFromExn,
   maxSuggestedBlockIntervalKey,
+  getSourceMaxBlockInterval,
+  mergeAndDedupItems,
   getNextPage,
   getSelectionConfig,
   memoGetSelectionConfig,