envio 3.3.0-alpha.7 → 3.3.0-alpha.8

package/src/FetchState.res.mjs

@@ -5,6 +5,7 @@ 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";
@@ -22,16 +23,9 @@ let deriveContractNameByAddress = Utils.$$WeakMap.memoize(addressesByContractNam
   return result;
 });
 
-function calculateDefaultEstResponseSize(partitionsCount) {
-  return Primitive_float.max(2000, Primitive_float.min(10000, 20000 / partitionsCount));
-}
-
-function calculateEstResponseSize(p, fromBlock, toBlock, knownHeight, partitionsCount) {
-  if (p.prevQueryRange <= 0) {
-    return calculateDefaultEstResponseSize(partitionsCount);
-  }
+function densityItemsTarget(p, fromBlock, toBlock, chainTargetBlock) {
   let density = p.prevRangeSize / p.prevQueryRange;
-  return ((Stdlib_Option.getOr(toBlock, knownHeight) - fromBlock | 0) + 1 | 0) * density;
+  return ((Stdlib_Option.getOr(toBlock, chainTargetBlock) - fromBlock | 0) + 1 | 0) * density;
 }
 
 function getMinHistoryRange(p) {
@@ -491,27 +485,27 @@ function compareBufferItem(a, b) {
   }
 }
 
-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;
       }
@@ -525,9 +519,9 @@ function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, blockLagOp
   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
@@ -543,7 +537,7 @@ function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, blockLagOp
     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;
   }
@@ -555,7 +549,7 @@ function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, blockLagOp
   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,
@@ -568,7 +562,7 @@ function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, blockLagOp
     blockLag: blockLag,
     buffer: updatedFetchState_buffer,
     maxOnBlockBufferSize: updatedFetchState_maxOnBlockBufferSize,
-    onBlockConfigs: updatedFetchState_onBlockConfigs,
+    onBlockRegistrations: updatedFetchState_onBlockRegistrations,
     knownHeight: knownHeight,
     firstEventBlock: updatedFetchState_firstEventBlock
   };
@@ -757,7 +751,7 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
 }
 
 function registerDynamicContracts(fetchState, indexingAddresses, items) {
-  if (Utils.$$Array.isEmpty(fetchState.normalSelection.eventConfigs)) {
+  if (Utils.$$Array.isEmpty(fetchState.normalSelection.onEventRegistrations)) {
     Stdlib_JsError.throwWithMessage("Invalid configuration. No events to fetch for the dynamic contract registration.");
   }
   let registeringContractsByContract = {};
@@ -943,7 +937,7 @@ function handleQueryResult(fetchState, indexingAddresses, query, latestFetchedBl
     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, IndexingAddresses.rawForFilter(indexingAddresses));
     } else {
@@ -964,7 +958,7 @@ function startFetchingQueries(param, queries) {
       fromBlock: q.fromBlock,
       toBlock: q.toBlock,
       isChunk: q.isChunk,
-      estResponseSize: q.estResponseSize,
+      itemsTarget: q.itemsTarget,
       fetchedBlock: undefined
     };
     let inserted = false;
@@ -982,64 +976,68 @@ function startFetchingQueries(param, queries) {
   }
 }
 
-function pushQueriesForRange(queries, partitionId, rangeFromBlock, rangeEndBlock, knownHeight, maybeChunkRange, maxChunks, partition, selection, addressesByContractName, partitionsCount) {
-  if (!(rangeFromBlock <= knownHeight && maxChunks > 0)) {
-    return;
-  }
-  if (rangeEndBlock !== undefined && rangeFromBlock > rangeEndBlock) {
-    return;
-  }
-  if (maybeChunkRange !== undefined) {
-    let maxBlock = rangeEndBlock !== undefined ? rangeEndBlock : knownHeight;
-    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;
+function pushGapFillQueries(queries, partitionId, rangeFromBlock, rangeEndBlock, knownHeight, chainTargetBlock, maybeChunkRange, maxChunks, partition, selection, addressesByContractName) {
+  let cost = 0;
+  if (rangeFromBlock <= knownHeight && maxChunks > 0) {
+    let exit = 0;
+    if (!(rangeEndBlock !== undefined && rangeFromBlock > rangeEndBlock)) {
+      exit = 1;
+    }
+    if (exit === 1) {
+      if (maybeChunkRange !== undefined) {
+        let maxBlock = rangeEndBlock !== undefined ? rangeEndBlock : chainTargetBlock;
+        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(partition, chunkFromBlock, chunkToBlock, chainTargetBlock);
+            queries.push({
+              partitionId: partitionId,
+              fromBlock: chunkFromBlock,
+              toBlock: chunkToBlock,
+              isChunk: true,
+              itemsTarget: itemsTarget,
+              selection: selection,
+              addressesByContractName: addressesByContractName
+            });
+            cost = cost + itemsTarget;
+            chunkFromBlock = chunkToBlock + 1 | 0;
+            chunkIdx = chunkIdx + 1 | 0;
+          };
+        } else {
+          let itemsTarget$1 = densityItemsTarget(partition, rangeFromBlock, rangeEndBlock, chainTargetBlock);
+          queries.push({
+            partitionId: partitionId,
+            fromBlock: rangeFromBlock,
+            toBlock: rangeEndBlock,
+            isChunk: rangeEndBlock !== undefined,
+            itemsTarget: itemsTarget$1,
+            selection: selection,
+            addressesByContractName: addressesByContractName
+          });
+          cost = cost + itemsTarget$1;
+        }
+      } else {
+        let itemsTarget$2 = densityItemsTarget(partition, rangeFromBlock, rangeEndBlock, chainTargetBlock);
         queries.push({
           partitionId: partitionId,
-          fromBlock: chunkFromBlock,
-          toBlock: chunkToBlock,
-          isChunk: true,
-          estResponseSize: calculateEstResponseSize(partition, chunkFromBlock, chunkToBlock, knownHeight, partitionsCount),
-          chainId: 0,
-          progress: 0,
+          fromBlock: rangeFromBlock,
+          toBlock: rangeEndBlock,
+          isChunk: false,
+          itemsTarget: itemsTarget$2,
           selection: selection,
           addressesByContractName: addressesByContractName
         });
-        chunkFromBlock = chunkToBlock + 1 | 0;
-        chunkIdx = chunkIdx + 1 | 0;
-      };
-      return;
+        cost = cost + itemsTarget$2;
+      }
     }
-    queries.push({
-      partitionId: partitionId,
-      fromBlock: rangeFromBlock,
-      toBlock: rangeEndBlock,
-      isChunk: rangeEndBlock !== undefined,
-      estResponseSize: calculateEstResponseSize(partition, rangeFromBlock, rangeEndBlock, knownHeight, partitionsCount),
-      chainId: 0,
-      progress: 0,
-      selection: selection,
-      addressesByContractName: addressesByContractName
-    });
-    return;
   }
-  queries.push({
-    partitionId: partitionId,
-    fromBlock: rangeFromBlock,
-    toBlock: rangeEndBlock,
-    isChunk: false,
-    estResponseSize: calculateEstResponseSize(partition, rangeFromBlock, rangeEndBlock, knownHeight, partitionsCount),
-    chainId: 0,
-    progress: 0,
-    selection: selection,
-    addressesByContractName: addressesByContractName
-  });
+  return cost;
 }
 
-function getNextQuery(param) {
+function getNextQuery(param, chainTargetBlock, chainTargetItems) {
   let knownHeight = param.knownHeight;
   let blockLag = param.blockLag;
   let endBlock = param.endBlock;
@@ -1052,90 +1050,55 @@ function getNextQuery(param) {
   let shouldWaitForNewBlock = (
     endBlock !== undefined ? headBlockNumber < endBlock : true
   ) && !isOnBlockBehindTheHead;
-  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 queriesByPartitionIndex = Stdlib_Array.fromInitializer(partitionsCount, param => []);
+  let computeQueryEndBlock = p => {
     let queryEndBlock = Utils.$$Math.minOptInt(endBlock, p.mergeBlock);
-    let queryEndBlock$1 = blockLag !== 0 ? Utils.$$Math.minOptInt(headBlockNumber, queryEndBlock) : queryEndBlock;
-    let maybeChunkRange = getMinHistoryRange(p);
-    let cursor = p.latestFetchedBlock.blockNumber + 1 | 0;
+    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].itemsTarget;
+    }
+    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 maxChunks = (10 - pendingCount | 0) - (queries.length - partitionQueriesStart | 0) | 0;
-        let rangeEndBlock = Utils.$$Math.minOptInt(pq.fromBlock - 1 | 0, queryEndBlock$1);
-        let rangeFromBlock = cursor;
-        if (rangeFromBlock <= knownHeight && maxChunks > 0) {
-          let exit = 0;
-          if (!(rangeEndBlock !== undefined && rangeFromBlock > rangeEndBlock)) {
-            exit = 1;
-          }
-          if (exit === 1) {
-            if (maybeChunkRange !== undefined) {
-              let maxBlock = rangeEndBlock !== undefined ? rangeEndBlock : knownHeight;
-              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;
-                  queries.push({
-                    partitionId: partitionId,
-                    fromBlock: chunkFromBlock,
-                    toBlock: chunkToBlock,
-                    isChunk: true,
-                    estResponseSize: calculateEstResponseSize(p, chunkFromBlock, chunkToBlock, knownHeight, partitionsCount),
-                    chainId: 0,
-                    progress: 0,
-                    selection: selection,
-                    addressesByContractName: addressesByContractName
-                  });
-                  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, knownHeight, partitionsCount),
-                  chainId: 0,
-                  progress: 0,
-                  selection: selection,
-                  addressesByContractName: addressesByContractName
-                });
-              }
-            } else {
-              queries.push({
-                partitionId: partitionId,
-                fromBlock: rangeFromBlock,
-                toBlock: rangeEndBlock,
-                isChunk: false,
-                estResponseSize: calculateEstResponseSize(p, rangeFromBlock, rangeEndBlock, knownHeight, partitionsCount),
-                chainId: 0,
-                progress: 0,
-                selection: selection,
-                addressesByContractName: addressesByContractName
-              });
-            }
-          }
-        }
+        let beforeLen = bucket.length;
+        let cost$1 = pushGapFillQueries(bucket, partitionId$2, cursor, Utils.$$Math.minOptInt(pq.fromBlock - 1 | 0, queryEndBlock), knownHeight, chainTargetBlock, maybeChunkRange, (10 - pendingCount | 0) - chunksUsedThisCall | 0, p$2, 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) {
@@ -1149,72 +1112,122 @@ function getNextQuery(param) {
       } 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 maxChunks$1 = (10 - pendingCount | 0) - (queries.length - partitionQueriesStart | 0) | 0;
-      let rangeFromBlock$1 = cursor;
-      if (rangeFromBlock$1 <= knownHeight && maxChunks$1 > 0) {
-        let exit$1 = 0;
-        if (!(queryEndBlock$1 !== undefined && rangeFromBlock$1 > queryEndBlock$1)) {
-          exit$1 = 1;
-        }
-        if (exit$1 === 1) {
-          if (maybeChunkRange !== undefined) {
-            let maxBlock$1 = queryEndBlock$1 !== undefined ? queryEndBlock$1 : knownHeight;
-            let chunkSize$1 = Js_math.ceil_int(maybeChunkRange * 1.8);
-            if (((rangeFromBlock$1 + (chunkSize$1 << 1) | 0) - 1 | 0) <= maxBlock$1) {
-              let chunkFromBlock$1 = rangeFromBlock$1;
-              let chunkIdx$1 = 0;
-              while (chunkIdx$1 < maxChunks$1 && ((chunkFromBlock$1 + chunkSize$1 | 0) - 1 | 0) <= maxBlock$1) {
-                let chunkToBlock$1 = (chunkFromBlock$1 + chunkSize$1 | 0) - 1 | 0;
-                queries.push({
-                  partitionId: partitionId,
-                  fromBlock: chunkFromBlock$1,
-                  toBlock: chunkToBlock$1,
-                  isChunk: true,
-                  estResponseSize: calculateEstResponseSize(p, chunkFromBlock$1, chunkToBlock$1, knownHeight, partitionsCount),
-                  chainId: 0,
-                  progress: 0,
-                  selection: selection$1,
-                  addressesByContractName: addressesByContractName$1
-                });
-                chunkFromBlock$1 = chunkToBlock$1 + 1 | 0;
-                chunkIdx$1 = chunkIdx$1 + 1 | 0;
-              };
-            } else {
-              queries.push({
-                partitionId: partitionId,
-                fromBlock: rangeFromBlock$1,
-                toBlock: queryEndBlock$1,
-                isChunk: queryEndBlock$1 !== undefined,
-                estResponseSize: calculateEstResponseSize(p, rangeFromBlock$1, queryEndBlock$1, knownHeight, partitionsCount),
-                chainId: 0,
-                progress: 0,
-                selection: selection$1,
-                addressesByContractName: addressesByContractName$1
-              });
-            }
-          } else {
-            queries.push({
-              partitionId: partitionId,
-              fromBlock: rangeFromBlock$1,
-              toBlock: queryEndBlock$1,
-              isChunk: false,
-              estResponseSize: calculateEstResponseSize(p, rangeFromBlock$1, queryEndBlock$1, knownHeight, partitionsCount),
-              chainId: 0,
-              progress: 0,
-              selection: selection$1,
-              addressesByContractName: addressesByContractName$1
-            });
-          }
-        }
-      }
+      fillStates.push({
+        partitionId: partitionId$2,
+        p: p$2,
+        cursor: cursor,
+        chunksUsedThisCall: chunksUsedThisCall,
+        pendingCount: pendingCount,
+        queryEndBlock: queryEndBlock,
+        maybeChunkRange: maybeChunkRange,
+        bucket: bucket
+      });
     }
-    idxRef = idxRef + 1 | 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].itemsTarget;
+    }
+    reservedByPartition[fs.partitionId] = cost;
+  });
+  let emitQueries = (fs, budget) => {
+    let p = fs.p;
+    let eb = fs.queryEndBlock;
+    let maxBlock = eb !== undefined ? eb : chainTargetBlock;
+    let minHistoryRange = fs.maybeChunkRange;
+    if (minHistoryRange !== undefined) {
+      let density = p.prevRangeSize / p.prevQueryRange;
+      let chunkSize = Js_math.ceil_int(minHistoryRange * 1.8);
+      let chunkCost = density * chunkSize;
+      let maxChunksRemaining = (10 - fs.pendingCount | 0) - fs.chunksUsedThisCall | 0;
+      let affordable = chunkCost > 0 ? Math.floor(budget / chunkCost) | 0 : maxChunksRemaining;
+      let numChunks = Primitive_int.max(1, Primitive_int.min(affordable, maxChunksRemaining));
+      let consumed = 0;
+      let created = 0;
+      let chunkFromBlock = fs.cursor;
+      while (created < numChunks && chunkFromBlock <= maxBlock) {
+        let chunkToBlock = Primitive_int.min((chunkFromBlock + chunkSize | 0) - 1 | 0, maxBlock);
+        let itemsTarget = density * ((chunkToBlock - chunkFromBlock | 0) + 1 | 0);
+        fs.bucket.push({
+          partitionId: fs.partitionId,
+          fromBlock: chunkFromBlock,
+          toBlock: chunkToBlock,
+          isChunk: true,
+          itemsTarget: itemsTarget,
+          selection: p.selection,
+          addressesByContractName: p.addressesByContractName
+        });
+        consumed = consumed + itemsTarget;
+        chunkFromBlock = chunkToBlock + 1 | 0;
+        created = created + 1 | 0;
+      };
+      fs.cursor = chunkFromBlock;
+      fs.chunksUsedThisCall = fs.chunksUsedThisCall + created | 0;
+      return consumed;
+    }
+    let itemsTarget$1 = Primitive_float.min(Math.round(budget), 10000);
+    fs.bucket.push({
+      partitionId: fs.partitionId,
+      fromBlock: fs.cursor,
+      toBlock: fs.queryEndBlock,
+      isChunk: false,
+      itemsTarget: itemsTarget$1,
+      selection: p.selection,
+      addressesByContractName: p.addressesByContractName
+    });
+    fs.cursor = maxBlock + 1 | 0;
+    fs.chunksUsedThisCall = fs.chunksUsedThisCall + 1 | 0;
+    return itemsTarget$1;
   };
+  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) < 10;
+    } else {
+      return false;
+    }
+  };
+  let notFilledPartitions = fillStates.filter(isInRange);
+  let reservedFromRange = {
+    contents: 0
+  };
+  while (notFilledPartitions.length !== 0 && reservedFromRange.contents < rangeItemsTarget) {
+    let n = notFilledPartitions.length;
+    let footprintSum = {
+      contents: 0
+    };
+    notFilledPartitions.forEach(fs => {
+      footprintSum.contents = footprintSum.contents + reservedByPartition[fs.partitionId];
+    });
+    let line = (rangeItemsTarget - reservedFromRange.contents + footprintSum.contents) / n;
+    let next = [];
+    notFilledPartitions.forEach(fs => {
+      let reserved = reservedByPartition[fs.partitionId];
+      let budget = line - reserved;
+      if (budget <= 0) {
+        return;
+      }
+      let consumed = emitQueries(fs, budget);
+      reservedByPartition[fs.partitionId] = reserved + consumed;
+      reservedFromRange.contents = reservedFromRange.contents + consumed;
+      if (isInRange(fs)) {
+        next.push(fs);
+        return;
+      }
+    });
+    notFilledPartitions = next;
+  };
+  let queries = queriesByPartitionIndex.flat();
   if (Utils.$$Array.isEmpty(queries)) {
     if (shouldWaitForNewBlock) {
       return "WaitingForNewBlock";
@@ -1261,9 +1274,9 @@ function getReadyItemsCount(fetchState, targetSize, fromItem) {
   return acc;
 }
 
-function make$1(startBlock, endBlock, eventConfigs, contractConfigs, 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 = {
@@ -1271,14 +1284,14 @@ function make$1(startBlock, endBlock, eventConfigs, contractConfigs, addresses,
     blockTimestamp: 0
   };
   let notDependingOnAddresses = [];
-  let normalEventConfigs = [];
+  let normalRegistrations = [];
   let contractNamesWithNormalEvents = new Set();
-  eventConfigs.forEach(ec => {
-    if (ec.dependsOnAddresses) {
-      normalEventConfigs.push(ec);
-      contractNamesWithNormalEvents.add(ec.contractName);
+  onEventRegistrations.forEach(reg => {
+    if (reg.dependsOnAddresses) {
+      normalRegistrations.push(reg);
+      contractNamesWithNormalEvents.add(reg.eventConfig.contractName);
     } else {
-      notDependingOnAddresses.push(ec);
+      notDependingOnAddresses.push(reg);
     }
   });
   let partitions = [];
@@ -1287,7 +1300,7 @@ function make$1(startBlock, endBlock, eventConfigs, contractConfigs, addresses,
       id: partitions.length.toString(),
       latestFetchedBlock: latestFetchedBlock,
       selection: {
-        eventConfigs: notDependingOnAddresses,
+        onEventRegistrations: notDependingOnAddresses,
         dependsOnAddresses: false
       },
       addressesByContractName: {},
@@ -1301,7 +1314,7 @@ function make$1(startBlock, endBlock, eventConfigs, contractConfigs, addresses,
     });
   }
   let normalSelection = {
-    eventConfigs: normalEventConfigs,
+    onEventRegistrations: normalRegistrations,
     dependsOnAddresses: true
   };
   let registeringContractsByContract = {};
@@ -1319,16 +1332,16 @@ function make$1(startBlock, endBlock, eventConfigs, contractConfigs, addresses,
     }
   });
   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;
   }
@@ -1343,7 +1356,7 @@ function make$1(startBlock, endBlock, eventConfigs, contractConfigs, addresses,
     blockLag: blockLag,
     buffer: buffer,
     maxOnBlockBufferSize: maxOnBlockBufferSize,
-    onBlockConfigs: onBlockConfigs,
+    onBlockRegistrations: onBlockRegistrations,
     knownHeight: knownHeight,
     firstEventBlock: firstEventBlock
   };
@@ -1372,7 +1385,7 @@ function rollbackPendingQueries(mutPendingQueries, targetBlockNumber) {
             fromBlock: pq.fromBlock,
             toBlock: pq.toBlock,
             isChunk: pq.isChunk,
-            estResponseSize: pq.estResponseSize,
+            itemsTarget: pq.itemsTarget,
             fetchedBlock: {
               blockNumber: targetBlockNumber,
               blockTimestamp: 0
@@ -1471,7 +1484,7 @@ function rollback(fetchState, indexingAddresses, targetBlockNumber) {
     blockLag: fetchState.blockLag,
     buffer: fetchState.buffer,
     maxOnBlockBufferSize: fetchState.maxOnBlockBufferSize,
-    onBlockConfigs: fetchState.onBlockConfigs,
+    onBlockRegistrations: fetchState.onBlockRegistrations,
     knownHeight: fetchState.knownHeight,
     firstEventBlock: fetchState.firstEventBlock
   }, optimizedPartitions, fetchState.buffer.filter(item => {
@@ -1521,7 +1534,7 @@ function resetPendingQueries(fetchState) {
     blockLag: fetchState.blockLag,
     buffer: fetchState.buffer,
     maxOnBlockBufferSize: fetchState.maxOnBlockBufferSize,
-    onBlockConfigs: fetchState.onBlockConfigs,
+    onBlockRegistrations: fetchState.onBlockRegistrations,
     knownHeight: fetchState.knownHeight,
     firstEventBlock: fetchState.firstEventBlock
   };
@@ -1584,19 +1597,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) {
@@ -1650,9 +1650,9 @@ function updateKnownHeight(fetchState, knownHeight) {
   }
 }
 
-let minEstResponseSize = 2000;
+let minItemsTarget = 2000;
 
-let maxEstResponseSize = 10000;
+let maxItemsTarget = 10000;
 
 let blockItemLogIndex = 16777216;
 
@@ -1660,10 +1660,9 @@ let maxPendingChunksPerPartition = 10;
 
 export {
   deriveContractNameByAddress,
-  minEstResponseSize,
-  maxEstResponseSize,
-  calculateDefaultEstResponseSize,
-  calculateEstResponseSize,
+  minItemsTarget,
+  maxItemsTarget,
+  densityItemsTarget,
   getMinHistoryRange,
   getMinQueryRange,
   OptimizedPartitions,
@@ -1682,7 +1681,7 @@ export {
   handleQueryResult,
   startFetchingQueries,
   maxPendingChunksPerPartition,
-  pushQueriesForRange,
+  pushGapFillQueries,
   getNextQuery,
   hasReadyItem,
   getReadyItemsCount,
@@ -1695,7 +1694,6 @@ export {
   isFetchingAtHead,
   isReadyToEnterReorgThreshold,
   getProgressPercentage,
-  getProgressPercentageAt,
   sortForBatch,
   getProgressBlockNumberAt,
   updateKnownHeight,