envio 3.0.0-alpha.2 → 3.0.0-alpha.21

package/src/FetchState.res

@@ -11,7 +11,15 @@ type blockNumberAndLogIndex = {blockNumber: int, logIndex: int}
 
 type selection = {eventConfigs: array<Internal.eventConfig>, dependsOnAddresses: bool}
 
-type status = {mutable fetchingStateId: option<int>}
+type pendingQuery = {
+  fromBlock: int,
+  toBlock: option<int>,
+  isChunk: bool,
+  // Stores latestFetchedBlock when query completes. Only needed to persist
+  // timestamp while earlier queries are still pending before updating
+  // the partition's latestFetchedBlock.
+  mutable fetchedBlock: option<blockNumberAndTimestamp>,
+}
 
 /**
 A state that holds a queue of events and data regarding what to fetch next
@@ -21,20 +29,450 @@ the are getting merged until the maxAddrInPartition is reached.
 */
 type partition = {
   id: string,
-  status: status,
+  // The block number of the latest fetched query
+  // which added all its events to the queue
   latestFetchedBlock: blockNumberAndTimestamp,
   selection: selection,
   addressesByContractName: dict<array<Address.t>>,
+  mergeBlock: option<int>,
+  // When set, partition indexes a single dynamic contract type.
+  // The addressesByContractName must contain only addresses for this contract.
+  dynamicContract: option<string>,
+  // Mutable array for SourceManager sync - queries exist only while being fetched
+  mutPendingQueries: array<pendingQuery>,
+  // Track last 3 successful query ranges for chunking heuristic (0 means no data)
+  prevQueryRange: int,
+  prevPrevQueryRange: int,
+  // Tracks the latestFetchedBlock.blockNumber of the most recent response
+  // that updated prevQueryRange. Prevents degradation of the chunking heuristic
+  // when parallel query responses arrive out of order.
+  latestBlockRangeUpdateBlock: int,
+}
+
+type query = {
+  partitionId: string,
+  fromBlock: int,
+  toBlock: option<int>,
+  isChunk: bool,
+  selection: selection,
+  addressesByContractName: dict<array<Address.t>>,
+  indexingContracts: dict<Internal.indexingContract>,
+}
+
+// Calculate the chunk range from history using min-of-last-3-ranges heuristic
+let getMinHistoryRange = (p: partition) => {
+  switch (p.prevQueryRange, p.prevPrevQueryRange) {
+  | (0, _) | (_, 0) => None
+  | (a, b) => Some(a < b ? a : b)
+  }
+}
+
+let getMinQueryRange = (partitions: array<partition>) => {
+  let min = ref(0)
+  for i in 0 to partitions->Array.length - 1 {
+    let p = partitions->Js.Array2.unsafe_get(i)
+    let a = p.prevQueryRange
+    let b = p.prevPrevQueryRange
+    if a > 0 && (min.contents == 0 || a < min.contents) {
+      min := a
+    }
+    if b > 0 && (min.contents == 0 || b < min.contents) {
+      min := b
+    }
+  }
+  min.contents
+}
+
+module OptimizedPartitions = {
+  type t = {
+    idsInAscOrder: array<string>,
+    entities: dict<partition>, // hello redux-toolkit :)
+    // Used for the incremental partition id. Can't use the partitions length,
+    // since partitions might be deleted on merge or cleaned up
+    maxAddrInPartition: int,
+    nextPartitionIndex: int,
+    // Tracks all contract names that have been dynamically added.
+    // Never reset - used to determine when to split existing partitions.
+    dynamicContracts: Utils.Set.t<string>,
+  }
+
+  @inline
+  let count = (optimizedPartitions: t) => optimizedPartitions.idsInAscOrder->Array.length
+
+  @inline
+  let getOrThrow = (optimizedPartitions: t, ~partitionId) => {
+    switch optimizedPartitions.entities->Js.Dict.get(partitionId) {
+    | Some(p) => p
+    | None => Js.Exn.raiseError(`Unexpected case: Couldn't find partition ${partitionId}`)
+    }
+  }
+
+  // Merges two partitions at a given potentialMergeBlock.
+  // Returns array<partition> where the last element is the continuing partition
+  // and all preceding elements are completed (have mergeBlock set).
+  // Handles address overflow splitting inline.
+  let mergePartitionsAtBlock = (
+    ~p1: partition,
+    ~p2: partition,
+    ~potentialMergeBlock: int,
+    ~contractName: string,
+    ~maxAddrInPartition: int,
+    ~nextPartitionIndexRef: ref<int>,
+  ) => {
+    let combinedAddresses =
+      p1.addressesByContractName
+      ->Js.Dict.unsafeGet(contractName)
+      ->Js.Array2.concat(p2.addressesByContractName->Js.Dict.unsafeGet(contractName))
+
+    let p1Below = p1.latestFetchedBlock.blockNumber < potentialMergeBlock
+    let p2Below = p2.latestFetchedBlock.blockNumber < potentialMergeBlock
+
+    // Build the continuing partition (at potentialMergeBlock with combined addresses),
+    // collecting completed partitions (with mergeBlock) along the way
+    let completed = []
+    let continuingBase = switch (p1Below, p2Below) {
+    | (false, false) => p1
+    | (false, true) =>
+      completed->Js.Array2.push({...p2, mergeBlock: Some(potentialMergeBlock)})->ignore
+      p1
+    | (true, false) =>
+      completed->Js.Array2.push({...p1, mergeBlock: Some(potentialMergeBlock)})->ignore
+      p2
+    | (true, true) =>
+      completed->Js.Array2.push({...p1, mergeBlock: Some(potentialMergeBlock)})->ignore
+      completed->Js.Array2.push({...p2, mergeBlock: Some(potentialMergeBlock)})->ignore
+      let newId = nextPartitionIndexRef.contents->Js.Int.toString
+      nextPartitionIndexRef := nextPartitionIndexRef.contents + 1
+      let minRange = getMinQueryRange([p1, p2])
+      {
+        id: newId,
+        dynamicContract: Some(contractName),
+        selection: p1.selection,
+        latestFetchedBlock: {blockNumber: potentialMergeBlock, blockTimestamp: 0},
+        mergeBlock: None,
+        addressesByContractName: Js.Dict.empty(), // set below
+        mutPendingQueries: [],
+        prevQueryRange: minRange,
+        prevPrevQueryRange: minRange,
+        latestBlockRangeUpdateBlock: 0,
+      }
+    }
+
+    // Apply address split on the continuing partition
+    if combinedAddresses->Js.Array2.length > maxAddrInPartition {
+      let addressesFull = combinedAddresses->Js.Array2.slice(~start=0, ~end_=maxAddrInPartition)
+      let addressesRest = combinedAddresses->Js.Array2.sliceFrom(maxAddrInPartition)
+      let abcFull = Js.Dict.empty()
+      abcFull->Js.Dict.set(contractName, addressesFull)
+      let abcRest = Js.Dict.empty()
+      abcRest->Js.Dict.set(contractName, addressesRest)
+      completed->Js.Array2.push({...continuingBase, addressesByContractName: abcFull})->ignore
+      let restId = nextPartitionIndexRef.contents->Js.Int.toString
+      nextPartitionIndexRef := nextPartitionIndexRef.contents + 1
+      completed
+      ->Js.Array2.push({
+        ...continuingBase,
+        id: restId,
+        addressesByContractName: abcRest,
+        mutPendingQueries: [],
+      })
+      ->ignore
+      completed
+    } else {
+      let abc = Js.Dict.empty()
+      abc->Js.Dict.set(contractName, combinedAddresses)
+      completed->Js.Array2.push({...continuingBase, addressesByContractName: abc})->ignore
+      completed
+    }
+  }
+
+  // Random number from my head
+  // Not super critical if it's too big or too small
+  // We optimize for fastest data which we get in any case.
+  // If the value is off, it'll only result in
+  // quering the same block range multiple times
+  let tooFarBlockRange = 20_000
+
+  let ascSortFn = (a, b) => a.latestFetchedBlock.blockNumber - b.latestFetchedBlock.blockNumber
+
+  /**
+   * Optimizes partitions by finding opportunities to merge partitions that
+   * are behind other partitions with same/superset of contract names.
+   *
+   * Only partitions with dynamicContract set are eligible for optimization.
+   * This way we don't have optimization overhead when partitions are stable.
+   */
+  let make = (
+    ~partitions: array<partition>,
+    ~maxAddrInPartition,
+    ~nextPartitionIndex: int,
+    ~dynamicContracts: Utils.Set.t<string>,
+  ) => {
+    let newPartitions = []
+    let mergingPartitions = Js.Dict.empty()
+    let nextPartitionIndexRef = ref(nextPartitionIndex)
+
+    for idx in 0 to partitions->Array.length - 1 {
+      let p = partitions->Js.Array2.unsafe_get(idx)
+      switch p {
+      // Since it's not a dynamic contract partition,
+      // there's no need for merge logic
+      | {dynamicContract: None}
+      | // Wildcard doesn't need merging
+      {selection: {dependsOnAddresses: false}}
+      | // For now don't merge partitions with mergeBlock,
+      // assuming they are already merged,
+      // TODO: Although there might be cases with too far away mergeBlock,
+      // which is worth merging
+      {mergeBlock: Some(_)} =>
+        newPartitions->Js.Array2.push(p)->ignore
+      | {dynamicContract: Some(contractName)} =>
+        let pAddressesCount =
+          p.addressesByContractName->Js.Dict.unsafeGet(contractName)->Js.Array2.length
+        // Compute merge block: last pending query's toBlock, or lfb if idle
+        let potentialMergeBlock = switch p.mutPendingQueries->Utils.Array.last {
+        | Some({isChunk: true, toBlock: Some(toBlock)}) => Some(toBlock)
+        | Some(_) => None // unbounded query -- can't merge
+        | None => Some(p.latestFetchedBlock.blockNumber)
+        }
+        switch potentialMergeBlock {
+        | None => newPartitions->Js.Array2.push(p)->ignore
+        | Some(potentialMergeBlock) =>
+          if pAddressesCount >= maxAddrInPartition {
+            newPartitions->Js.Array2.push(p)->ignore
+          } else {
+            let partitionsByMergeBlock =
+              mergingPartitions->Utils.Dict.getOrInsertEmptyDict(contractName)
+            switch partitionsByMergeBlock->Utils.Dict.dangerouslyGetByIntNonOption(
+              potentialMergeBlock,
+            ) {
+            | Some(existingPartition) =>
+              let result = mergePartitionsAtBlock(
+                ~p1=existingPartition,
+                ~p2=p,
+                ~potentialMergeBlock,
+                ~contractName,
+                ~maxAddrInPartition,
+                ~nextPartitionIndexRef,
+              )
+              for i in 0 to result->Array.length - 2 {
+                newPartitions->Js.Array2.push(result->Js.Array2.unsafe_get(i))->ignore
+              }
+              partitionsByMergeBlock->Utils.Dict.setByInt(
+                potentialMergeBlock,
+                result->Utils.Array.lastUnsafe,
+              )
+            | None => partitionsByMergeBlock->Utils.Dict.setByInt(potentialMergeBlock, p)
+            }
+          }
+        }
+      }
+    }
+
+    let merginDynamicContracts = mergingPartitions->Js.Dict.keys
+    for idx in 0 to merginDynamicContracts->Array.length - 1 {
+      let contractName = merginDynamicContracts->Js.Array2.unsafe_get(idx)
+      let partitionsByMergeBlock = mergingPartitions->Js.Dict.unsafeGet(contractName)
+      // JS engine automatically sorts number keys in objects
+      let ascPartitionKeys = partitionsByMergeBlock->Js.Dict.keys
+
+      // But -1 is placed last...
+      if ascPartitionKeys->Js.Array2.unsafe_get(ascPartitionKeys->Array.length - 1) === "-1" {
+        ascPartitionKeys
+        ->Js.Array2.unshift(ascPartitionKeys->Js.Array2.pop->Option.getUnsafe)
+        ->ignore
+      }
+      let currentPRef = ref(
+        partitionsByMergeBlock->Js.Dict.unsafeGet(ascPartitionKeys->Utils.Array.firstUnsafe),
+      )
+      let currentPMergeBlockRef = ref(
+        ascPartitionKeys->Utils.Array.firstUnsafe->Int.fromString->Option.getUnsafe,
+      )
+      let nextJdx = ref(1)
+      while nextJdx.contents < ascPartitionKeys->Array.length {
+        let nextKey = ascPartitionKeys->Js.Array2.unsafe_get(nextJdx.contents)
+        let currentP = currentPRef.contents
+        let nextP = partitionsByMergeBlock->Js.Dict.unsafeGet(nextKey)
+        let nextPMergeBlock = nextKey->Int.fromString->Option.getUnsafe
+        let currentPMergeBlock = currentPMergeBlockRef.contents
+
+        let isTooFar = currentPMergeBlock + tooFarBlockRange < nextPMergeBlock
+        if isTooFar {
+          newPartitions->Js.Array2.push(currentP)->ignore
+          currentPRef := nextP
+          currentPMergeBlockRef := nextPMergeBlock
+        } else {
+          let result = mergePartitionsAtBlock(
+            ~p1=nextP,
+            ~p2=currentP,
+            ~potentialMergeBlock=nextPMergeBlock,
+            ~contractName,
+            ~maxAddrInPartition,
+            ~nextPartitionIndexRef,
+          )
+          for i in 0 to result->Array.length - 2 {
+            newPartitions->Js.Array2.push(result->Js.Array2.unsafe_get(i))->ignore
+          }
+          currentPRef := result->Utils.Array.lastUnsafe
+          currentPMergeBlockRef := nextPMergeBlock
+        }
+
+        nextJdx := nextJdx.contents + 1
+      }
+
+      newPartitions->Js.Array2.push(currentPRef.contents)->ignore
+    }
+
+    // Sort partitions by latestFetchedBlock ascending
+    let _ = newPartitions->Js.Array2.sortInPlaceWith(ascSortFn)
+
+    let partitionsCount = newPartitions->Array.length
+    let idsInAscOrder = Belt.Array.makeUninitializedUnsafe(partitionsCount)
+    let entities = Js.Dict.empty()
+    for idx in 0 to partitionsCount - 1 {
+      let p = newPartitions->Js.Array2.unsafe_get(idx)
+      idsInAscOrder->Js.Array2.unsafe_set(idx, p.id)
+      entities->Js.Dict.set(p.id, p)
+    }
+
+    {
+      idsInAscOrder,
+      entities,
+      maxAddrInPartition,
+      nextPartitionIndex: nextPartitionIndexRef.contents,
+      dynamicContracts,
+    }
+  }
+
+  // Helper to process fetched queries from the front of the queue
+  // Removes consecutive fetched queries and returns the last fetchedBlock.
+  // Stops if the next query's fromBlock is not contiguous with the current
+  // latestFetchedBlock (gap from a partial chunk fetch).
+  @inline
+  let consumeFetchedQueries = (
+    mutPendingQueries: array<pendingQuery>,
+    ~initialLatestFetchedBlock: blockNumberAndTimestamp,
+  ) => {
+    let latestFetchedBlock = ref(initialLatestFetchedBlock)
+
+    while (
+      mutPendingQueries->Array.length > 0 && {
+          let pq = mutPendingQueries->Utils.Array.firstUnsafe
+          pq.fetchedBlock !== None && pq.fromBlock <= latestFetchedBlock.contents.blockNumber + 1
+        }
+    ) {
+      let removedQuery = mutPendingQueries->Js.Array2.shift->Option.getUnsafe
+      latestFetchedBlock := removedQuery.fetchedBlock->Option.getUnsafe
+    }
+
+    latestFetchedBlock.contents
+  }
+
+  let getPendingQueryOrThrow = (p: partition, ~fromBlock) => {
+    let idxRef = ref(0)
+    let pendingQueryRef = ref(None)
+    while idxRef.contents < p.mutPendingQueries->Array.length && pendingQueryRef.contents === None {
+      let pq = p.mutPendingQueries->Js.Array2.unsafe_get(idxRef.contents)
+      if pq.fromBlock === fromBlock {
+        pendingQueryRef := Some(pq)
+      }
+      idxRef := idxRef.contents + 1
+    }
+    switch pendingQueryRef.contents {
+    | Some(pq) => pq
+    | None =>
+      Js.Exn.raiseError(
+        `Pending query not found for partition ${p.id} fromBlock ${fromBlock->Int.toString}`,
+      )
+    }
+  }
+
+  let handleQueryResponse = (
+    optimizedPartitions: t,
+    ~query,
+    ~knownHeight,
+    ~latestFetchedBlock: blockNumberAndTimestamp,
+  ) => {
+    let p = optimizedPartitions->getOrThrow(~partitionId=query.partitionId)
+    let mutEntities = optimizedPartitions.entities->Utils.Dict.shallowCopy
+
+    // Mark query as fetched
+    let pendingQuery = getPendingQueryOrThrow(p, ~fromBlock=query.fromBlock)
+    pendingQuery.fetchedBlock = Some(latestFetchedBlock)
+
+    let blockRange = latestFetchedBlock.blockNumber - query.fromBlock + 1
+    // Skip updating block range if a later response already updated it.
+    // Prevents degradation of the chunking heuristic when parallel query
+    // responses arrive out of order (e.g. earlier query with smaller range
+    // arriving after a later query with bigger range).
+    let shouldUpdateBlockRange =
+      latestFetchedBlock.blockNumber > p.latestBlockRangeUpdateBlock &&
+        switch query.toBlock {
+        | None => latestFetchedBlock.blockNumber < knownHeight - 10 // Don't update block range when very close to the head
+        | Some(queryToBlock) =>
+          // Update on partial response (direct capacity evidence),
+          // or when the query's intended range covers at least the partition's
+          // current chunk range — meaning it was a capacity-based split chunk,
+          // not a small gap-fill whose toBlock is an artificial boundary.
+          latestFetchedBlock.blockNumber < queryToBlock ||
+            switch getMinHistoryRange(p) {
+            | None => false // Chunking not active yet, don't update
+            | Some(minHistoryRange) => queryToBlock - query.fromBlock + 1 >= minHistoryRange
+            }
+        }
+    let updatedPrevQueryRange = shouldUpdateBlockRange ? blockRange : p.prevQueryRange
+    let updatedPrevPrevQueryRange = shouldUpdateBlockRange ? p.prevQueryRange : p.prevPrevQueryRange
+
+    // Process fetched queries from front of queue for main partition
+    let updatedLatestFetchedBlock = consumeFetchedQueries(
+      p.mutPendingQueries,
+      ~initialLatestFetchedBlock=p.latestFetchedBlock,
+    )
+
+    // Check if partition reached its mergeBlock and should be removed
+    let partitionReachedMergeBlock = switch p.mergeBlock {
+    | Some(mergeBlock) => updatedLatestFetchedBlock.blockNumber >= mergeBlock
+    | None => false
+    }
+
+    if partitionReachedMergeBlock {
+      mutEntities->Utils.Dict.deleteInPlace(p.id)
+    } else {
+      let updatedMainPartition = {
+        ...p,
+        latestFetchedBlock: updatedLatestFetchedBlock,
+        prevQueryRange: updatedPrevQueryRange,
+        prevPrevQueryRange: updatedPrevPrevQueryRange,
+        latestBlockRangeUpdateBlock: shouldUpdateBlockRange
+          ? latestFetchedBlock.blockNumber
+          : p.latestBlockRangeUpdateBlock,
+      }
+
+      mutEntities->Js.Dict.set(p.id, updatedMainPartition)
+    }
+
+    // Re-optimize to maintain sorted order and apply optimizations
+    make(
+      ~partitions=mutEntities->Js.Dict.values,
+      ~maxAddrInPartition=optimizedPartitions.maxAddrInPartition,
+      ~nextPartitionIndex=optimizedPartitions.nextPartitionIndex,
+      ~dynamicContracts=optimizedPartitions.dynamicContracts,
+    )
+  }
+
+  @inline
+  let getLatestFullyFetchedBlock = (optimizedPartitions: t) => {
+    switch optimizedPartitions.idsInAscOrder->Array.get(0) {
+    | Some(id) => Some((optimizedPartitions.entities->Js.Dict.unsafeGet(id)).latestFetchedBlock)
+    | None => None
+    }
+  }
 }
 
 type t = {
-  partitions: array<partition>,
-  // Used for the incremental partition id. Can't use the partitions length,
-  // since partitions might be deleted on merge or cleaned up
-  nextPartitionIndex: int,
+  optimizedPartitions: OptimizedPartitions.t,
   startBlock: int,
   endBlock: option<int>,
-  maxAddrInPartition: int,
   normalSelection: selection,
   // By address
   indexingContracts: dict<Internal.indexingContract>,
@@ -42,9 +480,6 @@ type t = {
   contractConfigs: dict<contractConfig>,
   // Not used for logic - only metadata
   chainId: int,
-  // The block number of the latest block fetched
-  // which added all its events to the queue
-  latestFullyFetchedBlock: blockNumberAndTimestamp,
   // The block number of the latest block which was added to the queue
   // by the onBlock configs
   // Need a separate pointer for this
@@ -59,104 +494,39 @@ type t = {
   // ready for processing
   targetBufferSize: int,
   onBlockConfigs: array<Internal.onBlockConfig>,
-}
-
-let mergeIntoPartition = (p: partition, ~target: partition, ~maxAddrInPartition) => {
-  switch (p, target) {
-  | ({selection: {dependsOnAddresses: true}}, {selection: {dependsOnAddresses: true}}) => {
-      let latestFetchedBlock = target.latestFetchedBlock
-
-      let mergedAddresses = Js.Dict.empty()
-
-      let allowedAddressesNumber = ref(maxAddrInPartition)
-
-      target.addressesByContractName->Utils.Dict.forEachWithKey((addresses, contractName) => {
-        allowedAddressesNumber := allowedAddressesNumber.contents - addresses->Array.length
-        mergedAddresses->Js.Dict.set(contractName, addresses)
-      })
-
-      // Start with putting all addresses to the merging dict
-      // And if they exceed the limit, start removing from the merging dict
-      // and putting into the rest dict
-      p.addressesByContractName->Utils.Dict.forEachWithKey((addresses, contractName) => {
-        allowedAddressesNumber := allowedAddressesNumber.contents - addresses->Array.length
-        switch mergedAddresses->Utils.Dict.dangerouslyGetNonOption(contractName) {
-        | Some(targetAddresses) =>
-          mergedAddresses->Js.Dict.set(contractName, Array.concat(targetAddresses, addresses))
-        | None => mergedAddresses->Js.Dict.set(contractName, addresses)
-        }
-      })
-
-      let rest = if allowedAddressesNumber.contents < 0 {
-        let restAddresses = Js.Dict.empty()
-
-        mergedAddresses->Utils.Dict.forEachWithKey((addresses, contractName) => {
-          if allowedAddressesNumber.contents === 0 {
-            ()
-          } else if addresses->Array.length <= -allowedAddressesNumber.contents {
-            allowedAddressesNumber := allowedAddressesNumber.contents + addresses->Array.length
-            mergedAddresses->Utils.Dict.deleteInPlace(contractName)
-            restAddresses->Js.Dict.set(contractName, addresses)
-          } else {
-            let restFrom = addresses->Array.length + allowedAddressesNumber.contents
-            mergedAddresses->Js.Dict.set(
-              contractName,
-              addresses->Js.Array2.slice(~start=0, ~end_=restFrom),
-            )
-            restAddresses->Js.Dict.set(contractName, addresses->Js.Array2.sliceFrom(restFrom))
-            allowedAddressesNumber := 0
-          }
-        })
-
-        Some({
-          id: p.id,
-          status: {
-            fetchingStateId: None,
-          },
-          selection: target.selection,
-          addressesByContractName: restAddresses,
-          latestFetchedBlock,
-        })
-      } else {
-        None
-      }
-
-      (
-        {
-          id: target.id,
-          status: {
-            fetchingStateId: None,
-          },
-          selection: target.selection,
-          addressesByContractName: mergedAddresses,
-          latestFetchedBlock,
-        },
-        rest,
-      )
-    }
-  | ({selection: {dependsOnAddresses: false}}, _)
-  | (_, {selection: {dependsOnAddresses: false}}) => (p, Some(target))
-  }
+  knownHeight: int,
+  firstEventBlock: option<int>,
 }
 
 @inline
-let bufferBlockNumber = ({latestFullyFetchedBlock, latestOnBlockBlockNumber}: t) => {
-  latestOnBlockBlockNumber < latestFullyFetchedBlock.blockNumber
-    ? latestOnBlockBlockNumber
-    : latestFullyFetchedBlock.blockNumber
+let bufferBlockNumber = ({latestOnBlockBlockNumber, optimizedPartitions}: t) => {
+  switch optimizedPartitions->OptimizedPartitions.getLatestFullyFetchedBlock {
+  | None => latestOnBlockBlockNumber
+  | Some(latestFullyFetchedBlock) =>
+    latestOnBlockBlockNumber < latestFullyFetchedBlock.blockNumber
+      ? latestOnBlockBlockNumber
+      : latestFullyFetchedBlock.blockNumber
+  }
 }
 
 /**
 * Returns the latest block which is ready to be consumed
 */
 @inline
-let bufferBlock = ({latestFullyFetchedBlock, latestOnBlockBlockNumber}: t) => {
-  latestOnBlockBlockNumber < latestFullyFetchedBlock.blockNumber
-    ? {
-        blockNumber: latestOnBlockBlockNumber,
-        blockTimestamp: 0,
-      }
-    : latestFullyFetchedBlock
+let bufferBlock = ({optimizedPartitions, latestOnBlockBlockNumber}: t) => {
+  switch optimizedPartitions->OptimizedPartitions.getLatestFullyFetchedBlock {
+  | None => {
+      blockNumber: latestOnBlockBlockNumber,
+      blockTimestamp: 0,
+    }
+  | Some(latestFullyFetchedBlock) =>
+    latestOnBlockBlockNumber < latestFullyFetchedBlock.blockNumber
+      ? {
+          blockNumber: latestOnBlockBlockNumber,
+          blockTimestamp: 0,
+        }
+      : latestFullyFetchedBlock
+  }
 }
 
 /*
@@ -174,31 +544,24 @@ let compareBufferItem = (a: Internal.item, b: Internal.item) => {
 // Some big number which should be bigger than any log index
 let blockItemLogIndex = 16777216
 
+let numAddresses = fetchState => fetchState.indexingContracts->Js.Dict.keys->Array.length
+
 /*
- Update fetchState, merge registers and recompute derived values
- */
+Update fetchState, merge registers and recompute derived values.
+Runs partition optimization when partitions change.
+*/
 let updateInternal = (
   fetchState: t,
-  ~partitions=fetchState.partitions,
-  ~nextPartitionIndex=fetchState.nextPartitionIndex,
+  ~optimizedPartitions=fetchState.optimizedPartitions,
   ~indexingContracts=fetchState.indexingContracts,
   ~mutItems=?,
   ~blockLag=fetchState.blockLag,
+  ~knownHeight=fetchState.knownHeight,
 ): t => {
-  let firstPartition = partitions->Js.Array2.unsafe_get(0)
-  let latestFullyFetchedBlock = ref(firstPartition.latestFetchedBlock)
-  for idx in 0 to partitions->Array.length - 1 {
-    let p = partitions->Js.Array2.unsafe_get(idx)
-    if latestFullyFetchedBlock.contents.blockNumber > p.latestFetchedBlock.blockNumber {
-      latestFullyFetchedBlock := p.latestFetchedBlock
-    }
-  }
-  let latestFullyFetchedBlock = latestFullyFetchedBlock.contents
-
   let mutItemsRef = ref(mutItems)
 
   let latestOnBlockBlockNumber = switch fetchState.onBlockConfigs {
-  | [] => latestFullyFetchedBlock.blockNumber
+  | [] => knownHeight
   | onBlockConfigs => {
       // Calculate the max block number we are going to create items for
       // Use targetBufferSize to get the last target item in the buffer
@@ -212,7 +575,11 @@ let updateInternal = (
       | None => fetchState.buffer
       }->Belt.Array.get(fetchState.targetBufferSize - 1) {
       | Some(item) => item->Internal.getItemBlockNumber
-      | None => latestFullyFetchedBlock.blockNumber
+      | None =>
+        switch optimizedPartitions->OptimizedPartitions.getLatestFullyFetchedBlock {
+        | None => knownHeight
+        | Some(latestFullyFetchedBlock) => latestFullyFetchedBlock.blockNumber
+        }
       }
 
       let mutItems = switch mutItemsRef.contents {
@@ -268,7 +635,6 @@ let updateInternal = (
   }
 
   let updatedFetchState = {
-    maxAddrInPartition: fetchState.maxAddrInPartition,
     startBlock: fetchState.startBlock,
     endBlock: fetchState.endBlock,
     contractConfigs: fetchState.contractConfigs,
@@ -276,12 +642,11 @@ let updateInternal = (
     chainId: fetchState.chainId,
     onBlockConfigs: fetchState.onBlockConfigs,
     targetBufferSize: fetchState.targetBufferSize,
-    nextPartitionIndex,
-    partitions,
+    optimizedPartitions,
     latestOnBlockBlockNumber,
-    latestFullyFetchedBlock,
     indexingContracts,
     blockLag,
+    knownHeight,
     buffer: switch mutItemsRef.contents {
     // Theoretically it could be faster to asume that
     // the items are sorted, but there are cases
@@ -289,10 +654,11 @@ let updateInternal = (
     | Some(mutItems) => mutItems->Js.Array2.sortInPlaceWith(compareBufferItem)
     | None => fetchState.buffer
     },
+    firstEventBlock: fetchState.firstEventBlock,
   }
 
   Prometheus.IndexingPartitions.set(
-    ~partitionsCount=partitions->Array.length,
+    ~partitionsCount=optimizedPartitions->OptimizedPartitions.count,
     ~chainId=fetchState.chainId,
   )
   Prometheus.IndexingBufferSize.set(
@@ -303,12 +669,16 @@ let updateInternal = (
     ~blockNumber=updatedFetchState->bufferBlockNumber,
     ~chainId=fetchState.chainId,
   )
+  if indexingContracts !== fetchState.indexingContracts {
+    Prometheus.IndexingAddresses.set(
+      ~addressesCount=updatedFetchState->numAddresses,
+      ~chainId=fetchState.chainId,
+    )
+  }
 
   updatedFetchState
 }
 
-let numAddresses = fetchState => fetchState.indexingContracts->Js.Dict.keys->Array.length
-
 let warnDifferentContractType = (
   fetchState,
   ~existingContract: Internal.indexingContract,
@@ -325,6 +695,234 @@ let warnDifferentContractType = (
   logger->Logging.childWarn(`Skipping contract registration: Contract address is already registered for one contract and cannot be registered for another contract.`)
 }
 
+let addressesByContractNameCount = (addressesByContractName: dict<array<Address.t>>) => {
+  let numAddresses = ref(0)
+  let contractNames = addressesByContractName->Js.Dict.keys
+  for idx in 0 to contractNames->Array.length - 1 {
+    let contractName = contractNames->Js.Array2.unsafe_get(idx)
+    numAddresses :=
+      numAddresses.contents + addressesByContractName->Js.Dict.unsafeGet(contractName)->Array.length
+  }
+  numAddresses.contents
+}
+
+let addressesByContractNameGetAll = (addressesByContractName: dict<array<Address.t>>) => {
+  let all = ref([])
+  let contractNames = addressesByContractName->Js.Dict.keys
+  for idx in 0 to contractNames->Array.length - 1 {
+    let contractName = contractNames->Js.Array2.unsafe_get(idx)
+    all := all.contents->Array.concat(addressesByContractName->Js.Dict.unsafeGet(contractName))
+  }
+  all.contents
+}
+
+/**
+Creates partitions from indexing addresses with two phases:
+Phase 1: Create per-contract-name partitions (smart grouping by startBlock)
+Phase 2: Merge non-dynamic partitions together to reduce unnecessary concurrency
+Returns OptimizedPartitions.t directly.
+(Dynamic partitions are merged by OptimizedPartitions.make automatically)
+*/
+let createPartitionsFromIndexingAddresses = (
+  ~registeringContractsByContract: dict<dict<Internal.indexingContract>>,
+  ~contractConfigs: dict<contractConfig>,
+  ~dynamicContracts: Utils.Set.t<string>,
+  ~normalSelection: selection,
+  ~maxAddrInPartition: int,
+  ~nextPartitionIndex: int,
+  ~existingPartitions: array<partition>,
+  ~progressBlockNumber: int,
+): // Floor for latestFetchedBlock (use progressBlockNumber from make, or 0 for registerDynamicContracts)
+OptimizedPartitions.t => {
+  let nextPartitionIndexRef = ref(nextPartitionIndex)
+
+  // ── Phase 1: Create per-contract-name partitions ──
+  let dynamicPartitions = []
+  let nonDynamicPartitions = []
+
+  let contractNames = registeringContractsByContract->Js.Dict.keys
+  for cIdx in 0 to contractNames->Js.Array2.length - 1 {
+    let contractName = contractNames->Js.Array2.unsafe_get(cIdx)
+    let registeringContracts = registeringContractsByContract->Js.Dict.unsafeGet(contractName)
+    let addresses =
+      registeringContracts->Js.Dict.keys->(Utils.magic: array<string> => array<Address.t>)
+
+    // Can unsafely get it, because we already filtered out the contracts
+    // that don't have any events to fetch
+    let contractConfig = contractConfigs->Js.Dict.unsafeGet(contractName)
+    let isDynamic = dynamicContracts->Utils.Set.has(contractName)
+    let partitions = isDynamic ? dynamicPartitions : nonDynamicPartitions
+
+    let byStartBlock = Js.Dict.empty()
+    for jdx in 0 to addresses->Array.length - 1 {
+      let address = addresses->Js.Array2.unsafe_get(jdx)
+      let indexingContract = registeringContracts->Js.Dict.unsafeGet(address->Address.toString)
+      byStartBlock->Utils.Dict.push(indexingContract.startBlock->Int.toString, address)
+    }
+
+    // Will be in ASC order by JS spec
+    let ascKeys = byStartBlock->Js.Dict.keys
+    let initialKey = ascKeys->Utils.Array.firstUnsafe
+
+    let startBlockRef = ref(initialKey->Int.fromString->Option.getUnsafe)
+    let addressesRef = ref(byStartBlock->Js.Dict.unsafeGet(initialKey))
+
+    for idx in 0 to ascKeys->Js.Array2.length - 1 {
+      let maybeNextStartBlockKey =
+        ascKeys->Js.Array2.unsafe_get(idx + 1)->(Utils.magic: string => option<string>)
+
+      // For this case we can't filter out events earlier than contract registration
+      // on the client side, so we need to keep the old logic of creating
+      // a partition for every block range, so there are no irrelevant events
+      let shouldAllocateNewPartition = if contractConfig.filterByAddresses {
+        true
+      } else {
+        switch maybeNextStartBlockKey {
+        | None => true
+        | Some(nextStartBlockKey) => {
+            let nextStartBlock = nextStartBlockKey->Int.fromString->Option.getUnsafe
+            let shouldJoinCurrentStartBlock =
+              nextStartBlock - startBlockRef.contents < OptimizedPartitions.tooFarBlockRange
+
+            // If dynamic contract registration are close to eachother
+            // and it's possible to use dc.startBlock to filter out events on client side
+            // then we can optimize the number of partitions,
+            // by putting dcs with different startBlocks in the same partition
+            if shouldJoinCurrentStartBlock {
+              addressesRef :=
+                addressesRef.contents->Array.concat(
+                  byStartBlock->Js.Dict.unsafeGet(nextStartBlockKey),
+                )
+              false
+            } else {
+              true
+            }
+          }
+        }
+      }
+
+      if shouldAllocateNewPartition {
+        let latestFetchedBlock = {
+          blockNumber: Pervasives.max(startBlockRef.contents - 1, progressBlockNumber),
+          blockTimestamp: 0,
+        }
+        while addressesRef.contents->Array.length > 0 {
+          let pAddresses =
+            addressesRef.contents->Js.Array2.slice(~start=0, ~end_=maxAddrInPartition)
+          addressesRef.contents = addressesRef.contents->Js.Array2.sliceFrom(maxAddrInPartition)
+
+          let addressesByContractName = Js.Dict.empty()
+          addressesByContractName->Js.Dict.set(contractName, pAddresses)
+          partitions->Array.push({
+            id: nextPartitionIndexRef.contents->Int.toString,
+            latestFetchedBlock,
+            selection: normalSelection,
+            dynamicContract: isDynamic ? Some(contractName) : None,
+            addressesByContractName,
+            mergeBlock: None,
+            mutPendingQueries: [],
+            prevQueryRange: 0,
+            prevPrevQueryRange: 0,
+            latestBlockRangeUpdateBlock: 0,
+          })
+          nextPartitionIndexRef := nextPartitionIndexRef.contents + 1
+        }
+
+        switch maybeNextStartBlockKey {
+        | None => ()
+        | Some(nextStartBlockKey) => {
+            startBlockRef := nextStartBlockKey->Int.fromString->Option.getUnsafe
+            addressesRef := byStartBlock->Js.Dict.unsafeGet(nextStartBlockKey)
+          }
+        }
+      }
+    }
+  }
+
+  // ── Phase 2: Merge non-dynamic partitions ──
+  let mergedNonDynamic = []
+
+  if nonDynamicPartitions->Array.length > 0 {
+    // Sort non-dynamic partitions by latestFetchedBlock ascending
+    let _ = nonDynamicPartitions->Js.Array2.sortInPlaceWith(OptimizedPartitions.ascSortFn)
+
+    let currentPRef = ref(nonDynamicPartitions->Js.Array2.unsafe_get(0))
+    let nextIdx = ref(1)
+
+    while nextIdx.contents < nonDynamicPartitions->Array.length {
+      let nextP = nonDynamicPartitions->Js.Array2.unsafe_get(nextIdx.contents)
+      let currentP = currentPRef.contents
+      let currentPBlock = currentP.latestFetchedBlock.blockNumber
+      let nextPBlock = nextP.latestFetchedBlock.blockNumber
+
+      // Compute total count WITHOUT mutating any arrays
+      let totalCount =
+        currentP.addressesByContractName->addressesByContractNameCount +
+          nextP.addressesByContractName->addressesByContractNameCount
+
+      if totalCount > maxAddrInPartition {
+        // Exceeds address limit - don't merge, keep partitions separate
+        mergedNonDynamic->Js.Array2.push(currentP)->ignore
+        currentPRef := nextP
+      } else {
+        // Build merged addresses using Array.concat (non-mutating)
+        let mergedAddresses = nextP.addressesByContractName->Utils.Dict.shallowCopy
+        let currentContractNames = currentP.addressesByContractName->Js.Dict.keys
+        for jdx in 0 to currentContractNames->Js.Array2.length - 1 {
+          let cn = currentContractNames->Js.Array2.unsafe_get(jdx)
+          let currentAddrs = currentP.addressesByContractName->Js.Dict.unsafeGet(cn)
+          switch mergedAddresses->Utils.Dict.dangerouslyGetNonOption(cn) {
+          | Some(existingAddrs) =>
+            // Use concat (non-mutating) to avoid corrupting nextP's arrays
+            mergedAddresses->Js.Dict.set(cn, existingAddrs->Array.concat(currentAddrs))
+          | None => mergedAddresses->Js.Dict.set(cn, currentAddrs)
+          }
+        }
+
+        let nextContractName = nextP.addressesByContractName->Js.Dict.keys->Utils.Array.firstUnsafe
+        let hasFilterByAddresses = (
+          contractConfigs->Js.Dict.unsafeGet(nextContractName)
+        ).filterByAddresses
+        let isTooFar = currentPBlock + OptimizedPartitions.tooFarBlockRange < nextPBlock
+
+        if isTooFar || hasFilterByAddresses {
+          // Too far or address-filtered: mergeBlock on current, merge addresses into next
+          mergedNonDynamic
+          ->Js.Array2.push({
+            ...currentP,
+            mergeBlock: currentPBlock < nextPBlock ? Some(nextPBlock) : None,
+          })
+          ->ignore
+          currentPRef := {
+              ...nextP,
+              addressesByContractName: mergedAddresses,
+            }
+        } else {
+          // Close and not address-filtered: push next's addresses into current
+          currentPRef := {
+              ...currentP,
+              addressesByContractName: mergedAddresses,
+            }
+        }
+      }
+
+      nextIdx := nextIdx.contents + 1
+    }
+
+    mergedNonDynamic->Js.Array2.push(currentPRef.contents)->ignore
+  }
+
+  let mergedPartitions = mergedNonDynamic->Js.Array2.concat(dynamicPartitions)
+
+  // Final step: concat existing partitions with phase 1+2 result and call OptimizedPartitions.make
+  OptimizedPartitions.make(
+    ~partitions=existingPartitions->Js.Array2.concat(mergedPartitions),
+    ~maxAddrInPartition,
+    ~nextPartitionIndex=nextPartitionIndexRef.contents,
+    ~dynamicContracts,
+  )
+}
+
 let registerDynamicContracts = (
   fetchState: t,
   // These are raw items which might have dynamic contracts received from contractRegister call.
@@ -333,16 +931,13 @@ let registerDynamicContracts = (
 ) => {
   if fetchState.normalSelection.eventConfigs->Utils.Array.isEmpty {
     // Can the normalSelection be empty?
-    // Probably only on pre-registration, but we don't
-    // register dynamic contracts during it
     Js.Exn.raiseError(
       "Invalid configuration. No events to fetch for the dynamic contract registration.",
     )
   }
 
   let indexingContracts = fetchState.indexingContracts
-  let registeringContracts: dict<Internal.indexingContract> = Js.Dict.empty()
-  let addressesByContractName = Js.Dict.empty()
+  let registeringContractsByContract: dict<dict<Internal.indexingContract>> = Js.Dict.empty()
   let earliestRegisteringEventBlockNumber = ref(%raw(`Infinity`))
   let hasDCWithFilterByAddresses = ref(false)
 
@@ -383,6 +978,8 @@ let registerDynamicContracts = (
             }
             shouldRemove := true
           | None =>
+            let registeringContracts =
+              registeringContractsByContract->Utils.Dict.getOrInsertEmptyDict(dc.contractName)
             let shouldUpdate = switch registeringContracts->Utils.Dict.dangerouslyGetNonOption(
               dc.address->Address.toString,
             ) {
@@ -395,7 +992,6 @@ let registerDynamicContracts = (
               false
             | None =>
               hasDCWithFilterByAddresses := hasDCWithFilterByAddresses.contents || filterByAddresses
-              addressesByContractName->Utils.Dict.push(dc.contractName, dc.address)
               true
             }
             if shouldUpdate {
@@ -430,270 +1026,139 @@ let registerDynamicContracts = (
     }
   }
 
-  let dcsToStore = registeringContracts->Js.Dict.values
-  switch dcsToStore {
+  let dcContractNamesToStore = registeringContractsByContract->Js.Dict.keys
+  switch dcContractNamesToStore {
   // Dont update anything when everything was filter out
   | [] => fetchState
   | _ => {
-      let newPartitions = if (
-        // This case is more like a simple case when we need to create a single partition.
-        // Theoretically, we can only keep else, but don't want to iterate over the addresses again.
-
-        dcsToStore->Array.length <= fetchState.maxAddrInPartition &&
-          !hasDCWithFilterByAddresses.contents
-      ) {
-        [
-          {
-            id: fetchState.nextPartitionIndex->Int.toString,
-            status: {
-              fetchingStateId: None,
-            },
-            latestFetchedBlock: {
-              blockNumber: earliestRegisteringEventBlockNumber.contents - 1,
-              blockTimestamp: 0,
-            },
-            selection: fetchState.normalSelection,
-            addressesByContractName,
-          },
-        ]
-      } else {
-        let partitions = []
-
-        let earliestRegisteringEventBlockNumber = ref(%raw(`Infinity`))
-        let pendingAddressesByContractName = ref(Js.Dict.empty())
-        let pendingCount = ref(0)
-
-        let addPartition = () =>
-          partitions->Array.push({
-            id: (fetchState.nextPartitionIndex + partitions->Array.length)->Int.toString,
-            status: {
-              fetchingStateId: None,
-            },
-            latestFetchedBlock: {
-              blockNumber: earliestRegisteringEventBlockNumber.contents - 1,
-              blockTimestamp: 0,
-            },
-            selection: fetchState.normalSelection,
-            addressesByContractName: pendingAddressesByContractName.contents,
-          })
-
-        // I use for loops instead of forEach, so ReScript better inlines ref access
-        for idx in 0 to addressesByContractName->Js.Dict.keys->Array.length - 1 {
-          let contractName = addressesByContractName->Js.Dict.keys->Js.Array2.unsafe_get(idx)
-          let addresses = addressesByContractName->Js.Dict.unsafeGet(contractName)
-
-          // Can unsafely get it, because we already filtered out the contracts
-          // that don't have any events to fetch
-          let contractConfig = fetchState.contractConfigs->Js.Dict.unsafeGet(contractName)
-
-          // For this case we can't filter out events earlier than contract registration
-          // on the client side, so we need to keep the old logic of creating
-          // a partition for every block range, so there are no irrelevant events
-          if contractConfig.filterByAddresses {
-            let byStartBlock = Js.Dict.empty()
-
-            for jdx in 0 to addresses->Array.length - 1 {
-              let address = addresses->Js.Array2.unsafe_get(jdx)
-              let indexingContract =
-                registeringContracts->Js.Dict.unsafeGet(address->Address.toString)
-
-              byStartBlock->Utils.Dict.push(indexingContract.startBlock->Int.toString, address)
-            }
-
-            // Will be in the ASC order by Js spec
-            byStartBlock
-            ->Js.Dict.keys
-            ->Js.Array2.forEach(startBlockKey => {
-              let addresses = byStartBlock->Js.Dict.unsafeGet(startBlockKey)
-              let addressesByContractName = Js.Dict.empty()
-              addressesByContractName->Js.Dict.set(contractName, addresses)
-              partitions->Array.push({
-                id: (fetchState.nextPartitionIndex + partitions->Array.length)->Int.toString,
-                status: {
-                  fetchingStateId: None,
-                },
-                latestFetchedBlock: {
-                  blockNumber: Pervasives.max(startBlockKey->Int.fromString->Option.getExn - 1, 0),
-                  blockTimestamp: 0,
-                },
-                selection: fetchState.normalSelection,
-                addressesByContractName,
-              })
-            })
-          } else {
-            // The goal is to try to split partitions the way,
-            // so there are mostly addresses of the same contract in each partition
-            // TODO: Should do the same for the initial FetchState creation
-            for jdx in 0 to addresses->Array.length - 1 {
-              let address = addresses->Js.Array2.unsafe_get(jdx)
-              if pendingCount.contents === fetchState.maxAddrInPartition {
-                addPartition()
-                pendingAddressesByContractName := Js.Dict.empty()
-                pendingCount := 0
-                earliestRegisteringEventBlockNumber := %raw(`Infinity`)
+      let newPartitions = []
+      let newIndexingContracts = indexingContracts->Utils.Dict.shallowCopy
+      let dynamicContractsRef = ref(fetchState.optimizedPartitions.dynamicContracts)
+      let mutExistingPartitions = fetchState.optimizedPartitions.entities->Js.Dict.values
+
+      for idx in 0 to dcContractNamesToStore->Js.Array2.length - 1 {
+        let contractName = dcContractNamesToStore->Js.Array2.unsafe_get(idx)
+
+        // When a new contract name is added as a dynamic contract for the first time (not in dynamicContracts set):
+        // Walks through existing partitions that have addresses for this contract name
+        // - If partition has ONLY this contract's addresses -> sets dynamicContract field
+        // - If partition has this contract's addresses AND other contracts -> splits them
+        // For the sake of merging simplicity we want to make sure that
+        // partition has addresses of only one contract
+        if !(dynamicContractsRef.contents->Utils.Set.has(contractName)) {
+          dynamicContractsRef := dynamicContractsRef.contents->Utils.Set.immutableAdd(contractName)
+
+          for idx in 0 to mutExistingPartitions->Js.Array2.length - 1 {
+            let p = mutExistingPartitions->Js.Array2.unsafe_get(idx)
+            switch p.addressesByContractName->Utils.Dict.dangerouslyGetNonOption(contractName) {
+            | None => () // Skip partitions which don't have our contract
+            | Some(addresses) =>
+              // Also filter out partitions which are 100% not mergable
+              if p.selection.dependsOnAddresses && p.mergeBlock === None {
+                let allPartitionContractNames = p.addressesByContractName->Js.Dict.keys
+                switch allPartitionContractNames {
+                | [_] =>
+                  mutExistingPartitions->Js.Array2.unsafe_set(
+                    idx,
+                    // Even if it's fetching, set dynamicContract field
+                    {
+                      ...p,
+                      dynamicContract: Some(contractName),
+                    },
+                  )
+                | _ => {
+                    let isFetching = p.mutPendingQueries->Array.length > 0
+                    if isFetching {
+                      // The partition won't be split and won't get a dynamicContract field
+                      // This won't allow to optimize the partitions to the potential max
+                      // Not super critical - at least we won't have a burden of
+                      // splitting a fetching partition and then handing the response
+                      ()
+                    } else {
+                      let newPartitionId =
+                        (fetchState.optimizedPartitions.nextPartitionIndex +
+                        newPartitions->Array.length)->Int.toString
+
+                      let restAddressesByContractName =
+                        p.addressesByContractName->Utils.Dict.shallowCopy
+                      restAddressesByContractName->Utils.Dict.deleteInPlace(contractName)
+
+                      mutExistingPartitions->Js.Array2.unsafe_set(
+                        idx,
+                        {
+                          ...p,
+                          addressesByContractName: restAddressesByContractName,
+                        },
+                      )
+
+                      let addressesByContractName = Js.Dict.empty()
+                      addressesByContractName->Js.Dict.set(contractName, addresses)
+                      newPartitions->Array.push({
+                        id: newPartitionId,
+                        latestFetchedBlock: p.latestFetchedBlock,
+                        selection: fetchState.normalSelection,
+                        dynamicContract: Some(contractName),
+                        addressesByContractName,
+                        mergeBlock: None,
+                        mutPendingQueries: p.mutPendingQueries,
+                        prevQueryRange: p.prevQueryRange,
+                        prevPrevQueryRange: p.prevPrevQueryRange,
+                        latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock,
+                      })
+                    }
+                  }
+                }
               }
-
-              let indexingContract =
-                registeringContracts->Js.Dict.unsafeGet(address->Address.toString)
-
-              pendingCount := pendingCount.contents + 1
-              pendingAddressesByContractName.contents->Utils.Dict.push(contractName, address)
-              earliestRegisteringEventBlockNumber :=
-                Pervasives.min(
-                  earliestRegisteringEventBlockNumber.contents,
-                  indexingContract.startBlock,
-                )
             }
           }
         }
 
-        if pendingCount.contents > 0 {
-          addPartition()
-        }
-
-        partitions
+        let registeringContracts = registeringContractsByContract->Js.Dict.unsafeGet(contractName)
+        let _ = Utils.Dict.mergeInPlace(newIndexingContracts, registeringContracts)
       }
 
-      Prometheus.IndexingAddresses.set(
-        ~addressesCount=fetchState->numAddresses + dcsToStore->Array.length,
-        ~chainId=fetchState.chainId,
+      let optimizedPartitions = createPartitionsFromIndexingAddresses(
+        ~registeringContractsByContract,
+        ~contractConfigs=fetchState.contractConfigs,
+        ~dynamicContracts=dynamicContractsRef.contents,
+        ~normalSelection=fetchState.normalSelection,
+        ~maxAddrInPartition=fetchState.optimizedPartitions.maxAddrInPartition,
+        ~nextPartitionIndex=fetchState.optimizedPartitions.nextPartitionIndex +
+        newPartitions->Array.length,
+        ~existingPartitions=mutExistingPartitions->Js.Array2.concat(newPartitions),
+        ~progressBlockNumber=0,
       )
 
-      fetchState->updateInternal(
-        ~partitions=fetchState.partitions->Js.Array2.concat(newPartitions),
-        ~indexingContracts=// We don't need registeringContracts anymore,
-        // so we can safely mixin indexingContracts in it
-        // The original indexingContracts won't be mutated
-        Utils.Dict.mergeInPlace(registeringContracts, indexingContracts),
-        ~nextPartitionIndex=fetchState.nextPartitionIndex + newPartitions->Array.length,
-      )
+      fetchState->updateInternal(~optimizedPartitions, ~indexingContracts=newIndexingContracts)
     }
   }
 }
 
-type queryTarget =
-  | Head
-  | EndBlock({toBlock: int})
-  | Merge({
-      // The partition we are going to merge into
-      // It shouldn't be fetching during the query
-      intoPartitionId: string,
-      toBlock: int,
-    })
-
-type query = {
-  partitionId: string,
-  fromBlock: int,
-  selection: selection,
-  addressesByContractName: dict<array<Address.t>>,
-  target: queryTarget,
-  indexingContracts: dict<Internal.indexingContract>,
-}
-
-exception UnexpectedPartitionNotFound({partitionId: string})
-exception UnexpectedMergeQueryResponse({message: string})
-
 /*
 Updates fetchState with a response for a given query.
 Returns Error if the partition with given query cannot be found (unexpected)
-If MergeQuery caught up to the target partition, it triggers the merge of the partitions.
 
 newItems are ordered earliest to latest (as they are returned from the worker)
 */
 let handleQueryResult = (
-  {partitions} as fetchState: t,
+  fetchState: t,
   ~query: query,
   ~latestFetchedBlock: blockNumberAndTimestamp,
   ~newItems,
-): result<t, exn> =>
-  {
-    let partitionId = query.partitionId
-
-    switch partitions->Array.getIndexBy(p => p.id === partitionId) {
-    | Some(pIndex) =>
-      let p = partitions->Js.Array2.unsafe_get(pIndex)
-      let updatedPartition = {
-        ...p,
-        status: {
-          fetchingStateId: None,
-        },
-        latestFetchedBlock,
-      }
-
-      switch query.target {
-      | Head
-      | EndBlock(_) =>
-        Ok(partitions->Utils.Array.setIndexImmutable(pIndex, updatedPartition))
-      | Merge({intoPartitionId}) =>
-        switch partitions->Array.getIndexBy(p => p.id === intoPartitionId) {
-        | Some(targetIndex)
-          if (partitions->Js.Array2.unsafe_get(targetIndex)).latestFetchedBlock.blockNumber ===
-            latestFetchedBlock.blockNumber => {
-            let target = partitions->Js.Array2.unsafe_get(targetIndex)
-            let (merged, rest) =
-              updatedPartition->mergeIntoPartition(
-                ~target,
-                ~maxAddrInPartition=fetchState.maxAddrInPartition,
-              )
-
-            let updatedPartitions = partitions->Utils.Array.setIndexImmutable(targetIndex, merged)
-            let updatedPartitions = switch rest {
-            | Some(rest) => {
-                updatedPartitions->Js.Array2.unsafe_set(pIndex, rest)
-                updatedPartitions
-              }
-            | None => updatedPartitions->Utils.Array.removeAtIndex(pIndex)
-            }
-            Ok(updatedPartitions)
-          }
-        | _ => Ok(partitions->Utils.Array.setIndexImmutable(pIndex, updatedPartition))
-        }
+): t => {
+  fetchState->updateInternal(
+    ~optimizedPartitions=fetchState.optimizedPartitions->OptimizedPartitions.handleQueryResponse(
+      ~query,
+      ~knownHeight=fetchState.knownHeight,
+      ~latestFetchedBlock,
+    ),
+    ~mutItems=?{
+      switch newItems {
+      | [] => None
+      | _ => Some(fetchState.buffer->Array.concat(newItems))
       }
-    | None =>
-      Error(
-        UnexpectedPartitionNotFound({
-          partitionId: partitionId,
-        }),
-      )
-    }
-  }->Result.map(partitions => {
-    fetchState->updateInternal(
-      ~partitions,
-      ~mutItems=?{
-        switch newItems {
-        | [] => None
-        | _ => Some(fetchState.buffer->Array.concat(newItems))
-        }
-      },
-    )
-  })
-
-let makePartitionQuery = (p: partition, ~indexingContracts, ~endBlock, ~mergeTarget) => {
-  let fromBlock = switch p.latestFetchedBlock.blockNumber {
-  | 0 => 0
-  | latestFetchedBlockNumber => latestFetchedBlockNumber + 1
-  }
-  switch (endBlock, mergeTarget) {
-  | (Some(endBlock), _) if fromBlock > endBlock => None
-  | (_, Some(mergeTarget)) =>
-    Some(
-      Merge({
-        toBlock: mergeTarget.latestFetchedBlock.blockNumber,
-        intoPartitionId: mergeTarget.id,
-      }),
-    )
-  | (Some(endBlock), None) => Some(EndBlock({toBlock: endBlock}))
-  | (None, None) => Some(Head)
-  }->Option.map(target => {
-    {
-      partitionId: p.id,
-      fromBlock,
-      target,
-      selection: p.selection,
-      addressesByContractName: p.addressesByContractName,
-      indexingContracts,
-    }
-  })
+    },
+  )
 }
 
 type nextQuery =
@@ -702,200 +1167,235 @@ type nextQuery =
   | NothingToQuery
   | Ready(array<query>)
 
-let startFetchingQueries = ({partitions}: t, ~queries: array<query>, ~stateId) => {
-  queries->Array.forEach(q => {
-    switch partitions->Js.Array2.find(p => p.id === q.partitionId) {
-    // Shouldn't be mutated to None anymore
-    // The status will be immutably set to the initial one when we handle response
-    | Some(p) => p.status.fetchingStateId = Some(stateId)
-    | None => Js.Exn.raiseError("Unexpected case: Couldn't find partition for the fetching query")
-    }
-  })
-}
+let startFetchingQueries = ({optimizedPartitions}: t, ~queries: array<query>) => {
+  for qIdx in 0 to queries->Array.length - 1 {
+    let q = queries->Js.Array2.unsafe_get(qIdx)
+    let p = optimizedPartitions->OptimizedPartitions.getOrThrow(~partitionId=q.partitionId)
 
-let addressesByContractNameCount = (addressesByContractName: dict<array<Address.t>>) => {
-  let numAddresses = ref(0)
-  let contractNames = addressesByContractName->Js.Dict.keys
-  for idx in 0 to contractNames->Array.length - 1 {
-    let contractName = contractNames->Js.Array2.unsafe_get(idx)
-    numAddresses :=
-      numAddresses.contents + addressesByContractName->Js.Dict.unsafeGet(contractName)->Array.length
-  }
-  numAddresses.contents
-}
+    let pq = {
+      fromBlock: q.fromBlock,
+      toBlock: q.toBlock,
+      isChunk: q.isChunk,
+      fetchedBlock: None,
+    }
 
-let addressesByContractNameGetAll = (addressesByContractName: dict<array<Address.t>>) => {
-  let all = ref([])
-  let contractNames = addressesByContractName->Js.Dict.keys
-  for idx in 0 to contractNames->Array.length - 1 {
-    let contractName = contractNames->Js.Array2.unsafe_get(idx)
-    all := all.contents->Array.concat(addressesByContractName->Js.Dict.unsafeGet(contractName))
+    // Insert in sorted order by fromBlock to maintain queue invariant.
+    // Gap-fill queries may have lower fromBlock than existing pending queries.
+    let inserted = ref(false)
+    let i = ref(0)
+    while i.contents < p.mutPendingQueries->Array.length && !inserted.contents {
+      if (p.mutPendingQueries->Js.Array2.unsafe_get(i.contents)).fromBlock > q.fromBlock {
+        p.mutPendingQueries->Js.Array2.spliceInPlace(~pos=i.contents, ~remove=0, ~add=[pq])->ignore
+        inserted := true
+      }
+      i := i.contents + 1
+    }
+    if !inserted.contents {
+      p.mutPendingQueries->Array.push(pq)->ignore
+    }
   }
-  all.contents
 }
 
 @inline
-let isFullPartition = (p: partition, ~maxAddrInPartition) => {
-  switch p {
-  | {selection: {dependsOnAddresses: false}} => true
-  | _ => p.addressesByContractName->addressesByContractNameCount >= maxAddrInPartition
+let pushQueriesForRange = (
+  queries: array<query>,
+  ~partitionId: string,
+  ~rangeFromBlock: int,
+  ~rangeEndBlock: option<int>,
+  ~maxQueryBlockNumber: int,
+  ~maybeChunkRange: option<int>,
+  ~selection: selection,
+  ~addressesByContractName: dict<array<Address.t>>,
+  ~indexingContracts: dict<Internal.indexingContract>,
+) => {
+  if rangeFromBlock <= maxQueryBlockNumber {
+    switch rangeEndBlock {
+    | Some(endBlock) if rangeFromBlock > endBlock => ()
+    | _ =>
+      switch maybeChunkRange {
+      | None =>
+        queries->Array.push({
+          partitionId,
+          fromBlock: rangeFromBlock,
+          toBlock: rangeEndBlock,
+          selection,
+          isChunk: false,
+          addressesByContractName,
+          indexingContracts,
+        })
+      | Some(chunkRange) =>
+        let maxBlock = switch rangeEndBlock {
+        | Some(eb) => eb
+        | None => maxQueryBlockNumber
+        }
+        let chunkSize = Js.Math.ceil_int(chunkRange->Int.toFloat *. 1.8)
+        if rangeFromBlock + 2 * chunkSize - 1 <= maxBlock {
+          // Create 2 chunks of ceil(1.8 * chunkRange) each
+          queries->Array.push({
+            partitionId,
+            fromBlock: rangeFromBlock,
+            toBlock: Some(rangeFromBlock + chunkSize - 1),
+            isChunk: true,
+            selection,
+            addressesByContractName,
+            indexingContracts,
+          })
+          queries->Array.push({
+            partitionId,
+            fromBlock: rangeFromBlock + chunkSize,
+            toBlock: Some(rangeFromBlock + 2 * chunkSize - 1),
+            isChunk: true,
+            selection,
+            addressesByContractName,
+            indexingContracts,
+          })
+        } else {
+          // Not enough room for 2 chunks, fall back to a single query
+          queries->Array.push({
+            partitionId,
+            fromBlock: rangeFromBlock,
+            toBlock: rangeEndBlock,
+            selection,
+            isChunk: rangeEndBlock !== None,
+            addressesByContractName,
+            indexingContracts,
+          })
+        }
+      }
+    }
   }
 }
 
 let getNextQuery = (
   {
     buffer,
-    partitions,
+    optimizedPartitions,
     targetBufferSize,
-    maxAddrInPartition,
-    endBlock,
     indexingContracts,
     blockLag,
-  }: t,
+    latestOnBlockBlockNumber,
+    knownHeight,
+  } as fetchState: t,
   ~concurrencyLimit,
-  ~currentBlockHeight,
-  ~stateId,
 ) => {
-  let headBlock = currentBlockHeight - blockLag
-  if headBlock <= 0 {
+  let headBlockNumber = knownHeight - blockLag
+  if headBlockNumber <= 0 {
     WaitingForNewBlock
   } else if concurrencyLimit === 0 {
     ReachedMaxConcurrency
   } else {
-    let fullPartitions = []
-    let mergingPartitions = []
-    let areMergingPartitionsFetching = ref(false)
-    let mostBehindMergingPartition = ref(None)
-    let mergingPartitionTarget = ref(None)
+    let isOnBlockBehindTheHead = latestOnBlockBlockNumber < headBlockNumber
     let shouldWaitForNewBlock = ref(
-      switch endBlock {
-      | Some(endBlock) => headBlock < endBlock
+      switch fetchState.endBlock {
+      | Some(endBlock) => headBlockNumber < endBlock
       | None => true
-      },
+      } &&
+      !isOnBlockBehindTheHead,
     )
 
-    let checkIsFetchingPartition = p => {
-      switch p.status.fetchingStateId {
-      | Some(fetchingStateId) => stateId <= fetchingStateId
-      | None => false
+    // We want to limit the buffer size to targetBufferSize (usually 3 * batchSize)
+    // To make sure the processing always has some buffer
+    // and not increase the memory usage too much
+    // If a partition fetched further
+    // it should be skipped until the buffer is consumed
+    let maxQueryBlockNumber = {
+      switch buffer->Array.get(targetBufferSize - 1) {
+      | Some(item) =>
+        // Just in case check that we don't query beyond the current block
+        Pervasives.min(item->Internal.getItemBlockNumber, knownHeight)
+      | None => knownHeight
       }
     }
 
-    for idx in 0 to partitions->Js.Array2.length - 1 {
-      let p = partitions->Js.Array2.unsafe_get(idx)
+    let queries = []
 
-      let isFetching = checkIsFetchingPartition(p)
-      let hasReachedTheHead = p.latestFetchedBlock.blockNumber >= headBlock
+    let partitionsCount = optimizedPartitions.idsInAscOrder->Js.Array2.length
+    let idxRef = ref(0)
+    while idxRef.contents < partitionsCount {
+      let idx = idxRef.contents
+      let partitionId = optimizedPartitions.idsInAscOrder->Js.Array2.unsafe_get(idx)
+      let p = optimizedPartitions.entities->Js.Dict.unsafeGet(partitionId)
 
-      if isFetching || !hasReachedTheHead {
+      let isBehindTheHead = p.latestFetchedBlock.blockNumber < headBlockNumber
+      let hasPendingQueries = p.mutPendingQueries->Utils.Array.notEmpty
+
+      if hasPendingQueries || isBehindTheHead {
         // Even if there are some partitions waiting for the new block
         // We still want to wait for all partitions reaching the head
-        // because they might update currentBlockHeight in their response
+        // because they might update knownHeight in their response
         // Also, there are cases when some partitions fetching at 50% of the chain
         // and we don't want to poll the head for a few small partitions
         shouldWaitForNewBlock := false
       }
 
-      if p->isFullPartition(~maxAddrInPartition) {
-        fullPartitions->Array.push(p)
-      } else {
-        mergingPartitions->Array.push(p)
-
-        mostBehindMergingPartition :=
-          switch mostBehindMergingPartition.contents {
-          | Some(mostBehindMergingPartition) =>
-            if (
-              // The = check is important here. We don't want to have a target
-              // with the same latestFetchedBlock. They should be merged in separate queries
-              mostBehindMergingPartition.latestFetchedBlock.blockNumber ===
-                p.latestFetchedBlock.blockNumber
-            ) {
-              mostBehindMergingPartition
-            } else if (
-              mostBehindMergingPartition.latestFetchedBlock.blockNumber <
-              p.latestFetchedBlock.blockNumber
-            ) {
-              mergingPartitionTarget :=
-                switch mergingPartitionTarget.contents {
-                | Some(mergingPartitionTarget)
-                  if mergingPartitionTarget.latestFetchedBlock.blockNumber <
-                  p.latestFetchedBlock.blockNumber => mergingPartitionTarget
-                | _ => p
-                }->Some
-              mostBehindMergingPartition
-            } else {
-              mergingPartitionTarget := Some(mostBehindMergingPartition)
-              p
-            }
-          | None => p
-          }->Some
-
-        if isFetching {
-          areMergingPartitionsFetching := true
-        }
+      // Compute queryEndBlock for this partition
+      let queryEndBlock = Utils.Math.minOptInt(fetchState.endBlock, p.mergeBlock)
+      let queryEndBlock = switch blockLag {
+      | 0 => queryEndBlock
+      | _ =>
+        // Force head block as an endBlock when blockLag is set
+        // because otherwise HyperSync might return bigger range
+        Utils.Math.minOptInt(Some(headBlockNumber), queryEndBlock)
       }
-    }
-
-    // We want to limit the buffer size to targetBufferSize (usually 3 * batchSize)
-    // To make sure the processing always has some buffer
-    // and not increase the memory usage too much
-    // If a partition fetched further than 3 * batchSize,
-    // it should be skipped until the buffer is consumed
-    let maxQueryBlockNumber = {
-      switch buffer->Array.get(targetBufferSize - 1) {
-      | Some(item) =>
-        // Just in case check that we don't query beyond the current block
-        Pervasives.min(item->Internal.getItemBlockNumber, currentBlockHeight)
-      | None => currentBlockHeight
+      // Enforce the response range up until target block
+      // Otherwise for indexers with 100+ partitions
+      // we might blow up the buffer size to more than 600k events
+      // simply because of HyperSync returning extra blocks
+      let queryEndBlock = switch (queryEndBlock, maxQueryBlockNumber < knownHeight) {
+      | (Some(endBlock), true) => Some(Pervasives.min(maxQueryBlockNumber, endBlock))
+      | (None, true) => Some(maxQueryBlockNumber)
+      | (_, false) => queryEndBlock
       }
-    }
-    let queries = []
 
-    let registerPartitionQuery = (p, ~mergeTarget=?) => {
-      if (
-        p->checkIsFetchingPartition->not && p.latestFetchedBlock.blockNumber < maxQueryBlockNumber
-      ) {
-        let endBlock = switch blockLag {
-        | 0 => endBlock
-        | _ =>
-          switch endBlock {
-          | Some(endBlock) => Some(Pervasives.min(headBlock, endBlock))
-          // Force head block as an endBlock when blockLag is set
-          // because otherwise HyperSync might return bigger range
-          | None => Some(headBlock)
-          }
+      let maybeChunkRange = getMinHistoryRange(p)
+
+      // Walk pending queries to find open ranges and create queries for each
+      let cursor = ref(p.latestFetchedBlock.blockNumber + 1)
+      let canContinue = ref(true)
+      let pqIdx = ref(0)
+      while pqIdx.contents < p.mutPendingQueries->Array.length && canContinue.contents {
+        let pq = p.mutPendingQueries->Js.Array2.unsafe_get(pqIdx.contents)
+
+        // Gap before this pending query → create queries for the gap range
+        if pq.fromBlock > cursor.contents {
+          pushQueriesForRange(
+            queries,
+            ~partitionId,
+            ~rangeFromBlock=cursor.contents,
+            ~rangeEndBlock=Utils.Math.minOptInt(Some(pq.fromBlock - 1), queryEndBlock),
+            ~maxQueryBlockNumber,
+            ~maybeChunkRange,
+            ~selection=p.selection,
+            ~addressesByContractName=p.addressesByContractName,
+            ~indexingContracts,
+          )
         }
-        // Enforce the respose range up until target block
-        // Otherwise for indexers with 100+ partitions
-        // we might blow up the buffer size to more than 600k events
-        // simply because of HyperSync returning extra blocks
-        let endBlock = switch (endBlock, maxQueryBlockNumber < currentBlockHeight) {
-        | (Some(endBlock), true) => Some(Pervasives.min(maxQueryBlockNumber, endBlock))
-        | (None, true) => Some(maxQueryBlockNumber)
-        | (_, false) => endBlock
-        }
-
-        switch p->makePartitionQuery(~indexingContracts, ~endBlock, ~mergeTarget) {
-        | Some(q) => queries->Array.push(q)
-        | None => ()
+        switch pq {
+        | {isChunk: true, toBlock: Some(toBlock), fetchedBlock: Some({blockNumber})}
+          if blockNumber < toBlock =>
+          cursor := blockNumber + 1
+        | {isChunk: true, toBlock: Some(toBlock)} => cursor := toBlock + 1
+        | _ => canContinue := false
         }
+        pqIdx := pqIdx.contents + 1
       }
-    }
-
-    fullPartitions->Array.forEach(p => p->registerPartitionQuery)
 
-    if areMergingPartitionsFetching.contents->not {
-      switch mergingPartitions {
-      | [] => ()
-      | [p] => p->registerPartitionQuery
-      | _ =>
-        switch (mostBehindMergingPartition.contents, mergingPartitionTarget.contents) {
-        | (Some(p), None) => p->registerPartitionQuery
-        | (Some(p), Some(mergeTarget)) => p->registerPartitionQuery(~mergeTarget)
-        | (None, _) =>
-          Js.Exn.raiseError("Unexpected case, should always have a most behind partition.")
-        }
+      // Tail range after all pending queries
+      if canContinue.contents {
+        pushQueriesForRange(
+          queries,
+          ~partitionId,
+          ~rangeFromBlock=cursor.contents,
+          ~rangeEndBlock=queryEndBlock,
+          ~maxQueryBlockNumber,
+          ~maybeChunkRange,
+          ~selection=p.selection,
+          ~addressesByContractName=p.addressesByContractName,
+          ~indexingContracts,
+        )
       }
+
+      idxRef := idxRef.contents + 1
     }
 
     if queries->Utils.Array.isEmpty {
@@ -905,15 +1405,14 @@ let getNextQuery = (
         NothingToQuery
       }
     } else {
-      Ready(
-        if queries->Array.length > concurrencyLimit {
-          queries
-          ->Js.Array2.sortInPlaceWith((a, b) => a.fromBlock - b.fromBlock)
-          ->Js.Array2.slice(~start=0, ~end_=concurrencyLimit)
-        } else {
-          queries
-        },
-      )
+      // Enforce concurrency limit: sort by fromBlock and take the first concurrencyLimit
+      let queries = if queries->Array.length > concurrencyLimit {
+        queries->Js.Array2.sortInPlaceWith((a, b) => a.fromBlock - b.fromBlock)->ignore
+        queries->Js.Array2.slice(~start=0, ~end_=concurrencyLimit)
+      } else {
+        queries
+      }
+      Ready(queries)
     }
   }
 }
@@ -968,9 +1467,11 @@ let make = (
   ~maxAddrInPartition,
   ~chainId,
   ~targetBufferSize,
+  ~knownHeight,
   ~progressBlockNumber=startBlock - 1,
   ~onBlockConfigs=[],
   ~blockLag=0,
+  ~firstEventBlock=None,
 ): t => {
   let latestFetchedBlock = {
     blockTimestamp: 0,
@@ -1007,15 +1508,18 @@ let make = (
   if notDependingOnAddresses->Array.length > 0 {
     partitions->Array.push({
       id: partitions->Array.length->Int.toString,
-      status: {
-        fetchingStateId: None,
-      },
       latestFetchedBlock,
       selection: {
         dependsOnAddresses: false,
         eventConfigs: notDependingOnAddresses,
       },
       addressesByContractName: Js.Dict.empty(),
+      mergeBlock: None,
+      dynamicContract: None,
+      mutPendingQueries: [],
+      prevQueryRange: 0,
+      prevPrevQueryRange: 0,
+      latestBlockRangeUpdateBlock: 0,
     })
   }
 
@@ -1024,56 +1528,51 @@ let make = (
     eventConfigs: normalEventConfigs,
   }
 
+  let registeringContractsByContract: dict<dict<Internal.indexingContract>> = Js.Dict.empty()
+  let dynamicContracts = Utils.Set.make()
+
   switch normalEventConfigs {
   | [] => ()
-  | _ => {
-      let makePendingNormalPartition = () => {
-        {
-          id: partitions->Array.length->Int.toString,
-          status: {
-            fetchingStateId: None,
-          },
-          latestFetchedBlock,
-          selection: normalSelection,
-          addressesByContractName: Js.Dict.empty(),
-        }
-      }
-
-      let pendingNormalPartition = ref(makePendingNormalPartition())
-
-      contracts->Array.forEach(contract => {
-        let contractName = contract.contractName
-        if contractNamesWithNormalEvents->Utils.Set.has(contractName) {
-          let pendingPartition = pendingNormalPartition.contents
-          pendingPartition.addressesByContractName->Utils.Dict.push(contractName, contract.address)
-          indexingContracts->Js.Dict.set(contract.address->Address.toString, contract)
-          if (
-            pendingPartition.addressesByContractName->addressesByContractNameCount ===
-              maxAddrInPartition
-          ) {
-            // FIXME: should split into separate partitions
-            // depending on the start block
-            partitions->Array.push(pendingPartition)
-            pendingNormalPartition := makePendingNormalPartition()
-          }
+  | _ =>
+    contracts->Array.forEach(contract => {
+      let contractName = contract.contractName
+      if contractNamesWithNormalEvents->Utils.Set.has(contractName) {
+        let registeringContracts =
+          registeringContractsByContract->Utils.Dict.getOrInsertEmptyDict(contractName)
+        registeringContracts->Js.Dict.set(contract.address->Address.toString, contract)
+        indexingContracts->Js.Dict.set(contract.address->Address.toString, contract)
+
+        // Detect dynamic contracts by registrationBlock
+        if contract.registrationBlock !== None {
+          dynamicContracts->Utils.Set.add(contractName)->ignore
         }
-      })
-
-      if pendingNormalPartition.contents.addressesByContractName->addressesByContractNameCount > 0 {
-        partitions->Array.push(pendingNormalPartition.contents)
       }
-    }
+    })
   }
 
-  if partitions->Array.length === 0 {
+  let optimizedPartitions = createPartitionsFromIndexingAddresses(
+    ~registeringContractsByContract,
+    ~contractConfigs,
+    ~dynamicContracts,
+    ~normalSelection,
+    ~maxAddrInPartition,
+    ~nextPartitionIndex=partitions->Array.length,
+    ~existingPartitions=partitions, // wildcard partition(s) if any
+    ~progressBlockNumber,
+  )
+
+  if optimizedPartitions->OptimizedPartitions.count === 0 && onBlockConfigs->Utils.Array.isEmpty {
     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.",
+      "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.",
     )
   }
 
   let numAddresses = indexingContracts->Js.Dict.keys->Array.length
   Prometheus.IndexingAddresses.set(~addressesCount=numAddresses, ~chainId)
-  Prometheus.IndexingPartitions.set(~partitionsCount=partitions->Array.length, ~chainId)
+  Prometheus.IndexingPartitions.set(
+    ~partitionsCount=optimizedPartitions->OptimizedPartitions.count,
+    ~chainId,
+  )
   Prometheus.IndexingBufferSize.set(~bufferSize=0, ~chainId)
   Prometheus.IndexingBufferBlockNumber.set(~blockNumber=latestFetchedBlock.blockNumber, ~chainId)
   switch endBlock {
@@ -1082,73 +1581,57 @@ let make = (
   }
 
   {
-    partitions,
-    nextPartitionIndex: partitions->Array.length,
+    optimizedPartitions,
     contractConfigs,
-    maxAddrInPartition,
     chainId,
     startBlock,
     endBlock,
-    latestFullyFetchedBlock: latestFetchedBlock,
     latestOnBlockBlockNumber: progressBlockNumber,
     normalSelection,
     indexingContracts,
     blockLag,
     onBlockConfigs,
     targetBufferSize,
+    knownHeight,
     buffer: [],
+    firstEventBlock,
   }
 }
 
 let bufferSize = ({buffer}: t) => buffer->Array.length
 
-/**
-Rolls back partitions to the given valid block
-*/
-let rollbackPartition = (p: partition, ~targetBlockNumber, ~addressesToRemove) => {
-  let shouldRollbackFetched = p.latestFetchedBlock.blockNumber > targetBlockNumber
-  let latestFetchedBlock = shouldRollbackFetched
-    ? {
-        blockNumber: targetBlockNumber,
-        blockTimestamp: 0,
-      }
-    : p.latestFetchedBlock
-  switch p {
-  | {selection: {dependsOnAddresses: false}} =>
-    Some({
-      ...p,
-      latestFetchedBlock,
-      status: {
-        fetchingStateId: None,
-      },
-    })
-  | {addressesByContractName} =>
-    let rollbackedAddressesByContractName = Js.Dict.empty()
-    addressesByContractName->Utils.Dict.forEachWithKey((addresses, contractName) => {
-      let keptAddresses =
-        addresses->Array.keep(address => !(addressesToRemove->Utils.Set.has(address)))
-      if keptAddresses->Array.length > 0 {
-        rollbackedAddressesByContractName->Js.Dict.set(contractName, keptAddresses)
+let rollbackPendingQueries = (mutPendingQueries: array<pendingQuery>, ~targetBlockNumber) => {
+  // - Remove queries where fromBlock > target
+  // - Cap fetchedBlock at target where fetchedBlock > target
+  let adjusted = []
+  for qIdx in 0 to mutPendingQueries->Array.length - 1 {
+    let pq = mutPendingQueries->Js.Array2.unsafe_get(qIdx)
+    if pq.fromBlock <= targetBlockNumber {
+      switch pq.fetchedBlock {
+      | Some({blockNumber}) if blockNumber > targetBlockNumber =>
+        adjusted
+        ->Js.Array2.push({
+          ...pq,
+          fetchedBlock: Some({blockNumber: targetBlockNumber, blockTimestamp: 0}),
+        })
+        ->ignore
+      | Some(_) => adjusted->Js.Array2.push(pq)->ignore
+      | None => Js.Exn.raiseError("Internal error: Must not have a fetching query during rollback")
       }
-    })
-
-    if rollbackedAddressesByContractName->Js.Dict.keys->Array.length === 0 {
-      None
-    } else {
-      Some({
-        id: p.id,
-        selection: p.selection,
-        status: {
-          fetchingStateId: None,
-        },
-        addressesByContractName: rollbackedAddressesByContractName,
-        latestFetchedBlock,
-      })
     }
   }
+  adjusted
 }
 
+/**
+Rolls back fetch state to the given valid block.
+Always recreates optimized partitions to avoid duplicate addresses:
+- Wildcard: only rollback latestFetchedBlock
+- Non-wildcard with lfb <= target: keep, adjust pending queries and mergeBlock
+- Non-wildcard with lfb > target: delete, track addresses for recreation
+*/
 let rollback = (fetchState: t, ~targetBlockNumber) => {
+  // Step 1: Build addressesToRemove and surviving indexingContracts
   let addressesToRemove = Utils.Set.make()
   let indexingContracts = Js.Dict.empty()
 
@@ -1157,25 +1640,113 @@ let rollback = (fetchState: t, ~targetBlockNumber) => {
   ->Array.forEach(address => {
     let indexingContract = fetchState.indexingContracts->Js.Dict.unsafeGet(address)
     switch indexingContract.registrationBlock {
-    | Some(registrationBlock) if registrationBlock > targetBlockNumber => {
-        //If the registration block is later than the first change event,
-        //Do not keep it and add to the removed addresses
-        let _ = addressesToRemove->Utils.Set.add(address->Address.unsafeFromString)
-      }
+    | Some(registrationBlock) if registrationBlock > targetBlockNumber =>
+      let _ = addressesToRemove->Utils.Set.add(address->Address.unsafeFromString)
     | _ => indexingContracts->Js.Dict.set(address, indexingContract)
     }
   })
 
-  let partitions =
-    fetchState.partitions->Array.keepMap(p =>
-      p->rollbackPartition(~targetBlockNumber, ~addressesToRemove)
-    )
+  // Step 2: Categorize partitions
+  let keptPartitions = []
+  let nextKeptIdRef = ref(0)
+  let registeringContractsByContract: dict<dict<Internal.indexingContract>> = Js.Dict.empty()
+
+  let partitions = fetchState.optimizedPartitions.entities->Js.Dict.values
+  for idx in 0 to partitions->Array.length - 1 {
+    let p = partitions->Js.Array2.unsafe_get(idx)
+    switch p {
+    // Wildcard: rollback latestFetchedBlock and adjust pending queries
+    | {selection: {dependsOnAddresses: false}} =>
+      let id = nextKeptIdRef.contents->Int.toString
+      nextKeptIdRef := nextKeptIdRef.contents + 1
+      keptPartitions
+      ->Js.Array2.push({
+        ...p,
+        id,
+        latestFetchedBlock: p.latestFetchedBlock.blockNumber > targetBlockNumber
+          ? {blockNumber: targetBlockNumber, blockTimestamp: 0}
+          : p.latestFetchedBlock,
+        mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, ~targetBlockNumber),
+      })
+      ->ignore
+
+    // Non-wildcard with lfb > target: delete, collect addresses for recreation
+    | _ if p.latestFetchedBlock.blockNumber > targetBlockNumber =>
+      p.addressesByContractName->Utils.Dict.forEachWithKey((addresses, contractName) => {
+        addresses->Array.forEach(address => {
+          if (
+            !(addressesToRemove->Utils.Set.has(address)) &&
+            indexingContracts
+            ->Utils.Dict.dangerouslyGetNonOption(address->Address.toString)
+            ->Option.isSome
+          ) {
+            let registeringContracts =
+              registeringContractsByContract->Utils.Dict.getOrInsertEmptyDict(contractName)
+            registeringContracts->Js.Dict.set(
+              address->Address.toString,
+              indexingContracts->Js.Dict.unsafeGet(address->Address.toString),
+            )
+          }
+        })
+      })
+
+    // Non-wildcard with lfb <= target: keep, adjust pending queries and mergeBlock
+    | {addressesByContractName} => {
+        // Cap mergeBlock at target
+        let mergeBlock = switch p.mergeBlock {
+        | Some(mergeBlock) if mergeBlock > targetBlockNumber => Some(targetBlockNumber)
+        | other => other
+        }
+
+        // Remove addresses that should be removed
+        let rollbackedAddressesByContractName = Js.Dict.empty()
+        addressesByContractName->Utils.Dict.forEachWithKey((addresses, contractName) => {
+          let keptAddresses =
+            addresses->Array.keep(address => !(addressesToRemove->Utils.Set.has(address)))
+          if keptAddresses->Array.length > 0 {
+            rollbackedAddressesByContractName->Js.Dict.set(contractName, keptAddresses)
+          }
+        })
+
+        if rollbackedAddressesByContractName->Js.Dict.keys->Array.length > 0 {
+          let id = nextKeptIdRef.contents->Int.toString
+          nextKeptIdRef := nextKeptIdRef.contents + 1
+          keptPartitions
+          ->Js.Array2.push({
+            ...p,
+            id,
+            addressesByContractName: rollbackedAddressesByContractName,
+            mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, ~targetBlockNumber),
+            mergeBlock,
+          })
+          ->ignore
+        }
+      }
+    }
+  }
+
+  // Step 3: Recreate partitions from deleted partition addresses
+  let optimizedPartitions = createPartitionsFromIndexingAddresses(
+    ~registeringContractsByContract,
+    ~contractConfigs=fetchState.contractConfigs,
+    ~dynamicContracts=fetchState.optimizedPartitions.dynamicContracts,
+    ~normalSelection=fetchState.normalSelection,
+    ~maxAddrInPartition=fetchState.optimizedPartitions.maxAddrInPartition,
+    ~nextPartitionIndex=nextKeptIdRef.contents,
+    ~existingPartitions=keptPartitions,
+    ~progressBlockNumber=targetBlockNumber,
+  )
 
+  // Step 4: Update state
   {
     ...fetchState,
-    latestOnBlockBlockNumber: targetBlockNumber, // TODO: This is not tested. I assume there might be a possible issue of it skipping some blocks
+    // TODO: Test this. Currently it's not tested.
+    latestOnBlockBlockNumber: Pervasives.min(
+      fetchState.latestOnBlockBlockNumber,
+      targetBlockNumber,
+    ),
   }->updateInternal(
-    ~partitions,
+    ~optimizedPartitions,
     ~indexingContracts,
     ~mutItems=fetchState.buffer->Array.keep(item =>
       switch item {
@@ -1187,6 +1758,32 @@ let rollback = (fetchState: t, ~targetBlockNumber) => {
   )
 }
 
+// Reset pending queries by removing in-flight queries (ones without fetchedBlock).
+// Completed queries (with fetchedBlock) are kept so rollback can handle them.
+// Since we can continue fetching partitions with holes, this works correctly.
+let resetPendingQueries = (fetchState: t) => {
+  let newEntities = fetchState.optimizedPartitions.entities->Utils.Dict.shallowCopy
+
+  for idx in 0 to fetchState.optimizedPartitions.idsInAscOrder->Array.length - 1 {
+    let partitionId = fetchState.optimizedPartitions.idsInAscOrder->Js.Array2.unsafe_get(idx)
+    let partition = fetchState.optimizedPartitions.entities->Js.Dict.unsafeGet(partitionId)
+
+    if partition.mutPendingQueries->Array.length > 0 {
+      // Keep only completed queries (with fetchedBlock)
+      let kept = partition.mutPendingQueries->Array.keep(pq => pq.fetchedBlock !== None)
+      newEntities->Js.Dict.set(partitionId, {...partition, mutPendingQueries: kept})
+    }
+  }
+
+  {
+    ...fetchState,
+    optimizedPartitions: {
+      ...fetchState.optimizedPartitions,
+      entities: newEntities,
+    },
+  }
+}
+
 /**
 * Returns a boolean indicating whether the fetch state is actively indexing
 * used for comparing event queues in the chain manager
@@ -1204,15 +1801,12 @@ let isActivelyIndexing = ({endBlock} as fetchState: t) => {
   }
 }
 
-let isReadyToEnterReorgThreshold = (
-  {endBlock, blockLag, buffer} as fetchState: t,
-  ~currentBlockHeight,
-) => {
+let isReadyToEnterReorgThreshold = ({endBlock, blockLag, buffer, knownHeight} as fetchState: t) => {
   let bufferBlockNumber = fetchState->bufferBlockNumber
-  currentBlockHeight !== 0 &&
+  knownHeight !== 0 &&
   switch endBlock {
   | Some(endBlock) if bufferBlockNumber >= endBlock => true
-  | _ => bufferBlockNumber >= currentBlockHeight - blockLag
+  | _ => bufferBlockNumber >= knownHeight - blockLag
   } &&
   buffer->Utils.Array.isEmpty
 }
@@ -1225,26 +1819,40 @@ let sortForUnorderedBatch = {
     }
   }
 
+  // Lower progress percentage = further behind = higher priority
+  let getProgressPercentage = (fetchState: t) => {
+    switch fetchState.firstEventBlock {
+    | None => 0.
+    | Some(firstEventBlock) =>
+      let totalRange = fetchState.knownHeight - firstEventBlock
+      if totalRange <= 0 {
+        0.
+      } else {
+        let progress = switch fetchState.buffer->Belt.Array.get(0) {
+        | Some(item) => item->Internal.getItemBlockNumber - firstEventBlock
+        | None => fetchState->bufferBlockNumber - firstEventBlock
+        }
+        progress->Int.toFloat /. totalRange->Int.toFloat
+      }
+    }
+  }
+
   (fetchStates: array<t>, ~batchSizeTarget: int) => {
     fetchStates
     ->Array.copy
     ->Js.Array2.sortInPlaceWith((a: t, b: t) => {
       switch (a->hasFullBatch(~batchSizeTarget), b->hasFullBatch(~batchSizeTarget)) {
       | (true, true)
-      | (false, false) =>
-        switch (a.buffer->Belt.Array.get(0), b.buffer->Belt.Array.get(0)) {
-        | (Some(Event({timestamp: aTimestamp})), Some(Event({timestamp: bTimestamp}))) =>
-          aTimestamp - bTimestamp
-        | (Some(Block(_)), _)
-        | (_, Some(Block(_))) =>
-          // Currently block items don't have a timestamp,
-          // so we sort chains with them in a random order
-          Js.Math.random_int(-1, 1)
-        // We don't care about the order of chains with no items
-        // Just keep them to increase the progress block number when relevant
-        | (Some(_), None) => -1
-        | (None, Some(_)) => 1
-        | (None, None) => 0
+      | (false, false) => {
+          let aProgress = a->getProgressPercentage
+          let bProgress = b->getProgressPercentage
+          if aProgress < bProgress {
+            -1
+          } else if aProgress > bProgress {
+            1
+          } else {
+            0
+          }
         }
       | (true, false) => -1
       | (false, true) => 1
@@ -1262,3 +1870,12 @@ let getUnorderedMultichainProgressBlockNumberAt = ({buffer} as fetchState: t, ~i
   | _ => bufferBlockNumber
   }
 }
+
+let updateKnownHeight = (fetchState: t, ~knownHeight) => {
+  if knownHeight > fetchState.knownHeight {
+    Prometheus.IndexingKnownHeight.set(~blockNumber=knownHeight, ~chainId=fetchState.chainId)
+    fetchState->updateInternal(~knownHeight)
+  } else {
+    fetchState
+  }
+}