envio 3.3.0-alpha.0 → 3.3.0-alpha.10

package/src/FetchState.res.mjs

@@ -5,13 +5,26 @@ import * as Js_math from "@rescript/runtime/lib/es6/Js_math.js";
 import * as Logging from "./Logging.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_float from "@rescript/runtime/lib/es6/Primitive_float.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as IndexingAddresses from "./IndexingAddresses.res.mjs";
 
-function deriveEffectiveStartBlock(registrationBlock, contractStartBlock) {
-  return Primitive_int.max(Primitive_int.max(registrationBlock, 0), Stdlib_Option.getOr(contractStartBlock, 0));
+let deriveContractNameByAddress = Utils.$$WeakMap.memoize(addressesByContractName => {
+  let result = {};
+  Utils.Dict.forEachWithKey(addressesByContractName, (addresses, contractName) => {
+    for (let i = 0, i_finish = addresses.length; i < i_finish; ++i) {
+      result[addresses[i]] = contractName;
+    }
+  });
+  return result;
+});
+
+function densityItemsTarget(density, fromBlock, toBlock, chainTargetBlock) {
+  return Primitive_int.max(1, Math.ceil(((Stdlib_Option.getOr(toBlock, chainTargetBlock) - fromBlock | 0) + 1 | 0) * density) | 0);
 }
 
 function getMinHistoryRange(p) {
@@ -22,6 +35,14 @@ function getMinHistoryRange(p) {
   }
 }
 
+function getTrustedDensity(p) {
+  let match = p.prevQueryRange;
+  let match$1 = p.prevPrevQueryRange;
+  if (match !== 0 && match$1 !== 0) {
+    return p.prevRangeSize / match;
+  }
+}
+
 function getMinQueryRange(partitions) {
   let min = 0;
   for (let i = 0, i_finish = partitions.length; i < i_finish; ++i) {
@@ -69,6 +90,7 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         mutPendingQueries: p1.mutPendingQueries,
         prevQueryRange: p1.prevQueryRange,
         prevPrevQueryRange: p1.prevPrevQueryRange,
+        prevRangeSize: p1.prevRangeSize,
         latestBlockRangeUpdateBlock: p1.latestBlockRangeUpdateBlock
       });
       completed.push({
@@ -81,6 +103,7 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         mutPendingQueries: p2.mutPendingQueries,
         prevQueryRange: p2.prevQueryRange,
         prevPrevQueryRange: p2.prevPrevQueryRange,
+        prevRangeSize: p2.prevRangeSize,
         latestBlockRangeUpdateBlock: p2.latestBlockRangeUpdateBlock
       });
       let newId = nextPartitionIndexRef.contents.toString();
@@ -89,6 +112,7 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         p1,
         p2
       ]);
+      let inheritedDensity = Stdlib_Option.getOr(getTrustedDensity(p1), 0) + Stdlib_Option.getOr(getTrustedDensity(p2), 0);
       continuingBase = {
         id: newId,
         latestFetchedBlock: {
@@ -102,6 +126,7 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         mutPendingQueries: [],
         prevQueryRange: minRange,
         prevPrevQueryRange: minRange,
+        prevRangeSize: Math.ceil(inheritedDensity * minRange) | 0,
         latestBlockRangeUpdateBlock: 0
       };
     } else {
@@ -115,6 +140,7 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         mutPendingQueries: p1.mutPendingQueries,
         prevQueryRange: p1.prevQueryRange,
         prevPrevQueryRange: p1.prevPrevQueryRange,
+        prevRangeSize: p1.prevRangeSize,
         latestBlockRangeUpdateBlock: p1.latestBlockRangeUpdateBlock
       });
       continuingBase = p2;
@@ -130,6 +156,7 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
       mutPendingQueries: p2.mutPendingQueries,
       prevQueryRange: p2.prevQueryRange,
       prevPrevQueryRange: p2.prevPrevQueryRange,
+      prevRangeSize: p2.prevRangeSize,
       latestBlockRangeUpdateBlock: p2.latestBlockRangeUpdateBlock
     });
     continuingBase = p1;
@@ -153,6 +180,7 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
       mutPendingQueries: continuingBase.mutPendingQueries,
       prevQueryRange: continuingBase.prevQueryRange,
       prevPrevQueryRange: continuingBase.prevPrevQueryRange,
+      prevRangeSize: continuingBase.prevRangeSize,
       latestBlockRangeUpdateBlock: continuingBase.latestBlockRangeUpdateBlock
     });
     let restId = nextPartitionIndexRef.contents.toString();
@@ -167,6 +195,7 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
       mutPendingQueries: [],
       prevQueryRange: continuingBase.prevQueryRange,
       prevPrevQueryRange: continuingBase.prevPrevQueryRange,
+      prevRangeSize: continuingBase.prevRangeSize,
       latestBlockRangeUpdateBlock: continuingBase.latestBlockRangeUpdateBlock
     });
     return completed;
@@ -183,6 +212,7 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
     mutPendingQueries: continuingBase.mutPendingQueries,
     prevQueryRange: continuingBase.prevQueryRange,
     prevPrevQueryRange: continuingBase.prevPrevQueryRange,
+    prevRangeSize: continuingBase.prevRangeSize,
     latestBlockRangeUpdateBlock: continuingBase.latestBlockRangeUpdateBlock
   });
   return completed;
@@ -320,7 +350,7 @@ function getPendingQueryOrThrow(p, fromBlock) {
   }
 }
 
-function handleQueryResponse(optimizedPartitions, query, knownHeight, latestFetchedBlock) {
+function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount, latestFetchedBlock) {
   let partitionId = query.partitionId;
   let p = optimizedPartitions.entities[partitionId];
   let p$1 = p !== undefined ? p : Stdlib_JsError.throwWithMessage(`Unexpected case: Couldn't find partition ` + partitionId);
@@ -333,11 +363,11 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, latestFetc
     let queryToBlock = query.toBlock;
     let tmp;
     if (queryToBlock !== undefined) {
-      if (latestFetchedBlock.blockNumber >= queryToBlock) {
+      if (latestFetchedBlock.blockNumber < queryToBlock) {
+        tmp = itemsCount < query.itemsTarget;
+      } else {
         let minHistoryRange = getMinHistoryRange(p$1);
         tmp = minHistoryRange !== undefined ? ((queryToBlock - query.fromBlock | 0) + 1 | 0) >= minHistoryRange : false;
-      } else {
-        tmp = true;
       }
     } else {
       tmp = latestFetchedBlock.blockNumber < (knownHeight - 10 | 0);
@@ -346,6 +376,7 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, latestFetc
   }
   let updatedPrevQueryRange = shouldUpdateBlockRange ? blockRange : p$1.prevQueryRange;
   let updatedPrevPrevQueryRange = shouldUpdateBlockRange ? p$1.prevQueryRange : p$1.prevPrevQueryRange;
+  let updatedPrevRangeSize = shouldUpdateBlockRange ? itemsCount : p$1.prevRangeSize;
   let mutPendingQueries = p$1.mutPendingQueries;
   let latestFetchedBlock$1 = p$1.latestFetchedBlock;
   while ((() => {
@@ -382,6 +413,7 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, latestFetc
       mutPendingQueries: updatedMainPartition_mutPendingQueries,
       prevQueryRange: updatedPrevQueryRange,
       prevPrevQueryRange: updatedPrevPrevQueryRange,
+      prevRangeSize: updatedPrevRangeSize,
       latestBlockRangeUpdateBlock: updatedMainPartition_latestBlockRangeUpdateBlock
     };
     mutEntities[p$1.id] = updatedMainPartition;
@@ -436,6 +468,22 @@ function bufferBlock(param) {
   }
 }
 
+function bufferReadyCount(fetchState) {
+  let frontier = bufferBlockNumber(fetchState);
+  let buffer = fetchState.buffer;
+  let lo = 0;
+  let hi = buffer.length;
+  while (lo < hi) {
+    let mid = (lo + hi | 0) / 2 | 0;
+    if (buffer[mid].blockNumber <= frontier) {
+      lo = mid + 1 | 0;
+    } else {
+      hi = mid;
+    }
+  };
+  return lo;
+}
+
 function compareBufferItem(a, b) {
   let blockOrdering = Primitive_int.compare(a.blockNumber, b.blockNumber);
   if (blockOrdering === 0) {
@@ -445,31 +493,27 @@ function compareBufferItem(a, b) {
   }
 }
 
-function numAddresses(fetchState) {
-  return Utils.Dict.size(fetchState.indexingAddresses);
-}
-
-function appendOnBlockItems(mutItems, onBlockConfigs, indexerStartBlock, fromBlock, maxBlockNumber, maxOnBlockBufferSize) {
+function appendOnBlockItems(mutItems, onBlockRegistrations, indexerStartBlock, fromBlock, maxBlockNumber, maxOnBlockBufferSize) {
   let newItemsCounter = 0;
   let latestOnBlockBlockNumber = fromBlock;
   while (latestOnBlockBlockNumber < maxBlockNumber && newItemsCounter <= maxOnBlockBufferSize) {
     let blockNumber = latestOnBlockBlockNumber + 1 | 0;
     latestOnBlockBlockNumber = blockNumber;
-    for (let configIdx = 0, configIdx_finish = onBlockConfigs.length; configIdx < configIdx_finish; ++configIdx) {
-      let onBlockConfig = onBlockConfigs[configIdx];
-      let startBlock = onBlockConfig.startBlock;
+    for (let configIdx = 0, configIdx_finish = onBlockRegistrations.length; configIdx < configIdx_finish; ++configIdx) {
+      let onBlockRegistration = onBlockRegistrations[configIdx];
+      let startBlock = onBlockRegistration.startBlock;
       let handlerStartBlock = startBlock !== undefined ? startBlock : indexerStartBlock;
       let tmp = false;
       if (blockNumber >= handlerStartBlock) {
-        let endBlock = onBlockConfig.endBlock;
+        let endBlock = onBlockRegistration.endBlock;
         tmp = endBlock !== undefined ? blockNumber <= endBlock : true;
       }
-      if (tmp && Primitive_int.mod_(blockNumber - handlerStartBlock | 0, onBlockConfig.interval) === 0) {
+      if (tmp && Primitive_int.mod_(blockNumber - handlerStartBlock | 0, onBlockRegistration.interval) === 0) {
         mutItems.push({
           kind: 1,
-          onBlockConfig: onBlockConfig,
+          onBlockRegistration: onBlockRegistration,
           blockNumber: blockNumber,
-          logIndex: 16777216 + onBlockConfig.index | 0
+          logIndex: 16777216 + onBlockRegistration.index | 0
         });
         newItemsCounter = newItemsCounter + 1 | 0;
       }
@@ -478,15 +522,14 @@ function appendOnBlockItems(mutItems, onBlockConfigs, indexerStartBlock, fromBlo
   return latestOnBlockBlockNumber;
 }
 
-function updateInternal(fetchState, optimizedPartitionsOpt, indexingAddressesOpt, mutItems, blockLagOpt, knownHeightOpt) {
+function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, blockLagOpt, knownHeightOpt) {
   let optimizedPartitions = optimizedPartitionsOpt !== undefined ? optimizedPartitionsOpt : fetchState.optimizedPartitions;
-  let indexingAddresses = indexingAddressesOpt !== undefined ? indexingAddressesOpt : fetchState.indexingAddresses;
   let blockLag = blockLagOpt !== undefined ? blockLagOpt : fetchState.blockLag;
   let knownHeight = knownHeightOpt !== undefined ? knownHeightOpt : fetchState.knownHeight;
   let mutItemsRef = mutItems;
-  let onBlockConfigs = fetchState.onBlockConfigs;
+  let onBlockRegistrations = fetchState.onBlockRegistrations;
   let latestOnBlockBlockNumber;
-  if (onBlockConfigs.length !== 0) {
+  if (onBlockRegistrations.length !== 0) {
     let mutItems$1 = mutItemsRef;
     let item = (
         mutItems$1 !== undefined ? mutItems$1 : fetchState.buffer
@@ -502,7 +545,7 @@ function updateInternal(fetchState, optimizedPartitionsOpt, indexingAddressesOpt
     let mutItems$2 = mutItemsRef;
     let mutItems$3 = mutItems$2 !== undefined ? mutItems$2 : fetchState.buffer.slice();
     mutItemsRef = mutItems$3;
-    latestOnBlockBlockNumber = appendOnBlockItems(mutItems$3, onBlockConfigs, fetchState.startBlock, fetchState.latestOnBlockBlockNumber, maxBlockNumber, fetchState.maxOnBlockBufferSize);
+    latestOnBlockBlockNumber = appendOnBlockItems(mutItems$3, onBlockRegistrations, fetchState.startBlock, fetchState.latestOnBlockBlockNumber, maxBlockNumber, fetchState.maxOnBlockBufferSize);
   } else {
     latestOnBlockBlockNumber = knownHeight;
   }
@@ -514,30 +557,26 @@ function updateInternal(fetchState, optimizedPartitionsOpt, indexingAddressesOpt
   let updatedFetchState_chainId = fetchState.chainId;
   let updatedFetchState_buffer = mutItems$4 !== undefined ? (mutItems$4.sort(compareBufferItem), mutItems$4) : fetchState.buffer;
   let updatedFetchState_maxOnBlockBufferSize = fetchState.maxOnBlockBufferSize;
-  let updatedFetchState_onBlockConfigs = fetchState.onBlockConfigs;
+  let updatedFetchState_onBlockRegistrations = fetchState.onBlockRegistrations;
   let updatedFetchState_firstEventBlock = fetchState.firstEventBlock;
   let updatedFetchState = {
     optimizedPartitions: optimizedPartitions,
     startBlock: updatedFetchState_startBlock,
     endBlock: updatedFetchState_endBlock,
     normalSelection: updatedFetchState_normalSelection,
-    indexingAddresses: indexingAddresses,
     contractConfigs: updatedFetchState_contractConfigs,
     chainId: updatedFetchState_chainId,
     latestOnBlockBlockNumber: latestOnBlockBlockNumber,
     blockLag: blockLag,
     buffer: updatedFetchState_buffer,
     maxOnBlockBufferSize: updatedFetchState_maxOnBlockBufferSize,
-    onBlockConfigs: updatedFetchState_onBlockConfigs,
+    onBlockRegistrations: updatedFetchState_onBlockRegistrations,
     knownHeight: knownHeight,
     firstEventBlock: updatedFetchState_firstEventBlock
   };
   Prometheus.IndexingPartitions.set(optimizedPartitions.idsInAscOrder.length, fetchState.chainId);
   Prometheus.IndexingBufferSize.set(updatedFetchState_buffer.length, fetchState.chainId);
   Prometheus.IndexingBufferBlockNumber.set(bufferBlockNumber(updatedFetchState), fetchState.chainId);
-  if (indexingAddresses !== fetchState.indexingAddresses) {
-    Prometheus.IndexingAddresses.set(Utils.Dict.size(indexingAddresses), fetchState.chainId);
-  }
   return updatedFetchState;
 }
 
@@ -628,6 +667,7 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
             mutPendingQueries: [],
             prevQueryRange: 0,
             prevPrevQueryRange: 0,
+            prevRangeSize: 0,
             latestBlockRangeUpdateBlock: 0
           });
           nextPartitionIndexRef = nextPartitionIndexRef + 1 | 0;
@@ -678,6 +718,7 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
             mutPendingQueries: currentP.mutPendingQueries,
             prevQueryRange: currentP.prevQueryRange,
             prevPrevQueryRange: currentP.prevPrevQueryRange,
+            prevRangeSize: currentP.prevRangeSize,
             latestBlockRangeUpdateBlock: currentP.latestBlockRangeUpdateBlock
           });
           currentPRef = {
@@ -690,6 +731,7 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
             mutPendingQueries: nextP.mutPendingQueries,
             prevQueryRange: nextP.prevQueryRange,
             prevPrevQueryRange: nextP.prevPrevQueryRange,
+            prevRangeSize: nextP.prevRangeSize,
             latestBlockRangeUpdateBlock: nextP.latestBlockRangeUpdateBlock
           };
         } else {
@@ -703,6 +745,7 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
             mutPendingQueries: currentP.mutPendingQueries,
             prevQueryRange: currentP.prevQueryRange,
             prevPrevQueryRange: currentP.prevPrevQueryRange,
+            prevRangeSize: currentP.prevRangeSize,
             latestBlockRangeUpdateBlock: currentP.latestBlockRangeUpdateBlock
           };
         }
@@ -715,11 +758,10 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
   return make(existingPartitions.concat(mergedPartitions), maxAddrInPartition, nextPartitionIndexRef, dynamicContracts);
 }
 
-function registerDynamicContracts(fetchState, items) {
-  if (Utils.$$Array.isEmpty(fetchState.normalSelection.eventConfigs)) {
+function registerDynamicContracts(fetchState, indexingAddresses, items) {
+  if (Utils.$$Array.isEmpty(fetchState.normalSelection.onEventRegistrations)) {
     Stdlib_JsError.throwWithMessage("Invalid configuration. No events to fetch for the dynamic contract registration.");
   }
-  let indexingAddresses = fetchState.indexingAddresses;
   let registeringContractsByContract = {};
   let earliestRegisteringEventBlockNumber = Infinity;
   let noEventsAddresses = {};
@@ -737,14 +779,14 @@ function registerDynamicContracts(fetchState, items) {
           let dcWithStartBlock_address = dc.address;
           let dcWithStartBlock_contractName = dc.contractName;
           let dcWithStartBlock_registrationBlock = dc.registrationBlock;
-          let dcWithStartBlock_effectiveStartBlock = deriveEffectiveStartBlock(dc.registrationBlock, match.startBlock);
+          let dcWithStartBlock_effectiveStartBlock = IndexingAddresses.deriveEffectiveStartBlock(dc.registrationBlock, match.startBlock);
           let dcWithStartBlock = {
             address: dcWithStartBlock_address,
             contractName: dcWithStartBlock_contractName,
             registrationBlock: dcWithStartBlock_registrationBlock,
             effectiveStartBlock: dcWithStartBlock_effectiveStartBlock
           };
-          let existingContract = indexingAddresses[dc.address];
+          let existingContract = IndexingAddresses.get(indexingAddresses, dc.address);
           if (existingContract !== undefined) {
             if (existingContract.contractName !== dc.contractName) {
               warnDifferentContractType(fetchState, existingContract, dcWithStartBlock);
@@ -775,14 +817,14 @@ function registerDynamicContracts(fetchState, items) {
           let dcAsIndexingAddress_address = dc.address;
           let dcAsIndexingAddress_contractName = dc.contractName;
           let dcAsIndexingAddress_registrationBlock = dc.registrationBlock;
-          let dcAsIndexingAddress_effectiveStartBlock = deriveEffectiveStartBlock(dc.registrationBlock, undefined);
+          let dcAsIndexingAddress_effectiveStartBlock = IndexingAddresses.deriveEffectiveStartBlock(dc.registrationBlock, undefined);
           let dcAsIndexingAddress = {
             address: dcAsIndexingAddress_address,
             contractName: dcAsIndexingAddress_contractName,
             registrationBlock: dcAsIndexingAddress_registrationBlock,
             effectiveStartBlock: dcAsIndexingAddress_effectiveStartBlock
           };
-          let existingContract$1 = indexingAddresses[dc.address];
+          let existingContract$1 = IndexingAddresses.get(indexingAddresses, dc.address);
           if (existingContract$1 !== undefined) {
             if (existingContract$1.contractName !== dc.contractName) {
               warnDifferentContractType(fetchState, existingContract$1, dcAsIndexingAddress);
@@ -817,98 +859,100 @@ function registerDynamicContracts(fetchState, items) {
   }
   let dcContractNamesToStore = Object.keys(registeringContractsByContract);
   let hasNoEventsUpdates = !Utils.Dict.isEmpty(noEventsAddresses);
-  if (dcContractNamesToStore.length !== 0) {
-    let newPartitions = [];
-    let newIndexingAddresses = Utils.Dict.shallowCopy(indexingAddresses);
-    let dynamicContractsRef = fetchState.optimizedPartitions.dynamicContracts;
-    let mutExistingPartitions = Object.values(fetchState.optimizedPartitions.entities);
-    for (let idx$1 = 0, idx_finish = dcContractNamesToStore.length; idx$1 < idx_finish; ++idx$1) {
-      let contractName = dcContractNamesToStore[idx$1];
-      if (!dynamicContractsRef.has(contractName)) {
-        dynamicContractsRef = Utils.$$Set.immutableAdd(dynamicContractsRef, contractName);
-        for (let idx$2 = 0, idx_finish$1 = mutExistingPartitions.length; idx$2 < idx_finish$1; ++idx$2) {
-          let p = mutExistingPartitions[idx$2];
-          let addresses = p.addressesByContractName[contractName];
-          if (addresses !== undefined && p.selection.dependsOnAddresses && p.mergeBlock === undefined) {
-            let allPartitionContractNames = Object.keys(p.addressesByContractName);
-            if (allPartitionContractNames.length !== 1) {
-              let isFetching = p.mutPendingQueries.length !== 0;
-              if (!isFetching) {
-                let newPartitionId = (fetchState.optimizedPartitions.nextPartitionIndex + newPartitions.length | 0).toString();
-                let restAddressesByContractName = Utils.Dict.shallowCopy(p.addressesByContractName);
-                Utils.Dict.deleteInPlace(restAddressesByContractName, contractName);
-                mutExistingPartitions[idx$2] = {
-                  id: p.id,
-                  latestFetchedBlock: p.latestFetchedBlock,
-                  selection: p.selection,
-                  addressesByContractName: restAddressesByContractName,
-                  mergeBlock: p.mergeBlock,
-                  dynamicContract: p.dynamicContract,
-                  mutPendingQueries: p.mutPendingQueries,
-                  prevQueryRange: p.prevQueryRange,
-                  prevPrevQueryRange: p.prevPrevQueryRange,
-                  latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
-                };
-                let addressesByContractName = {};
-                addressesByContractName[contractName] = addresses;
-                newPartitions.push({
-                  id: newPartitionId,
-                  latestFetchedBlock: p.latestFetchedBlock,
-                  selection: fetchState.normalSelection,
-                  addressesByContractName: addressesByContractName,
-                  mergeBlock: undefined,
-                  dynamicContract: contractName,
-                  mutPendingQueries: p.mutPendingQueries,
-                  prevQueryRange: p.prevQueryRange,
-                  prevPrevQueryRange: p.prevPrevQueryRange,
-                  latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
-                });
-              }
-            } else {
+  if (dcContractNamesToStore.length === 0) {
+    if (hasNoEventsUpdates) {
+      IndexingAddresses.register(indexingAddresses, noEventsAddresses);
+      return fetchState;
+    } else {
+      return fetchState;
+    }
+  }
+  let newPartitions = [];
+  let dynamicContractsRef = fetchState.optimizedPartitions.dynamicContracts;
+  let mutExistingPartitions = Object.values(fetchState.optimizedPartitions.entities);
+  for (let idx$1 = 0, idx_finish = dcContractNamesToStore.length; idx$1 < idx_finish; ++idx$1) {
+    let contractName = dcContractNamesToStore[idx$1];
+    if (!dynamicContractsRef.has(contractName)) {
+      dynamicContractsRef = Utils.$$Set.immutableAdd(dynamicContractsRef, contractName);
+      for (let idx$2 = 0, idx_finish$1 = mutExistingPartitions.length; idx$2 < idx_finish$1; ++idx$2) {
+        let p = mutExistingPartitions[idx$2];
+        let addresses = p.addressesByContractName[contractName];
+        if (addresses !== undefined && p.selection.dependsOnAddresses && p.mergeBlock === undefined) {
+          let allPartitionContractNames = Object.keys(p.addressesByContractName);
+          if (allPartitionContractNames.length !== 1) {
+            let isFetching = p.mutPendingQueries.length !== 0;
+            if (!isFetching) {
+              let newPartitionId = (fetchState.optimizedPartitions.nextPartitionIndex + newPartitions.length | 0).toString();
+              let restAddressesByContractName = Utils.Dict.shallowCopy(p.addressesByContractName);
+              Utils.Dict.deleteInPlace(restAddressesByContractName, contractName);
               mutExistingPartitions[idx$2] = {
                 id: p.id,
                 latestFetchedBlock: p.latestFetchedBlock,
                 selection: p.selection,
-                addressesByContractName: p.addressesByContractName,
+                addressesByContractName: restAddressesByContractName,
                 mergeBlock: p.mergeBlock,
-                dynamicContract: contractName,
+                dynamicContract: p.dynamicContract,
                 mutPendingQueries: p.mutPendingQueries,
                 prevQueryRange: p.prevQueryRange,
                 prevPrevQueryRange: p.prevPrevQueryRange,
+                prevRangeSize: p.prevRangeSize,
                 latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
               };
+              let addressesByContractName = {};
+              addressesByContractName[contractName] = addresses;
+              newPartitions.push({
+                id: newPartitionId,
+                latestFetchedBlock: p.latestFetchedBlock,
+                selection: fetchState.normalSelection,
+                addressesByContractName: addressesByContractName,
+                mergeBlock: undefined,
+                dynamicContract: contractName,
+                mutPendingQueries: p.mutPendingQueries,
+                prevQueryRange: p.prevQueryRange,
+                prevPrevQueryRange: p.prevPrevQueryRange,
+                prevRangeSize: p.prevRangeSize,
+                latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+              });
             }
+          } else {
+            mutExistingPartitions[idx$2] = {
+              id: p.id,
+              latestFetchedBlock: p.latestFetchedBlock,
+              selection: p.selection,
+              addressesByContractName: p.addressesByContractName,
+              mergeBlock: p.mergeBlock,
+              dynamicContract: contractName,
+              mutPendingQueries: p.mutPendingQueries,
+              prevQueryRange: p.prevQueryRange,
+              prevPrevQueryRange: p.prevPrevQueryRange,
+              prevRangeSize: p.prevRangeSize,
+              latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+            };
           }
         }
       }
-      let registeringContracts = registeringContractsByContract[contractName];
-      Object.assign(newIndexingAddresses, registeringContracts);
     }
-    Object.assign(newIndexingAddresses, noEventsAddresses);
-    let optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, dynamicContractsRef, fetchState.normalSelection, fetchState.optimizedPartitions.maxAddrInPartition, fetchState.optimizedPartitions.nextPartitionIndex + newPartitions.length | 0, mutExistingPartitions.concat(newPartitions), 0);
-    return updateInternal(fetchState, optimizedPartitions, newIndexingAddresses, undefined, undefined, undefined);
-  }
-  if (!hasNoEventsUpdates) {
-    return fetchState;
+    let registeringContracts = registeringContractsByContract[contractName];
+    IndexingAddresses.register(indexingAddresses, registeringContracts);
   }
-  let newIndexingContracts = Utils.Dict.shallowCopy(indexingAddresses);
-  Object.assign(newIndexingContracts, noEventsAddresses);
-  return updateInternal(fetchState, undefined, newIndexingContracts, undefined, undefined, undefined);
+  IndexingAddresses.register(indexingAddresses, noEventsAddresses);
+  let optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, dynamicContractsRef, fetchState.normalSelection, fetchState.optimizedPartitions.maxAddrInPartition, fetchState.optimizedPartitions.nextPartitionIndex + newPartitions.length | 0, mutExistingPartitions.concat(newPartitions), 0);
+  return updateInternal(fetchState, optimizedPartitions, undefined, undefined, undefined);
 }
 
-function handleQueryResult(fetchState, query, latestFetchedBlock, newItems) {
+function handleQueryResult(fetchState, indexingAddresses, query, latestFetchedBlock, newItems) {
   let newItems$1 = newItems.filter(item => {
     if (item.kind !== 0) {
       return true;
     }
-    let filter = item.eventConfig.clientAddressFilter;
+    let filter = item.onEventRegistration.clientAddressFilter;
     if (filter !== undefined) {
-      return filter(item.payload, item.blockNumber, fetchState.indexingAddresses);
+      return filter(item.payload, item.blockNumber, IndexingAddresses.rawForFilter(indexingAddresses));
     } else {
       return true;
     }
   });
-  return updateInternal(fetchState, handleQueryResponse(fetchState.optimizedPartitions, query, fetchState.knownHeight, latestFetchedBlock), undefined, newItems$1.length !== 0 ? fetchState.buffer.concat(newItems$1) : undefined, undefined, undefined);
+  return updateInternal(fetchState, handleQueryResponse(fetchState.optimizedPartitions, query, fetchState.knownHeight, newItems$1.length, latestFetchedBlock), newItems$1.length !== 0 ? fetchState.buffer.concat(newItems$1) : undefined, undefined, undefined);
 }
 
 function startFetchingQueries(param, queries) {
@@ -922,6 +966,8 @@ function startFetchingQueries(param, queries) {
       fromBlock: q.fromBlock,
       toBlock: q.toBlock,
       isChunk: q.isChunk,
+      itemsTarget: q.itemsTarget,
+      itemsEst: q.itemsEst,
       fetchedBlock: undefined
     };
     let inserted = false;
@@ -939,184 +985,159 @@ function startFetchingQueries(param, queries) {
   }
 }
 
-function pushQueriesForRange(queries, partitionId, rangeFromBlock, rangeEndBlock, maxQueryBlockNumber, maybeChunkRange, selection, addressesByContractName, indexingAddresses) {
-  if (rangeFromBlock > maxQueryBlockNumber) {
-    return;
-  }
-  if (rangeEndBlock !== undefined && rangeFromBlock > rangeEndBlock) {
-    return;
-  }
-  if (maybeChunkRange !== undefined) {
-    let maxBlock = rangeEndBlock !== undefined ? rangeEndBlock : maxQueryBlockNumber;
-    let chunkSize = Js_math.ceil_int(maybeChunkRange * 1.8);
-    let probeSize = Js_math.ceil_int(maybeChunkRange * 0.9);
-    let getChunkSize = chunkIdx => {
-      if (chunkIdx < 2) {
-        return probeSize;
-      } else {
-        return chunkSize;
-      }
-    };
-    if ((((rangeFromBlock + probeSize | 0) + probeSize | 0) - 1 | 0) <= maxBlock) {
-      let chunkFromBlock = rangeFromBlock;
-      let chunkIdx = 0;
-      while (chunkIdx < 5 && ((chunkFromBlock + getChunkSize(chunkIdx) | 0) - 1 | 0) <= maxBlock) {
-        let chunkToBlock = (chunkFromBlock + getChunkSize(chunkIdx) | 0) - 1 | 0;
+function pushGapFillQueries(queries, partitionId, rangeFromBlock, rangeEndBlock, knownHeight, chainTargetBlock, maybeChunkRange, maxChunks, partition, partitionBudget, chunkItemsMultiplier, selection, addressesByContractName) {
+  let cost = {
+    contents: 0
+  };
+  if (rangeFromBlock <= Primitive_int.min(knownHeight, chainTargetBlock) && maxChunks > 0) {
+    let exit = 0;
+    if (!(rangeEndBlock !== undefined && rangeFromBlock > rangeEndBlock)) {
+      exit = 1;
+    }
+    if (exit === 1) {
+      let trustedDensity = getTrustedDensity(partition);
+      let maxBlock = rangeEndBlock !== undefined ? rangeEndBlock : chainTargetBlock;
+      let pushSingleQuery = (density, isChunk) => {
+        let itemsTarget = densityItemsTarget(density * chunkItemsMultiplier, rangeFromBlock, rangeEndBlock, chainTargetBlock);
+        let itemsEst = densityItemsTarget(density, rangeFromBlock, rangeEndBlock, chainTargetBlock);
         queries.push({
           partitionId: partitionId,
-          fromBlock: chunkFromBlock,
-          toBlock: chunkToBlock,
-          isChunk: true,
+          fromBlock: rangeFromBlock,
+          toBlock: rangeEndBlock,
+          isChunk: isChunk,
+          itemsTarget: itemsTarget,
+          itemsEst: itemsEst,
           selection: selection,
-          addressesByContractName: addressesByContractName,
-          indexingAddresses: indexingAddresses
+          addressesByContractName: addressesByContractName
         });
-        chunkFromBlock = chunkToBlock + 1 | 0;
-        chunkIdx = chunkIdx + 1 | 0;
+        cost.contents = cost.contents + itemsEst;
       };
-      return;
+      if (trustedDensity !== undefined) {
+        if (maybeChunkRange !== undefined && trustedDensity > 0) {
+          let chunkSize = Js_math.ceil_int(maybeChunkRange * 1.8);
+          if (((rangeFromBlock + (chunkSize << 1) | 0) - 1 | 0) <= maxBlock) {
+            let chunkFromBlock = rangeFromBlock;
+            let chunkIdx = 0;
+            while (chunkIdx < maxChunks && ((chunkFromBlock + chunkSize | 0) - 1 | 0) <= maxBlock) {
+              let chunkToBlock = (chunkFromBlock + chunkSize | 0) - 1 | 0;
+              let itemsTarget = densityItemsTarget(trustedDensity * chunkItemsMultiplier, chunkFromBlock, chunkToBlock, chainTargetBlock);
+              let itemsEst = densityItemsTarget(trustedDensity, chunkFromBlock, chunkToBlock, chainTargetBlock);
+              queries.push({
+                partitionId: partitionId,
+                fromBlock: chunkFromBlock,
+                toBlock: chunkToBlock,
+                isChunk: true,
+                itemsTarget: itemsTarget,
+                itemsEst: itemsEst,
+                selection: selection,
+                addressesByContractName: addressesByContractName
+              });
+              cost.contents = cost.contents + itemsEst;
+              chunkFromBlock = chunkToBlock + 1 | 0;
+              chunkIdx = chunkIdx + 1 | 0;
+            };
+          } else {
+            pushSingleQuery(trustedDensity, rangeEndBlock !== undefined);
+          }
+        } else {
+          pushSingleQuery(trustedDensity, false);
+        }
+      } else {
+        let remainingRange = Primitive_int.max(1, (chainTargetBlock - rangeFromBlock | 0) + 1 | 0);
+        pushSingleQuery(partitionBudget / remainingRange, false);
+      }
     }
-    queries.push({
-      partitionId: partitionId,
-      fromBlock: rangeFromBlock,
-      toBlock: rangeEndBlock,
-      isChunk: rangeEndBlock !== undefined,
-      selection: selection,
-      addressesByContractName: addressesByContractName,
-      indexingAddresses: indexingAddresses
-    });
-    return;
   }
-  queries.push({
-    partitionId: partitionId,
-    fromBlock: rangeFromBlock,
-    toBlock: rangeEndBlock,
-    isChunk: false,
-    selection: selection,
-    addressesByContractName: addressesByContractName,
-    indexingAddresses: indexingAddresses
-  });
+  return cost.contents;
 }
 
-function getNextQuery(fetchState, concurrencyLimit, bufferLimit) {
-  let knownHeight = fetchState.knownHeight;
-  let blockLag = fetchState.blockLag;
-  let indexingAddresses = fetchState.indexingAddresses;
-  let optimizedPartitions = fetchState.optimizedPartitions;
+function waterLevel(budget, footprints) {
+  let sorted = footprints.toSorted(Primitive_float.compare);
+  let n = sorted.length;
+  let prefix = 0;
+  let level;
+  let idx = 0;
+  while (level === undefined && idx < n) {
+    let i = idx;
+    prefix = prefix + sorted[i];
+    let candidate = (budget + prefix) / (i + 1 | 0);
+    if (i === (n - 1 | 0) || candidate <= sorted[i + 1 | 0]) {
+      level = candidate;
+    }
+    idx = idx + 1 | 0;
+  };
+  return Stdlib_Option.getOr(level, 0);
+}
+
+function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star) {
+  let knownHeight = param.knownHeight;
+  let blockLag = param.blockLag;
+  let endBlock = param.endBlock;
+  let optimizedPartitions = param.optimizedPartitions;
+  let chunkItemsMultiplier = $staropt$star !== undefined ? $staropt$star : 1;
   let headBlockNumber = knownHeight - blockLag | 0;
   if (headBlockNumber <= 0) {
     return "WaitingForNewBlock";
   }
-  if (concurrencyLimit === 0) {
-    return "ReachedMaxConcurrency";
-  }
-  if (bufferLimit <= 0) {
-    return "NothingToQuery";
-  }
-  let isOnBlockBehindTheHead = fetchState.latestOnBlockBlockNumber < headBlockNumber;
-  let endBlock = fetchState.endBlock;
+  let isOnBlockBehindTheHead = param.latestOnBlockBlockNumber < headBlockNumber;
   let shouldWaitForNewBlock = (
     endBlock !== undefined ? headBlockNumber < endBlock : true
   ) && !isOnBlockBehindTheHead;
-  let item = fetchState.buffer[bufferLimit - 1 | 0];
-  let maxQueryBlockNumber = item !== undefined ? Primitive_int.min(item.blockNumber, knownHeight) : knownHeight;
-  let queries = [];
   let partitionsCount = optimizedPartitions.idsInAscOrder.length;
-  let idxRef = 0;
-  while (idxRef < partitionsCount) {
-    let idx = idxRef;
+  for (let idx = 0; idx < partitionsCount; ++idx) {
     let partitionId = optimizedPartitions.idsInAscOrder[idx];
     let p = optimizedPartitions.entities[partitionId];
-    let pendingCount = p.mutPendingQueries.length;
-    let isBehindTheHead = p.latestFetchedBlock.blockNumber < headBlockNumber;
-    let hasPendingQueries = pendingCount > 0;
-    if (hasPendingQueries || isBehindTheHead) {
+    if (p.mutPendingQueries.length !== 0 || p.latestFetchedBlock.blockNumber < headBlockNumber) {
       shouldWaitForNewBlock = false;
     }
-    let partitionQueriesStart = queries.length;
-    let queryEndBlock = Utils.$$Math.minOptInt(fetchState.endBlock, p.mergeBlock);
-    let queryEndBlock$1 = blockLag !== 0 ? Utils.$$Math.minOptInt(headBlockNumber, queryEndBlock) : queryEndBlock;
-    let match = maxQueryBlockNumber < knownHeight;
-    let queryEndBlock$2 = queryEndBlock$1 !== undefined ? (
-        match ? Primitive_int.min(maxQueryBlockNumber, queryEndBlock$1) : queryEndBlock$1
-      ) : (
-        match ? maxQueryBlockNumber : queryEndBlock$1
-      );
-    let maybeChunkRange = getMinHistoryRange(p);
-    let cursor = p.latestFetchedBlock.blockNumber + 1 | 0;
+  }
+  let queriesByPartitionIndex = Stdlib_Array.fromInitializer(partitionsCount, param => []);
+  let computeQueryEndBlock = p => {
+    let queryEndBlock = Utils.$$Math.minOptInt(endBlock, p.mergeBlock);
+    if (blockLag !== 0) {
+      return Utils.$$Math.minOptInt(headBlockNumber, queryEndBlock);
+    } else {
+      return queryEndBlock;
+    }
+  };
+  let existingReservedByPartition = {};
+  let chainReserved = 0;
+  for (let idx$1 = 0; idx$1 < partitionsCount; ++idx$1) {
+    let partitionId$1 = optimizedPartitions.idsInAscOrder[idx$1];
+    let p$1 = optimizedPartitions.entities[partitionId$1];
+    let cost = 0;
+    for (let pqIdx = 0, pqIdx_finish = p$1.mutPendingQueries.length; pqIdx < pqIdx_finish; ++pqIdx) {
+      cost = cost + p$1.mutPendingQueries[pqIdx].itemsEst;
+    }
+    existingReservedByPartition[partitionId$1] = cost;
+    chainReserved = chainReserved + cost;
+  }
+  let fillStates = [];
+  let gapFillCost = 0;
+  for (let idx$2 = 0; idx$2 < partitionsCount; ++idx$2) {
+    let partitionId$2 = optimizedPartitions.idsInAscOrder[idx$2];
+    let p$2 = optimizedPartitions.entities[partitionId$2];
+    let bucket = queriesByPartitionIndex[idx$2];
+    let pendingCount = p$2.mutPendingQueries.length;
+    let queryEndBlock = computeQueryEndBlock(p$2);
+    let maybeChunkRange = getMinHistoryRange(p$2);
+    let cursor = p$2.latestFetchedBlock.blockNumber + 1 | 0;
     let canContinue = true;
-    let pqIdx = 0;
-    while (pqIdx < p.mutPendingQueries.length && canContinue) {
-      let pq = p.mutPendingQueries[pqIdx];
+    let chunksUsedThisCall = 0;
+    let pqIdx$1 = 0;
+    while (pqIdx$1 < pendingCount && canContinue) {
+      let pq = p$2.mutPendingQueries[pqIdx$1];
       if (pq.fromBlock > cursor) {
-        let addressesByContractName = p.addressesByContractName;
-        let selection = p.selection;
-        let rangeEndBlock = Utils.$$Math.minOptInt(pq.fromBlock - 1 | 0, queryEndBlock$2);
-        let rangeFromBlock = cursor;
-        if (rangeFromBlock <= maxQueryBlockNumber) {
-          let exit = 0;
-          if (!(rangeEndBlock !== undefined && rangeFromBlock > rangeEndBlock)) {
-            exit = 1;
-          }
-          if (exit === 1) {
-            if (maybeChunkRange !== undefined) {
-              let maxBlock = rangeEndBlock !== undefined ? rangeEndBlock : maxQueryBlockNumber;
-              let chunkSize = Js_math.ceil_int(maybeChunkRange * 1.8);
-              let probeSize = Js_math.ceil_int(maybeChunkRange * 0.9);
-              let getChunkSize = chunkIdx => {
-                if (chunkIdx < 2) {
-                  return probeSize;
-                } else {
-                  return chunkSize;
-                }
-              };
-              if ((((rangeFromBlock + getChunkSize(0) | 0) + getChunkSize(1) | 0) - 1 | 0) <= maxBlock) {
-                let chunkFromBlock = rangeFromBlock;
-                let chunkIdx = 0;
-                while (chunkIdx < 5 && ((chunkFromBlock + getChunkSize(chunkIdx) | 0) - 1 | 0) <= maxBlock) {
-                  let chunkToBlock = (chunkFromBlock + getChunkSize(chunkIdx) | 0) - 1 | 0;
-                  queries.push({
-                    partitionId: partitionId,
-                    fromBlock: chunkFromBlock,
-                    toBlock: chunkToBlock,
-                    isChunk: true,
-                    selection: selection,
-                    addressesByContractName: addressesByContractName,
-                    indexingAddresses: indexingAddresses
-                  });
-                  chunkFromBlock = chunkToBlock + 1 | 0;
-                  chunkIdx = chunkIdx + 1 | 0;
-                };
-              } else {
-                queries.push({
-                  partitionId: partitionId,
-                  fromBlock: rangeFromBlock,
-                  toBlock: rangeEndBlock,
-                  isChunk: rangeEndBlock !== undefined,
-                  selection: selection,
-                  addressesByContractName: addressesByContractName,
-                  indexingAddresses: indexingAddresses
-                });
-              }
-            } else {
-              queries.push({
-                partitionId: partitionId,
-                fromBlock: rangeFromBlock,
-                toBlock: rangeEndBlock,
-                isChunk: false,
-                selection: selection,
-                addressesByContractName: addressesByContractName,
-                indexingAddresses: indexingAddresses
-              });
-            }
-          }
-        }
+        let beforeLen = bucket.length;
+        let cost$1 = pushGapFillQueries(bucket, partitionId$2, cursor, Utils.$$Math.minOptInt(pq.fromBlock - 1 | 0, queryEndBlock), knownHeight, chainTargetBlock, maybeChunkRange, (12 - pendingCount | 0) - chunksUsedThisCall | 0, p$2, chainTargetItems / partitionsCount, chunkItemsMultiplier, p$2.selection, p$2.addressesByContractName);
+        chunksUsedThisCall = chunksUsedThisCall + (bucket.length - beforeLen | 0) | 0;
+        gapFillCost = gapFillCost + cost$1;
       }
       let toBlock = pq.toBlock;
       if (toBlock !== undefined && pq.isChunk) {
-        let match$1 = pq.fetchedBlock;
-        if (match$1 !== undefined) {
-          let blockNumber = match$1.blockNumber;
+        let match = pq.fetchedBlock;
+        if (match !== undefined) {
+          let blockNumber = match.blockNumber;
           cursor = blockNumber < toBlock ? blockNumber + 1 | 0 : toBlock + 1 | 0;
         } else {
           cursor = toBlock + 1 | 0;
@@ -1124,90 +1145,134 @@ function getNextQuery(fetchState, concurrencyLimit, bufferLimit) {
       } else {
         canContinue = false;
       }
-      pqIdx = pqIdx + 1 | 0;
+      pqIdx$1 = pqIdx$1 + 1 | 0;
     };
     if (canContinue) {
-      let addressesByContractName$1 = p.addressesByContractName;
-      let selection$1 = p.selection;
-      let rangeFromBlock$1 = cursor;
-      if (rangeFromBlock$1 <= maxQueryBlockNumber) {
-        let exit$1 = 0;
-        if (!(queryEndBlock$2 !== undefined && rangeFromBlock$1 > queryEndBlock$2)) {
-          exit$1 = 1;
-        }
-        if (exit$1 === 1) {
-          if (maybeChunkRange !== undefined) {
-            let maxBlock$1 = queryEndBlock$2 !== undefined ? queryEndBlock$2 : maxQueryBlockNumber;
-            let chunkSize$1 = Js_math.ceil_int(maybeChunkRange * 1.8);
-            let probeSize$1 = Js_math.ceil_int(maybeChunkRange * 0.9);
-            let getChunkSize$1 = chunkIdx => {
-              if (chunkIdx < 2) {
-                return probeSize$1;
-              } else {
-                return chunkSize$1;
-              }
-            };
-            if ((((rangeFromBlock$1 + getChunkSize$1(0) | 0) + getChunkSize$1(1) | 0) - 1 | 0) <= maxBlock$1) {
-              let chunkFromBlock$1 = rangeFromBlock$1;
-              let chunkIdx$1 = 0;
-              while (chunkIdx$1 < 5 && ((chunkFromBlock$1 + getChunkSize$1(chunkIdx$1) | 0) - 1 | 0) <= maxBlock$1) {
-                let chunkToBlock$1 = (chunkFromBlock$1 + getChunkSize$1(chunkIdx$1) | 0) - 1 | 0;
-                queries.push({
-                  partitionId: partitionId,
-                  fromBlock: chunkFromBlock$1,
-                  toBlock: chunkToBlock$1,
-                  isChunk: true,
-                  selection: selection$1,
-                  addressesByContractName: addressesByContractName$1,
-                  indexingAddresses: indexingAddresses
-                });
-                chunkFromBlock$1 = chunkToBlock$1 + 1 | 0;
-                chunkIdx$1 = chunkIdx$1 + 1 | 0;
-              };
-            } else {
-              queries.push({
-                partitionId: partitionId,
-                fromBlock: rangeFromBlock$1,
-                toBlock: queryEndBlock$2,
-                isChunk: queryEndBlock$2 !== undefined,
-                selection: selection$1,
-                addressesByContractName: addressesByContractName$1,
-                indexingAddresses: indexingAddresses
-              });
-            }
-          } else {
-            queries.push({
-              partitionId: partitionId,
-              fromBlock: rangeFromBlock$1,
-              toBlock: queryEndBlock$2,
-              isChunk: false,
-              selection: selection$1,
-              addressesByContractName: addressesByContractName$1,
-              indexingAddresses: indexingAddresses
-            });
-          }
-        }
-      }
+      fillStates.push({
+        partitionId: partitionId$2,
+        p: p$2,
+        cursor: cursor,
+        chunksUsedThisCall: chunksUsedThisCall,
+        pendingCount: pendingCount,
+        queryEndBlock: queryEndBlock,
+        maybeChunkRange: maybeChunkRange,
+        bucket: bucket
+      });
     }
-    let maxNewChunks = Primitive_int.max(0, 10 - pendingCount | 0);
-    let generatedCount = queries.length - partitionQueriesStart | 0;
-    if (generatedCount > maxNewChunks) {
-      queries.splice(partitionQueriesStart + maxNewChunks | 0, generatedCount - maxNewChunks | 0);
+  }
+  let rangeItemsTarget = Primitive_float.max(0, chainTargetItems - chainReserved - gapFillCost);
+  let reservedByPartition = {};
+  fillStates.forEach(fs => {
+    let cost = existingReservedByPartition[fs.partitionId];
+    for (let i = 0, i_finish = fs.bucket.length; i < i_finish; ++i) {
+      cost = cost + fs.bucket[i].itemsEst;
     }
-    idxRef = idxRef + 1 | 0;
+    reservedByPartition[fs.partitionId] = cost;
+  });
+  let isInRange = fs => {
+    let tmp = false;
+    if (fs.cursor <= chainTargetBlock) {
+      let eb = fs.queryEndBlock;
+      tmp = eb !== undefined ? fs.cursor <= eb : true;
+    }
+    if (tmp) {
+      return (fs.pendingCount + fs.chunksUsedThisCall | 0) < 12;
+    } else {
+      return false;
+    }
+  };
+  let inRangeStates = fillStates.filter(isInRange);
+  let emitQueries = (fs, budget) => {
+    let p = fs.p;
+    let eb = fs.queryEndBlock;
+    let maxBlock = eb !== undefined ? eb : chainTargetBlock;
+    let match = fs.maybeChunkRange;
+    let match$1 = getTrustedDensity(p);
+    if (match !== undefined && match$1 !== undefined && match$1 > 0) {
+      let chunkSize = Js_math.ceil_int(match * 1.8);
+      let maxChunksRemaining = (12 - fs.pendingCount | 0) - fs.chunksUsedThisCall | 0;
+      let consumed = 0;
+      let created = 0;
+      let chunkFromBlock = fs.cursor;
+      let budgetLeft = true;
+      while (budgetLeft && created < maxChunksRemaining && chunkFromBlock <= Primitive_int.min(maxBlock, chainTargetBlock)) {
+        let chunkToBlock = Primitive_int.min((chunkFromBlock + chunkSize | 0) - 1 | 0, maxBlock);
+        let rawEst = match$1 * ((chunkToBlock - chunkFromBlock | 0) + 1 | 0);
+        let itemsEst = Primitive_int.max(1, Math.ceil(rawEst) | 0);
+        let itemsTarget = Primitive_int.max(1, Math.ceil(rawEst * chunkItemsMultiplier) | 0);
+        if (consumed === 0 || consumed + itemsEst <= budget) {
+          fs.bucket.push({
+            partitionId: fs.partitionId,
+            fromBlock: chunkFromBlock,
+            toBlock: chunkToBlock,
+            isChunk: true,
+            itemsTarget: itemsTarget,
+            itemsEst: itemsEst,
+            selection: p.selection,
+            addressesByContractName: p.addressesByContractName
+          });
+          consumed = consumed + itemsEst;
+          chunkFromBlock = chunkToBlock + 1 | 0;
+          created = created + 1 | 0;
+        } else {
+          budgetLeft = false;
+        }
+      };
+      fs.cursor = chunkFromBlock;
+      fs.chunksUsedThisCall = fs.chunksUsedThisCall + created | 0;
+      return consumed;
+    }
+    let itemsTarget$1 = Primitive_int.max(1, Math.round(budget) | 0);
+    fs.bucket.push({
+      partitionId: fs.partitionId,
+      fromBlock: fs.cursor,
+      toBlock: fs.queryEndBlock,
+      isChunk: false,
+      itemsTarget: itemsTarget$1,
+      itemsEst: itemsTarget$1,
+      selection: p.selection,
+      addressesByContractName: p.addressesByContractName
+    });
+    fs.cursor = maxBlock + 1 | 0;
+    fs.chunksUsedThisCall = fs.chunksUsedThisCall + 1 | 0;
+    return itemsTarget$1;
+  };
+  let notFilledPartitions = inRangeStates;
+  let remainingBudget = {
+    contents: rangeItemsTarget
   };
+  while (notFilledPartitions.length !== 0 && remainingBudget.contents > 0) {
+    let level = waterLevel(remainingBudget.contents, notFilledPartitions.map(fs => reservedByPartition[fs.partitionId]));
+    let next = [];
+    notFilledPartitions.forEach(fs => {
+      let reserved = reservedByPartition[fs.partitionId];
+      let budget = level - reserved;
+      if (budget <= 0) {
+        return;
+      }
+      let consumed = emitQueries(fs, budget);
+      reservedByPartition[fs.partitionId] = reserved + consumed;
+      remainingBudget.contents = remainingBudget.contents - consumed;
+      if (isInRange(fs)) {
+        next.push(fs);
+        return;
+      }
+    });
+    notFilledPartitions = next;
+  };
+  let queries = queriesByPartitionIndex.flat();
   if (Utils.$$Array.isEmpty(queries)) {
     if (shouldWaitForNewBlock) {
       return "WaitingForNewBlock";
     } else {
       return "NothingToQuery";
     }
+  } else {
+    return {
+      TAG: "Ready",
+      _0: queries
+    };
   }
-  let queries$1 = queries.length > concurrencyLimit ? (queries.sort((a, b) => Primitive_int.compare(a.fromBlock, b.fromBlock)), queries.slice(0, concurrencyLimit)) : queries;
-  return {
-    TAG: "Ready",
-    _0: queries$1
-  };
 }
 
 function hasReadyItem(fetchState) {
@@ -1242,9 +1307,9 @@ function getReadyItemsCount(fetchState, targetSize, fromItem) {
   return acc;
 }
 
-function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartition, chainId, maxOnBlockBufferSize, knownHeight, progressBlockNumberOpt, onBlockConfigsOpt, blockLagOpt, firstEventBlockOpt) {
+function make$1(startBlock, endBlock, onEventRegistrations, contractConfigs, addresses, maxAddrInPartition, chainId, maxOnBlockBufferSize, knownHeight, progressBlockNumberOpt, onBlockRegistrationsOpt, blockLagOpt, firstEventBlockOpt) {
   let progressBlockNumber = progressBlockNumberOpt !== undefined ? progressBlockNumberOpt : startBlock - 1 | 0;
-  let onBlockConfigs = onBlockConfigsOpt !== undefined ? onBlockConfigsOpt : [];
+  let onBlockRegistrations = onBlockRegistrationsOpt !== undefined ? onBlockRegistrationsOpt : [];
   let blockLag = blockLagOpt !== undefined ? blockLagOpt : 0;
   let firstEventBlock = firstEventBlockOpt !== undefined ? Primitive_option.valFromOption(firstEventBlockOpt) : undefined;
   let latestFetchedBlock = {
@@ -1252,32 +1317,14 @@ function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartitio
     blockTimestamp: 0
   };
   let notDependingOnAddresses = [];
-  let normalEventConfigs = [];
+  let normalRegistrations = [];
   let contractNamesWithNormalEvents = new Set();
-  let indexingAddresses = {};
-  let contractConfigs = {};
-  eventConfigs.forEach(ec => {
-    let match = contractConfigs[ec.contractName];
-    if (match !== undefined) {
-      let startBlock = match.startBlock;
-      let match$1 = ec.startBlock;
-      contractConfigs[ec.contractName] = {
-        startBlock: startBlock !== undefined ? (
-            match$1 !== undefined ? Primitive_int.min(startBlock, match$1) : startBlock
-          ) : (
-            match$1 !== undefined ? match$1 : undefined
-          )
-      };
+  onEventRegistrations.forEach(reg => {
+    if (reg.dependsOnAddresses) {
+      normalRegistrations.push(reg);
+      contractNamesWithNormalEvents.add(reg.eventConfig.contractName);
     } else {
-      contractConfigs[ec.contractName] = {
-        startBlock: ec.startBlock
-      };
-    }
-    if (ec.dependsOnAddresses) {
-      normalEventConfigs.push(ec);
-      contractNamesWithNormalEvents.add(ec.contractName);
-    } else {
-      notDependingOnAddresses.push(ec);
+      notDependingOnAddresses.push(reg);
     }
   });
   let partitions = [];
@@ -1286,7 +1333,7 @@ function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartitio
       id: partitions.length.toString(),
       latestFetchedBlock: latestFetchedBlock,
       selection: {
-        eventConfigs: notDependingOnAddresses,
+        onEventRegistrations: notDependingOnAddresses,
         dependsOnAddresses: false
       },
       addressesByContractName: {},
@@ -1295,51 +1342,39 @@ function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartitio
       mutPendingQueries: [],
       prevQueryRange: 0,
       prevPrevQueryRange: 0,
+      prevRangeSize: 0,
       latestBlockRangeUpdateBlock: 0
     });
   }
   let normalSelection = {
-    eventConfigs: normalEventConfigs,
+    onEventRegistrations: normalRegistrations,
     dependsOnAddresses: true
   };
   let registeringContractsByContract = {};
   let dynamicContracts = new Set();
   addresses.forEach(contract => {
     let contractName = contract.contractName;
-    let match = contractConfigs[contractName];
-    let contractStartBlock = match !== undefined ? match.startBlock : undefined;
-    let ia_address = contract.address;
-    let ia_contractName = contract.contractName;
-    let ia_registrationBlock = contract.registrationBlock;
-    let ia_effectiveStartBlock = deriveEffectiveStartBlock(contract.registrationBlock, contractStartBlock);
-    let ia = {
-      address: ia_address,
-      contractName: ia_contractName,
-      registrationBlock: ia_registrationBlock,
-      effectiveStartBlock: ia_effectiveStartBlock
-    };
-    indexingAddresses[contract.address] = ia;
-    if (!contractNamesWithNormalEvents.has(contractName)) {
-      return;
-    }
-    let registeringContracts = Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, contractName);
-    registeringContracts[contract.address] = ia;
-    if (contract.registrationBlock !== -1) {
-      dynamicContracts.add(contractName);
-      return;
+    if (contractNamesWithNormalEvents.has(contractName)) {
+      Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, contractName)[contract.address] = IndexingAddresses.makeIndexingAddress(contract, contractConfigs);
+      if (contract.registrationBlock !== -1) {
+        dynamicContracts.add(contractName);
+        return;
+      } else {
+        return;
+      }
     }
   });
   let optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, dynamicContracts, normalSelection, maxAddrInPartition, partitions.length, partitions, progressBlockNumber);
-  if (optimizedPartitions.idsInAscOrder.length === 0 && Utils.$$Array.isEmpty(onBlockConfigs)) {
-    Stdlib_JsError.throwWithMessage(`Invalid configuration: Nothing to fetch on chain ` + chainId.toString() + `. ` + (`addresses=` + addresses.length.toString() + `, `) + (`eventConfigs=` + eventConfigs.length.toString() + `, `) + (`normalEventConfigs=` + normalEventConfigs.length.toString() + `. `) + `Make sure that you provided at least one contract address to index, or have events with Wildcard mode enabled, or have onBlock handlers.`);
+  if (optimizedPartitions.idsInAscOrder.length === 0 && Utils.$$Array.isEmpty(onBlockRegistrations)) {
+    Stdlib_JsError.throwWithMessage(`Invalid configuration: Nothing to fetch on chain ` + chainId.toString() + `. ` + (`addresses=` + addresses.length.toString() + `, `) + (`onEventRegistrations=` + onEventRegistrations.length.toString() + `, `) + (`normalRegistrations=` + normalRegistrations.length.toString() + `. `) + `Make sure that you provided at least one contract address to index, or have events with Wildcard mode enabled, or have onBlock handlers.`);
   }
   let buffer = [];
   let latestOnBlockBlockNumber;
-  if (knownHeight > 0 && Utils.$$Array.notEmpty(onBlockConfigs)) {
+  if (knownHeight > 0 && Utils.$$Array.notEmpty(onBlockRegistrations)) {
     let id = optimizedPartitions.idsInAscOrder[0];
     let latestFullyFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
     let maxBlockNumber = latestFullyFetchedBlock !== undefined ? latestFullyFetchedBlock.blockNumber : knownHeight;
-    latestOnBlockBlockNumber = appendOnBlockItems(buffer, onBlockConfigs, startBlock, progressBlockNumber, maxBlockNumber, maxOnBlockBufferSize);
+    latestOnBlockBlockNumber = appendOnBlockItems(buffer, onBlockRegistrations, startBlock, progressBlockNumber, maxBlockNumber, maxOnBlockBufferSize);
   } else {
     latestOnBlockBlockNumber = progressBlockNumber;
   }
@@ -1348,19 +1383,16 @@ function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartitio
     startBlock: startBlock,
     endBlock: endBlock,
     normalSelection: normalSelection,
-    indexingAddresses: indexingAddresses,
     contractConfigs: contractConfigs,
     chainId: chainId,
     latestOnBlockBlockNumber: latestOnBlockBlockNumber,
     blockLag: blockLag,
     buffer: buffer,
     maxOnBlockBufferSize: maxOnBlockBufferSize,
-    onBlockConfigs: onBlockConfigs,
+    onBlockRegistrations: onBlockRegistrations,
     knownHeight: knownHeight,
     firstEventBlock: firstEventBlock
   };
-  let numAddresses = Utils.Dict.size(indexingAddresses);
-  Prometheus.IndexingAddresses.set(numAddresses, chainId);
   Prometheus.IndexingPartitions.set(optimizedPartitions.idsInAscOrder.length, chainId);
   Prometheus.IndexingBufferSize.set(buffer.length, chainId);
   Prometheus.IndexingBufferBlockNumber.set(bufferBlockNumber(fetchState), chainId);
@@ -1374,22 +1406,6 @@ function bufferSize(param) {
   return param.buffer.length;
 }
 
-function bufferReadyCount(fetchState) {
-  let frontier = bufferBlockNumber(fetchState);
-  let buffer = fetchState.buffer;
-  let lo = 0;
-  let hi = buffer.length;
-  while (lo < hi) {
-    let mid = (lo + hi | 0) / 2 | 0;
-    if (buffer[mid].blockNumber <= frontier) {
-      lo = mid + 1 | 0;
-    } else {
-      hi = mid;
-    }
-  };
-  return lo;
-}
-
 function rollbackPendingQueries(mutPendingQueries, targetBlockNumber) {
   let adjusted = [];
   for (let qIdx = 0, qIdx_finish = mutPendingQueries.length; qIdx < qIdx_finish; ++qIdx) {
@@ -1402,6 +1418,8 @@ function rollbackPendingQueries(mutPendingQueries, targetBlockNumber) {
             fromBlock: pq.fromBlock,
             toBlock: pq.toBlock,
             isChunk: pq.isChunk,
+            itemsTarget: pq.itemsTarget,
+            itemsEst: pq.itemsEst,
             fetchedBlock: {
               blockNumber: targetBlockNumber,
               blockTimestamp: 0
@@ -1418,16 +1436,8 @@ function rollbackPendingQueries(mutPendingQueries, targetBlockNumber) {
   return adjusted;
 }
 
-function rollback(fetchState, targetBlockNumber) {
-  let addressesToRemove = new Set();
-  let indexingAddresses = {};
-  Utils.Dict.forEachWithKey(fetchState.indexingAddresses, (indexingContract, address) => {
-    if (indexingContract.registrationBlock > targetBlockNumber) {
-      addressesToRemove.add(address);
-    } else {
-      indexingAddresses[address] = indexingContract;
-    }
-  });
+function rollback(fetchState, indexingAddresses, targetBlockNumber) {
+  IndexingAddresses.rollbackInPlace(indexingAddresses, targetBlockNumber);
   let keptPartitions = [];
   let nextKeptIdRef = 0;
   let registeringContractsByContract = {};
@@ -1438,11 +1448,12 @@ function rollback(fetchState, targetBlockNumber) {
       if (p.latestFetchedBlock.blockNumber > targetBlockNumber) {
         Utils.Dict.forEachWithKey(p.addressesByContractName, (addresses, contractName) => {
           addresses.forEach(address => {
-            if (!(!addressesToRemove.has(address) && Stdlib_Option.isSome(indexingAddresses[address]))) {
+            let indexingContract = IndexingAddresses.get(indexingAddresses, address);
+            if (indexingContract === undefined) {
               return;
             }
             let registeringContracts = Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, contractName);
-            registeringContracts[address] = indexingAddresses[address];
+            registeringContracts[address] = indexingContract;
           });
         });
       } else {
@@ -1450,7 +1461,7 @@ function rollback(fetchState, targetBlockNumber) {
         let mergeBlock$1 = mergeBlock !== undefined && mergeBlock > targetBlockNumber ? targetBlockNumber : mergeBlock;
         let rollbackedAddressesByContractName = {};
         Utils.Dict.forEachWithKey(p.addressesByContractName, (addresses, contractName) => {
-          let keptAddresses = addresses.filter(address => !addressesToRemove.has(address));
+          let keptAddresses = addresses.filter(address => Stdlib_Option.isSome(IndexingAddresses.get(indexingAddresses, address)));
           if (keptAddresses.length !== 0) {
             rollbackedAddressesByContractName[contractName] = keptAddresses;
             return;
@@ -1469,6 +1480,7 @@ function rollback(fetchState, targetBlockNumber) {
             mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, targetBlockNumber),
             prevQueryRange: p.prevQueryRange,
             prevPrevQueryRange: p.prevPrevQueryRange,
+            prevRangeSize: p.prevRangeSize,
             latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
           });
         }
@@ -1489,6 +1501,7 @@ function rollback(fetchState, targetBlockNumber) {
         mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, targetBlockNumber),
         prevQueryRange: p.prevQueryRange,
         prevPrevQueryRange: p.prevPrevQueryRange,
+        prevRangeSize: p.prevRangeSize,
         latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
       });
     }
@@ -1499,17 +1512,16 @@ function rollback(fetchState, targetBlockNumber) {
     startBlock: fetchState.startBlock,
     endBlock: fetchState.endBlock,
     normalSelection: fetchState.normalSelection,
-    indexingAddresses: fetchState.indexingAddresses,
     contractConfigs: fetchState.contractConfigs,
     chainId: fetchState.chainId,
     latestOnBlockBlockNumber: Primitive_int.min(fetchState.latestOnBlockBlockNumber, targetBlockNumber),
     blockLag: fetchState.blockLag,
     buffer: fetchState.buffer,
     maxOnBlockBufferSize: fetchState.maxOnBlockBufferSize,
-    onBlockConfigs: fetchState.onBlockConfigs,
+    onBlockRegistrations: fetchState.onBlockRegistrations,
     knownHeight: fetchState.knownHeight,
     firstEventBlock: fetchState.firstEventBlock
-  }, optimizedPartitions, indexingAddresses, fetchState.buffer.filter(item => {
+  }, optimizedPartitions, fetchState.buffer.filter(item => {
     let tmp;
     tmp = item.kind === 0 ? item.blockNumber : item.blockNumber;
     return tmp <= targetBlockNumber;
@@ -1533,6 +1545,7 @@ function resetPendingQueries(fetchState) {
         mutPendingQueries: kept,
         prevQueryRange: partition.prevQueryRange,
         prevPrevQueryRange: partition.prevPrevQueryRange,
+        prevRangeSize: partition.prevRangeSize,
         latestBlockRangeUpdateBlock: partition.latestBlockRangeUpdateBlock
       };
     }
@@ -1549,14 +1562,13 @@ function resetPendingQueries(fetchState) {
     startBlock: fetchState.startBlock,
     endBlock: fetchState.endBlock,
     normalSelection: fetchState.normalSelection,
-    indexingAddresses: fetchState.indexingAddresses,
     contractConfigs: fetchState.contractConfigs,
     chainId: fetchState.chainId,
     latestOnBlockBlockNumber: fetchState.latestOnBlockBlockNumber,
     blockLag: fetchState.blockLag,
     buffer: fetchState.buffer,
     maxOnBlockBufferSize: fetchState.maxOnBlockBufferSize,
-    onBlockConfigs: fetchState.onBlockConfigs,
+    onBlockRegistrations: fetchState.onBlockRegistrations,
     knownHeight: fetchState.knownHeight,
     firstEventBlock: fetchState.firstEventBlock
   };
@@ -1666,7 +1678,7 @@ function getProgressBlockNumberAt(fetchState, index) {
 function updateKnownHeight(fetchState, knownHeight) {
   if (knownHeight > fetchState.knownHeight) {
     Prometheus.IndexingKnownHeight.set(knownHeight, fetchState.chainId);
-    return updateInternal(fetchState, undefined, undefined, undefined, undefined, knownHeight);
+    return updateInternal(fetchState, undefined, undefined, undefined, knownHeight);
   } else {
     return fetchState;
   }
@@ -1674,18 +1686,20 @@ function updateKnownHeight(fetchState, knownHeight) {
 
 let blockItemLogIndex = 16777216;
 
-let maxPendingChunksPerPartition = 10;
+let maxPendingChunksPerPartition = 12;
 
 export {
-  deriveEffectiveStartBlock,
+  deriveContractNameByAddress,
+  densityItemsTarget,
   getMinHistoryRange,
+  getTrustedDensity,
   getMinQueryRange,
   OptimizedPartitions,
   bufferBlockNumber,
   bufferBlock,
+  bufferReadyCount,
   compareBufferItem,
   blockItemLogIndex,
-  numAddresses,
   appendOnBlockItems,
   updateInternal,
   warnDifferentContractType,
@@ -1695,14 +1709,14 @@ export {
   registerDynamicContracts,
   handleQueryResult,
   startFetchingQueries,
-  pushQueriesForRange,
   maxPendingChunksPerPartition,
+  pushGapFillQueries,
+  waterLevel,
   getNextQuery,
   hasReadyItem,
   getReadyItemsCount,
   make$1 as make,
   bufferSize,
-  bufferReadyCount,
   rollbackPendingQueries,
   rollback,
   resetPendingQueries,
@@ -1714,4 +1728,4 @@ export {
   getProgressBlockNumberAt,
   updateKnownHeight,
 }
-/* Utils Not a pure module */
+/* deriveContractNameByAddress Not a pure module */