envio 3.3.0-alpha.10 → 3.3.0-alpha.12

package/src/FetchState.res.mjs

@@ -28,27 +28,23 @@ function densityItemsTarget(density, fromBlock, toBlock, chainTargetBlock) {
 }
 
 function getMinHistoryRange(p) {
-  let match = p.prevQueryRange;
-  let match$1 = p.prevPrevQueryRange;
+  let match = p.sourceRangeCapacity;
+  let match$1 = p.prevSourceRangeCapacity;
   if (match !== 0 && match$1 !== 0) {
     return match < match$1 ? match : match$1;
   }
 }
 
 function getTrustedDensity(p) {
-  let match = p.prevQueryRange;
-  let match$1 = p.prevPrevQueryRange;
-  if (match !== 0 && match$1 !== 0) {
-    return p.prevRangeSize / match;
-  }
+  return p.eventDensity;
 }
 
 function getMinQueryRange(partitions) {
   let min = 0;
   for (let i = 0, i_finish = partitions.length; i < i_finish; ++i) {
     let p = partitions[i];
-    let a = p.prevQueryRange;
-    let b = p.prevPrevQueryRange;
+    let a = p.sourceRangeCapacity;
+    let b = p.prevSourceRangeCapacity;
     if (a > 0 && (min === 0 || a < min)) {
       min = a;
     }
@@ -88,10 +84,10 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         mergeBlock: potentialMergeBlock,
         dynamicContract: p1.dynamicContract,
         mutPendingQueries: p1.mutPendingQueries,
-        prevQueryRange: p1.prevQueryRange,
-        prevPrevQueryRange: p1.prevPrevQueryRange,
-        prevRangeSize: p1.prevRangeSize,
-        latestBlockRangeUpdateBlock: p1.latestBlockRangeUpdateBlock
+        sourceRangeCapacity: p1.sourceRangeCapacity,
+        prevSourceRangeCapacity: p1.prevSourceRangeCapacity,
+        eventDensity: p1.eventDensity,
+        latestSourceRangeCapacityUpdateBlock: p1.latestSourceRangeCapacityUpdateBlock
       });
       completed.push({
         id: p2.id,
@@ -101,10 +97,10 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         mergeBlock: potentialMergeBlock,
         dynamicContract: p2.dynamicContract,
         mutPendingQueries: p2.mutPendingQueries,
-        prevQueryRange: p2.prevQueryRange,
-        prevPrevQueryRange: p2.prevPrevQueryRange,
-        prevRangeSize: p2.prevRangeSize,
-        latestBlockRangeUpdateBlock: p2.latestBlockRangeUpdateBlock
+        sourceRangeCapacity: p2.sourceRangeCapacity,
+        prevSourceRangeCapacity: p2.prevSourceRangeCapacity,
+        eventDensity: p2.eventDensity,
+        latestSourceRangeCapacityUpdateBlock: p2.latestSourceRangeCapacityUpdateBlock
       });
       let newId = nextPartitionIndexRef.contents.toString();
       nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
@@ -112,7 +108,13 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         p1,
         p2
       ]);
-      let inheritedDensity = Stdlib_Option.getOr(getTrustedDensity(p1), 0) + Stdlib_Option.getOr(getTrustedDensity(p2), 0);
+      let match = p1.eventDensity;
+      let match$1 = p2.eventDensity;
+      let inheritedDensity = match !== undefined ? (
+          match$1 !== undefined ? match + match$1 : match
+        ) : (
+          match$1 !== undefined ? match$1 : undefined
+        );
       continuingBase = {
         id: newId,
         latestFetchedBlock: {
@@ -124,10 +126,10 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         mergeBlock: undefined,
         dynamicContract: contractName,
         mutPendingQueries: [],
-        prevQueryRange: minRange,
-        prevPrevQueryRange: minRange,
-        prevRangeSize: Math.ceil(inheritedDensity * minRange) | 0,
-        latestBlockRangeUpdateBlock: 0
+        sourceRangeCapacity: minRange,
+        prevSourceRangeCapacity: minRange,
+        eventDensity: inheritedDensity,
+        latestSourceRangeCapacityUpdateBlock: 0
       };
     } else {
       completed.push({
@@ -138,10 +140,10 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         mergeBlock: potentialMergeBlock,
         dynamicContract: p1.dynamicContract,
         mutPendingQueries: p1.mutPendingQueries,
-        prevQueryRange: p1.prevQueryRange,
-        prevPrevQueryRange: p1.prevPrevQueryRange,
-        prevRangeSize: p1.prevRangeSize,
-        latestBlockRangeUpdateBlock: p1.latestBlockRangeUpdateBlock
+        sourceRangeCapacity: p1.sourceRangeCapacity,
+        prevSourceRangeCapacity: p1.prevSourceRangeCapacity,
+        eventDensity: p1.eventDensity,
+        latestSourceRangeCapacityUpdateBlock: p1.latestSourceRangeCapacityUpdateBlock
       });
       continuingBase = p2;
     }
@@ -154,10 +156,10 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
       mergeBlock: potentialMergeBlock,
       dynamicContract: p2.dynamicContract,
       mutPendingQueries: p2.mutPendingQueries,
-      prevQueryRange: p2.prevQueryRange,
-      prevPrevQueryRange: p2.prevPrevQueryRange,
-      prevRangeSize: p2.prevRangeSize,
-      latestBlockRangeUpdateBlock: p2.latestBlockRangeUpdateBlock
+      sourceRangeCapacity: p2.sourceRangeCapacity,
+      prevSourceRangeCapacity: p2.prevSourceRangeCapacity,
+      eventDensity: p2.eventDensity,
+      latestSourceRangeCapacityUpdateBlock: p2.latestSourceRangeCapacityUpdateBlock
     });
     continuingBase = p1;
   } else {
@@ -178,10 +180,10 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
       mergeBlock: continuingBase.mergeBlock,
       dynamicContract: continuingBase.dynamicContract,
       mutPendingQueries: continuingBase.mutPendingQueries,
-      prevQueryRange: continuingBase.prevQueryRange,
-      prevPrevQueryRange: continuingBase.prevPrevQueryRange,
-      prevRangeSize: continuingBase.prevRangeSize,
-      latestBlockRangeUpdateBlock: continuingBase.latestBlockRangeUpdateBlock
+      sourceRangeCapacity: continuingBase.sourceRangeCapacity,
+      prevSourceRangeCapacity: continuingBase.prevSourceRangeCapacity,
+      eventDensity: continuingBase.eventDensity,
+      latestSourceRangeCapacityUpdateBlock: continuingBase.latestSourceRangeCapacityUpdateBlock
     });
     let restId = nextPartitionIndexRef.contents.toString();
     nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
@@ -193,10 +195,10 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
       mergeBlock: continuingBase.mergeBlock,
       dynamicContract: continuingBase.dynamicContract,
       mutPendingQueries: [],
-      prevQueryRange: continuingBase.prevQueryRange,
-      prevPrevQueryRange: continuingBase.prevPrevQueryRange,
-      prevRangeSize: continuingBase.prevRangeSize,
-      latestBlockRangeUpdateBlock: continuingBase.latestBlockRangeUpdateBlock
+      sourceRangeCapacity: continuingBase.sourceRangeCapacity,
+      prevSourceRangeCapacity: continuingBase.prevSourceRangeCapacity,
+      eventDensity: continuingBase.eventDensity,
+      latestSourceRangeCapacityUpdateBlock: continuingBase.latestSourceRangeCapacityUpdateBlock
     });
     return completed;
   }
@@ -210,10 +212,10 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
     mergeBlock: continuingBase.mergeBlock,
     dynamicContract: continuingBase.dynamicContract,
     mutPendingQueries: continuingBase.mutPendingQueries,
-    prevQueryRange: continuingBase.prevQueryRange,
-    prevPrevQueryRange: continuingBase.prevPrevQueryRange,
-    prevRangeSize: continuingBase.prevRangeSize,
-    latestBlockRangeUpdateBlock: continuingBase.latestBlockRangeUpdateBlock
+    sourceRangeCapacity: continuingBase.sourceRangeCapacity,
+    prevSourceRangeCapacity: continuingBase.prevSourceRangeCapacity,
+    eventDensity: continuingBase.eventDensity,
+    latestSourceRangeCapacityUpdateBlock: continuingBase.latestSourceRangeCapacityUpdateBlock
   });
   return completed;
 }
@@ -358,8 +360,11 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount
   let pendingQuery = getPendingQueryOrThrow(p$1, query.fromBlock);
   pendingQuery.fetchedBlock = latestFetchedBlock;
   let blockRange = (latestFetchedBlock.blockNumber - query.fromBlock | 0) + 1 | 0;
-  let shouldUpdateBlockRange = false;
-  if (latestFetchedBlock.blockNumber > p$1.latestBlockRangeUpdateBlock) {
+  let observedEventDensity = itemsCount / blockRange;
+  let eventDensity = p$1.eventDensity;
+  let updatedEventDensity = eventDensity !== undefined ? (eventDensity + observedEventDensity) / 2 : observedEventDensity;
+  let shouldUpdateSourceRangeCapacity = false;
+  if (latestFetchedBlock.blockNumber > p$1.latestSourceRangeCapacityUpdateBlock) {
     let queryToBlock = query.toBlock;
     let tmp;
     if (queryToBlock !== undefined) {
@@ -372,11 +377,10 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount
     } else {
       tmp = latestFetchedBlock.blockNumber < (knownHeight - 10 | 0);
     }
-    shouldUpdateBlockRange = tmp;
+    shouldUpdateSourceRangeCapacity = tmp;
   }
-  let updatedPrevQueryRange = shouldUpdateBlockRange ? blockRange : p$1.prevQueryRange;
-  let updatedPrevPrevQueryRange = shouldUpdateBlockRange ? p$1.prevQueryRange : p$1.prevPrevQueryRange;
-  let updatedPrevRangeSize = shouldUpdateBlockRange ? itemsCount : p$1.prevRangeSize;
+  let updatedSourceRangeCapacity = shouldUpdateSourceRangeCapacity ? blockRange : p$1.sourceRangeCapacity;
+  let updatedPrevSourceRangeCapacity = shouldUpdateSourceRangeCapacity ? p$1.sourceRangeCapacity : p$1.prevSourceRangeCapacity;
   let mutPendingQueries = p$1.mutPendingQueries;
   let latestFetchedBlock$1 = p$1.latestFetchedBlock;
   while ((() => {
@@ -402,7 +406,7 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount
     let updatedMainPartition_mergeBlock = p$1.mergeBlock;
     let updatedMainPartition_dynamicContract = p$1.dynamicContract;
     let updatedMainPartition_mutPendingQueries = p$1.mutPendingQueries;
-    let updatedMainPartition_latestBlockRangeUpdateBlock = shouldUpdateBlockRange ? latestFetchedBlock.blockNumber : p$1.latestBlockRangeUpdateBlock;
+    let updatedMainPartition_latestSourceRangeCapacityUpdateBlock = shouldUpdateSourceRangeCapacity ? latestFetchedBlock.blockNumber : p$1.latestSourceRangeCapacityUpdateBlock;
     let updatedMainPartition = {
       id: updatedMainPartition_id,
       latestFetchedBlock: updatedLatestFetchedBlock,
@@ -411,10 +415,10 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount
       mergeBlock: updatedMainPartition_mergeBlock,
       dynamicContract: updatedMainPartition_dynamicContract,
       mutPendingQueries: updatedMainPartition_mutPendingQueries,
-      prevQueryRange: updatedPrevQueryRange,
-      prevPrevQueryRange: updatedPrevPrevQueryRange,
-      prevRangeSize: updatedPrevRangeSize,
-      latestBlockRangeUpdateBlock: updatedMainPartition_latestBlockRangeUpdateBlock
+      sourceRangeCapacity: updatedSourceRangeCapacity,
+      prevSourceRangeCapacity: updatedPrevSourceRangeCapacity,
+      eventDensity: updatedEventDensity,
+      latestSourceRangeCapacityUpdateBlock: updatedMainPartition_latestSourceRangeCapacityUpdateBlock
     };
     mutEntities[p$1.id] = updatedMainPartition;
   }
@@ -484,15 +488,92 @@ function bufferReadyCount(fetchState) {
   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 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, onBlockRegistrations, indexerStartBlock, fromBlock, maxBlockNumber, maxOnBlockBufferSize) {
   let newItemsCounter = 0;
   let latestOnBlockBlockNumber = fromBlock;
@@ -522,18 +603,19 @@ function appendOnBlockItems(mutItems, onBlockRegistrations, indexerStartBlock, f
   return latestOnBlockBlockNumber;
 }
 
-function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, blockLagOpt, knownHeightOpt) {
+function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, mutItemsSortedOpt, blockLagOpt, knownHeightOpt) {
   let optimizedPartitions = optimizedPartitionsOpt !== undefined ? optimizedPartitionsOpt : fetchState.optimizedPartitions;
+  let mutItemsSorted = mutItemsSortedOpt !== undefined ? mutItemsSortedOpt : false;
   let blockLag = blockLagOpt !== undefined ? blockLagOpt : fetchState.blockLag;
   let knownHeight = knownHeightOpt !== undefined ? knownHeightOpt : fetchState.knownHeight;
-  let mutItemsRef = mutItems;
+  let base = mutItems !== undefined ? (
+      mutItemsSorted ? mutItems : mergeIntoBuffer([], mutItems)
+    ) : fetchState.buffer;
+  let blockItems = [];
   let onBlockRegistrations = fetchState.onBlockRegistrations;
   let latestOnBlockBlockNumber;
   if (onBlockRegistrations.length !== 0) {
-    let mutItems$1 = mutItemsRef;
-    let item = (
-        mutItems$1 !== undefined ? mutItems$1 : fetchState.buffer
-      )[fetchState.maxOnBlockBufferSize - 1 | 0];
+    let item = base[fetchState.maxOnBlockBufferSize - 1 | 0];
     let maxBlockNumber;
     if (item !== undefined) {
       maxBlockNumber = item.blockNumber;
@@ -542,20 +624,16 @@ function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, blockLagOp
       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, onBlockRegistrations, 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_onBlockRegistrations = fetchState.onBlockRegistrations;
   let updatedFetchState_firstEventBlock = fetchState.firstEventBlock;
@@ -665,10 +743,10 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
             mergeBlock: undefined,
             dynamicContract: isDynamic ? contractName : undefined,
             mutPendingQueries: [],
-            prevQueryRange: 0,
-            prevPrevQueryRange: 0,
-            prevRangeSize: 0,
-            latestBlockRangeUpdateBlock: 0
+            sourceRangeCapacity: 0,
+            prevSourceRangeCapacity: 0,
+            eventDensity: undefined,
+            latestSourceRangeCapacityUpdateBlock: 0
           });
           nextPartitionIndexRef = nextPartitionIndexRef + 1 | 0;
         };
@@ -716,10 +794,10 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
             mergeBlock: currentPBlock < nextPBlock ? nextPBlock : undefined,
             dynamicContract: currentP.dynamicContract,
             mutPendingQueries: currentP.mutPendingQueries,
-            prevQueryRange: currentP.prevQueryRange,
-            prevPrevQueryRange: currentP.prevPrevQueryRange,
-            prevRangeSize: currentP.prevRangeSize,
-            latestBlockRangeUpdateBlock: currentP.latestBlockRangeUpdateBlock
+            sourceRangeCapacity: currentP.sourceRangeCapacity,
+            prevSourceRangeCapacity: currentP.prevSourceRangeCapacity,
+            eventDensity: currentP.eventDensity,
+            latestSourceRangeCapacityUpdateBlock: currentP.latestSourceRangeCapacityUpdateBlock
           });
           currentPRef = {
             id: nextP.id,
@@ -729,10 +807,10 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
             mergeBlock: nextP.mergeBlock,
             dynamicContract: nextP.dynamicContract,
             mutPendingQueries: nextP.mutPendingQueries,
-            prevQueryRange: nextP.prevQueryRange,
-            prevPrevQueryRange: nextP.prevPrevQueryRange,
-            prevRangeSize: nextP.prevRangeSize,
-            latestBlockRangeUpdateBlock: nextP.latestBlockRangeUpdateBlock
+            sourceRangeCapacity: nextP.sourceRangeCapacity,
+            prevSourceRangeCapacity: nextP.prevSourceRangeCapacity,
+            eventDensity: nextP.eventDensity,
+            latestSourceRangeCapacityUpdateBlock: nextP.latestSourceRangeCapacityUpdateBlock
           };
         } else {
           currentPRef = {
@@ -743,10 +821,10 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
             mergeBlock: currentP.mergeBlock,
             dynamicContract: currentP.dynamicContract,
             mutPendingQueries: currentP.mutPendingQueries,
-            prevQueryRange: currentP.prevQueryRange,
-            prevPrevQueryRange: currentP.prevPrevQueryRange,
-            prevRangeSize: currentP.prevRangeSize,
-            latestBlockRangeUpdateBlock: currentP.latestBlockRangeUpdateBlock
+            sourceRangeCapacity: currentP.sourceRangeCapacity,
+            prevSourceRangeCapacity: currentP.prevSourceRangeCapacity,
+            eventDensity: currentP.eventDensity,
+            latestSourceRangeCapacityUpdateBlock: currentP.latestSourceRangeCapacityUpdateBlock
           };
         }
       }
@@ -893,10 +971,10 @@ function registerDynamicContracts(fetchState, indexingAddresses, items) {
                 mergeBlock: p.mergeBlock,
                 dynamicContract: p.dynamicContract,
                 mutPendingQueries: p.mutPendingQueries,
-                prevQueryRange: p.prevQueryRange,
-                prevPrevQueryRange: p.prevPrevQueryRange,
-                prevRangeSize: p.prevRangeSize,
-                latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+                sourceRangeCapacity: p.sourceRangeCapacity,
+                prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+                eventDensity: p.eventDensity,
+                latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
               };
               let addressesByContractName = {};
               addressesByContractName[contractName] = addresses;
@@ -908,10 +986,10 @@ function registerDynamicContracts(fetchState, indexingAddresses, items) {
                 mergeBlock: undefined,
                 dynamicContract: contractName,
                 mutPendingQueries: p.mutPendingQueries,
-                prevQueryRange: p.prevQueryRange,
-                prevPrevQueryRange: p.prevPrevQueryRange,
-                prevRangeSize: p.prevRangeSize,
-                latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+                sourceRangeCapacity: p.sourceRangeCapacity,
+                prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+                eventDensity: p.eventDensity,
+                latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
               });
             }
           } else {
@@ -923,10 +1001,10 @@ function registerDynamicContracts(fetchState, indexingAddresses, items) {
               mergeBlock: p.mergeBlock,
               dynamicContract: contractName,
               mutPendingQueries: p.mutPendingQueries,
-              prevQueryRange: p.prevQueryRange,
-              prevPrevQueryRange: p.prevPrevQueryRange,
-              prevRangeSize: p.prevRangeSize,
-              latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+              sourceRangeCapacity: p.sourceRangeCapacity,
+              prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+              eventDensity: p.eventDensity,
+              latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
             };
           }
         }
@@ -937,11 +1015,11 @@ function registerDynamicContracts(fetchState, indexingAddresses, items) {
   }
   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);
+  return updateInternal(fetchState, optimizedPartitions, undefined, undefined, undefined, undefined);
 }
 
-function handleQueryResult(fetchState, indexingAddresses, query, latestFetchedBlock, newItems) {
-  let newItems$1 = newItems.filter(item => {
+function filterByClientAddress(items, indexingAddresses) {
+  return items.filter(item => {
     if (item.kind !== 0) {
       return true;
     }
@@ -952,7 +1030,10 @@ function handleQueryResult(fetchState, indexingAddresses, query, latestFetchedBl
       return true;
     }
   });
-  return updateInternal(fetchState, handleQueryResponse(fetchState.optimizedPartitions, query, fetchState.knownHeight, newItems$1.length, latestFetchedBlock), newItems$1.length !== 0 ? fetchState.buffer.concat(newItems$1) : undefined, undefined, undefined);
+}
+
+function 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) {
@@ -995,7 +1076,7 @@ function pushGapFillQueries(queries, partitionId, rangeFromBlock, rangeEndBlock,
       exit = 1;
     }
     if (exit === 1) {
-      let trustedDensity = getTrustedDensity(partition);
+      let trustedDensity = partition.eventDensity;
       let maxBlock = rangeEndBlock !== undefined ? rangeEndBlock : chainTargetBlock;
       let pushSingleQuery = (density, isChunk) => {
         let itemsTarget = densityItemsTarget(density * chunkItemsMultiplier, rangeFromBlock, rangeEndBlock, chainTargetBlock);
@@ -1051,24 +1132,6 @@ function pushGapFillQueries(queries, partitionId, rangeFromBlock, rangeEndBlock,
   return cost.contents;
 }
 
-function waterLevel(budget, footprints) {
-  let sorted = footprints.toSorted(Primitive_float.compare);
-  let n = sorted.length;
-  let prefix = 0;
-  let level;
-  let idx = 0;
-  while (level === undefined && idx < n) {
-    let i = idx;
-    prefix = prefix + sorted[i];
-    let candidate = (budget + prefix) / (i + 1 | 0);
-    if (i === (n - 1 | 0) || candidate <= sorted[i + 1 | 0]) {
-      level = candidate;
-    }
-    idx = idx + 1 | 0;
-  };
-  return Stdlib_Option.getOr(level, 0);
-}
-
 function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star) {
   let knownHeight = param.knownHeight;
   let blockLag = param.blockLag;
@@ -1091,7 +1154,8 @@ function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star)
       shouldWaitForNewBlock = false;
     }
   }
-  let queriesByPartitionIndex = Stdlib_Array.fromInitializer(partitionsCount, param => []);
+  let partitionsCount$1 = chainTargetItems <= 0 || shouldWaitForNewBlock ? 0 : partitionsCount;
+  let queriesByPartitionIndex = Stdlib_Array.fromInitializer(partitionsCount$1, param => []);
   let computeQueryEndBlock = p => {
     let queryEndBlock = Utils.$$Math.minOptInt(endBlock, p.mergeBlock);
     if (blockLag !== 0) {
@@ -1100,42 +1164,42 @@ function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star)
       return queryEndBlock;
     }
   };
-  let existingReservedByPartition = {};
   let chainReserved = 0;
-  for (let idx$1 = 0; idx$1 < partitionsCount; ++idx$1) {
+  let reservations = [];
+  let partitionIndexById = {};
+  let candidates = [];
+  let fillStates = [];
+  for (let idx$1 = 0; idx$1 < partitionsCount$1; ++idx$1) {
     let partitionId$1 = optimizedPartitions.idsInAscOrder[idx$1];
     let p$1 = optimizedPartitions.entities[partitionId$1];
-    let cost = 0;
-    for (let pqIdx = 0, pqIdx_finish = p$1.mutPendingQueries.length; pqIdx < pqIdx_finish; ++pqIdx) {
-      cost = cost + p$1.mutPendingQueries[pqIdx].itemsEst;
+    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
+        ]);
+      }
     }
-    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 queryEndBlock = computeQueryEndBlock(p$1);
+    let maybeChunkRange = getMinHistoryRange(p$1);
+    let cursor = p$1.latestFetchedBlock.blockNumber + 1 | 0;
     let canContinue = true;
     let chunksUsedThisCall = 0;
     let pqIdx$1 = 0;
     while (pqIdx$1 < pendingCount && canContinue) {
-      let pq = p$2.mutPendingQueries[pqIdx$1];
-      if (pq.fromBlock > cursor) {
-        let beforeLen = bucket.length;
-        let cost$1 = pushGapFillQueries(bucket, partitionId$2, cursor, Utils.$$Math.minOptInt(pq.fromBlock - 1 | 0, queryEndBlock), knownHeight, chainTargetBlock, maybeChunkRange, (12 - pendingCount | 0) - chunksUsedThisCall | 0, p$2, chainTargetItems / partitionsCount, chunkItemsMultiplier, p$2.selection, p$2.addressesByContractName);
-        chunksUsedThisCall = chunksUsedThisCall + (bucket.length - beforeLen | 0) | 0;
-        gapFillCost = gapFillCost + cost$1;
+      let 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$1, 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 = pq.fetchedBlock;
+      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;
@@ -1149,26 +1213,17 @@ function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star)
     };
     if (canContinue) {
       fillStates.push({
-        partitionId: partitionId$2,
-        p: p$2,
+        partitionId: partitionId$1,
+        p: p$1,
         cursor: cursor,
         chunksUsedThisCall: chunksUsedThisCall,
         pendingCount: pendingCount,
         queryEndBlock: queryEndBlock,
-        maybeChunkRange: maybeChunkRange,
-        bucket: bucket
+        maybeChunkRange: maybeChunkRange
       });
     }
   }
-  let rangeItemsTarget = Primitive_float.max(0, chainTargetItems - chainReserved - gapFillCost);
-  let reservedByPartition = {};
-  fillStates.forEach(fs => {
-    let cost = existingReservedByPartition[fs.partitionId];
-    for (let i = 0, i_finish = fs.bucket.length; i < i_finish; ++i) {
-      cost = cost + fs.bucket[i].itemsEst;
-    }
-    reservedByPartition[fs.partitionId] = cost;
-  });
+  let freshBudget = Primitive_float.max(0, chainTargetItems - chainReserved);
   let isInRange = fs => {
     let tmp = false;
     if (fs.cursor <= chainTargetBlock) {
@@ -1182,48 +1237,53 @@ function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star)
     }
   };
   let inRangeStates = fillStates.filter(isInRange);
-  let emitQueries = (fs, budget) => {
+  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);
+    let match$1 = p.eventDensity;
     if (match !== undefined && match$1 !== undefined && match$1 > 0) {
       let chunkSize = Js_math.ceil_int(match * 1.8);
       let maxChunksRemaining = (12 - fs.pendingCount | 0) - fs.chunksUsedThisCall | 0;
-      let consumed = 0;
+      let chunkStartCeiling = Primitive_int.min(maxBlock, chainTargetBlock);
       let created = 0;
       let chunkFromBlock = fs.cursor;
-      let budgetLeft = true;
-      while (budgetLeft && created < maxChunksRemaining && chunkFromBlock <= Primitive_int.min(maxBlock, chainTargetBlock)) {
+      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);
-        if (consumed === 0 || consumed + itemsEst <= budget) {
-          fs.bucket.push({
-            partitionId: fs.partitionId,
-            fromBlock: chunkFromBlock,
-            toBlock: chunkToBlock,
-            isChunk: true,
-            itemsTarget: itemsTarget,
-            itemsEst: itemsEst,
-            selection: p.selection,
-            addressesByContractName: p.addressesByContractName
-          });
-          consumed = consumed + itemsEst;
-          chunkFromBlock = chunkToBlock + 1 | 0;
-          created = created + 1 | 0;
-        } else {
-          budgetLeft = false;
-        }
+        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;
       };
-      fs.cursor = chunkFromBlock;
-      fs.chunksUsedThisCall = fs.chunksUsedThisCall + created | 0;
-      return consumed;
+      return;
     }
-    let itemsTarget$1 = Primitive_int.max(1, Math.round(budget) | 0);
-    fs.bucket.push({
+    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,
@@ -1233,32 +1293,53 @@ function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star)
       selection: p.selection,
       addressesByContractName: p.addressesByContractName
     });
-    fs.cursor = maxBlock + 1 | 0;
-    fs.chunksUsedThisCall = fs.chunksUsedThisCall + 1 | 0;
-    return itemsTarget$1;
-  };
-  let notFilledPartitions = inRangeStates;
-  let remainingBudget = {
-    contents: rangeItemsTarget
-  };
-  while (notFilledPartitions.length !== 0 && remainingBudget.contents > 0) {
-    let level = waterLevel(remainingBudget.contents, notFilledPartitions.map(fs => reservedByPartition[fs.partitionId]));
-    let next = [];
-    notFilledPartitions.forEach(fs => {
-      let reserved = reservedByPartition[fs.partitionId];
-      let budget = level - reserved;
-      if (budget <= 0) {
-        return;
-      }
-      let consumed = emitQueries(fs, budget);
-      reservedByPartition[fs.partitionId] = reserved + consumed;
-      remainingBudget.contents = remainingBudget.contents - consumed;
-      if (isInRange(fs)) {
-        next.push(fs);
-        return;
+  });
+  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;
       }
-    });
-    notFilledPartitions = next;
+    } else if (bQuery !== undefined) {
+      return -1;
+    } else {
+      return 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);
+    }
+    remainingBudget = remainingBudget - match$1[1];
+    acceptIdx = acceptIdx + 1 | 0;
   };
   let queries = queriesByPartitionIndex.flat();
   if (Utils.$$Array.isEmpty(queries)) {
@@ -1340,10 +1421,10 @@ function make$1(startBlock, endBlock, onEventRegistrations, contractConfigs, add
       mergeBlock: undefined,
       dynamicContract: undefined,
       mutPendingQueries: [],
-      prevQueryRange: 0,
-      prevPrevQueryRange: 0,
-      prevRangeSize: 0,
-      latestBlockRangeUpdateBlock: 0
+      sourceRangeCapacity: 0,
+      prevSourceRangeCapacity: 0,
+      eventDensity: undefined,
+      latestSourceRangeCapacityUpdateBlock: 0
     });
   }
   let normalSelection = {
@@ -1478,10 +1559,10 @@ function rollback(fetchState, indexingAddresses, targetBlockNumber) {
             mergeBlock: mergeBlock$1,
             dynamicContract: p.dynamicContract,
             mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, targetBlockNumber),
-            prevQueryRange: p.prevQueryRange,
-            prevPrevQueryRange: p.prevPrevQueryRange,
-            prevRangeSize: p.prevRangeSize,
-            latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+            sourceRangeCapacity: p.sourceRangeCapacity,
+            prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+            eventDensity: p.eventDensity,
+            latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
           });
         }
       }
@@ -1499,10 +1580,10 @@ function rollback(fetchState, indexingAddresses, targetBlockNumber) {
         mergeBlock: p.mergeBlock,
         dynamicContract: p.dynamicContract,
         mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, targetBlockNumber),
-        prevQueryRange: p.prevQueryRange,
-        prevPrevQueryRange: p.prevPrevQueryRange,
-        prevRangeSize: p.prevRangeSize,
-        latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+        sourceRangeCapacity: p.sourceRangeCapacity,
+        prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+        eventDensity: p.eventDensity,
+        latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
       });
     }
   }
@@ -1525,7 +1606,7 @@ function rollback(fetchState, indexingAddresses, targetBlockNumber) {
     let tmp;
     tmp = item.kind === 0 ? item.blockNumber : item.blockNumber;
     return tmp <= targetBlockNumber;
-  }), undefined, undefined);
+  }), true, undefined, undefined);
 }
 
 function resetPendingQueries(fetchState) {
@@ -1543,10 +1624,10 @@ function resetPendingQueries(fetchState) {
         mergeBlock: partition.mergeBlock,
         dynamicContract: partition.dynamicContract,
         mutPendingQueries: kept,
-        prevQueryRange: partition.prevQueryRange,
-        prevPrevQueryRange: partition.prevPrevQueryRange,
-        prevRangeSize: partition.prevRangeSize,
-        latestBlockRangeUpdateBlock: partition.latestBlockRangeUpdateBlock
+        sourceRangeCapacity: partition.sourceRangeCapacity,
+        prevSourceRangeCapacity: partition.prevSourceRangeCapacity,
+        eventDensity: partition.eventDensity,
+        latestSourceRangeCapacityUpdateBlock: partition.latestSourceRangeCapacityUpdateBlock
       };
     }
   }
@@ -1622,7 +1703,7 @@ function getProgressPercentage(fetchState) {
   if (firstEventBlock === undefined) {
     return 0;
   }
-  let totalRange = fetchState.knownHeight - firstEventBlock | 0;
+  let totalRange = (fetchState.knownHeight - fetchState.blockLag | 0) - firstEventBlock | 0;
   if (totalRange <= 0) {
     return 0;
   }
@@ -1678,7 +1759,7 @@ function getProgressBlockNumberAt(fetchState, index) {
 function updateKnownHeight(fetchState, knownHeight) {
   if (knownHeight > fetchState.knownHeight) {
     Prometheus.IndexingKnownHeight.set(knownHeight, fetchState.chainId);
-    return updateInternal(fetchState, undefined, undefined, undefined, knownHeight);
+    return updateInternal(fetchState, undefined, undefined, undefined, undefined, knownHeight);
   } else {
     return fetchState;
   }
@@ -1698,7 +1779,9 @@ export {
   bufferBlockNumber,
   bufferBlock,
   bufferReadyCount,
+  getRegistrationIndex,
   compareBufferItem,
+  mergeIntoBuffer,
   blockItemLogIndex,
   appendOnBlockItems,
   updateInternal,
@@ -1707,11 +1790,11 @@ export {
   addressesByContractNameGetAll,
   createPartitionsFromIndexingAddresses,
   registerDynamicContracts,
+  filterByClientAddress,
   handleQueryResult,
   startFetchingQueries,
   maxPendingChunksPerPartition,
   pushGapFillQueries,
-  waterLevel,
   getNextQuery,
   hasReadyItem,
   getReadyItemsCount,