envio 3.0.0-alpha.2 → 3.0.0-alpha.20

package/src/FetchState.res.mjs

@@ -11,104 +11,418 @@ import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
 import * as Caml_int32 from "rescript/lib/es6/caml_int32.js";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
-import * as Belt_Result from "rescript/lib/es6/belt_Result.js";
-import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
+import * as Caml_option from "rescript/lib/es6/caml_option.js";
 
-function mergeIntoPartition(p, target, maxAddrInPartition) {
-  if (!p.selection.dependsOnAddresses) {
-    return [
-            p,
-            target
-          ];
+function getMinHistoryRange(p) {
+  var match = p.prevQueryRange;
+  var match$1 = p.prevPrevQueryRange;
+  if (match !== 0 && match$1 !== 0) {
+    return match < match$1 ? match : match$1;
   }
-  if (!target.selection.dependsOnAddresses) {
-    return [
-            p,
-            target
-          ];
+  
+}
+
+function getMinQueryRange(partitions) {
+  var min = 0;
+  for(var i = 0 ,i_finish = partitions.length; i < i_finish; ++i){
+    var p = partitions[i];
+    var a = p.prevQueryRange;
+    var b = p.prevPrevQueryRange;
+    if (a > 0 && (min === 0 || a < min)) {
+      min = a;
+    }
+    if (b > 0 && (min === 0 || b < min)) {
+      min = b;
+    }
+    
+  }
+  return min;
+}
+
+function count(optimizedPartitions) {
+  return optimizedPartitions.idsInAscOrder.length;
+}
+
+function getOrThrow(optimizedPartitions, partitionId) {
+  var p = Js_dict.get(optimizedPartitions.entities, partitionId);
+  if (p !== undefined) {
+    return p;
+  } else {
+    return Js_exn.raiseError("Unexpected case: Couldn't find partition " + partitionId);
+  }
+}
+
+function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAddrInPartition, nextPartitionIndexRef) {
+  var combinedAddresses = p1.addressesByContractName[contractName].concat(p2.addressesByContractName[contractName]);
+  var p1Below = p1.latestFetchedBlock.blockNumber < potentialMergeBlock;
+  var p2Below = p2.latestFetchedBlock.blockNumber < potentialMergeBlock;
+  var completed = [];
+  var continuingBase;
+  if (p1Below) {
+    completed.push({
+          id: p1.id,
+          latestFetchedBlock: p1.latestFetchedBlock,
+          selection: p1.selection,
+          addressesByContractName: p1.addressesByContractName,
+          mergeBlock: potentialMergeBlock,
+          dynamicContract: p1.dynamicContract,
+          mutPendingQueries: p1.mutPendingQueries,
+          prevQueryRange: p1.prevQueryRange,
+          prevPrevQueryRange: p1.prevPrevQueryRange,
+          latestBlockRangeUpdateBlock: p1.latestBlockRangeUpdateBlock
+        });
+    if (p2Below) {
+      completed.push({
+            id: p2.id,
+            latestFetchedBlock: p2.latestFetchedBlock,
+            selection: p2.selection,
+            addressesByContractName: p2.addressesByContractName,
+            mergeBlock: potentialMergeBlock,
+            dynamicContract: p2.dynamicContract,
+            mutPendingQueries: p2.mutPendingQueries,
+            prevQueryRange: p2.prevQueryRange,
+            prevPrevQueryRange: p2.prevPrevQueryRange,
+            latestBlockRangeUpdateBlock: p2.latestBlockRangeUpdateBlock
+          });
+      var newId = nextPartitionIndexRef.contents.toString();
+      nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
+      var minRange = getMinQueryRange([
+            p1,
+            p2
+          ]);
+      continuingBase = {
+        id: newId,
+        latestFetchedBlock: {
+          blockNumber: potentialMergeBlock,
+          blockTimestamp: 0
+        },
+        selection: p1.selection,
+        addressesByContractName: {},
+        mergeBlock: undefined,
+        dynamicContract: contractName,
+        mutPendingQueries: [],
+        prevQueryRange: minRange,
+        prevPrevQueryRange: minRange,
+        latestBlockRangeUpdateBlock: 0
+      };
+    } else {
+      continuingBase = p2;
+    }
+  } else if (p2Below) {
+    completed.push({
+          id: p2.id,
+          latestFetchedBlock: p2.latestFetchedBlock,
+          selection: p2.selection,
+          addressesByContractName: p2.addressesByContractName,
+          mergeBlock: potentialMergeBlock,
+          dynamicContract: p2.dynamicContract,
+          mutPendingQueries: p2.mutPendingQueries,
+          prevQueryRange: p2.prevQueryRange,
+          prevPrevQueryRange: p2.prevPrevQueryRange,
+          latestBlockRangeUpdateBlock: p2.latestBlockRangeUpdateBlock
+        });
+    continuingBase = p1;
+  } else {
+    continuingBase = p1;
   }
-  var latestFetchedBlock = target.latestFetchedBlock;
-  var mergedAddresses = {};
-  var allowedAddressesNumber = {
-    contents: maxAddrInPartition
+  if (combinedAddresses.length > maxAddrInPartition) {
+    var addressesFull = combinedAddresses.slice(0, maxAddrInPartition);
+    var addressesRest = combinedAddresses.slice(maxAddrInPartition);
+    var abcFull = {};
+    abcFull[contractName] = addressesFull;
+    var abcRest = {};
+    abcRest[contractName] = addressesRest;
+    completed.push({
+          id: continuingBase.id,
+          latestFetchedBlock: continuingBase.latestFetchedBlock,
+          selection: continuingBase.selection,
+          addressesByContractName: abcFull,
+          mergeBlock: continuingBase.mergeBlock,
+          dynamicContract: continuingBase.dynamicContract,
+          mutPendingQueries: continuingBase.mutPendingQueries,
+          prevQueryRange: continuingBase.prevQueryRange,
+          prevPrevQueryRange: continuingBase.prevPrevQueryRange,
+          latestBlockRangeUpdateBlock: continuingBase.latestBlockRangeUpdateBlock
+        });
+    var restId = nextPartitionIndexRef.contents.toString();
+    nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
+    completed.push({
+          id: restId,
+          latestFetchedBlock: continuingBase.latestFetchedBlock,
+          selection: continuingBase.selection,
+          addressesByContractName: abcRest,
+          mergeBlock: continuingBase.mergeBlock,
+          dynamicContract: continuingBase.dynamicContract,
+          mutPendingQueries: [],
+          prevQueryRange: continuingBase.prevQueryRange,
+          prevPrevQueryRange: continuingBase.prevPrevQueryRange,
+          latestBlockRangeUpdateBlock: continuingBase.latestBlockRangeUpdateBlock
+        });
+    return completed;
+  }
+  var abc = {};
+  abc[contractName] = combinedAddresses;
+  completed.push({
+        id: continuingBase.id,
+        latestFetchedBlock: continuingBase.latestFetchedBlock,
+        selection: continuingBase.selection,
+        addressesByContractName: abc,
+        mergeBlock: continuingBase.mergeBlock,
+        dynamicContract: continuingBase.dynamicContract,
+        mutPendingQueries: continuingBase.mutPendingQueries,
+        prevQueryRange: continuingBase.prevQueryRange,
+        prevPrevQueryRange: continuingBase.prevPrevQueryRange,
+        latestBlockRangeUpdateBlock: continuingBase.latestBlockRangeUpdateBlock
+      });
+  return completed;
+}
+
+function ascSortFn(a, b) {
+  return a.latestFetchedBlock.blockNumber - b.latestFetchedBlock.blockNumber | 0;
+}
+
+function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContracts) {
+  var newPartitions = [];
+  var mergingPartitions = {};
+  var nextPartitionIndexRef = {
+    contents: nextPartitionIndex
   };
-  Utils.Dict.forEachWithKey(target.addressesByContractName, (function (addresses, contractName) {
-          allowedAddressesNumber.contents = allowedAddressesNumber.contents - addresses.length | 0;
-          mergedAddresses[contractName] = addresses;
-        }));
-  Utils.Dict.forEachWithKey(p.addressesByContractName, (function (addresses, contractName) {
-          allowedAddressesNumber.contents = allowedAddressesNumber.contents - addresses.length | 0;
-          var targetAddresses = mergedAddresses[contractName];
-          if (targetAddresses !== undefined) {
-            mergedAddresses[contractName] = Belt_Array.concat(targetAddresses, addresses);
-          } else {
-            mergedAddresses[contractName] = addresses;
+  for(var idx = 0 ,idx_finish = partitions.length; idx < idx_finish; ++idx){
+    var p = partitions[idx];
+    if (p.dynamicContract !== undefined && !(p.mergeBlock !== undefined || !p.selection.dependsOnAddresses)) {
+      var contractName = p.dynamicContract;
+      var pAddressesCount = p.addressesByContractName[contractName].length;
+      var match = Utils.$$Array.last(p.mutPendingQueries);
+      var potentialMergeBlock;
+      if (match !== undefined) {
+        var toBlock = match.toBlock;
+        potentialMergeBlock = toBlock !== undefined && match.isChunk ? toBlock : undefined;
+      } else {
+        potentialMergeBlock = p.latestFetchedBlock.blockNumber;
+      }
+      if (potentialMergeBlock !== undefined && pAddressesCount < maxAddrInPartition) {
+        var partitionsByMergeBlock = Utils.Dict.getOrInsertEmptyDict(mergingPartitions, contractName);
+        var existingPartition = partitionsByMergeBlock[potentialMergeBlock];
+        if (existingPartition !== undefined) {
+          var result = mergePartitionsAtBlock(existingPartition, p, potentialMergeBlock, contractName, maxAddrInPartition, nextPartitionIndexRef);
+          for(var i = 0 ,i_finish = result.length - 2 | 0; i <= i_finish; ++i){
+            newPartitions.push(result[i]);
           }
-        }));
-  var rest;
-  if (allowedAddressesNumber.contents < 0) {
-    var restAddresses = {};
-    Utils.Dict.forEachWithKey(mergedAddresses, (function (addresses, contractName) {
-            if (allowedAddressesNumber.contents === 0) {
-              return ;
-            }
-            if (addresses.length <= (-allowedAddressesNumber.contents | 0)) {
-              allowedAddressesNumber.contents = allowedAddressesNumber.contents + addresses.length | 0;
-              Utils.Dict.deleteInPlace(mergedAddresses, contractName);
-              restAddresses[contractName] = addresses;
-              return ;
-            }
-            var restFrom = addresses.length + allowedAddressesNumber.contents | 0;
-            mergedAddresses[contractName] = addresses.slice(0, restFrom);
-            restAddresses[contractName] = addresses.slice(restFrom);
-            allowedAddressesNumber.contents = 0;
-          }));
-    rest = {
-      id: p.id,
-      status: {
-        fetchingStateId: undefined
-      },
-      latestFetchedBlock: latestFetchedBlock,
-      selection: target.selection,
-      addressesByContractName: restAddresses
+          partitionsByMergeBlock[potentialMergeBlock] = Utils.$$Array.lastUnsafe(result);
+        } else {
+          partitionsByMergeBlock[potentialMergeBlock] = p;
+        }
+      } else {
+        newPartitions.push(p);
+      }
+    } else {
+      newPartitions.push(p);
+    }
+  }
+  var merginDynamicContracts = Object.keys(mergingPartitions);
+  for(var idx$1 = 0 ,idx_finish$1 = merginDynamicContracts.length; idx$1 < idx_finish$1; ++idx$1){
+    var contractName$1 = merginDynamicContracts[idx$1];
+    var partitionsByMergeBlock$1 = mergingPartitions[contractName$1];
+    var ascPartitionKeys = Object.keys(partitionsByMergeBlock$1);
+    if (ascPartitionKeys[ascPartitionKeys.length - 1 | 0] === "-1") {
+      ascPartitionKeys.unshift(Caml_option.undefined_to_opt(ascPartitionKeys.pop()));
+    }
+    var currentPRef = partitionsByMergeBlock$1[Utils.$$Array.firstUnsafe(ascPartitionKeys)];
+    var currentPMergeBlockRef = Belt_Int.fromString(Utils.$$Array.firstUnsafe(ascPartitionKeys));
+    var nextJdx = 1;
+    while(nextJdx < ascPartitionKeys.length) {
+      var nextKey = ascPartitionKeys[nextJdx];
+      var currentP = currentPRef;
+      var nextP = partitionsByMergeBlock$1[nextKey];
+      var nextPMergeBlock = Belt_Int.fromString(nextKey);
+      var currentPMergeBlock = currentPMergeBlockRef;
+      var isTooFar = (currentPMergeBlock + 20000 | 0) < nextPMergeBlock;
+      if (isTooFar) {
+        newPartitions.push(currentP);
+        currentPRef = nextP;
+        currentPMergeBlockRef = nextPMergeBlock;
+      } else {
+        var result$1 = mergePartitionsAtBlock(nextP, currentP, nextPMergeBlock, contractName$1, maxAddrInPartition, nextPartitionIndexRef);
+        for(var i$1 = 0 ,i_finish$1 = result$1.length - 2 | 0; i$1 <= i_finish$1; ++i$1){
+          newPartitions.push(result$1[i$1]);
+        }
+        currentPRef = Utils.$$Array.lastUnsafe(result$1);
+        currentPMergeBlockRef = nextPMergeBlock;
+      }
+      nextJdx = nextJdx + 1 | 0;
     };
+    newPartitions.push(currentPRef);
+  }
+  newPartitions.sort(ascSortFn);
+  var partitionsCount = newPartitions.length;
+  var idsInAscOrder = new Array(partitionsCount);
+  var entities = {};
+  for(var idx$2 = 0; idx$2 < partitionsCount; ++idx$2){
+    var p$1 = newPartitions[idx$2];
+    idsInAscOrder[idx$2] = p$1.id;
+    entities[p$1.id] = p$1;
+  }
+  return {
+          idsInAscOrder: idsInAscOrder,
+          entities: entities,
+          maxAddrInPartition: maxAddrInPartition,
+          nextPartitionIndex: nextPartitionIndexRef.contents,
+          dynamicContracts: dynamicContracts
+        };
+}
+
+function consumeFetchedQueries(mutPendingQueries, initialLatestFetchedBlock) {
+  var latestFetchedBlock = initialLatestFetchedBlock;
+  while((function () {
+          var tmp = false;
+          if (mutPendingQueries.length !== 0) {
+            var pq = Utils.$$Array.firstUnsafe(mutPendingQueries);
+            tmp = pq.fetchedBlock !== undefined && pq.fromBlock <= (latestFetchedBlock.blockNumber + 1 | 0);
+          }
+          return tmp;
+        })()) {
+    var removedQuery = mutPendingQueries.shift();
+    latestFetchedBlock = (
+      removedQuery === undefined ? undefined : Caml_option.some(removedQuery)
+    ).fetchedBlock;
+  };
+  return latestFetchedBlock;
+}
+
+function getPendingQueryOrThrow(p, fromBlock) {
+  var idxRef = 0;
+  var pendingQueryRef;
+  while(idxRef < p.mutPendingQueries.length && pendingQueryRef === undefined) {
+    var pq = p.mutPendingQueries[idxRef];
+    if (pq.fromBlock === fromBlock) {
+      pendingQueryRef = pq;
+    }
+    idxRef = idxRef + 1 | 0;
+  };
+  var pq$1 = pendingQueryRef;
+  if (pq$1 !== undefined) {
+    return pq$1;
   } else {
-    rest = undefined;
+    return Js_exn.raiseError("Pending query not found for partition " + p.id + " fromBlock " + String(fromBlock));
   }
-  return [
-          {
-            id: target.id,
-            status: {
-              fetchingStateId: undefined
-            },
-            latestFetchedBlock: latestFetchedBlock,
-            selection: target.selection,
-            addressesByContractName: mergedAddresses
-          },
-          rest
-        ];
 }
 
+function handleQueryResponse(optimizedPartitions, query, knownHeight, latestFetchedBlock) {
+  var partitionId = query.partitionId;
+  var p = Js_dict.get(optimizedPartitions.entities, partitionId);
+  var p$1 = p !== undefined ? p : Js_exn.raiseError("Unexpected case: Couldn't find partition " + partitionId);
+  var mutEntities = Utils.Dict.shallowCopy(optimizedPartitions.entities);
+  var pendingQuery = getPendingQueryOrThrow(p$1, query.fromBlock);
+  pendingQuery.fetchedBlock = latestFetchedBlock;
+  var blockRange = (latestFetchedBlock.blockNumber - query.fromBlock | 0) + 1 | 0;
+  var shouldUpdateBlockRange = false;
+  if (latestFetchedBlock.blockNumber > p$1.latestBlockRangeUpdateBlock) {
+    var queryToBlock = query.toBlock;
+    var tmp;
+    if (queryToBlock !== undefined) {
+      if (latestFetchedBlock.blockNumber >= queryToBlock) {
+        var 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);
+    }
+    shouldUpdateBlockRange = tmp;
+  }
+  var updatedPrevQueryRange = shouldUpdateBlockRange ? blockRange : p$1.prevQueryRange;
+  var updatedPrevPrevQueryRange = shouldUpdateBlockRange ? p$1.prevQueryRange : p$1.prevPrevQueryRange;
+  var mutPendingQueries = p$1.mutPendingQueries;
+  var latestFetchedBlock$1 = p$1.latestFetchedBlock;
+  while((function () {
+          var tmp = false;
+          if (mutPendingQueries.length !== 0) {
+            var pq = Utils.$$Array.firstUnsafe(mutPendingQueries);
+            tmp = pq.fetchedBlock !== undefined && pq.fromBlock <= (latestFetchedBlock$1.blockNumber + 1 | 0);
+          }
+          return tmp;
+        })()) {
+    var removedQuery = mutPendingQueries.shift();
+    latestFetchedBlock$1 = (
+      removedQuery === undefined ? undefined : Caml_option.some(removedQuery)
+    ).fetchedBlock;
+  };
+  var updatedLatestFetchedBlock = latestFetchedBlock$1;
+  var mergeBlock = p$1.mergeBlock;
+  var partitionReachedMergeBlock = mergeBlock !== undefined ? updatedLatestFetchedBlock.blockNumber >= mergeBlock : false;
+  if (partitionReachedMergeBlock) {
+    Utils.Dict.deleteInPlace(mutEntities, p$1.id);
+  } else {
+    var updatedMainPartition_id = p$1.id;
+    var updatedMainPartition_selection = p$1.selection;
+    var updatedMainPartition_addressesByContractName = p$1.addressesByContractName;
+    var updatedMainPartition_mergeBlock = p$1.mergeBlock;
+    var updatedMainPartition_dynamicContract = p$1.dynamicContract;
+    var updatedMainPartition_mutPendingQueries = p$1.mutPendingQueries;
+    var updatedMainPartition_latestBlockRangeUpdateBlock = shouldUpdateBlockRange ? latestFetchedBlock.blockNumber : p$1.latestBlockRangeUpdateBlock;
+    var updatedMainPartition = {
+      id: updatedMainPartition_id,
+      latestFetchedBlock: updatedLatestFetchedBlock,
+      selection: updatedMainPartition_selection,
+      addressesByContractName: updatedMainPartition_addressesByContractName,
+      mergeBlock: updatedMainPartition_mergeBlock,
+      dynamicContract: updatedMainPartition_dynamicContract,
+      mutPendingQueries: updatedMainPartition_mutPendingQueries,
+      prevQueryRange: updatedPrevQueryRange,
+      prevPrevQueryRange: updatedPrevPrevQueryRange,
+      latestBlockRangeUpdateBlock: updatedMainPartition_latestBlockRangeUpdateBlock
+    };
+    mutEntities[p$1.id] = updatedMainPartition;
+  }
+  return make(Js_dict.values(mutEntities), optimizedPartitions.maxAddrInPartition, optimizedPartitions.nextPartitionIndex, optimizedPartitions.dynamicContracts);
+}
+
+function getLatestFullyFetchedBlock(optimizedPartitions) {
+  var id = Belt_Array.get(optimizedPartitions.idsInAscOrder, 0);
+  if (id !== undefined) {
+    return optimizedPartitions.entities[id].latestFetchedBlock;
+  }
+  
+}
+
+var OptimizedPartitions = {
+  count: count,
+  getOrThrow: getOrThrow,
+  mergePartitionsAtBlock: mergePartitionsAtBlock,
+  tooFarBlockRange: 20000,
+  ascSortFn: ascSortFn,
+  make: make,
+  consumeFetchedQueries: consumeFetchedQueries,
+  getPendingQueryOrThrow: getPendingQueryOrThrow,
+  handleQueryResponse: handleQueryResponse,
+  getLatestFullyFetchedBlock: getLatestFullyFetchedBlock
+};
+
 function bufferBlockNumber(param) {
   var latestOnBlockBlockNumber = param.latestOnBlockBlockNumber;
-  var latestFullyFetchedBlock = param.latestFullyFetchedBlock;
-  if (latestOnBlockBlockNumber < latestFullyFetchedBlock.blockNumber) {
-    return latestOnBlockBlockNumber;
-  } else {
+  var optimizedPartitions = param.optimizedPartitions;
+  var id = Belt_Array.get(optimizedPartitions.idsInAscOrder, 0);
+  var latestFullyFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
+  if (latestFullyFetchedBlock !== undefined && latestOnBlockBlockNumber >= latestFullyFetchedBlock.blockNumber) {
     return latestFullyFetchedBlock.blockNumber;
+  } else {
+    return latestOnBlockBlockNumber;
   }
 }
 
 function bufferBlock(param) {
   var latestOnBlockBlockNumber = param.latestOnBlockBlockNumber;
-  var latestFullyFetchedBlock = param.latestFullyFetchedBlock;
-  if (latestOnBlockBlockNumber < latestFullyFetchedBlock.blockNumber) {
+  var optimizedPartitions = param.optimizedPartitions;
+  var id = Belt_Array.get(optimizedPartitions.idsInAscOrder, 0);
+  var latestFullyFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
+  if (latestFullyFetchedBlock !== undefined && latestOnBlockBlockNumber >= latestFullyFetchedBlock.blockNumber) {
+    return latestFullyFetchedBlock;
+  } else {
     return {
             blockNumber: latestOnBlockBlockNumber,
             blockTimestamp: 0
           };
-  } else {
-    return latestFullyFetchedBlock;
   }
 }
 
@@ -121,28 +435,29 @@ function compareBufferItem(a, b) {
   }
 }
 
-function updateInternal(fetchState, partitionsOpt, nextPartitionIndexOpt, indexingContractsOpt, mutItems, blockLagOpt) {
-  var partitions = partitionsOpt !== undefined ? partitionsOpt : fetchState.partitions;
-  var nextPartitionIndex = nextPartitionIndexOpt !== undefined ? nextPartitionIndexOpt : fetchState.nextPartitionIndex;
+function numAddresses(fetchState) {
+  return Object.keys(fetchState.indexingContracts).length;
+}
+
+function updateInternal(fetchState, optimizedPartitionsOpt, indexingContractsOpt, mutItems, blockLagOpt, knownHeightOpt) {
+  var optimizedPartitions = optimizedPartitionsOpt !== undefined ? optimizedPartitionsOpt : fetchState.optimizedPartitions;
   var indexingContracts = indexingContractsOpt !== undefined ? indexingContractsOpt : fetchState.indexingContracts;
   var blockLag = blockLagOpt !== undefined ? blockLagOpt : fetchState.blockLag;
-  var firstPartition = partitions[0];
-  var latestFullyFetchedBlock = firstPartition.latestFetchedBlock;
-  for(var idx = 0 ,idx_finish = partitions.length; idx < idx_finish; ++idx){
-    var p = partitions[idx];
-    if (latestFullyFetchedBlock.blockNumber > p.latestFetchedBlock.blockNumber) {
-      latestFullyFetchedBlock = p.latestFetchedBlock;
-    }
-    
-  }
-  var latestFullyFetchedBlock$1 = latestFullyFetchedBlock;
+  var knownHeight = knownHeightOpt !== undefined ? knownHeightOpt : fetchState.knownHeight;
   var mutItemsRef = mutItems;
   var onBlockConfigs = fetchState.onBlockConfigs;
   var latestOnBlockBlockNumber;
   if (onBlockConfigs.length !== 0) {
     var mutItems$1 = mutItemsRef;
     var item = Belt_Array.get(mutItems$1 !== undefined ? mutItems$1 : fetchState.buffer, fetchState.targetBufferSize - 1 | 0);
-    var maxBlockNumber = item !== undefined ? item.blockNumber : latestFullyFetchedBlock$1.blockNumber;
+    var maxBlockNumber;
+    if (item !== undefined) {
+      maxBlockNumber = item.blockNumber;
+    } else {
+      var id = Belt_Array.get(optimizedPartitions.idsInAscOrder, 0);
+      var latestFullyFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
+      maxBlockNumber = latestFullyFetchedBlock !== undefined ? latestFullyFetchedBlock.blockNumber : knownHeight;
+    }
     var mutItems$2 = mutItemsRef;
     var mutItems$3 = mutItems$2 !== undefined ? mutItems$2 : fetchState.buffer.slice(0);
     mutItemsRef = mutItems$3;
@@ -174,45 +489,43 @@ function updateInternal(fetchState, partitionsOpt, nextPartitionIndexOpt, indexi
     };
     latestOnBlockBlockNumber = latestOnBlockBlockNumber$1;
   } else {
-    latestOnBlockBlockNumber = latestFullyFetchedBlock$1.blockNumber;
+    latestOnBlockBlockNumber = knownHeight;
   }
   var mutItems$4 = mutItemsRef;
   var updatedFetchState_startBlock = fetchState.startBlock;
   var updatedFetchState_endBlock = fetchState.endBlock;
-  var updatedFetchState_maxAddrInPartition = fetchState.maxAddrInPartition;
   var updatedFetchState_normalSelection = fetchState.normalSelection;
   var updatedFetchState_contractConfigs = fetchState.contractConfigs;
   var updatedFetchState_chainId = fetchState.chainId;
   var updatedFetchState_buffer = mutItems$4 !== undefined ? mutItems$4.sort(compareBufferItem) : fetchState.buffer;
   var updatedFetchState_targetBufferSize = fetchState.targetBufferSize;
   var updatedFetchState_onBlockConfigs = fetchState.onBlockConfigs;
+  var updatedFetchState_firstEventBlock = fetchState.firstEventBlock;
   var updatedFetchState = {
-    partitions: partitions,
-    nextPartitionIndex: nextPartitionIndex,
+    optimizedPartitions: optimizedPartitions,
     startBlock: updatedFetchState_startBlock,
     endBlock: updatedFetchState_endBlock,
-    maxAddrInPartition: updatedFetchState_maxAddrInPartition,
     normalSelection: updatedFetchState_normalSelection,
     indexingContracts: indexingContracts,
     contractConfigs: updatedFetchState_contractConfigs,
     chainId: updatedFetchState_chainId,
-    latestFullyFetchedBlock: latestFullyFetchedBlock$1,
     latestOnBlockBlockNumber: latestOnBlockBlockNumber,
     blockLag: blockLag,
     buffer: updatedFetchState_buffer,
     targetBufferSize: updatedFetchState_targetBufferSize,
-    onBlockConfigs: updatedFetchState_onBlockConfigs
+    onBlockConfigs: updatedFetchState_onBlockConfigs,
+    knownHeight: knownHeight,
+    firstEventBlock: updatedFetchState_firstEventBlock
   };
-  Prometheus.IndexingPartitions.set(partitions.length, fetchState.chainId);
+  Prometheus.IndexingPartitions.set(optimizedPartitions.idsInAscOrder.length, fetchState.chainId);
   Prometheus.IndexingBufferSize.set(updatedFetchState_buffer.length, fetchState.chainId);
-  Prometheus.IndexingBufferBlockNumber.set(latestOnBlockBlockNumber < latestFullyFetchedBlock$1.blockNumber ? latestOnBlockBlockNumber : latestFullyFetchedBlock$1.blockNumber, fetchState.chainId);
+  Prometheus.IndexingBufferBlockNumber.set(bufferBlockNumber(updatedFetchState), fetchState.chainId);
+  if (indexingContracts !== fetchState.indexingContracts) {
+    Prometheus.IndexingAddresses.set(Object.keys(indexingContracts).length, fetchState.chainId);
+  }
   return updatedFetchState;
 }
 
-function numAddresses(fetchState) {
-  return Object.keys(fetchState.indexingContracts).length;
-}
-
 function warnDifferentContractType(fetchState, existingContract, dc) {
   var logger = Logging.createChild({
         chainId: fetchState.chainId,
@@ -223,13 +536,181 @@ function warnDifferentContractType(fetchState, existingContract, dc) {
   Logging.childWarn(logger, "Skipping contract registration: Contract address is already registered for one contract and cannot be registered for another contract.");
 }
 
+function addressesByContractNameCount(addressesByContractName) {
+  var numAddresses = 0;
+  var contractNames = Object.keys(addressesByContractName);
+  for(var idx = 0 ,idx_finish = contractNames.length; idx < idx_finish; ++idx){
+    var contractName = contractNames[idx];
+    numAddresses = numAddresses + addressesByContractName[contractName].length | 0;
+  }
+  return numAddresses;
+}
+
+function addressesByContractNameGetAll(addressesByContractName) {
+  var all = [];
+  var contractNames = Object.keys(addressesByContractName);
+  for(var idx = 0 ,idx_finish = contractNames.length; idx < idx_finish; ++idx){
+    var contractName = contractNames[idx];
+    all = Belt_Array.concat(all, addressesByContractName[contractName]);
+  }
+  return all;
+}
+
+function createPartitionsFromIndexingAddresses(registeringContractsByContract, contractConfigs, dynamicContracts, normalSelection, maxAddrInPartition, nextPartitionIndex, existingPartitions, progressBlockNumber) {
+  var nextPartitionIndexRef = nextPartitionIndex;
+  var dynamicPartitions = [];
+  var nonDynamicPartitions = [];
+  var contractNames = Object.keys(registeringContractsByContract);
+  for(var cIdx = 0 ,cIdx_finish = contractNames.length; cIdx < cIdx_finish; ++cIdx){
+    var contractName = contractNames[cIdx];
+    var registeringContracts = registeringContractsByContract[contractName];
+    var addresses = Object.keys(registeringContracts);
+    var contractConfig = contractConfigs[contractName];
+    var isDynamic = dynamicContracts.has(contractName);
+    var partitions = isDynamic ? dynamicPartitions : nonDynamicPartitions;
+    var byStartBlock = {};
+    for(var jdx = 0 ,jdx_finish = addresses.length; jdx < jdx_finish; ++jdx){
+      var address = addresses[jdx];
+      var indexingContract = registeringContracts[address];
+      Utils.Dict.push(byStartBlock, String(indexingContract.startBlock), address);
+    }
+    var ascKeys = Object.keys(byStartBlock);
+    var initialKey = Utils.$$Array.firstUnsafe(ascKeys);
+    var startBlockRef = Belt_Int.fromString(initialKey);
+    var addressesRef = byStartBlock[initialKey];
+    for(var idx = 0 ,idx_finish = ascKeys.length; idx < idx_finish; ++idx){
+      var maybeNextStartBlockKey = ascKeys[idx + 1 | 0];
+      var shouldAllocateNewPartition;
+      if (contractConfig.filterByAddresses || maybeNextStartBlockKey === undefined) {
+        shouldAllocateNewPartition = true;
+      } else {
+        var nextStartBlock = Belt_Int.fromString(maybeNextStartBlockKey);
+        var shouldJoinCurrentStartBlock = (nextStartBlock - startBlockRef | 0) < 20000;
+        if (shouldJoinCurrentStartBlock) {
+          addressesRef = Belt_Array.concat(addressesRef, byStartBlock[maybeNextStartBlockKey]);
+          shouldAllocateNewPartition = false;
+        } else {
+          shouldAllocateNewPartition = true;
+        }
+      }
+      if (shouldAllocateNewPartition) {
+        var latestFetchedBlock_blockNumber = Caml.int_max(startBlockRef - 1 | 0, progressBlockNumber);
+        var latestFetchedBlock = {
+          blockNumber: latestFetchedBlock_blockNumber,
+          blockTimestamp: 0
+        };
+        while(addressesRef.length !== 0) {
+          var pAddresses = addressesRef.slice(0, maxAddrInPartition);
+          addressesRef = addressesRef.slice(maxAddrInPartition);
+          var addressesByContractName = {};
+          addressesByContractName[contractName] = pAddresses;
+          partitions.push({
+                id: String(nextPartitionIndexRef),
+                latestFetchedBlock: latestFetchedBlock,
+                selection: normalSelection,
+                addressesByContractName: addressesByContractName,
+                mergeBlock: undefined,
+                dynamicContract: isDynamic ? contractName : undefined,
+                mutPendingQueries: [],
+                prevQueryRange: 0,
+                prevPrevQueryRange: 0,
+                latestBlockRangeUpdateBlock: 0
+              });
+          nextPartitionIndexRef = nextPartitionIndexRef + 1 | 0;
+        };
+        if (maybeNextStartBlockKey !== undefined) {
+          startBlockRef = Belt_Int.fromString(maybeNextStartBlockKey);
+          addressesRef = byStartBlock[maybeNextStartBlockKey];
+        }
+        
+      }
+      
+    }
+  }
+  var mergedNonDynamic = [];
+  if (nonDynamicPartitions.length !== 0) {
+    nonDynamicPartitions.sort(ascSortFn);
+    var currentPRef = nonDynamicPartitions[0];
+    var nextIdx = 1;
+    while(nextIdx < nonDynamicPartitions.length) {
+      var nextP = nonDynamicPartitions[nextIdx];
+      var currentP = currentPRef;
+      var currentPBlock = currentP.latestFetchedBlock.blockNumber;
+      var nextPBlock = nextP.latestFetchedBlock.blockNumber;
+      var totalCount = addressesByContractNameCount(currentP.addressesByContractName) + addressesByContractNameCount(nextP.addressesByContractName) | 0;
+      if (totalCount > maxAddrInPartition) {
+        mergedNonDynamic.push(currentP);
+        currentPRef = nextP;
+      } else {
+        var mergedAddresses = Utils.Dict.shallowCopy(nextP.addressesByContractName);
+        var currentContractNames = Object.keys(currentP.addressesByContractName);
+        for(var jdx$1 = 0 ,jdx_finish$1 = currentContractNames.length; jdx$1 < jdx_finish$1; ++jdx$1){
+          var cn = currentContractNames[jdx$1];
+          var currentAddrs = currentP.addressesByContractName[cn];
+          var existingAddrs = mergedAddresses[cn];
+          if (existingAddrs !== undefined) {
+            mergedAddresses[cn] = Belt_Array.concat(existingAddrs, currentAddrs);
+          } else {
+            mergedAddresses[cn] = currentAddrs;
+          }
+        }
+        var nextContractName = Utils.$$Array.firstUnsafe(Object.keys(nextP.addressesByContractName));
+        var hasFilterByAddresses = contractConfigs[nextContractName].filterByAddresses;
+        var isTooFar = (currentPBlock + 20000 | 0) < nextPBlock;
+        if (isTooFar || hasFilterByAddresses) {
+          mergedNonDynamic.push({
+                id: currentP.id,
+                latestFetchedBlock: currentP.latestFetchedBlock,
+                selection: currentP.selection,
+                addressesByContractName: currentP.addressesByContractName,
+                mergeBlock: currentPBlock < nextPBlock ? nextPBlock : undefined,
+                dynamicContract: currentP.dynamicContract,
+                mutPendingQueries: currentP.mutPendingQueries,
+                prevQueryRange: currentP.prevQueryRange,
+                prevPrevQueryRange: currentP.prevPrevQueryRange,
+                latestBlockRangeUpdateBlock: currentP.latestBlockRangeUpdateBlock
+              });
+          currentPRef = {
+            id: nextP.id,
+            latestFetchedBlock: nextP.latestFetchedBlock,
+            selection: nextP.selection,
+            addressesByContractName: mergedAddresses,
+            mergeBlock: nextP.mergeBlock,
+            dynamicContract: nextP.dynamicContract,
+            mutPendingQueries: nextP.mutPendingQueries,
+            prevQueryRange: nextP.prevQueryRange,
+            prevPrevQueryRange: nextP.prevPrevQueryRange,
+            latestBlockRangeUpdateBlock: nextP.latestBlockRangeUpdateBlock
+          };
+        } else {
+          currentPRef = {
+            id: currentP.id,
+            latestFetchedBlock: currentP.latestFetchedBlock,
+            selection: currentP.selection,
+            addressesByContractName: mergedAddresses,
+            mergeBlock: currentP.mergeBlock,
+            dynamicContract: currentP.dynamicContract,
+            mutPendingQueries: currentP.mutPendingQueries,
+            prevQueryRange: currentP.prevQueryRange,
+            prevPrevQueryRange: currentP.prevPrevQueryRange,
+            latestBlockRangeUpdateBlock: currentP.latestBlockRangeUpdateBlock
+          };
+        }
+      }
+      nextIdx = nextIdx + 1 | 0;
+    };
+    mergedNonDynamic.push(currentPRef);
+  }
+  var mergedPartitions = mergedNonDynamic.concat(dynamicPartitions);
+  return make(existingPartitions.concat(mergedPartitions), maxAddrInPartition, nextPartitionIndexRef, dynamicContracts);
+}
+
 function registerDynamicContracts(fetchState, items) {
   if (Utils.$$Array.isEmpty(fetchState.normalSelection.eventConfigs)) {
     Js_exn.raiseError("Invalid configuration. No events to fetch for the dynamic contract registration.");
   }
   var indexingContracts = fetchState.indexingContracts;
-  var registeringContracts = {};
-  var addressesByContractName = {};
+  var registeringContractsByContract = {};
   var earliestRegisteringEventBlockNumber = Infinity;
   var hasDCWithFilterByAddresses = false;
   for(var itemIdx = 0 ,itemIdx_finish = items.length; itemIdx < itemIdx_finish; ++itemIdx){
@@ -257,6 +738,7 @@ function registerDynamicContracts(fetchState, items) {
             }
             shouldRemove = true;
           } else {
+            var registeringContracts = Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, dc.contractName);
             var registeringContract = registeringContracts[dc.address];
             var shouldUpdate;
             if (registeringContract !== undefined) {
@@ -268,7 +750,6 @@ function registerDynamicContracts(fetchState, items) {
               }
             } else {
               hasDCWithFilterByAddresses = hasDCWithFilterByAddresses || match.filterByAddresses;
-              Utils.Dict.push(addressesByContractName, dc.contractName, dc.address);
               shouldUpdate = true;
             }
             if (shouldUpdate) {
@@ -296,390 +777,364 @@ function registerDynamicContracts(fetchState, items) {
     }
     
   }
-  var dcsToStore = Js_dict.values(registeringContracts);
-  if (dcsToStore.length === 0) {
+  var dcContractNamesToStore = Object.keys(registeringContractsByContract);
+  if (dcContractNamesToStore.length === 0) {
     return fetchState;
   }
-  var newPartitions;
-  if (dcsToStore.length <= fetchState.maxAddrInPartition && !hasDCWithFilterByAddresses) {
-    newPartitions = [{
-        id: String(fetchState.nextPartitionIndex),
-        status: {
-          fetchingStateId: undefined
-        },
-        latestFetchedBlock: {
-          blockNumber: earliestRegisteringEventBlockNumber - 1 | 0,
-          blockTimestamp: 0
-        },
-        selection: fetchState.normalSelection,
-        addressesByContractName: addressesByContractName
-      }];
-  } else {
-    var partitions = [];
-    var earliestRegisteringEventBlockNumber$1 = {
-      contents: Infinity
-    };
-    var pendingAddressesByContractName = {
-      contents: {}
-    };
-    var pendingCount = 0;
-    var addPartition = function () {
-      partitions.push({
-            id: String(fetchState.nextPartitionIndex + partitions.length | 0),
-            status: {
-              fetchingStateId: undefined
-            },
-            latestFetchedBlock: {
-              blockNumber: earliestRegisteringEventBlockNumber$1.contents - 1 | 0,
-              blockTimestamp: 0
-            },
-            selection: fetchState.normalSelection,
-            addressesByContractName: pendingAddressesByContractName.contents
-          });
-    };
-    for(var idx$1 = 0 ,idx_finish = Object.keys(addressesByContractName).length; idx$1 < idx_finish; ++idx$1){
-      var contractName = Object.keys(addressesByContractName)[idx$1];
-      var addresses = addressesByContractName[contractName];
-      var contractConfig = fetchState.contractConfigs[contractName];
-      if (contractConfig.filterByAddresses) {
-        var byStartBlock = {};
-        for(var jdx = 0 ,jdx_finish = addresses.length; jdx < jdx_finish; ++jdx){
-          var address = addresses[jdx];
-          var indexingContract = registeringContracts[address];
-          Utils.Dict.push(byStartBlock, String(indexingContract.startBlock), address);
-        }
-        Object.keys(byStartBlock).forEach((function(contractName,byStartBlock){
-            return function (startBlockKey) {
-              var addresses = byStartBlock[startBlockKey];
+  var newPartitions = [];
+  var newIndexingContracts = Utils.Dict.shallowCopy(indexingContracts);
+  var dynamicContractsRef = fetchState.optimizedPartitions.dynamicContracts;
+  var mutExistingPartitions = Js_dict.values(fetchState.optimizedPartitions.entities);
+  for(var idx$1 = 0 ,idx_finish = dcContractNamesToStore.length; idx$1 < idx_finish; ++idx$1){
+    var contractName = dcContractNamesToStore[idx$1];
+    if (!dynamicContractsRef.has(contractName)) {
+      dynamicContractsRef = Utils.$$Set.immutableAdd(dynamicContractsRef, contractName);
+      for(var idx$2 = 0 ,idx_finish$1 = mutExistingPartitions.length; idx$2 < idx_finish$1; ++idx$2){
+        var p = mutExistingPartitions[idx$2];
+        var addresses = p.addressesByContractName[contractName];
+        if (addresses !== undefined && p.selection.dependsOnAddresses && p.mergeBlock === undefined) {
+          var allPartitionContractNames = Object.keys(p.addressesByContractName);
+          if (allPartitionContractNames.length !== 1) {
+            var isFetching = p.mutPendingQueries.length !== 0;
+            if (!isFetching) {
+              var newPartitionId = String(fetchState.optimizedPartitions.nextPartitionIndex + newPartitions.length | 0);
+              var restAddressesByContractName = Utils.Dict.shallowCopy(p.addressesByContractName);
+              Utils.Dict.deleteInPlace(restAddressesByContractName, contractName);
+              mutExistingPartitions[idx$2] = {
+                id: p.id,
+                latestFetchedBlock: p.latestFetchedBlock,
+                selection: p.selection,
+                addressesByContractName: restAddressesByContractName,
+                mergeBlock: p.mergeBlock,
+                dynamicContract: p.dynamicContract,
+                mutPendingQueries: p.mutPendingQueries,
+                prevQueryRange: p.prevQueryRange,
+                prevPrevQueryRange: p.prevPrevQueryRange,
+                latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+              };
               var addressesByContractName = {};
               addressesByContractName[contractName] = addresses;
-              partitions.push({
-                    id: String(fetchState.nextPartitionIndex + partitions.length | 0),
-                    status: {
-                      fetchingStateId: undefined
-                    },
-                    latestFetchedBlock: {
-                      blockNumber: Caml.int_max(Belt_Option.getExn(Belt_Int.fromString(startBlockKey)) - 1 | 0, 0),
-                      blockTimestamp: 0
-                    },
+              newPartitions.push({
+                    id: newPartitionId,
+                    latestFetchedBlock: p.latestFetchedBlock,
                     selection: fetchState.normalSelection,
-                    addressesByContractName: addressesByContractName
+                    addressesByContractName: addressesByContractName,
+                    mergeBlock: undefined,
+                    dynamicContract: contractName,
+                    mutPendingQueries: p.mutPendingQueries,
+                    prevQueryRange: p.prevQueryRange,
+                    prevPrevQueryRange: p.prevPrevQueryRange,
+                    latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
                   });
             }
-            }(contractName,byStartBlock)));
-      } else {
-        for(var jdx$1 = 0 ,jdx_finish$1 = addresses.length; jdx$1 < jdx_finish$1; ++jdx$1){
-          var address$1 = addresses[jdx$1];
-          if (pendingCount === fetchState.maxAddrInPartition) {
-            addPartition();
-            pendingAddressesByContractName.contents = {};
-            pendingCount = 0;
-            earliestRegisteringEventBlockNumber$1.contents = Infinity;
+            
+          } 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,
+              latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+            };
           }
-          var indexingContract$1 = registeringContracts[address$1];
-          pendingCount = pendingCount + 1 | 0;
-          Utils.Dict.push(pendingAddressesByContractName.contents, contractName, address$1);
-          earliestRegisteringEventBlockNumber$1.contents = earliestRegisteringEventBlockNumber$1.contents < indexingContract$1.startBlock ? earliestRegisteringEventBlockNumber$1.contents : indexingContract$1.startBlock;
         }
+        
       }
     }
-    if (pendingCount > 0) {
-      addPartition();
-    }
-    newPartitions = partitions;
+    var registeringContracts$1 = registeringContractsByContract[contractName];
+    Object.assign(newIndexingContracts, registeringContracts$1);
   }
-  Prometheus.IndexingAddresses.set(Object.keys(fetchState.indexingContracts).length + dcsToStore.length | 0, fetchState.chainId);
-  return updateInternal(fetchState, fetchState.partitions.concat(newPartitions), fetchState.nextPartitionIndex + newPartitions.length | 0, Object.assign(registeringContracts, indexingContracts), undefined, undefined);
+  var optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, fetchState.contractConfigs, dynamicContractsRef, fetchState.normalSelection, fetchState.optimizedPartitions.maxAddrInPartition, fetchState.optimizedPartitions.nextPartitionIndex + newPartitions.length | 0, mutExistingPartitions.concat(newPartitions), 0);
+  return updateInternal(fetchState, optimizedPartitions, newIndexingContracts, undefined, undefined, undefined);
 }
 
-var UnexpectedPartitionNotFound = /* @__PURE__ */Caml_exceptions.create("FetchState.UnexpectedPartitionNotFound");
-
-var UnexpectedMergeQueryResponse = /* @__PURE__ */Caml_exceptions.create("FetchState.UnexpectedMergeQueryResponse");
-
 function handleQueryResult(fetchState, query, latestFetchedBlock, newItems) {
-  var partitions = fetchState.partitions;
-  var partitionId = query.partitionId;
-  var pIndex = Belt_Array.getIndexBy(partitions, (function (p) {
-          return p.id === partitionId;
-        }));
-  var tmp;
-  if (pIndex !== undefined) {
-    var p = partitions[pIndex];
-    var updatedPartition_id = p.id;
-    var updatedPartition_status = {
-      fetchingStateId: undefined
-    };
-    var updatedPartition_selection = p.selection;
-    var updatedPartition_addressesByContractName = p.addressesByContractName;
-    var updatedPartition = {
-      id: updatedPartition_id,
-      status: updatedPartition_status,
-      latestFetchedBlock: latestFetchedBlock,
-      selection: updatedPartition_selection,
-      addressesByContractName: updatedPartition_addressesByContractName
+  return updateInternal(fetchState, handleQueryResponse(fetchState.optimizedPartitions, query, fetchState.knownHeight, latestFetchedBlock), undefined, newItems.length !== 0 ? Belt_Array.concat(fetchState.buffer, newItems) : undefined, undefined, undefined);
+}
+
+function startFetchingQueries(param, queries) {
+  var optimizedPartitions = param.optimizedPartitions;
+  for(var qIdx = 0 ,qIdx_finish = queries.length; qIdx < qIdx_finish; ++qIdx){
+    var q = queries[qIdx];
+    var partitionId = q.partitionId;
+    var p = Js_dict.get(optimizedPartitions.entities, partitionId);
+    var p$1 = p !== undefined ? p : Js_exn.raiseError("Unexpected case: Couldn't find partition " + partitionId);
+    var pq = {
+      fromBlock: q.fromBlock,
+      toBlock: q.toBlock,
+      isChunk: q.isChunk,
+      fetchedBlock: undefined
     };
-    var match = query.target;
-    var exit = 0;
-    if (typeof match !== "object" || match.TAG === "EndBlock") {
-      exit = 1;
-    } else {
-      var intoPartitionId = match.intoPartitionId;
-      var targetIndex = Belt_Array.getIndexBy(partitions, (function (p) {
-              return p.id === intoPartitionId;
-            }));
-      var exit$1 = 0;
-      if (targetIndex !== undefined && partitions[targetIndex].latestFetchedBlock.blockNumber === latestFetchedBlock.blockNumber) {
-        var target = partitions[targetIndex];
-        var match$1 = mergeIntoPartition(updatedPartition, target, fetchState.maxAddrInPartition);
-        var rest = match$1[1];
-        var updatedPartitions = Utils.$$Array.setIndexImmutable(partitions, targetIndex, match$1[0]);
-        var updatedPartitions$1 = rest !== undefined ? (updatedPartitions[pIndex] = rest, updatedPartitions) : Utils.$$Array.removeAtIndex(updatedPartitions, pIndex);
-        tmp = {
-          TAG: "Ok",
-          _0: updatedPartitions$1
-        };
-      } else {
-        exit$1 = 2;
-      }
-      if (exit$1 === 2) {
-        tmp = {
-          TAG: "Ok",
-          _0: Utils.$$Array.setIndexImmutable(partitions, pIndex, updatedPartition)
-        };
-      }
-      
-    }
-    if (exit === 1) {
-      tmp = {
-        TAG: "Ok",
-        _0: Utils.$$Array.setIndexImmutable(partitions, pIndex, updatedPartition)
-      };
-    }
-    
-  } else {
-    tmp = {
-      TAG: "Error",
-      _0: {
-        RE_EXN_ID: UnexpectedPartitionNotFound,
-        partitionId: partitionId
+    var inserted = false;
+    var i = 0;
+    while(i < p$1.mutPendingQueries.length && !inserted) {
+      if (p$1.mutPendingQueries[i].fromBlock > q.fromBlock) {
+        p$1.mutPendingQueries.splice(i, 0, pq);
+        inserted = true;
       }
+      i = i + 1 | 0;
     };
-  }
-  return Belt_Result.map(tmp, (function (partitions) {
-                return updateInternal(fetchState, partitions, undefined, undefined, newItems.length !== 0 ? Belt_Array.concat(fetchState.buffer, newItems) : undefined, undefined);
-              }));
-}
-
-function makePartitionQuery(p, indexingContracts, endBlock, mergeTarget) {
-  var latestFetchedBlockNumber = p.latestFetchedBlock.blockNumber;
-  var fromBlock = latestFetchedBlockNumber !== 0 ? latestFetchedBlockNumber + 1 | 0 : 0;
-  var tmp;
-  var exit = 0;
-  if (endBlock !== undefined) {
-    if (fromBlock > endBlock) {
-      tmp = undefined;
-    } else if (mergeTarget !== undefined) {
-      exit = 1;
-    } else {
-      tmp = {
-        TAG: "EndBlock",
-        toBlock: endBlock
-      };
+    if (!inserted) {
+      p$1.mutPendingQueries.push(pq);
     }
-  } else if (mergeTarget !== undefined) {
-    exit = 1;
-  } else {
-    tmp = "Head";
-  }
-  if (exit === 1) {
-    tmp = {
-      TAG: "Merge",
-      intoPartitionId: mergeTarget.id,
-      toBlock: mergeTarget.latestFetchedBlock.blockNumber
-    };
+    
   }
-  return Belt_Option.map(tmp, (function (target) {
-                return {
-                        partitionId: p.id,
-                        fromBlock: fromBlock,
-                        selection: p.selection,
-                        addressesByContractName: p.addressesByContractName,
-                        target: target,
-                        indexingContracts: indexingContracts
-                      };
-              }));
-}
-
-function startFetchingQueries(param, queries, stateId) {
-  var partitions = param.partitions;
-  Belt_Array.forEach(queries, (function (q) {
-          var p = partitions.find(function (p) {
-                return p.id === q.partitionId;
-              });
-          if (p !== undefined) {
-            p.status.fetchingStateId = stateId;
-            return ;
-          } else {
-            return Js_exn.raiseError("Unexpected case: Couldn't find partition for the fetching query");
-          }
-        }));
 }
 
-function addressesByContractNameCount(addressesByContractName) {
-  var numAddresses = 0;
-  var contractNames = Object.keys(addressesByContractName);
-  for(var idx = 0 ,idx_finish = contractNames.length; idx < idx_finish; ++idx){
-    var contractName = contractNames[idx];
-    numAddresses = numAddresses + addressesByContractName[contractName].length | 0;
+function pushQueriesForRange(queries, partitionId, rangeFromBlock, rangeEndBlock, maxQueryBlockNumber, maybeChunkRange, selection, addressesByContractName, indexingContracts) {
+  if (rangeFromBlock > maxQueryBlockNumber) {
+    return ;
   }
-  return numAddresses;
-}
-
-function addressesByContractNameGetAll(addressesByContractName) {
-  var all = [];
-  var contractNames = Object.keys(addressesByContractName);
-  for(var idx = 0 ,idx_finish = contractNames.length; idx < idx_finish; ++idx){
-    var contractName = contractNames[idx];
-    all = Belt_Array.concat(all, addressesByContractName[contractName]);
+  if (rangeEndBlock !== undefined && rangeFromBlock > rangeEndBlock) {
+    return ;
   }
-  return all;
-}
-
-function isFullPartition(p, maxAddrInPartition) {
-  if (p.selection.dependsOnAddresses) {
-    return addressesByContractNameCount(p.addressesByContractName) >= maxAddrInPartition;
-  } else {
-    return true;
+  if (maybeChunkRange !== undefined) {
+    var maxBlock = rangeEndBlock !== undefined ? rangeEndBlock : maxQueryBlockNumber;
+    var chunkSize = Js_math.ceil_int(maybeChunkRange * 1.8);
+    if (((rangeFromBlock + (chunkSize << 1) | 0) - 1 | 0) <= maxBlock) {
+      queries.push({
+            partitionId: partitionId,
+            fromBlock: rangeFromBlock,
+            toBlock: (rangeFromBlock + chunkSize | 0) - 1 | 0,
+            isChunk: true,
+            selection: selection,
+            addressesByContractName: addressesByContractName,
+            indexingContracts: indexingContracts
+          });
+      queries.push({
+            partitionId: partitionId,
+            fromBlock: rangeFromBlock + chunkSize | 0,
+            toBlock: (rangeFromBlock + (chunkSize << 1) | 0) - 1 | 0,
+            isChunk: true,
+            selection: selection,
+            addressesByContractName: addressesByContractName,
+            indexingContracts: indexingContracts
+          });
+    } else {
+      queries.push({
+            partitionId: partitionId,
+            fromBlock: rangeFromBlock,
+            toBlock: rangeEndBlock,
+            isChunk: rangeEndBlock !== undefined,
+            selection: selection,
+            addressesByContractName: addressesByContractName,
+            indexingContracts: indexingContracts
+          });
+    }
+    return ;
   }
+  queries.push({
+        partitionId: partitionId,
+        fromBlock: rangeFromBlock,
+        toBlock: rangeEndBlock,
+        isChunk: false,
+        selection: selection,
+        addressesByContractName: addressesByContractName,
+        indexingContracts: indexingContracts
+      });
 }
 
-function getNextQuery(param, concurrencyLimit, currentBlockHeight, stateId) {
-  var blockLag = param.blockLag;
-  var indexingContracts = param.indexingContracts;
-  var maxAddrInPartition = param.maxAddrInPartition;
-  var endBlock = param.endBlock;
-  var partitions = param.partitions;
-  var headBlock = currentBlockHeight - blockLag | 0;
-  if (headBlock <= 0) {
+function getNextQuery(fetchState, concurrencyLimit) {
+  var knownHeight = fetchState.knownHeight;
+  var blockLag = fetchState.blockLag;
+  var indexingContracts = fetchState.indexingContracts;
+  var optimizedPartitions = fetchState.optimizedPartitions;
+  var headBlockNumber = knownHeight - blockLag | 0;
+  if (headBlockNumber <= 0) {
     return "WaitingForNewBlock";
   }
   if (concurrencyLimit === 0) {
     return "ReachedMaxConcurrency";
   }
-  var fullPartitions = [];
-  var mergingPartitions = [];
-  var areMergingPartitionsFetching = false;
-  var mostBehindMergingPartition;
-  var mergingPartitionTarget;
-  var shouldWaitForNewBlock = endBlock !== undefined ? headBlock < endBlock : true;
-  var checkIsFetchingPartition = function (p) {
-    var fetchingStateId = p.status.fetchingStateId;
-    if (fetchingStateId !== undefined) {
-      return stateId <= fetchingStateId;
-    } else {
-      return false;
-    }
-  };
-  for(var idx = 0 ,idx_finish = partitions.length; idx < idx_finish; ++idx){
-    var p = partitions[idx];
-    var isFetching = checkIsFetchingPartition(p);
-    var hasReachedTheHead = p.latestFetchedBlock.blockNumber >= headBlock;
-    if (isFetching || !hasReachedTheHead) {
+  var isOnBlockBehindTheHead = fetchState.latestOnBlockBlockNumber < headBlockNumber;
+  var endBlock = fetchState.endBlock;
+  var shouldWaitForNewBlock = (
+    endBlock !== undefined ? headBlockNumber < endBlock : true
+  ) && !isOnBlockBehindTheHead;
+  var item = Belt_Array.get(fetchState.buffer, fetchState.targetBufferSize - 1 | 0);
+  var maxQueryBlockNumber = item !== undefined && item.blockNumber < knownHeight ? item.blockNumber : knownHeight;
+  var queries = [];
+  var partitionsCount = optimizedPartitions.idsInAscOrder.length;
+  var idxRef = 0;
+  while(idxRef < partitionsCount) {
+    var idx = idxRef;
+    var partitionId = optimizedPartitions.idsInAscOrder[idx];
+    var p = optimizedPartitions.entities[partitionId];
+    var isBehindTheHead = p.latestFetchedBlock.blockNumber < headBlockNumber;
+    var hasPendingQueries = Utils.$$Array.notEmpty(p.mutPendingQueries);
+    if (hasPendingQueries || isBehindTheHead) {
       shouldWaitForNewBlock = false;
     }
-    if (p.selection.dependsOnAddresses ? addressesByContractNameCount(p.addressesByContractName) >= maxAddrInPartition : true) {
-      fullPartitions.push(p);
-    } else {
-      mergingPartitions.push(p);
-      var mostBehindMergingPartition$1 = mostBehindMergingPartition;
-      var tmp;
-      if (mostBehindMergingPartition$1 !== undefined) {
-        if (mostBehindMergingPartition$1.latestFetchedBlock.blockNumber === p.latestFetchedBlock.blockNumber) {
-          tmp = mostBehindMergingPartition$1;
-        } else if (mostBehindMergingPartition$1.latestFetchedBlock.blockNumber < p.latestFetchedBlock.blockNumber) {
-          var mergingPartitionTarget$1 = mergingPartitionTarget;
-          mergingPartitionTarget = mergingPartitionTarget$1 !== undefined && mergingPartitionTarget$1.latestFetchedBlock.blockNumber < p.latestFetchedBlock.blockNumber ? mergingPartitionTarget$1 : p;
-          tmp = mostBehindMergingPartition$1;
+    var queryEndBlock = Utils.$$Math.minOptInt(fetchState.endBlock, p.mergeBlock);
+    var queryEndBlock$1 = blockLag !== 0 ? Utils.$$Math.minOptInt(headBlockNumber, queryEndBlock) : queryEndBlock;
+    var match = maxQueryBlockNumber < knownHeight;
+    var queryEndBlock$2 = queryEndBlock$1 !== undefined ? (
+        match ? (
+            maxQueryBlockNumber < queryEndBlock$1 ? maxQueryBlockNumber : queryEndBlock$1
+          ) : queryEndBlock$1
+      ) : (
+        match ? maxQueryBlockNumber : queryEndBlock$1
+      );
+    var maybeChunkRange = getMinHistoryRange(p);
+    var cursor = p.latestFetchedBlock.blockNumber + 1 | 0;
+    var canContinue = true;
+    var pqIdx = 0;
+    while(pqIdx < p.mutPendingQueries.length && canContinue) {
+      var pq = p.mutPendingQueries[pqIdx];
+      if (pq.fromBlock > cursor) {
+        var addressesByContractName = p.addressesByContractName;
+        var selection = p.selection;
+        var rangeEndBlock = Utils.$$Math.minOptInt(pq.fromBlock - 1 | 0, queryEndBlock$2);
+        var rangeFromBlock = cursor;
+        if (rangeFromBlock <= maxQueryBlockNumber) {
+          var exit = 0;
+          if (!(rangeEndBlock !== undefined && rangeFromBlock > rangeEndBlock)) {
+            exit = 1;
+          }
+          if (exit === 1) {
+            if (maybeChunkRange !== undefined) {
+              var maxBlock = rangeEndBlock !== undefined ? rangeEndBlock : maxQueryBlockNumber;
+              var chunkSize = Js_math.ceil_int(maybeChunkRange * 1.8);
+              if (((rangeFromBlock + (chunkSize << 1) | 0) - 1 | 0) <= maxBlock) {
+                queries.push({
+                      partitionId: partitionId,
+                      fromBlock: rangeFromBlock,
+                      toBlock: (rangeFromBlock + chunkSize | 0) - 1 | 0,
+                      isChunk: true,
+                      selection: selection,
+                      addressesByContractName: addressesByContractName,
+                      indexingContracts: indexingContracts
+                    });
+                queries.push({
+                      partitionId: partitionId,
+                      fromBlock: rangeFromBlock + chunkSize | 0,
+                      toBlock: (rangeFromBlock + (chunkSize << 1) | 0) - 1 | 0,
+                      isChunk: true,
+                      selection: selection,
+                      addressesByContractName: addressesByContractName,
+                      indexingContracts: indexingContracts
+                    });
+              } else {
+                queries.push({
+                      partitionId: partitionId,
+                      fromBlock: rangeFromBlock,
+                      toBlock: rangeEndBlock,
+                      isChunk: rangeEndBlock !== undefined,
+                      selection: selection,
+                      addressesByContractName: addressesByContractName,
+                      indexingContracts: indexingContracts
+                    });
+              }
+            } else {
+              queries.push({
+                    partitionId: partitionId,
+                    fromBlock: rangeFromBlock,
+                    toBlock: rangeEndBlock,
+                    isChunk: false,
+                    selection: selection,
+                    addressesByContractName: addressesByContractName,
+                    indexingContracts: indexingContracts
+                  });
+            }
+          }
+          
+        }
+        
+      }
+      var toBlock = pq.toBlock;
+      if (toBlock !== undefined && pq.isChunk) {
+        var match$1 = pq.fetchedBlock;
+        if (match$1 !== undefined) {
+          var blockNumber = match$1.blockNumber;
+          cursor = blockNumber < toBlock ? blockNumber + 1 | 0 : toBlock + 1 | 0;
         } else {
-          mergingPartitionTarget = mostBehindMergingPartition$1;
-          tmp = p;
+          cursor = toBlock + 1 | 0;
         }
       } else {
-        tmp = p;
-      }
-      mostBehindMergingPartition = tmp;
-      if (isFetching) {
-        areMergingPartitionsFetching = true;
+        canContinue = false;
       }
-      
-    }
-  }
-  var item = Belt_Array.get(param.buffer, param.targetBufferSize - 1 | 0);
-  var maxQueryBlockNumber = item !== undefined && item.blockNumber < currentBlockHeight ? item.blockNumber : currentBlockHeight;
-  var queries = [];
-  var registerPartitionQuery = function (p, mergeTarget) {
-    if (!(!checkIsFetchingPartition(p) && p.latestFetchedBlock.blockNumber < maxQueryBlockNumber)) {
-      return ;
-    }
-    var endBlock$1 = blockLag !== 0 ? (
-        endBlock !== undefined ? (
-            headBlock < endBlock ? headBlock : endBlock
-          ) : headBlock
-      ) : endBlock;
-    var match = maxQueryBlockNumber < currentBlockHeight;
-    var endBlock$2 = endBlock$1 !== undefined ? (
-        match ? (
-            maxQueryBlockNumber < endBlock$1 ? maxQueryBlockNumber : endBlock$1
-          ) : endBlock$1
-      ) : (
-        match ? maxQueryBlockNumber : endBlock$1
-      );
-    var q = makePartitionQuery(p, indexingContracts, endBlock$2, mergeTarget);
-    if (q !== undefined) {
-      queries.push(q);
-      return ;
-    }
-    
-  };
-  Belt_Array.forEach(fullPartitions, (function (p) {
-          registerPartitionQuery(p, undefined);
-        }));
-  if (!areMergingPartitionsFetching) {
-    var len = mergingPartitions.length;
-    if (len !== 1) {
-      if (len !== 0) {
-        var match = mostBehindMergingPartition;
-        var match$1 = mergingPartitionTarget;
-        if (match !== undefined) {
-          if (match$1 !== undefined) {
-            registerPartitionQuery(match, match$1);
+      pqIdx = pqIdx + 1 | 0;
+    };
+    if (canContinue) {
+      var addressesByContractName$1 = p.addressesByContractName;
+      var selection$1 = p.selection;
+      var rangeFromBlock$1 = cursor;
+      if (rangeFromBlock$1 <= maxQueryBlockNumber) {
+        var exit$1 = 0;
+        if (!(queryEndBlock$2 !== undefined && rangeFromBlock$1 > queryEndBlock$2)) {
+          exit$1 = 1;
+        }
+        if (exit$1 === 1) {
+          if (maybeChunkRange !== undefined) {
+            var maxBlock$1 = queryEndBlock$2 !== undefined ? queryEndBlock$2 : maxQueryBlockNumber;
+            var chunkSize$1 = Js_math.ceil_int(maybeChunkRange * 1.8);
+            if (((rangeFromBlock$1 + (chunkSize$1 << 1) | 0) - 1 | 0) <= maxBlock$1) {
+              queries.push({
+                    partitionId: partitionId,
+                    fromBlock: rangeFromBlock$1,
+                    toBlock: (rangeFromBlock$1 + chunkSize$1 | 0) - 1 | 0,
+                    isChunk: true,
+                    selection: selection$1,
+                    addressesByContractName: addressesByContractName$1,
+                    indexingContracts: indexingContracts
+                  });
+              queries.push({
+                    partitionId: partitionId,
+                    fromBlock: rangeFromBlock$1 + chunkSize$1 | 0,
+                    toBlock: (rangeFromBlock$1 + (chunkSize$1 << 1) | 0) - 1 | 0,
+                    isChunk: true,
+                    selection: selection$1,
+                    addressesByContractName: addressesByContractName$1,
+                    indexingContracts: indexingContracts
+                  });
+            } else {
+              queries.push({
+                    partitionId: partitionId,
+                    fromBlock: rangeFromBlock$1,
+                    toBlock: queryEndBlock$2,
+                    isChunk: queryEndBlock$2 !== undefined,
+                    selection: selection$1,
+                    addressesByContractName: addressesByContractName$1,
+                    indexingContracts: indexingContracts
+                  });
+            }
           } else {
-            registerPartitionQuery(match, undefined);
+            queries.push({
+                  partitionId: partitionId,
+                  fromBlock: rangeFromBlock$1,
+                  toBlock: queryEndBlock$2,
+                  isChunk: false,
+                  selection: selection$1,
+                  addressesByContractName: addressesByContractName$1,
+                  indexingContracts: indexingContracts
+                });
           }
-        } else {
-          Js_exn.raiseError("Unexpected case, should always have a most behind partition.");
         }
+        
       }
       
-    } else {
-      var p$1 = mergingPartitions[0];
-      registerPartitionQuery(p$1, undefined);
     }
-  }
+    idxRef = idxRef + 1 | 0;
+  };
   if (Utils.$$Array.isEmpty(queries)) {
     if (shouldWaitForNewBlock) {
       return "WaitingForNewBlock";
     } else {
       return "NothingToQuery";
     }
-  } else {
-    return {
-            TAG: "Ready",
-            _0: queries.length > concurrencyLimit ? queries.sort(function (a, b) {
-                      return a.fromBlock - b.fromBlock | 0;
-                    }).slice(0, concurrencyLimit) : queries
-          };
   }
+  var queries$1 = queries.length > concurrencyLimit ? (queries.sort(function (a, b) {
+            return a.fromBlock - b.fromBlock | 0;
+          }), queries.slice(0, concurrencyLimit)) : queries;
+  return {
+          TAG: "Ready",
+          _0: queries$1
+        };
 }
 
 function getTimestampAt(fetchState, index) {
@@ -690,33 +1145,22 @@ function getTimestampAt(fetchState, index) {
     } else {
       return Js_exn.raiseError("Block handlers are not supported for ordered multichain mode.");
     }
+  } else {
+    return bufferBlock(fetchState).blockTimestamp;
   }
-  var latestOnBlockBlockNumber = fetchState.latestOnBlockBlockNumber;
-  var latestFullyFetchedBlock = fetchState.latestFullyFetchedBlock;
-  return (
-          latestOnBlockBlockNumber < latestFullyFetchedBlock.blockNumber ? ({
-                blockNumber: latestOnBlockBlockNumber,
-                blockTimestamp: 0
-              }) : latestFullyFetchedBlock
-        ).blockTimestamp;
 }
 
 function hasReadyItem(fetchState) {
   var item = Belt_Array.get(fetchState.buffer, 0);
-  if (item === undefined) {
+  if (item !== undefined) {
+    return item.blockNumber <= bufferBlockNumber(fetchState);
+  } else {
     return false;
   }
-  var latestOnBlockBlockNumber = fetchState.latestOnBlockBlockNumber;
-  var latestFullyFetchedBlock = fetchState.latestFullyFetchedBlock;
-  return item.blockNumber <= (
-          latestOnBlockBlockNumber < latestFullyFetchedBlock.blockNumber ? latestOnBlockBlockNumber : latestFullyFetchedBlock.blockNumber
-        );
 }
 
 function getReadyItemsCount(fetchState, targetSize, fromItem) {
-  var latestOnBlockBlockNumber = fetchState.latestOnBlockBlockNumber;
-  var latestFullyFetchedBlock = fetchState.latestFullyFetchedBlock;
-  var readyBlockNumber = latestOnBlockBlockNumber < latestFullyFetchedBlock.blockNumber ? latestOnBlockBlockNumber : latestFullyFetchedBlock.blockNumber;
+  var readyBlockNumber = bufferBlockNumber(fetchState);
   var acc = 0;
   var isFinished = false;
   while(!isFinished) {
@@ -739,10 +1183,11 @@ function getReadyItemsCount(fetchState, targetSize, fromItem) {
   return acc;
 }
 
-function make(startBlock, endBlock, eventConfigs, contracts, maxAddrInPartition, chainId, targetBufferSize, progressBlockNumberOpt, onBlockConfigsOpt, blockLagOpt) {
+function make$1(startBlock, endBlock, eventConfigs, contracts, maxAddrInPartition, chainId, targetBufferSize, knownHeight, progressBlockNumberOpt, onBlockConfigsOpt, blockLagOpt, firstEventBlockOpt) {
   var progressBlockNumber = progressBlockNumberOpt !== undefined ? progressBlockNumberOpt : startBlock - 1 | 0;
   var onBlockConfigs = onBlockConfigsOpt !== undefined ? onBlockConfigsOpt : [];
   var blockLag = blockLagOpt !== undefined ? blockLagOpt : 0;
+  var firstEventBlock = firstEventBlockOpt !== undefined ? Caml_option.valFromOption(firstEventBlockOpt) : undefined;
   var latestFetchedBlock = {
     blockNumber: progressBlockNumber,
     blockTimestamp: 0
@@ -774,83 +1219,69 @@ function make(startBlock, endBlock, eventConfigs, contracts, maxAddrInPartition,
   if (notDependingOnAddresses.length !== 0) {
     partitions.push({
           id: String(partitions.length),
-          status: {
-            fetchingStateId: undefined
-          },
           latestFetchedBlock: latestFetchedBlock,
           selection: {
             eventConfigs: notDependingOnAddresses,
             dependsOnAddresses: false
           },
-          addressesByContractName: {}
+          addressesByContractName: {},
+          mergeBlock: undefined,
+          dynamicContract: undefined,
+          mutPendingQueries: [],
+          prevQueryRange: 0,
+          prevPrevQueryRange: 0,
+          latestBlockRangeUpdateBlock: 0
         });
   }
   var normalSelection = {
     eventConfigs: normalEventConfigs,
     dependsOnAddresses: true
   };
+  var registeringContractsByContract = {};
+  var dynamicContracts = new Set();
   if (normalEventConfigs.length !== 0) {
-    var makePendingNormalPartition = function () {
-      return {
-              id: String(partitions.length),
-              status: {
-                fetchingStateId: undefined
-              },
-              latestFetchedBlock: latestFetchedBlock,
-              selection: normalSelection,
-              addressesByContractName: {}
-            };
-    };
-    var pendingNormalPartition = {
-      contents: makePendingNormalPartition()
-    };
     Belt_Array.forEach(contracts, (function (contract) {
             var contractName = contract.contractName;
             if (!contractNamesWithNormalEvents.has(contractName)) {
               return ;
             }
-            var pendingPartition = pendingNormalPartition.contents;
-            Utils.Dict.push(pendingPartition.addressesByContractName, contractName, contract.address);
+            var registeringContracts = Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, contractName);
+            registeringContracts[contract.address] = contract;
             indexingContracts[contract.address] = contract;
-            if (addressesByContractNameCount(pendingPartition.addressesByContractName) === maxAddrInPartition) {
-              partitions.push(pendingPartition);
-              pendingNormalPartition.contents = makePendingNormalPartition();
+            if (contract.registrationBlock !== undefined) {
+              dynamicContracts.add(contractName);
               return ;
             }
             
           }));
-    if (addressesByContractNameCount(pendingNormalPartition.contents.addressesByContractName) > 0) {
-      partitions.push(pendingNormalPartition.contents);
-    }
-    
   }
-  if (partitions.length === 0) {
-    Js_exn.raiseError("Invalid configuration: Nothing to fetch. Make sure that you provided at least one contract address to index, or have events with Wildcard mode enabled.");
+  var optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, contractConfigs, dynamicContracts, normalSelection, maxAddrInPartition, partitions.length, partitions, progressBlockNumber);
+  if (optimizedPartitions.idsInAscOrder.length === 0 && Utils.$$Array.isEmpty(onBlockConfigs)) {
+    Js_exn.raiseError("Invalid configuration: Nothing to fetch. Make sure that you provided at least one contract address to index, or have events with Wildcard mode enabled, or have onBlock handlers.");
   }
   var numAddresses = Object.keys(indexingContracts).length;
   Prometheus.IndexingAddresses.set(numAddresses, chainId);
-  Prometheus.IndexingPartitions.set(partitions.length, chainId);
+  Prometheus.IndexingPartitions.set(optimizedPartitions.idsInAscOrder.length, chainId);
   Prometheus.IndexingBufferSize.set(0, chainId);
   Prometheus.IndexingBufferBlockNumber.set(progressBlockNumber, chainId);
   if (endBlock !== undefined) {
     Prometheus.IndexingEndBlock.set(endBlock, chainId);
   }
   return {
-          partitions: partitions,
-          nextPartitionIndex: partitions.length,
+          optimizedPartitions: optimizedPartitions,
           startBlock: startBlock,
           endBlock: endBlock,
-          maxAddrInPartition: maxAddrInPartition,
           normalSelection: normalSelection,
           indexingContracts: indexingContracts,
           contractConfigs: contractConfigs,
           chainId: chainId,
-          latestFullyFetchedBlock: latestFetchedBlock,
           latestOnBlockBlockNumber: progressBlockNumber,
           blockLag: blockLag,
           buffer: [],
           targetBufferSize: targetBufferSize,
-          onBlockConfigs: onBlockConfigs
+          onBlockConfigs: onBlockConfigs,
+          knownHeight: knownHeight,
+          firstEventBlock: firstEventBlock
         };
 }
 
@@ -858,47 +1289,33 @@ function bufferSize(param) {
   return param.buffer.length;
 }
 
-function rollbackPartition(p, targetBlockNumber, addressesToRemove) {
-  var shouldRollbackFetched = p.latestFetchedBlock.blockNumber > targetBlockNumber;
-  var latestFetchedBlock = shouldRollbackFetched ? ({
-        blockNumber: targetBlockNumber,
-        blockTimestamp: 0
-      }) : p.latestFetchedBlock;
-  if (!p.selection.dependsOnAddresses) {
-    return {
-            id: p.id,
-            status: {
-              fetchingStateId: undefined
-            },
-            latestFetchedBlock: latestFetchedBlock,
-            selection: p.selection,
-            addressesByContractName: p.addressesByContractName
-          };
-  }
-  var rollbackedAddressesByContractName = {};
-  Utils.Dict.forEachWithKey(p.addressesByContractName, (function (addresses, contractName) {
-          var keptAddresses = Belt_Array.keep(addresses, (function (address) {
-                  return !addressesToRemove.has(address);
-                }));
-          if (keptAddresses.length !== 0) {
-            rollbackedAddressesByContractName[contractName] = keptAddresses;
-            return ;
-          }
-          
-        }));
-  if (Object.keys(rollbackedAddressesByContractName).length === 0) {
-    return ;
-  } else {
-    return {
-            id: p.id,
-            status: {
-              fetchingStateId: undefined
-            },
-            latestFetchedBlock: latestFetchedBlock,
-            selection: p.selection,
-            addressesByContractName: rollbackedAddressesByContractName
-          };
+function rollbackPendingQueries(mutPendingQueries, targetBlockNumber) {
+  var adjusted = [];
+  for(var qIdx = 0 ,qIdx_finish = mutPendingQueries.length; qIdx < qIdx_finish; ++qIdx){
+    var pq = mutPendingQueries[qIdx];
+    if (pq.fromBlock <= targetBlockNumber) {
+      var match = pq.fetchedBlock;
+      if (match !== undefined) {
+        if (match.blockNumber > targetBlockNumber) {
+          adjusted.push({
+                fromBlock: pq.fromBlock,
+                toBlock: pq.toBlock,
+                isChunk: pq.isChunk,
+                fetchedBlock: {
+                  blockNumber: targetBlockNumber,
+                  blockTimestamp: 0
+                }
+              });
+        } else {
+          adjusted.push(pq);
+        }
+      } else {
+        Js_exn.raiseError("Internal error: Must not have a fetching query during rollback");
+      }
+    }
+    
   }
+  return adjusted;
 }
 
 function rollback(fetchState, targetBlockNumber) {
@@ -913,30 +1330,147 @@ function rollback(fetchState, targetBlockNumber) {
             indexingContracts[address] = indexingContract;
           }
         }));
-  var partitions = Belt_Array.keepMap(fetchState.partitions, (function (p) {
-          return rollbackPartition(p, targetBlockNumber, addressesToRemove);
-        }));
+  var keptPartitions = [];
+  var nextKeptIdRef = 0;
+  var registeringContractsByContract = {};
+  var partitions = Js_dict.values(fetchState.optimizedPartitions.entities);
+  for(var idx = 0 ,idx_finish = partitions.length; idx < idx_finish; ++idx){
+    var p = partitions[idx];
+    if (p.selection.dependsOnAddresses) {
+      if (p.latestFetchedBlock.blockNumber > targetBlockNumber) {
+        Utils.Dict.forEachWithKey(p.addressesByContractName, (function (addresses, contractName) {
+                Belt_Array.forEach(addresses, (function (address) {
+                        if (!(!addressesToRemove.has(address) && Belt_Option.isSome(indexingContracts[address]))) {
+                          return ;
+                        }
+                        var registeringContracts = Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, contractName);
+                        registeringContracts[address] = indexingContracts[address];
+                      }));
+              }));
+      } else {
+        var mergeBlock = p.mergeBlock;
+        var mergeBlock$1 = mergeBlock !== undefined && mergeBlock > targetBlockNumber ? targetBlockNumber : mergeBlock;
+        var rollbackedAddressesByContractName = {};
+        Utils.Dict.forEachWithKey(p.addressesByContractName, (function(rollbackedAddressesByContractName){
+            return function (addresses, contractName) {
+              var keptAddresses = Belt_Array.keep(addresses, (function (address) {
+                      return !addressesToRemove.has(address);
+                    }));
+              if (keptAddresses.length !== 0) {
+                rollbackedAddressesByContractName[contractName] = keptAddresses;
+                return ;
+              }
+              
+            }
+            }(rollbackedAddressesByContractName)));
+        if (Object.keys(rollbackedAddressesByContractName).length !== 0) {
+          var id = String(nextKeptIdRef);
+          nextKeptIdRef = nextKeptIdRef + 1 | 0;
+          keptPartitions.push({
+                id: id,
+                latestFetchedBlock: p.latestFetchedBlock,
+                selection: p.selection,
+                addressesByContractName: rollbackedAddressesByContractName,
+                mergeBlock: mergeBlock$1,
+                dynamicContract: p.dynamicContract,
+                mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, targetBlockNumber),
+                prevQueryRange: p.prevQueryRange,
+                prevPrevQueryRange: p.prevPrevQueryRange,
+                latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+              });
+        }
+        
+      }
+    } else {
+      var id$1 = String(nextKeptIdRef);
+      nextKeptIdRef = nextKeptIdRef + 1 | 0;
+      keptPartitions.push({
+            id: id$1,
+            latestFetchedBlock: p.latestFetchedBlock.blockNumber > targetBlockNumber ? ({
+                  blockNumber: targetBlockNumber,
+                  blockTimestamp: 0
+                }) : p.latestFetchedBlock,
+            selection: p.selection,
+            addressesByContractName: p.addressesByContractName,
+            mergeBlock: p.mergeBlock,
+            dynamicContract: p.dynamicContract,
+            mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, targetBlockNumber),
+            prevQueryRange: p.prevQueryRange,
+            prevPrevQueryRange: p.prevPrevQueryRange,
+            latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+          });
+    }
+  }
+  var optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, fetchState.contractConfigs, fetchState.optimizedPartitions.dynamicContracts, fetchState.normalSelection, fetchState.optimizedPartitions.maxAddrInPartition, nextKeptIdRef, keptPartitions, targetBlockNumber);
   return updateInternal({
-              partitions: fetchState.partitions,
-              nextPartitionIndex: fetchState.nextPartitionIndex,
+              optimizedPartitions: fetchState.optimizedPartitions,
               startBlock: fetchState.startBlock,
               endBlock: fetchState.endBlock,
-              maxAddrInPartition: fetchState.maxAddrInPartition,
               normalSelection: fetchState.normalSelection,
               indexingContracts: fetchState.indexingContracts,
               contractConfigs: fetchState.contractConfigs,
               chainId: fetchState.chainId,
-              latestFullyFetchedBlock: fetchState.latestFullyFetchedBlock,
-              latestOnBlockBlockNumber: targetBlockNumber,
+              latestOnBlockBlockNumber: fetchState.latestOnBlockBlockNumber < targetBlockNumber ? fetchState.latestOnBlockBlockNumber : targetBlockNumber,
               blockLag: fetchState.blockLag,
               buffer: fetchState.buffer,
               targetBufferSize: fetchState.targetBufferSize,
-              onBlockConfigs: fetchState.onBlockConfigs
-            }, partitions, undefined, indexingContracts, Belt_Array.keep(fetchState.buffer, (function (item) {
+              onBlockConfigs: fetchState.onBlockConfigs,
+              knownHeight: fetchState.knownHeight,
+              firstEventBlock: fetchState.firstEventBlock
+            }, optimizedPartitions, indexingContracts, Belt_Array.keep(fetchState.buffer, (function (item) {
                     var tmp;
                     tmp = item.kind === 0 ? item.blockNumber : item.blockNumber;
                     return tmp <= targetBlockNumber;
-                  })), undefined);
+                  })), undefined, undefined);
+}
+
+function resetPendingQueries(fetchState) {
+  var newEntities = Utils.Dict.shallowCopy(fetchState.optimizedPartitions.entities);
+  for(var idx = 0 ,idx_finish = fetchState.optimizedPartitions.idsInAscOrder.length; idx < idx_finish; ++idx){
+    var partitionId = fetchState.optimizedPartitions.idsInAscOrder[idx];
+    var partition = fetchState.optimizedPartitions.entities[partitionId];
+    if (partition.mutPendingQueries.length !== 0) {
+      var kept = Belt_Array.keep(partition.mutPendingQueries, (function (pq) {
+              return pq.fetchedBlock !== undefined;
+            }));
+      newEntities[partitionId] = {
+        id: partition.id,
+        latestFetchedBlock: partition.latestFetchedBlock,
+        selection: partition.selection,
+        addressesByContractName: partition.addressesByContractName,
+        mergeBlock: partition.mergeBlock,
+        dynamicContract: partition.dynamicContract,
+        mutPendingQueries: kept,
+        prevQueryRange: partition.prevQueryRange,
+        prevPrevQueryRange: partition.prevPrevQueryRange,
+        latestBlockRangeUpdateBlock: partition.latestBlockRangeUpdateBlock
+      };
+    }
+    
+  }
+  var init = fetchState.optimizedPartitions;
+  return {
+          optimizedPartitions: {
+            idsInAscOrder: init.idsInAscOrder,
+            entities: newEntities,
+            maxAddrInPartition: init.maxAddrInPartition,
+            nextPartitionIndex: init.nextPartitionIndex,
+            dynamicContracts: init.dynamicContracts
+          },
+          startBlock: fetchState.startBlock,
+          endBlock: fetchState.endBlock,
+          normalSelection: fetchState.normalSelection,
+          indexingContracts: fetchState.indexingContracts,
+          contractConfigs: fetchState.contractConfigs,
+          chainId: fetchState.chainId,
+          latestOnBlockBlockNumber: fetchState.latestOnBlockBlockNumber,
+          blockLag: fetchState.blockLag,
+          buffer: fetchState.buffer,
+          targetBufferSize: fetchState.targetBufferSize,
+          onBlockConfigs: fetchState.onBlockConfigs,
+          knownHeight: fetchState.knownHeight,
+          firstEventBlock: fetchState.firstEventBlock
+        };
 }
 
 function isActivelyIndexing(fetchState) {
@@ -944,11 +1478,7 @@ function isActivelyIndexing(fetchState) {
   if (endBlock === undefined) {
     return true;
   }
-  var latestOnBlockBlockNumber = fetchState.latestOnBlockBlockNumber;
-  var latestFullyFetchedBlock = fetchState.latestFullyFetchedBlock;
-  var isPastEndblock = (
-    latestOnBlockBlockNumber < latestFullyFetchedBlock.blockNumber ? latestOnBlockBlockNumber : latestFullyFetchedBlock.blockNumber
-  ) >= endBlock;
+  var isPastEndblock = bufferBlockNumber(fetchState) >= endBlock;
   if (isPastEndblock) {
     return bufferSize(fetchState) > 0;
   } else {
@@ -956,14 +1486,13 @@ function isActivelyIndexing(fetchState) {
   }
 }
 
-function isReadyToEnterReorgThreshold(fetchState, currentBlockHeight) {
+function isReadyToEnterReorgThreshold(fetchState) {
+  var knownHeight = fetchState.knownHeight;
   var blockLag = fetchState.blockLag;
   var endBlock = fetchState.endBlock;
-  var latestOnBlockBlockNumber = fetchState.latestOnBlockBlockNumber;
-  var latestFullyFetchedBlock = fetchState.latestFullyFetchedBlock;
-  var bufferBlockNumber = latestOnBlockBlockNumber < latestFullyFetchedBlock.blockNumber ? latestOnBlockBlockNumber : latestFullyFetchedBlock.blockNumber;
-  if (currentBlockHeight !== 0 && (
-      endBlock !== undefined && bufferBlockNumber >= endBlock ? true : bufferBlockNumber >= (currentBlockHeight - blockLag | 0)
+  var bufferBlockNumber$1 = bufferBlockNumber(fetchState);
+  if (knownHeight !== 0 && (
+      endBlock !== undefined && bufferBlockNumber$1 >= endBlock ? true : bufferBlockNumber$1 >= (knownHeight - blockLag | 0)
     )) {
     return Utils.$$Array.isEmpty(fetchState.buffer);
   } else {
@@ -973,109 +1502,103 @@ function isReadyToEnterReorgThreshold(fetchState, currentBlockHeight) {
 
 function hasFullBatch(fetchState, batchSizeTarget) {
   var item = Belt_Array.get(fetchState.buffer, batchSizeTarget - 1 | 0);
-  if (item === undefined) {
+  if (item !== undefined) {
+    return item.blockNumber <= bufferBlockNumber(fetchState);
+  } else {
     return false;
   }
-  var latestOnBlockBlockNumber = fetchState.latestOnBlockBlockNumber;
-  var latestFullyFetchedBlock = fetchState.latestFullyFetchedBlock;
-  return item.blockNumber <= (
-          latestOnBlockBlockNumber < latestFullyFetchedBlock.blockNumber ? latestOnBlockBlockNumber : latestFullyFetchedBlock.blockNumber
-        );
+}
+
+function getProgressPercentage(fetchState) {
+  var firstEventBlock = fetchState.firstEventBlock;
+  if (firstEventBlock === undefined) {
+    return 0;
+  }
+  var totalRange = fetchState.knownHeight - firstEventBlock | 0;
+  if (totalRange <= 0) {
+    return 0;
+  }
+  var item = Belt_Array.get(fetchState.buffer, 0);
+  var progress = item !== undefined ? item.blockNumber - firstEventBlock | 0 : bufferBlockNumber(fetchState) - firstEventBlock | 0;
+  return progress / totalRange;
 }
 
 function sortForUnorderedBatch(fetchStates, batchSizeTarget) {
   return fetchStates.slice(0).sort(function (a, b) {
               var match = hasFullBatch(a, batchSizeTarget);
               var match$1 = hasFullBatch(b, batchSizeTarget);
-              var exit = 0;
               if (match) {
                 if (!match$1) {
                   return -1;
                 }
-                exit = 1;
-              } else {
-                if (match$1) {
-                  return 1;
-                }
-                exit = 1;
-              }
-              if (exit === 1) {
-                var match$2 = Belt_Array.get(a.buffer, 0);
-                var match$3 = Belt_Array.get(b.buffer, 0);
-                var exit$1 = 0;
-                if (match$2 !== undefined) {
-                  if (match$2.kind !== 0) {
-                    return Js_math.random_int(-1, 1);
-                  }
-                  if (match$3 === undefined) {
-                    return -1;
-                  }
-                  if (match$3.kind === 0) {
-                    return match$2.timestamp - match$3.timestamp | 0;
-                  }
-                  exit$1 = 2;
-                } else {
-                  if (match$3 === undefined) {
-                    return 0;
-                  }
-                  exit$1 = 2;
-                }
-                if (exit$1 === 2) {
-                  if (match$3.kind === 0) {
-                    return 1;
-                  } else {
-                    return Js_math.random_int(-1, 1);
-                  }
-                }
                 
+              } else if (match$1) {
+                return 1;
+              }
+              var aProgress = getProgressPercentage(a);
+              var bProgress = getProgressPercentage(b);
+              if (aProgress < bProgress) {
+                return -1;
+              } else if (aProgress > bProgress) {
+                return 1;
+              } else {
+                return 0;
               }
-              
             });
 }
 
 function getUnorderedMultichainProgressBlockNumberAt(fetchState, index) {
-  var latestOnBlockBlockNumber = fetchState.latestOnBlockBlockNumber;
-  var latestFullyFetchedBlock = fetchState.latestFullyFetchedBlock;
-  var bufferBlockNumber = latestOnBlockBlockNumber < latestFullyFetchedBlock.blockNumber ? latestOnBlockBlockNumber : latestFullyFetchedBlock.blockNumber;
+  var bufferBlockNumber$1 = bufferBlockNumber(fetchState);
   var item = Belt_Array.get(fetchState.buffer, index);
-  if (item !== undefined && bufferBlockNumber >= item.blockNumber) {
+  if (item !== undefined && bufferBlockNumber$1 >= item.blockNumber) {
     return item.blockNumber - 1 | 0;
   } else {
-    return bufferBlockNumber;
+    return bufferBlockNumber$1;
+  }
+}
+
+function updateKnownHeight(fetchState, knownHeight) {
+  if (knownHeight > fetchState.knownHeight) {
+    Prometheus.IndexingKnownHeight.set(knownHeight, fetchState.chainId);
+    return updateInternal(fetchState, undefined, undefined, undefined, undefined, knownHeight);
+  } else {
+    return fetchState;
   }
 }
 
 var blockItemLogIndex = 16777216;
 
 export {
-  mergeIntoPartition ,
+  getMinHistoryRange ,
+  getMinQueryRange ,
+  OptimizedPartitions ,
   bufferBlockNumber ,
   bufferBlock ,
   compareBufferItem ,
   blockItemLogIndex ,
-  updateInternal ,
   numAddresses ,
+  updateInternal ,
   warnDifferentContractType ,
+  addressesByContractNameCount ,
+  addressesByContractNameGetAll ,
+  createPartitionsFromIndexingAddresses ,
   registerDynamicContracts ,
-  UnexpectedPartitionNotFound ,
-  UnexpectedMergeQueryResponse ,
   handleQueryResult ,
-  makePartitionQuery ,
   startFetchingQueries ,
-  addressesByContractNameCount ,
-  addressesByContractNameGetAll ,
-  isFullPartition ,
+  pushQueriesForRange ,
   getNextQuery ,
   getTimestampAt ,
   hasReadyItem ,
   getReadyItemsCount ,
-  make ,
+  make$1 as make,
   bufferSize ,
-  rollbackPartition ,
+  rollbackPendingQueries ,
   rollback ,
+  resetPendingQueries ,
   isActivelyIndexing ,
   isReadyToEnterReorgThreshold ,
   sortForUnorderedBatch ,
   getUnorderedMultichainProgressBlockNumberAt ,
+  updateKnownHeight ,
 }
 /* Utils Not a pure module */