envio 3.3.0-alpha.5 → 3.3.0-alpha.7

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";
@@ -77,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/;
@@ -103,289 +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, rpcClient, 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 = rpcClient.getLogs({
-    fromBlock: fromBlock,
-    toBlock: toBlock,
-    addresses: addresses,
-    topics: topicQuery.map(filter => {
-      if (filter === null) {
-        return null;
-      } else if (typeof filter === "string") {
-        return [filter];
-      } else {
-        return filter;
-      }
-    })
-  }).then(async items => ({
-    items: items,
-    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
   };
 }
 
@@ -1005,21 +1040,21 @@ function make(param) {
       Error: new Error()
     };
   }, lowercaseAddresses);
-  let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, contractNameByAddress, knownHeight, partitionId, selection, retry, param) => {
+  let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, contractNameByAddress, knownHeight, partitionId, selection, param, retry, param$1) => {
     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, rpcClient, mutSuggestedBlockIntervals, partitionId, name, chain);
-    let latestFetchedBlockInfo = match$2.latestFetchedBlockInfo;
-    let items = match$2.items;
+    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);
+    if (executedBlockInterval >= suggestedBlockInterval) {
+      mutSuggestedBlockIntervals[partitionId] = Primitive_int.min(executedBlockInterval + syncConfig.accelerationAdditive | 0, sourceMaxBlockInterval);
     }
     let parsedQueueItems = await Promise.all(Stdlib_Array.filterMap(items, param => {
       let log = param.log;
@@ -1190,8 +1225,12 @@ export {
   getKnownRawBlock,
   parseBlockInfo,
   getKnownRawBlockWithBackoff,
+  getErrorMessage,
+  isResponseTooLargeError,
   getSuggestedBlockIntervalFromExn,
   maxSuggestedBlockIntervalKey,
+  getSourceMaxBlockInterval,
+  mergeAndDedupItems,
   getNextPage,
   getSelectionConfig,
   memoGetSelectionConfig,

package/src/sources/SimulateSource.res

@@ -6,6 +6,7 @@ let make = (~items: array<Internal.item>, ~endBlock: int, ~chain: ChainMap.Chain
 
   {
     name: "SimulateSource",
+    simulateItems: items,
     sourceFor: Sync,
     chain,
     poweredByHyperSync: false,
@@ -25,6 +26,7 @@ let make = (~items: array<Internal.item>, ~endBlock: int, ~chain: ChainMap.Chain
       ~knownHeight as _,
       ~partitionId as _,
       ~selection as _,
+      ~itemsTarget as _,
       ~retry as _,
       ~logger as _,
     ) => {

package/src/sources/SimulateSource.res.mjs

@@ -17,7 +17,7 @@ function make(items, endBlock, chain) {
       _0: []
     }),
     getHeightOrThrow: () => Promise.resolve(Primitive_int.max(endBlock, 1)),
-    getItemsOrThrow: (param, param$1, param$2, param$3, param$4, param$5, param$6, param$7, param$8) => {
+    getItemsOrThrow: (param, param$1, param$2, param$3, param$4, param$5, param$6, param$7, param$8, param$9) => {
       let result = delivered.contents ? [] : (delivered.contents = true, items);
       let reportedHeight = Primitive_int.max(endBlock, 1);
       return Promise.resolve({
@@ -32,7 +32,8 @@ function make(items, endBlock, chain) {
           "total time elapsed (s)": 0
         }
       });
-    }
+    },
+    simulateItems: items
   };
 }