envio 3.5.0-alpha.2 → 3.5.0-rc.0

package/src/FetchState.res

@@ -19,6 +19,42 @@ type selection = {
   // gates each item against the chain's address store instead of the
   // partition's set. Absent for normal partitions.
   clientFilteredContracts?: array<string>,
+  // The earliest block any of these registrations can produce an item at.
+  // Derived once here, by `makeSelection`, because `getNextQuery` reads it for
+  // every partition on every tick and a chain can hold hundreds of them.
+  //
+  // Absent when a registration is unrestricted and so can fire from the chain
+  // start — which is also the only case where nothing can be skipped, so absent
+  // and "block 0" are the same answer here. Build selections through
+  // `makeSelection` rather than as literals, or this goes stale.
+  startBlock?: int,
+}
+
+// The earliest block any of the registrations can produce an item at, or `None`
+// when one of them is unrestricted. Nothing below it is worth querying.
+let deriveSelectionStartBlock = (onEventRegistrations: array<Internal.onEventRegistration>) => {
+  let earliest = ref(None)
+  let idx = ref(0)
+  let unrestricted = ref(onEventRegistrations->Utils.Array.isEmpty)
+  while !unrestricted.contents && idx.contents < onEventRegistrations->Array.length {
+    switch (onEventRegistrations->Array.getUnsafe(idx.contents)).startBlock {
+    | None => unrestricted := true
+    | Some(startBlock) =>
+      switch earliest.contents {
+      | Some(current) if current <= startBlock => ()
+      | _ => earliest := Some(startBlock)
+      }
+    }
+    idx := idx.contents + 1
+  }
+  unrestricted.contents ? None : earliest.contents
+}
+
+let makeSelection = (~onEventRegistrations, ~dependsOnAddresses, ~clientFilteredContracts=?) => {
+  onEventRegistrations,
+  dependsOnAddresses,
+  ?clientFilteredContracts,
+  startBlock: ?deriveSelectionStartBlock(onEventRegistrations),
 }
 
 type pendingQuery = {
@@ -100,6 +136,43 @@ type query = {
 
 let withAddresses = (p: partition, addresses: AddressSet.t) => {...p, addresses}
 
+// The selection a query over [fromBlock, toBlock] actually needs: a registration
+// whose own start block sits past the range can't produce an item there, so
+// leaving it out keeps the source from asking the server for its logs at all.
+// The address gate can't express this — it's contract-wide, so an unrestricted
+// sibling holds it open from the chain start for every registration alike.
+//
+// Returns the selection as-is when nothing is dropped (the common case), and
+// for an open-ended query, which may reach any block and so can exclude nothing.
+// Also when every registration would be dropped: `selectionStartBlock` keeps a
+// partition's cursor at or above its earliest start block, so a query below all
+// of them shouldn't exist — and an empty selection is one no source can build.
+let narrowSelectionToRange = (selection: selection, ~toBlock) =>
+  switch toBlock {
+  | None => selection
+  | Some(toBlock) =>
+    let inRange = selection.onEventRegistrations->Array.filter(reg =>
+      switch reg.startBlock {
+      | Some(startBlock) => startBlock <= toBlock
+      | None => true
+      }
+    )
+    switch inRange->Array.length {
+    // Every registration starts above the range. Narrowing to nothing would
+    // build a selection with no log filters, which each source reads as
+    // "select everything" — the opposite of the intent. The partition is
+    // queried unnarrowed instead and the routers drop what hasn't started.
+    | 0 => selection
+    | length if length === selection.onEventRegistrations->Array.length => selection
+    | _ =>
+      makeSelection(
+        ~onEventRegistrations=inRange,
+        ~dependsOnAddresses=selection.dependsOnAddresses,
+        ~clientFilteredContracts=?selection.clientFilteredContracts,
+      )
+    }
+  }
+
 // itemsEst for a query over [fromBlock, toBlock] at the given event density
 // (items/block). toBlock None is the open-ended tail, capped at
 // chainTargetBlock — the soft per-tick horizon the owning chain wants to reach
@@ -127,6 +200,14 @@ let getMinHistoryRange = (p: partition) => {
 // source-capacity history, including when an itemsTarget cap truncates a response.
 let getTrustedDensity = (p: partition) => p.eventDensity
 
+// A response is still owed for this partition, so it owns range nothing else
+// accounts for: removing it would let the frontier advance over blocks the
+// response can still deliver items from, and orphan the response itself.
+// Narrower than a non-empty queue on purpose — a settled query parked behind a
+// gap is data already in hand, and waiting on it would wedge a partition that
+// no longer queries.
+let isFetching = (p: partition) => p.mutPendingQueries->Array.some(pq => pq.fetchedBlock === None)
+
 let getMinQueryRange = (partitions: array<partition>) => {
   let min = ref(0)
   for i in 0 to partitions->Array.length - 1 {
@@ -270,6 +351,47 @@ module OptimizedPartitions = {
   let ascSortFn = (a, b) =>
     Int.compare(a.latestFetchedBlock.blockNumber, b.latestFetchedBlock.blockNumber)
 
+  // Contracts a standing address-free partition already fetches client-side.
+  // Addresses registered for them after that partition passed get a normal
+  // address-bound partition which dies once it catches up (see make), instead
+  // of being folded into the address-free one.
+  let anchoredContracts = (partitions: array<partition>) => {
+    let set = Utils.Set.make()
+    partitions->Array.forEach(p =>
+      switch (p.mergeBlock, p.selection.clientFilteredContracts) {
+      | (None, Some(contractNames)) =>
+        contractNames->Array.forEach(name => set->Utils.Set.add(name)->ignore)
+      | _ => ()
+      }
+    )
+    set
+  }
+
+  // The furthest block an address-free partition's already-dispatched queries
+  // can deliver without the addresses registered from now on. A settled query
+  // claims only what it actually fetched — the rest of its range is re-queried
+  // later, by then against the updated address store — while an in-flight
+  // bounded query claims its whole toBlock. An in-flight unbounded query has no
+  // ceiling at all, so nothing is safe to stop a catch-up partition at yet.
+  let getAnchorSafeBlock = (p: partition) => {
+    let safeRef = ref(Some(p.latestFetchedBlock.blockNumber))
+    p.mutPendingQueries->Array.forEach(pq =>
+      switch (safeRef.contents, pq) {
+      | (None, _) => ()
+      | (Some(safe), {fetchedBlock: Some({blockNumber})}) =>
+        if blockNumber > safe {
+          safeRef := Some(blockNumber)
+        }
+      | (Some(safe), {toBlock: Some(toBlock)}) =>
+        if toBlock > safe {
+          safeRef := Some(toBlock)
+        }
+      | (Some(_), _) => safeRef := None
+      }
+    )
+    safeRef.contents
+  }
+
   /**
    * Optimizes partitions by finding opportunities to merge partitions that
    * are behind other partitions with same/superset of contract names.
@@ -288,19 +410,50 @@ module OptimizedPartitions = {
     let mergingPartitions = Dict.make()
     let nextPartitionIndexRef = ref(nextPartitionIndex)
 
+    // Where a catch-up partition for a client-filtered contract may stop, keyed
+    // by contract name. A contract absent from the dict while present in
+    // anchoredContractsSet has an unbounded query in flight on its address-free
+    // partition — its catch-up can't be bounded yet, and a later call will bound it.
+    let anchorSafeBlocks = Dict.make()
+    let anchoredContractsSet = Utils.Set.make()
+    if clientFilteredContracts->Utils.Set.size > 0 {
+      partitions->Array.forEach(p =>
+        switch (p.mergeBlock, p.selection.clientFilteredContracts) {
+        | (None, Some(contractNames)) =>
+          let safeBlock = p->getAnchorSafeBlock
+          contractNames->Array.forEach(name => {
+            anchoredContractsSet->Utils.Set.add(name)->ignore
+            switch safeBlock {
+            | Some(safeBlock) => anchorSafeBlocks->Dict.set(name, safeBlock)
+            | None => ()
+            }
+          })
+        | _ => ()
+        }
+      )
+    }
+
     for idx in 0 to partitions->Array.length - 1 {
       let p = partitions->Array.getUnsafe(idx)
       switch p {
+      // 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.
+      // A partition already at or past its merge block is done — normally
+      // handleQueryResponse removes it when the response lands, but a rollback
+      // can cap the merge block at the rolled-back frontier, leaving no
+      // response to ever remove it on. A retired partition still awaiting a
+      // response stays until it lands.
+      | {mergeBlock: Some(mergeBlock)} =>
+        if p.latestFetchedBlock.blockNumber < mergeBlock || p->isFetching {
+          newPartitions->Array.push(p)->ignore
+        }
       // 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(_)} =>
+      {selection: {dependsOnAddresses: false}} =>
         newPartitions->Array.push(p)->ignore
       | {dynamicContract: Some(contractName)} =>
         let pAddressesCount = p.addresses->AddressSet.countFor(contractName)
@@ -398,14 +551,46 @@ module OptimizedPartitions = {
       newPartitions->Array.push(currentPRef.contents)->ignore
     }
 
+    // A dynamic partition for a contract the address-free partition already
+    // fetches is a catch-up for addresses registered after that partition
+    // passed them. It merges by disappearing once it reaches the last block
+    // that partition's dispatched queries could have missed them on — its
+    // addresses are in the chain's store, so there is nothing to hand over.
+    let finalPartitions = if anchoredContractsSet->Utils.Set.size === 0 {
+      newPartitions
+    } else {
+      let anchored = []
+      newPartitions->Array.forEach(p =>
+        switch p {
+        | {dynamicContract: Some(contractName), mergeBlock: None}
+          if anchoredContractsSet->Utils.Set.has(contractName) =>
+          switch anchorSafeBlocks->Utils.Dict.dangerouslyGetNonOption(contractName) {
+          | None => anchored->Array.push(p)->ignore
+          | Some(anchorSafeBlock) =>
+            if p.latestFetchedBlock.blockNumber < anchorSafeBlock {
+              anchored->Array.push({...p, mergeBlock: Some(anchorSafeBlock)})->ignore
+            } else if p->isFetching {
+              // Caught up, but a response is still owed: keep it until that
+              // lands rather than dropping the range it owns.
+              anchored
+              ->Array.push({...p, mergeBlock: Some(p.latestFetchedBlock.blockNumber)})
+              ->ignore
+            }
+          }
+        | _ => anchored->Array.push(p)->ignore
+        }
+      )
+      anchored
+    }
+
     // Sort partitions by latestFetchedBlock ascending
-    let _ = newPartitions->Array.sort(ascSortFn)
+    let _ = finalPartitions->Array.sort(ascSortFn)
 
-    let partitionsCount = newPartitions->Array.length
+    let partitionsCount = finalPartitions->Array.length
     let idsInAscOrder = Utils.Array.jsArrayCreate(partitionsCount)
     let entities = Dict.make()
     for idx in 0 to partitionsCount - 1 {
-      let p = newPartitions->Array.getUnsafe(idx)
+      let p = finalPartitions->Array.getUnsafe(idx)
       idsInAscOrder->Array.setUnsafe(idx, p.id)
       entities->Dict.set(p.id, p)
     }
@@ -468,6 +653,10 @@ module OptimizedPartitions = {
     }
   }
 
+  // Every path that stops a partition from fetching keeps it until its last
+  // response lands, so a response always has a partition to advance. A rollback
+  // does delete partitions mid-run, but it bumps the indexer epoch and
+  // ChainFetching drops older responses before they reach here.
   let rec handleQueryResponse = (
     optimizedPartitions: t,
     ~query,
@@ -475,21 +664,13 @@ module OptimizedPartitions = {
     ~itemsCount,
     ~latestFetchedBlock: blockNumberAndTimestamp,
   ) =>
-    switch optimizedPartitions.entities->Utils.Dict.dangerouslyGetNonOption(query.partitionId) {
-    // The partition was absorbed into the address-free client-filtered partition
-    // while this query was in flight. Its items are still merged into the buffer
-    // by the caller (and deduped); there's no partition bookkeeping left to do,
-    // and its reservation is released by ChainState regardless.
-    | None => optimizedPartitions
-    | Some(p) =>
-      optimizedPartitions->handleQueryResponseForPartition(
-        ~p,
-        ~query,
-        ~knownHeight,
-        ~itemsCount,
-        ~latestFetchedBlock,
-      )
-    }
+    optimizedPartitions->handleQueryResponseForPartition(
+      ~p=optimizedPartitions->getOrThrow(~partitionId=query.partitionId),
+      ~query,
+      ~knownHeight,
+      ~itemsCount,
+      ~latestFetchedBlock,
+    )
 
   and handleQueryResponseForPartition = (
     optimizedPartitions: t,
@@ -562,11 +743,15 @@ module OptimizedPartitions = {
       ~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
-    }
+    // Check if partition reached its mergeBlock and should be removed. A
+    // retired partition can hold several queries at once, so it goes only when
+    // the last of them has landed.
+    let partitionReachedMergeBlock =
+      switch p.mergeBlock {
+      | Some(mergeBlock) => updatedLatestFetchedBlock.blockNumber >= mergeBlock
+      | None => false
+      } &&
+      !(p->isFetching)
 
     if partitionReachedMergeBlock {
       mutEntities->Utils.Dict.deleteInPlace(p.id)
@@ -648,7 +833,7 @@ type t = {
   endBlock: option<int>,
   normalSelection: selection,
   // Not used for logic - only metadata
-  chainId: int,
+  chainId: ChainId.t,
   // The block number of the latest block which was added to the queue
   // by the onBlock configs
   // Need a separate pointer for this
@@ -951,18 +1136,24 @@ let addClientFilteredContract = (
   ~chainId,
   ~addressCount,
   ~threshold,
+  // A resumed fetch state re-derives the switch from the persisted addresses,
+  // but it already happened - and was logged - in the run that crossed the
+  // threshold.
+  ~shouldLog=true,
 ) => {
   clientFilteredContracts->Utils.Set.add(contractName)->ignore
-  Logging.createChild(
-    ~params={
-      "chainId": chainId,
-      "contractName": contractName,
-      "addressCount": addressCount,
-      "threshold": threshold,
-    },
-  )->Logging.childTrace(
-    "Switching contract to client-side address filtering: registered address count crossed the server-side threshold.",
-  )
+  if shouldLog {
+    Logging.createChild(
+      ~params={
+        "chainId": chainId,
+        "contractName": contractName,
+        "addressCount": addressCount,
+        "threshold": threshold,
+      },
+    )->Logging.childTrace(
+      "Switching contract to client-side address filtering: registered address count crossed the server-side threshold.",
+    )
+  }
 }
 
 // The block a partition will have fetched to once everything on its pending
@@ -987,9 +1178,10 @@ let claimedFetchedBlock = (p: partition, ~knownHeight) =>
 // fetching without tearing down established state:
 // - The standing address-free partition (no mergeBlock) keeps its id, frontier,
 //   in-flight queries and learned density. Only when a newly-switched contract
-//   must be added does its selection change — under a fresh id, so in-flight
-//   responses built from the old selection are orphaned instead of advancing
-//   the frontier past ranges the new contract wasn't fetched for.
+//   must be added does its selection change — under a fresh id, so responses
+//   built from the old selection can't advance the frontier past ranges the new
+//   contract wasn't fetched for. The old generation is retired beside it,
+//   keeping the queue those responses belong to.
 // - Partitions absorbed below the standing partition's claimed block
 //   (single-contract dynamic partitions and config partitions all of whose
 //   contracts are client-filtered, plus any prior backfill) become one bounded
@@ -998,6 +1190,10 @@ let claimedFetchedBlock = (p: partition, ~knownHeight) =>
 //   it on arrival. The overlap it re-delivers is deduped by mergeIntoBuffer, and
 //   the re-fetch doubles as history for freshly registered addresses: events
 //   dropped before the address was registered now pass the address gate.
+// - A dynamic partition for a contract the standing partition already covers is
+//   left alone: it is a catch-up for addresses registered after that partition
+//   passed them, and OptimizedPartitions.make bounds it against the standing
+//   partition's own claims instead.
 // - A partition mixing client-filtered and server-side contracts stays,
 //   stripped of the client-filtered contracts' addresses — the address-free
 //   partition covers those logs, so fetching them server-side too would only
@@ -1014,6 +1210,10 @@ let collapseClientFilteredContracts = (
   ~normalSelection: selection,
   ~nextPartitionIndexRef: ref<int>,
   ~addressStore: AddressStore.t,
+  // Frontiers of the addresses that were never given a server-side partition
+  // because their contract is already client-filtered. They stand in for the
+  // partitions that would otherwise have been created only to be absorbed here.
+  ~clientFilteredFrontiers: array<blockNumberAndTimestamp>=[],
   ~knownHeight: int,
 ) => {
   if clientFilteredContracts->Utils.Set.size === 0 {
@@ -1024,6 +1224,22 @@ let collapseClientFilteredContracts = (
     let backfills = []
     let absorbedPartitions = []
     let strippedFrontiers = []
+    let anchoredContracts = partitions->OptimizedPartitions.anchoredContracts
+
+    // Retire a partition in place of removing it: same id and selection, same
+    // pending queue, capped at its own frontier so it issues nothing more. It
+    // holds the frontier down and owns its in-flight response until that lands,
+    // then handleQueryResponse drops it.
+    let retire = (p: partition) => {
+      ...p,
+      mergeBlock: Some(p.latestFetchedBlock.blockNumber),
+    }
+    let absorb = p => {
+      absorbedPartitions->Array.push(p)->ignore
+      if p->isFetching {
+        kept->Array.push(p->retire)->ignore
+      }
+    }
 
     partitions->Array.forEach(p =>
       switch p {
@@ -1032,15 +1248,33 @@ let collapseClientFilteredContracts = (
         standingRef := Some(p)
       | {selection: {dependsOnAddresses: false}, mergeBlock: Some(_)} =>
         backfills->Array.push(p)->ignore
-      | {selection: {dependsOnAddresses: false}} => absorbedPartitions->Array.push(p)->ignore
+
+        // The backfill this call builds covers its remaining range from the
+        // same min frontier, so it is superseded — but not before the response
+        // it is waiting on lands.
+        if p->isFetching {
+          kept->Array.push(p->retire)->ignore
+        }
+      | {selection: {dependsOnAddresses: false}} => p->absorb
       | _ =>
         let contractNames = p.addresses->AddressSet.contractNames
         let serverSideNames =
           contractNames->Array.filter(c => !(clientFilteredContracts->Utils.Set.has(c)))
         if serverSideNames->Array.length === contractNames->Array.length {
           kept->Array.push(p)->ignore
+        } else if (
+          switch p.dynamicContract {
+          | Some(contractName) => anchoredContracts->Utils.Set.has(contractName)
+          | None => false
+          }
+        ) {
+          // A catch-up partition for addresses registered after the address-free
+          // partition already covered their contract. It is the correctness
+          // barrier for those addresses until it catches up — absorbing it would
+          // hand that job back to a guessed ceiling.
+          kept->Array.push(p)->ignore
         } else if serverSideNames->Utils.Array.isEmpty {
-          absorbedPartitions->Array.push(p)->ignore
+          p->absorb
         } else {
           strippedFrontiers->Array.push(p.latestFetchedBlock)->ignore
           kept
@@ -1060,6 +1294,7 @@ let collapseClientFilteredContracts = (
     if (
       absorbedPartitions->Utils.Array.isEmpty &&
       strippedFrontiers->Utils.Array.isEmpty &&
+      clientFilteredFrontiers->Utils.Array.isEmpty &&
       !selectionChanged
     ) {
       // Nothing to fold in and no newly-switched contract: leave the standing
@@ -1075,6 +1310,7 @@ let collapseClientFilteredContracts = (
       absorbedPartitions->Array.forEach(p => considerFrontier(p.latestFetchedBlock))
       backfills->Array.forEach(p => considerFrontier(p.latestFetchedBlock))
       strippedFrontiers->Array.forEach(considerFrontier)
+      clientFilteredFrontiers->Array.forEach(considerFrontier)
 
       let regByIndex = Dict.make()
       let addRegs = (regs: array<Internal.onEventRegistration>) =>
@@ -1093,11 +1329,11 @@ let collapseClientFilteredContracts = (
           clientFilteredContracts->Utils.Set.has(reg.eventConfig.contractName)
         ),
       )
-      let newSelection = {
-        dependsOnAddresses: false,
-        onEventRegistrations: regByIndex->Dict.valuesToArray,
-        clientFilteredContracts: clientFilteredContracts->Utils.Set.toArray,
-      }
+      let newSelection = makeSelection(
+        ~dependsOnAddresses=false,
+        ~onEventRegistrations=regByIndex->Dict.valuesToArray,
+        ~clientFilteredContracts=clientFilteredContracts->Utils.Set.toArray,
+      )
 
       switch standingRef.contents {
       | None =>
@@ -1131,6 +1367,15 @@ let collapseClientFilteredContracts = (
         let standingOut = if selectionChanged {
           let id = nextPartitionIndexRef.contents->Int.toString
           nextPartitionIndexRef := nextPartitionIndexRef.contents + 1
+
+          // A response built from the old selection must not advance the new
+          // one's frontier over ranges the newly-switched contract wasn't
+          // fetched for, so the continuing partition takes a fresh id and an
+          // empty queue. The old generation is retired beside it rather than
+          // dropped: it keeps the queue those responses belong to.
+          if standing->isFetching {
+            kept->Array.push(standing->retire)->ignore
+          }
           {...standing, id, selection: newSelection, mutPendingQueries: []}
         } else {
           standing
@@ -1172,6 +1417,65 @@ let collapseClientFilteredContracts = (
   }
 }
 
+let warnAddressRegistration = (
+  ~chainId: ChainId.t,
+  ~contractAddress: Address.t,
+  ~params,
+  message,
+) =>
+  Logging.createChild(
+    ~params={
+      "chainId": chainId,
+      "contractAddress": contractAddress->Address.toString,
+      "details": params,
+    },
+  )->Logging.childWarn(message)
+
+// A rejected registration is simply absent from every partition, so without a
+// warning the user sees a contract that never indexes and nothing saying why.
+// Shared by config-time registration in `make` and by dynamic registration.
+let warnRejectedRegistration = (
+  verdict: AddressStore.verdict,
+  ~chainId: ChainId.t,
+  ~contractAddress: Address.t,
+  ~contractName: string,
+) =>
+  switch verdict {
+  | Conflict({existingContractName}) =>
+    warnAddressRegistration(
+      ~chainId,
+      ~contractAddress,
+      ~params={
+        "existingContractType": existingContractName,
+        "newContractType": contractName,
+      },
+      `Skipping contract registration: Contract address is already registered for one contract and cannot be registered for another contract.`,
+    )
+  | Duplicate({effectiveStartBlock, existingEffectiveStartBlock}) =>
+    // FIXME: Instead of filtering out duplicates, we should check the block
+    // number first. If a new registration has an earlier block number we
+    // should register it for the missing block range.
+    if existingEffectiveStartBlock > effectiveStartBlock {
+      warnAddressRegistration(
+        ~chainId,
+        ~contractAddress,
+        ~params={
+          "existingBlockNumber": existingEffectiveStartBlock,
+          "newBlockNumber": effectiveStartBlock,
+        },
+        `Skipping contract registration: Contract address is already registered at a later block number. Currently registration of the same contract address is not supported by Envio. Reach out to us if it's a problem for you.`,
+      )
+    }
+  | Invalid =>
+    warnAddressRegistration(
+      ~chainId,
+      ~contractAddress,
+      ~params={"contractName": contractName},
+      `Skipping contract registration: Not a valid address for this chain's ecosystem.`,
+    )
+  | Added(_) | NoEvents(_) => ()
+  }
+
 /**
 Creates partitions from indexing addresses with two phases:
 Phase 1: Create per-contract-name partitions (smart grouping by startBlock)
@@ -1199,68 +1503,96 @@ OptimizedPartitions.t => {
   // ── Phase 1: Create per-contract-name partitions ──
   let dynamicPartitions = []
   let nonDynamicPartitions = []
+  let clientFilteredFrontiers = []
+
+  // Contracts an address-free partition already fetches. Their new addresses
+  // need a partition of their own: the address-free partition passed the blocks
+  // they were registered at without them in the store.
+  let anchoredContracts = existingPartitions->OptimizedPartitions.anchoredContracts
 
   let contractNames = registeringSetsByContract->Dict.keysToArray
   for cIdx in 0 to contractNames->Array.length - 1 {
     let contractName = contractNames->Array.getUnsafe(cIdx)
     let contractSet = registeringSetsByContract->Dict.getUnsafe(contractName)
 
-    let isDynamic = dynamicContracts->Utils.Set.has(contractName)
+    let isAnchored = anchoredContracts->Utils.Set.has(contractName)
+    // A catch-up partition must go through the dynamic merge logic — that's
+    // what bounds it against its anchor and removes it once it catches up.
+    let isDynamic = dynamicContracts->Utils.Set.has(contractName) || isAnchored
     let partitions = isDynamic ? dynamicPartitions : nonDynamicPartitions
 
     // A set is ordered by effectiveStartBlock, so its start-block groups are
     // ascending and each group's addresses are a contiguous slice.
     let groups = contractSet->AddressSet.startBlockGroups
-    let offsetRef = ref(0)
-    let groupIdx = ref(0)
-    while groupIdx.contents < groups->Array.length {
-      let startBlock = (groups->Array.getUnsafe(groupIdx.contents)).startBlock
-      // Addresses with different start blocks within range share a partition;
-      // events before each address's effectiveStartBlock are dropped by the
-      // source's address gate.
-      let countRef = ref(0)
-      let nextIdx = ref(groupIdx.contents)
-      let joining = ref(true)
-      while joining.contents && nextIdx.contents < groups->Array.length {
-        let group = groups->Array.getUnsafe(nextIdx.contents)
-        if group.startBlock - startBlock < OptimizedPartitions.tooFarBlockRange {
-          countRef := countRef.contents + group.count
-          nextIdx := nextIdx.contents + 1
-        } else {
-          joining := false
-        }
-      }
 
-      let latestFetchedBlock = {
-        blockNumber: Pervasives.max(startBlock - 1, progressBlockNumber),
-        blockTimestamp: 0,
-      }
-      let remainingRef = ref(countRef.contents)
-      let chunkOffsetRef = ref(offsetRef.contents)
-      while remainingRef.contents > 0 {
-        let take = Pervasives.min(remainingRef.contents, maxAddrInPartition)
-        let pAddresses =
-          contractSet->AddressSet.slice(~offset=chunkOffsetRef.contents, ~limit=Some(take))
-        partitions->Array.push({
-          id: nextPartitionIndexRef.contents->Int.toString,
-          latestFetchedBlock,
-          selection: normalSelection,
-          dynamicContract: isDynamic ? Some(contractName) : None,
-          addresses: pAddresses,
-          mergeBlock: None,
-          mutPendingQueries: [],
-          sourceRangeCapacity: 0,
-          prevSourceRangeCapacity: 0,
-          eventDensity: None,
-          latestSourceRangeCapacityUpdateBlock: 0,
+    if clientFilteredContracts->Utils.Set.has(contractName) && !isAnchored {
+      // The contract is switching to client-side filtering in this very call, so
+      // the collapse below folds everything it has into the address-free
+      // partition anyway. Chunking these addresses by maxAddrInPartition would
+      // only build partitions for it to absorb - hundreds of them for a contract
+      // big enough to be client-filtered in the first place. All the collapse
+      // needs is the earliest block the addresses aren't covered from, which is
+      // the first group's since groups are ascending.
+      switch groups->Array.get(0) {
+      | Some({startBlock}) =>
+        clientFilteredFrontiers->Array.push({
+          blockNumber: Pervasives.max(startBlock - 1, progressBlockNumber),
+          blockTimestamp: 0,
         })
-        nextPartitionIndexRef := nextPartitionIndexRef.contents + 1
-        chunkOffsetRef := chunkOffsetRef.contents + take
-        remainingRef := remainingRef.contents - take
+      | None => ()
       }
+    } else {
+      let offsetRef = ref(0)
+      let groupIdx = ref(0)
+      while groupIdx.contents < groups->Array.length {
+        let startBlock = (groups->Array.getUnsafe(groupIdx.contents)).startBlock
+        // Addresses with different start blocks within range share a partition;
+        // events before each address's effectiveStartBlock are dropped by the
+        // source's address gate.
+        let countRef = ref(0)
+        let nextIdx = ref(groupIdx.contents)
+        let joining = ref(true)
+        while joining.contents && nextIdx.contents < groups->Array.length {
+          let group = groups->Array.getUnsafe(nextIdx.contents)
+          if group.startBlock - startBlock < OptimizedPartitions.tooFarBlockRange {
+            countRef := countRef.contents + group.count
+            nextIdx := nextIdx.contents + 1
+          } else {
+            joining := false
+          }
+        }
 
-      offsetRef := offsetRef.contents + countRef.contents
-      groupIdx := nextIdx.contents
+        let latestFetchedBlock = {
+          blockNumber: Pervasives.max(startBlock - 1, progressBlockNumber),
+          blockTimestamp: 0,
+        }
+        let remainingRef = ref(countRef.contents)
+        let chunkOffsetRef = ref(offsetRef.contents)
+        while remainingRef.contents > 0 {
+          let take = Pervasives.min(remainingRef.contents, maxAddrInPartition)
+          let pAddresses =
+            contractSet->AddressSet.slice(~offset=chunkOffsetRef.contents, ~limit=Some(take))
+          partitions->Array.push({
+            id: nextPartitionIndexRef.contents->Int.toString,
+            latestFetchedBlock,
+            selection: normalSelection,
+            dynamicContract: isDynamic ? Some(contractName) : None,
+            addresses: pAddresses,
+            mergeBlock: None,
+            mutPendingQueries: [],
+            sourceRangeCapacity: 0,
+            prevSourceRangeCapacity: 0,
+            eventDensity: None,
+            latestSourceRangeCapacityUpdateBlock: 0,
+          })
+          nextPartitionIndexRef := nextPartitionIndexRef.contents + 1
+          chunkOffsetRef := chunkOffsetRef.contents + take
+          remainingRef := remainingRef.contents - take
+        }
+
+        offsetRef := offsetRef.contents + countRef.contents
+        groupIdx := nextIdx.contents
+      }
     }
   }
 
@@ -1324,6 +1656,7 @@ OptimizedPartitions.t => {
       ~normalSelection,
       ~nextPartitionIndexRef,
       ~addressStore,
+      ~clientFilteredFrontiers,
       ~knownHeight,
     )
   OptimizedPartitions.make(
@@ -1389,21 +1722,12 @@ let registerDynamicContracts = (
   // single batch conflict the same way as across batches.
   let verdicts = addressStore->AddressStore.registerBatch(registrations)
 
-  let warn = (~contractAddress, ~params, message) =>
-    Logging.createChild(
-      ~params={
-        "chainId": fetchState.chainId,
-        "contractAddress": contractAddress,
-        "details": params,
-      },
-    )->Logging.childWarn(message)
-
   let registeringContractNames = []
   let hasNoEventsUpdatesRef = ref(false)
   for idx in 0 to verdicts->Array.length - 1 {
     let registration = registrations->Array.getUnsafe(idx)
-    let contractAddress = registration.address->Address.toString
-    let keep = switch verdicts->Array.getUnsafe(idx) {
+    let verdict = verdicts->Array.getUnsafe(idx)
+    let keep = switch verdict {
     | Added(_) =>
       if !(registeringContractNames->Array.includes(registration.contractName)) {
         registeringContractNames->Array.push(registration.contractName)->ignore
@@ -1414,42 +1738,18 @@ let registerDynamicContracts = (
       // Persist the address to the db so a future config change that adds
       // events for this contract can pick it up on restart, but skip partition
       // registration since there's nothing to fetch.
-      warn(
-        ~contractAddress,
+      warnAddressRegistration(
+        ~chainId=fetchState.chainId,
+        ~contractAddress=registration.address,
         ~params={"contractName": registration.contractName},
         `Persisting contract registration without fetching: Contract doesn't have any events to fetch. It'll be picked up on restart if you add events for the contract.`,
       )
       true
-    | Conflict({existingContractName}) =>
-      warn(
-        ~contractAddress,
-        ~params={
-          "existingContractType": existingContractName,
-          "newContractType": registration.contractName,
-        },
-        `Skipping contract registration: Contract address is already registered for one contract and cannot be registered for another contract.`,
-      )
-      false
-    | Duplicate({effectiveStartBlock, existingEffectiveStartBlock}) =>
-      // FIXME: Instead of filtering out duplicates, we should check the block
-      // number first. If a new registration has an earlier block number we
-      // should register it for the missing block range.
-      if existingEffectiveStartBlock > effectiveStartBlock {
-        warn(
-          ~contractAddress,
-          ~params={
-            "existingBlockNumber": existingEffectiveStartBlock,
-            "newBlockNumber": effectiveStartBlock,
-          },
-          `Skipping contract registration: Contract address is already registered at a later block number. Currently registration of the same contract address is not supported by Envio. Reach out to us if it's a problem for you.`,
-        )
-      }
-      false
-    | Invalid =>
-      warn(
-        ~contractAddress,
-        ~params={"contractName": registration.contractName},
-        `Skipping contract registration: Not a valid address for this chain's ecosystem.`,
+    | Conflict(_) | Duplicate(_) | Invalid =>
+      verdict->warnRejectedRegistration(
+        ~chainId=fetchState.chainId,
+        ~contractAddress=registration.address,
+        ~contractName=registration.contractName,
       )
       false
     }
@@ -1610,7 +1910,7 @@ let registerDynamicContracts = (
 
 /*
 Updates fetchState with a response for a given query.
-Returns Error if the partition with given query cannot be found (unexpected)
+Throws if the partition with given query cannot be found (unexpected)
 
 newItems are ordered earliest to latest (as they are returned from the worker)
 */
@@ -1884,11 +2184,27 @@ let walkPartitionPending = (
     pqIdx := pqIdx.contents + 1
   }
 
+  // Nothing in this partition's selection can match below its earliest start
+  // block, so forward work skips straight to it instead of scanning up to it and
+  // discarding whole pages. Only the cursor moves — `latestFetchedBlock` still
+  // advances solely on a response, so no block is ever reported fetched that
+  // wasn't. Bounded by the head and the query end block: past either, the
+  // partition would offer no candidate at all, so it queries as before rather
+  // than going quiet until the chain reaches its start block.
+  let cursor = switch p.selection.startBlock {
+  | Some(startBlock) if startBlock > cursor.contents =>
+    switch Utils.Math.minOptInt(Some(headBlockNumber), queryEndBlock) {
+    | Some(reachable) if startBlock <= reachable => startBlock
+    | _ => cursor.contents
+    }
+  | _ => cursor.contents
+  }
+
   canContinue.contents
     ? Some({
         partitionId,
         p,
-        cursor: cursor.contents,
+        cursor,
         chunksUsedThisCall: chunksUsedThisCall.contents,
         inFlightCount,
         queryEndBlock,
@@ -2335,7 +2651,7 @@ let make = (
   ~addressStore: AddressStore.t,
   ~addresses: array<Internal.indexingAddress>,
   ~maxAddrInPartition,
-  ~chainId,
+  ~chainId: ChainId.t,
   ~maxOnBlockBufferSize,
   ~knownHeight,
   ~progressBlockNumber=startBlock - 1,
@@ -2343,6 +2659,7 @@ let make = (
   ~blockLag=0,
   ~firstEventBlock=None,
   ~clientFilterAddressThreshold=None,
+  ~isResumed=false,
 ): t => {
   let latestFetchedBlock = {
     blockTimestamp: 0,
@@ -2368,10 +2685,10 @@ let make = (
     partitions->Array.push({
       id: partitions->Array.length->Int.toString,
       latestFetchedBlock,
-      selection: {
-        dependsOnAddresses: false,
-        onEventRegistrations: notDependingOnAddresses,
-      },
+      selection: makeSelection(
+        ~dependsOnAddresses=false,
+        ~onEventRegistrations=notDependingOnAddresses,
+      ),
       addresses: addressStore->AddressStore.emptySet,
       mergeBlock: None,
       dynamicContract: None,
@@ -2383,10 +2700,10 @@ let make = (
     })
   }
 
-  let normalSelection = {
-    dependsOnAddresses: true,
-    onEventRegistrations: normalRegistrations,
-  }
+  let normalSelection = makeSelection(
+    ~dependsOnAddresses=true,
+    ~onEventRegistrations=normalRegistrations,
+  )
 
   // Every address the chain indexes goes into the store — including ones whose
   // contract has no address-dependent events, so a later registration of the
@@ -2399,7 +2716,17 @@ let make = (
       registrationBlock: contract.registrationBlock,
     }),
   )
-  ->ignore
+  // Verdicts are in the batch's order, so they line up with `addresses`. A
+  // config address the store rejects is dropped exactly like a dynamic one, and
+  // needs the same warning — restored dynamic addresses come through here too.
+  ->Array.forEachWithIndex((verdict, idx) => {
+    let contract = addresses->Array.getUnsafe(idx)
+    verdict->warnRejectedRegistration(
+      ~chainId,
+      ~contractAddress=contract.address,
+      ~contractName=contract.contractName,
+    )
+  })
 
   let dynamicContracts = Utils.Set.make()
   let clientFilteredContracts = Utils.Set.make()
@@ -2438,6 +2765,7 @@ let make = (
           ~chainId,
           ~addressCount,
           ~threshold,
+          ~shouldLog=!isResumed,
         )
       }
     })
@@ -2462,7 +2790,7 @@ let make = (
       onBlockRegistrations->Utils.Array.isEmpty
   ) {
     JsError.throwWithMessage(
-      `Invalid configuration: Nothing to fetch on chain ${chainId->Int.toString}. ` ++
+      `Invalid configuration: Nothing to fetch on chain ${chainId->ChainId.toString}. ` ++
       `addresses=${addresses->Array.length->Int.toString}, ` ++
       `onEventRegistrations=${onEventRegistrations->Array.length->Int.toString}, ` ++
       `normalRegistrations=${normalRegistrations
@@ -2586,6 +2914,14 @@ let rollback = (fetchState: t, ~addressStore: AddressStore.t, ~targetBlockNumber
         latestFetchedBlock: p.latestFetchedBlock.blockNumber > targetBlockNumber
           ? {blockNumber: targetBlockNumber, blockTimestamp: 0}
           : p.latestFetchedBlock,
+        // Everything above the target is refetched by whichever partition this
+        // one was catching up to, so there is nothing left to catch up on past
+        // it. createPartitions drops the partition outright when the capped
+        // block is already reached.
+        mergeBlock: switch p.mergeBlock {
+        | Some(mergeBlock) if mergeBlock > targetBlockNumber => Some(targetBlockNumber)
+        | other => other
+        },
         mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, ~targetBlockNumber),
       })
       ->ignore