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

package/src/FetchState.res.mjs

@@ -5,21 +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 calculateEstResponseSize(p, fromBlock, toBlock, maxQueryBlockNumber) {
-  if (p.prevQueryRange <= 0) {
-    return 10000;
-  }
-  let density = p.prevRangeSize / p.prevQueryRange;
-  return ((Stdlib_Option.getOr(toBlock, maxQueryBlockNumber) - fromBlock | 0) + 1 | 0) * density;
+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) {
@@ -30,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) {
@@ -99,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: {
@@ -112,7 +126,7 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         mutPendingQueries: [],
         prevQueryRange: minRange,
         prevPrevQueryRange: minRange,
-        prevRangeSize: 0,
+        prevRangeSize: Math.ceil(inheritedDensity * minRange) | 0,
         latestBlockRangeUpdateBlock: 0
       };
     } else {
@@ -349,11 +363,11 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount
     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);
@@ -454,40 +468,129 @@ 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 getRegistrationIndex(item) {
+  if (item.kind === 0) {
+    return item.onEventRegistration.index;
+  } else {
+    return item.onBlockRegistration.index;
+  }
+}
+
 function compareBufferItem(a, b) {
-  let blockOrdering = Primitive_int.compare(a.blockNumber, b.blockNumber);
-  if (blockOrdering === 0) {
-    return Primitive_int.compare(a.logIndex, b.logIndex);
+  let ba = a.blockNumber;
+  let bb = b.blockNumber;
+  if (ba !== bb) {
+    if (ba < bb) {
+      return -1;
+    } else {
+      return 1;
+    }
+  }
+  let la = a.logIndex;
+  let lb = b.logIndex;
+  if (la !== lb) {
+    if (la < lb) {
+      return -1;
+    } else {
+      return 1;
+    }
+  }
+  let ia = getRegistrationIndex(a);
+  let ib = getRegistrationIndex(b);
+  if (ia < ib) {
+    return -1;
+  } else if (ia > ib) {
+    return 1;
   } else {
-    return blockOrdering;
+    return 0;
   }
 }
 
-function numAddresses(fetchState) {
-  return Utils.Dict.size(fetchState.indexingAddresses);
+function mergeIntoBuffer(buffer, newItems) {
+  let n = newItems.length;
+  for (let i = 1; i < n; ++i) {
+    let x = newItems[i];
+    let j = i - 1 | 0;
+    while (j >= 0 && compareBufferItem(newItems[j], x) > 0) {
+      newItems[j + 1 | 0] = newItems[j];
+      j = j - 1 | 0;
+    };
+    newItems[j + 1 | 0] = x;
+  }
+  let m = buffer.length;
+  let merged = [];
+  let last = {
+    contents: undefined
+  };
+  let push = item => {
+    let l = last.contents;
+    if (l !== undefined && compareBufferItem(l, item) === 0) {
+      return;
+    }
+    merged.push(item);
+    last.contents = item;
+  };
+  let i$1 = 0;
+  let j$1 = 0;
+  while (i$1 < m && j$1 < n) {
+    let a = buffer[i$1];
+    let b = newItems[j$1];
+    if (compareBufferItem(a, b) <= 0) {
+      push(a);
+      i$1 = i$1 + 1 | 0;
+    } else {
+      push(b);
+      j$1 = j$1 + 1 | 0;
+    }
+  };
+  while (i$1 < m) {
+    push(buffer[i$1]);
+    i$1 = i$1 + 1 | 0;
+  };
+  while (j$1 < n) {
+    push(newItems[j$1]);
+    j$1 = j$1 + 1 | 0;
+  };
+  return merged;
 }
 
-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;
       }
@@ -496,19 +599,19 @@ function appendOnBlockItems(mutItems, onBlockConfigs, indexerStartBlock, fromBlo
   return latestOnBlockBlockNumber;
 }
 
-function updateInternal(fetchState, optimizedPartitionsOpt, indexingAddressesOpt, mutItems, blockLagOpt, knownHeightOpt) {
+function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, mutItemsSortedOpt, blockLagOpt, knownHeightOpt) {
   let optimizedPartitions = optimizedPartitionsOpt !== undefined ? optimizedPartitionsOpt : fetchState.optimizedPartitions;
-  let indexingAddresses = indexingAddressesOpt !== undefined ? indexingAddressesOpt : fetchState.indexingAddresses;
+  let mutItemsSorted = mutItemsSortedOpt !== undefined ? mutItemsSortedOpt : false;
   let blockLag = blockLagOpt !== undefined ? blockLagOpt : fetchState.blockLag;
   let knownHeight = knownHeightOpt !== undefined ? knownHeightOpt : fetchState.knownHeight;
-  let mutItemsRef = mutItems;
-  let onBlockConfigs = fetchState.onBlockConfigs;
+  let base = mutItems !== undefined ? (
+      mutItemsSorted ? mutItems : mergeIntoBuffer([], mutItems)
+    ) : fetchState.buffer;
+  let blockItems = [];
+  let onBlockRegistrations = fetchState.onBlockRegistrations;
   let latestOnBlockBlockNumber;
-  if (onBlockConfigs.length !== 0) {
-    let mutItems$1 = mutItemsRef;
-    let item = (
-        mutItems$1 !== undefined ? mutItems$1 : fetchState.buffer
-      )[fetchState.maxOnBlockBufferSize - 1 | 0];
+  if (onBlockRegistrations.length !== 0) {
+    let item = base[fetchState.maxOnBlockBufferSize - 1 | 0];
     let maxBlockNumber;
     if (item !== undefined) {
       maxBlockNumber = item.blockNumber;
@@ -517,45 +620,37 @@ function updateInternal(fetchState, optimizedPartitionsOpt, indexingAddressesOpt
       let latestFullyFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
       maxBlockNumber = latestFullyFetchedBlock !== undefined ? latestFullyFetchedBlock.blockNumber : knownHeight;
     }
-    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(blockItems, onBlockRegistrations, fetchState.startBlock, fetchState.latestOnBlockBlockNumber, maxBlockNumber, fetchState.maxOnBlockBufferSize);
   } else {
     latestOnBlockBlockNumber = knownHeight;
   }
-  let mutItems$4 = mutItemsRef;
   let updatedFetchState_startBlock = fetchState.startBlock;
   let updatedFetchState_endBlock = fetchState.endBlock;
   let updatedFetchState_normalSelection = fetchState.normalSelection;
   let updatedFetchState_contractConfigs = fetchState.contractConfigs;
   let updatedFetchState_chainId = fetchState.chainId;
-  let updatedFetchState_buffer = mutItems$4 !== undefined ? (mutItems$4.sort(compareBufferItem), mutItems$4) : fetchState.buffer;
+  let updatedFetchState_buffer = blockItems.length !== 0 ? mergeIntoBuffer(base, blockItems) : base;
   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;
 }
 
@@ -737,11 +832,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 = {};
@@ -759,14 +853,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);
@@ -797,14 +891,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);
@@ -839,101 +933,103 @@ 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,
-                  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 {
+  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, undefined);
 }
 
-function handleQueryResult(fetchState, query, latestFetchedBlock, newItems) {
-  let newItems$1 = newItems.filter(item => {
+function filterByClientAddress(items, indexingAddresses) {
+  return items.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, newItems$1.length, latestFetchedBlock), undefined, newItems$1.length !== 0 ? fetchState.buffer.concat(newItems$1) : undefined, undefined, undefined);
+}
+
+function handleQueryResult(fetchState, query, latestFetchedBlock, newItems) {
+  return updateInternal(fetchState, handleQueryResponse(fetchState.optimizedPartitions, query, fetchState.knownHeight, newItems.length, latestFetchedBlock), newItems.length !== 0 ? mergeIntoBuffer(fetchState.buffer, newItems) : undefined, true, undefined, undefined);
 }
 
 function startFetchingQueries(param, queries) {
@@ -947,7 +1043,8 @@ function startFetchingQueries(param, queries) {
       fromBlock: q.fromBlock,
       toBlock: q.toBlock,
       isChunk: q.isChunk,
-      estResponseSize: q.estResponseSize,
+      itemsTarget: q.itemsTarget,
+      itemsEst: q.itemsEst,
       fetchedBlock: undefined
     };
     let inserted = false;
@@ -965,199 +1062,141 @@ function startFetchingQueries(param, queries) {
   }
 }
 
-function pushQueriesForRange(queries, partitionId, rangeFromBlock, rangeEndBlock, maxQueryBlockNumber, maybeChunkRange, partition, 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,
-          estResponseSize: calculateEstResponseSize(partition, chunkFromBlock, chunkToBlock, maxQueryBlockNumber),
-          chainId: 0,
-          progress: 0,
+          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,
-      estResponseSize: calculateEstResponseSize(partition, rangeFromBlock, rangeEndBlock, maxQueryBlockNumber),
-      chainId: 0,
-      progress: 0,
-      selection: selection,
-      addressesByContractName: addressesByContractName,
-      indexingAddresses: indexingAddresses
-    });
-    return;
   }
-  queries.push({
-    partitionId: partitionId,
-    fromBlock: rangeFromBlock,
-    toBlock: rangeEndBlock,
-    isChunk: false,
-    estResponseSize: calculateEstResponseSize(partition, rangeFromBlock, rangeEndBlock, maxQueryBlockNumber),
-    chainId: 0,
-    progress: 0,
-    selection: selection,
-    addressesByContractName: addressesByContractName,
-    indexingAddresses: indexingAddresses
-  });
+  return cost.contents;
 }
 
-function getNextQuery(fetchState, budget, chainPendingBudget) {
-  let knownHeight = fetchState.knownHeight;
-  let blockLag = fetchState.blockLag;
-  let indexingAddresses = fetchState.indexingAddresses;
-  let optimizedPartitions = fetchState.optimizedPartitions;
+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 (budget <= 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[(budget + (chainPendingBudget | 0) | 0) - 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 chainReserved = 0;
+  let reservations = [];
+  let partitionIndexById = {};
+  let candidates = [];
+  let fillStates = [];
+  for (let idx$1 = 0; idx$1 < partitionsCount; ++idx$1) {
+    let partitionId$1 = optimizedPartitions.idsInAscOrder[idx$1];
+    let p$1 = optimizedPartitions.entities[partitionId$1];
+    partitionIndexById[partitionId$1] = idx$1;
+    let pendingCount = p$1.mutPendingQueries.length;
+    for (let pqIdx = 0; pqIdx < pendingCount; ++pqIdx) {
+      let pq = p$1.mutPendingQueries[pqIdx];
+      if (pq.fetchedBlock === undefined) {
+        chainReserved = chainReserved + pq.itemsEst;
+        reservations.push([
+          pq.fromBlock,
+          pq.itemsEst
+        ]);
+      }
+    }
+    let queryEndBlock = computeQueryEndBlock(p$1);
+    let maybeChunkRange = getMinHistoryRange(p$1);
+    let cursor = p$1.latestFetchedBlock.blockNumber + 1 | 0;
     let canContinue = true;
-    let pqIdx = 0;
-    while (pqIdx < p.mutPendingQueries.length && canContinue) {
-      let pq = p.mutPendingQueries[pqIdx];
-      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,
-                    estResponseSize: calculateEstResponseSize(p, chunkFromBlock, chunkToBlock, maxQueryBlockNumber),
-                    chainId: 0,
-                    progress: 0,
-                    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,
-                  estResponseSize: calculateEstResponseSize(p, rangeFromBlock, rangeEndBlock, maxQueryBlockNumber),
-                  chainId: 0,
-                  progress: 0,
-                  selection: selection,
-                  addressesByContractName: addressesByContractName,
-                  indexingAddresses: indexingAddresses
-                });
-              }
-            } else {
-              queries.push({
-                partitionId: partitionId,
-                fromBlock: rangeFromBlock,
-                toBlock: rangeEndBlock,
-                isChunk: false,
-                estResponseSize: calculateEstResponseSize(p, rangeFromBlock, rangeEndBlock, maxQueryBlockNumber),
-                chainId: 0,
-                progress: 0,
-                selection: selection,
-                addressesByContractName: addressesByContractName,
-                indexingAddresses: indexingAddresses
-              });
-            }
-          }
-        }
+    let chunksUsedThisCall = 0;
+    let pqIdx$1 = 0;
+    while (pqIdx$1 < pendingCount && canContinue) {
+      let pq$1 = p$1.mutPendingQueries[pqIdx$1];
+      if (pq$1.fromBlock > cursor) {
+        let beforeLen = candidates.length;
+        pushGapFillQueries(candidates, partitionId$1, cursor, Utils.$$Math.minOptInt(pq$1.fromBlock - 1 | 0, queryEndBlock), knownHeight, chainTargetBlock, maybeChunkRange, (12 - pendingCount | 0) - chunksUsedThisCall | 0, p$1, chainTargetItems / partitionsCount, chunkItemsMultiplier, p$1.selection, p$1.addressesByContractName);
+        chunksUsedThisCall = chunksUsedThisCall + (candidates.length - beforeLen | 0) | 0;
       }
-      let toBlock = pq.toBlock;
-      if (toBlock !== undefined && pq.isChunk) {
-        let match$1 = pq.fetchedBlock;
-        if (match$1 !== undefined) {
-          let blockNumber = match$1.blockNumber;
+      let toBlock = pq$1.toBlock;
+      if (toBlock !== undefined && pq$1.isChunk) {
+        let match = pq$1.fetchedBlock;
+        if (match !== undefined) {
+          let blockNumber = match.blockNumber;
           cursor = blockNumber < toBlock ? blockNumber + 1 | 0 : toBlock + 1 | 0;
         } else {
           cursor = toBlock + 1 | 0;
@@ -1165,87 +1204,139 @@ function getNextQuery(fetchState, budget, chainPendingBudget) {
       } 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,
-                  estResponseSize: calculateEstResponseSize(p, chunkFromBlock$1, chunkToBlock$1, maxQueryBlockNumber),
-                  chainId: 0,
-                  progress: 0,
-                  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,
-                estResponseSize: calculateEstResponseSize(p, rangeFromBlock$1, queryEndBlock$2, maxQueryBlockNumber),
-                chainId: 0,
-                progress: 0,
-                selection: selection$1,
-                addressesByContractName: addressesByContractName$1,
-                indexingAddresses: indexingAddresses
-              });
-            }
-          } else {
-            queries.push({
-              partitionId: partitionId,
-              fromBlock: rangeFromBlock$1,
-              toBlock: queryEndBlock$2,
-              isChunk: false,
-              estResponseSize: calculateEstResponseSize(p, rangeFromBlock$1, queryEndBlock$2, maxQueryBlockNumber),
-              chainId: 0,
-              progress: 0,
-              selection: selection$1,
-              addressesByContractName: addressesByContractName$1,
-              indexingAddresses: indexingAddresses
-            });
-          }
-        }
+      fillStates.push({
+        partitionId: partitionId$1,
+        p: p$1,
+        cursor: cursor,
+        chunksUsedThisCall: chunksUsedThisCall,
+        pendingCount: pendingCount,
+        queryEndBlock: queryEndBlock,
+        maybeChunkRange: maybeChunkRange
+      });
+    }
+  }
+  let freshBudget = Primitive_float.max(0, chainTargetItems - chainReserved);
+  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 inRangeCount = inRangeStates.length;
+  let probeShare = inRangeCount === 0 ? 0 : freshBudget / inRangeCount;
+  let frontierCursor = Stdlib_Array.reduce(inRangeStates, chainTargetBlock, (min, fs) => {
+    if (fs.cursor < min) {
+      return fs.cursor;
+    } else {
+      return min;
+    }
+  });
+  let rangeToTarget = (chainTargetBlock - frontierCursor | 0) + 1 | 0;
+  let rangeTargetDensity = inRangeCount > 0 && rangeToTarget > 0 ? freshBudget / rangeToTarget : 0;
+  inRangeStates.forEach(fs => {
+    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 chunkStartCeiling = Primitive_int.min(maxBlock, chainTargetBlock);
+      let created = 0;
+      let chunkFromBlock = fs.cursor;
+      let generatedItems = 0;
+      while (created < maxChunksRemaining && chunkFromBlock <= chunkStartCeiling && generatedItems <= freshBudget) {
+        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);
+        candidates.push({
+          partitionId: fs.partitionId,
+          fromBlock: chunkFromBlock,
+          toBlock: chunkToBlock,
+          isChunk: true,
+          itemsTarget: itemsTarget,
+          itemsEst: itemsEst,
+          selection: p.selection,
+          addressesByContractName: p.addressesByContractName
+        });
+        generatedItems = generatedItems + itemsEst;
+        chunkFromBlock = chunkToBlock + 1 | 0;
+        created = created + 1 | 0;
+      };
+      return;
+    }
+    let itemsTarget$1 = rangeToTarget > 0 ? Primitive_int.max(1, Math.round(rangeTargetDensity * ((chainTargetBlock - fs.cursor | 0) + 1 | 0) / inRangeCount) | 0) : Primitive_int.max(1, Math.round(probeShare) | 0);
+    candidates.push({
+      partitionId: fs.partitionId,
+      fromBlock: fs.cursor,
+      toBlock: fs.queryEndBlock,
+      isChunk: false,
+      itemsTarget: itemsTarget$1,
+      itemsEst: itemsTarget$1,
+      selection: p.selection,
+      addressesByContractName: p.addressesByContractName
+    });
+  });
+  let acceptanceStream = [];
+  candidates.forEach(query => {
+    acceptanceStream.push([
+      query.fromBlock,
+      query.itemsEst,
+      query
+    ]);
+  });
+  reservations.forEach(param => {
+    acceptanceStream.push([
+      param[0],
+      param[1],
+      undefined
+    ]);
+  });
+  acceptanceStream.sort((param, param$1) => {
+    let bFrom = param$1[0];
+    let aFrom = param[0];
+    if (aFrom !== bFrom) {
+      return Primitive_int.compare(aFrom, bFrom);
+    }
+    let bQuery = param$1[2];
+    if (param[2] !== undefined) {
+      if (bQuery !== undefined) {
+        return 0;
+      } else {
+        return 1;
       }
+    } else if (bQuery !== undefined) {
+      return -1;
+    } else {
+      return 0;
     }
-    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 streamCount = acceptanceStream.length;
+  let remainingBudget = chainTargetItems;
+  let acceptIdx = 0;
+  while (remainingBudget > 0 && acceptIdx < streamCount) {
+    let match$1 = acceptanceStream[acceptIdx];
+    let maybeQuery = match$1[2];
+    if (maybeQuery !== undefined) {
+      let partitionIdx = partitionIndexById[maybeQuery.partitionId];
+      queriesByPartitionIndex[partitionIdx].push(maybeQuery);
     }
-    idxRef = idxRef + 1 | 0;
+    remainingBudget = remainingBudget - match$1[1];
+    acceptIdx = acceptIdx + 1 | 0;
   };
+  let queries = queriesByPartitionIndex.flat();
   if (Utils.$$Array.isEmpty(queries)) {
     if (shouldWaitForNewBlock) {
       return "WaitingForNewBlock";
@@ -1292,9 +1383,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 = {
@@ -1302,32 +1393,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 = [];
@@ -1336,7 +1409,7 @@ function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartitio
       id: partitions.length.toString(),
       latestFetchedBlock: latestFetchedBlock,
       selection: {
-        eventConfigs: notDependingOnAddresses,
+        onEventRegistrations: notDependingOnAddresses,
         dependsOnAddresses: false
       },
       addressesByContractName: {},
@@ -1350,47 +1423,34 @@ function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartitio
     });
   }
   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;
   }
@@ -1399,19 +1459,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);
@@ -1425,22 +1482,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) {
@@ -1453,7 +1494,8 @@ function rollbackPendingQueries(mutPendingQueries, targetBlockNumber) {
             fromBlock: pq.fromBlock,
             toBlock: pq.toBlock,
             isChunk: pq.isChunk,
-            estResponseSize: pq.estResponseSize,
+            itemsTarget: pq.itemsTarget,
+            itemsEst: pq.itemsEst,
             fetchedBlock: {
               blockNumber: targetBlockNumber,
               blockTimestamp: 0
@@ -1470,16 +1512,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 = {};
@@ -1490,11 +1524,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 {
@@ -1502,7 +1537,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;
@@ -1553,21 +1588,20 @@ 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;
-  }), undefined, undefined);
+  }), true, undefined, undefined);
 }
 
 function resetPendingQueries(fetchState) {
@@ -1604,14 +1638,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
   };
@@ -1674,19 +1707,6 @@ function getProgressPercentage(fetchState) {
   return progress / totalRange;
 }
 
-function getProgressPercentageAt(fetchState, blockNumber) {
-  let firstEventBlock = fetchState.firstEventBlock;
-  if (firstEventBlock === undefined) {
-    return 0;
-  }
-  let totalRange = fetchState.knownHeight - firstEventBlock | 0;
-  if (totalRange <= 0) {
-    return 0;
-  } else {
-    return (blockNumber - firstEventBlock | 0) / totalRange;
-  }
-}
-
 function hasFullBatch(fetchState, batchSizeTarget) {
   let item = fetchState.buffer[batchSizeTarget - 1 | 0];
   if (item !== undefined) {
@@ -1740,24 +1760,24 @@ function updateKnownHeight(fetchState, knownHeight) {
   }
 }
 
-let defaultEstResponseSize = 10000;
-
 let blockItemLogIndex = 16777216;
 
-let maxPendingChunksPerPartition = 10;
+let maxPendingChunksPerPartition = 12;
 
 export {
-  deriveEffectiveStartBlock,
-  defaultEstResponseSize,
-  calculateEstResponseSize,
+  deriveContractNameByAddress,
+  densityItemsTarget,
   getMinHistoryRange,
+  getTrustedDensity,
   getMinQueryRange,
   OptimizedPartitions,
   bufferBlockNumber,
   bufferBlock,
+  bufferReadyCount,
+  getRegistrationIndex,
   compareBufferItem,
+  mergeIntoBuffer,
   blockItemLogIndex,
-  numAddresses,
   appendOnBlockItems,
   updateInternal,
   warnDifferentContractType,
@@ -1765,16 +1785,16 @@ export {
   addressesByContractNameGetAll,
   createPartitionsFromIndexingAddresses,
   registerDynamicContracts,
+  filterByClientAddress,
   handleQueryResult,
   startFetchingQueries,
-  pushQueriesForRange,
   maxPendingChunksPerPartition,
+  pushGapFillQueries,
   getNextQuery,
   hasReadyItem,
   getReadyItemsCount,
   make$1 as make,
   bufferSize,
-  bufferReadyCount,
   rollbackPendingQueries,
   rollback,
   resetPendingQueries,
@@ -1782,9 +1802,8 @@ export {
   isFetchingAtHead,
   isReadyToEnterReorgThreshold,
   getProgressPercentage,
-  getProgressPercentageAt,
   sortForBatch,
   getProgressBlockNumberAt,
   updateKnownHeight,
 }
-/* Utils Not a pure module */
+/* deriveContractNameByAddress Not a pure module */