envio 3.12.0 → 3.13.0-alpha.0

package/src/Core.res.mjs

@@ -88,6 +88,10 @@ let loadDevAddon = (function(req, envioDir) {
     fs.copyFileSync(srcPath, nodePath);
   }
 
+  // Forked workers inherit this, so only the first process in a run pays for
+  // the cargo build (and they don't contend over the cargo lock).
+  process.env.ENVIO_DEV_ADDON = nodePath;
+
   return req(nodePath);
 });
 

package/src/CrossChainState.res

@@ -17,6 +17,11 @@ type t = {
   mutable isCaughtUp: bool,
   // Indexer-wide fetch buffer pool (item count), shared across all chains.
   targetBufferSize: int,
+  // Set on a process driving part of a split run: the chains it drives may be
+  // at the head while chains in another process are still backfilling, and an
+  // indexer switches to realtime as a whole or not at all. Cleared by the
+  // supervisor once every chain in the run has arrived.
+  mutable holdRealtime: bool,
 }
 
 // The whole-indexer fetch buffer pool, independent of chain count.
@@ -26,16 +31,50 @@ let calculateTargetBufferSize = () =>
   | None => 100_000
   }
 
-let make = (~chainStates, ~isRealtime, ~targetBufferSize=calculateTargetBufferSize()): t => {
+let make = (
+  ~chainStates,
+  ~isRealtime,
+  ~targetBufferSize=calculateTargetBufferSize(),
+  ~holdRealtime=false,
+): t => {
   {
     chainStates,
     chainIds: chainStates->Dict.valuesToArray->Array.map(cs => (cs->ChainState.chainConfig).id),
     isRealtime,
     isCaughtUp: isRealtime,
     targetBufferSize,
+    holdRealtime,
   }
 }
 
+// The supervisor's go-ahead: every chain in the run has reached the head, so
+// this process may make the transitions it has been holding back.
+let releaseRealtime = (crossChainState: t) => crossChainState.holdRealtime = false
+
+let isHoldingRealtime = (crossChainState: t) => crossChainState.holdRealtime
+
+// Whether this process has got as far as it can without the run's leave. What a
+// supervisor reads to decide that a split run may go realtime as one.
+//
+// Three ways to have arrived, because a chain can be as far along as it can get
+// in three different states. Its chains have caught up; or it resumed already
+// realtime; or every chain is waiting to enter the reorg threshold, which is as
+// far as one can fetch while the pre-threshold lag holds it at the safe block —
+// entering the threshold is what lifts that lag, so a run held until its chains
+// reached the head would be holding back the transition that gets them there.
+//
+// The process's own conclusion rather than a reading a supervisor reassembles:
+// a chain committed at what was the head and resumed once the head had moved on
+// has arrived, and no live reading of it can say so — which is the same reason
+// `markCaughtUpOnResume` decides before any source request.
+let hasArrivedAtHead = (crossChainState: t) =>
+  crossChainState.isCaughtUp ||
+  crossChainState.isRealtime || {
+      let chainStates = crossChainState.chainStates->Dict.valuesToArray
+      chainStates->Utils.Array.notEmpty &&
+        chainStates->Array.every(ChainState.isReadyToEnterReorgThreshold)
+    }
+
 // Resolve a chain's state by id. The id always comes from `chainIds`, which is
 // derived from `chainStates`, so the entry is guaranteed present.
 let getChainState = (crossChainState: t, chainId) =>
@@ -114,7 +153,7 @@ let createBatch = (
     ~history=config->HistoryPolicy.decide(~shouldSaveHistory=crossChainState->shouldSaveHistory),
     ~frontier,
     ~chainsBeforeBatch=crossChainState.chainStates->Utils.Dict.mapValues(
-      ChainState.toChainBeforeBatch,
+      ChainState.toChainBeforeBatch(~isRealtime=crossChainState.isRealtime, ...),
     ),
     ~batchSizeTarget,
   )
@@ -122,6 +161,16 @@ let createBatch = (
 
 // Enter the reorg threshold: shrink each chain's buffer by its configured
 // blockLag and flip the flag.
+// Whether every chain this process drives has buffered close enough to the head
+// to enter the threshold together — and, in a split run, whether the rest of the
+// run has too. Chains enter it as one indexer, so one chain still backfilling
+// holds the others back whatever process it runs in.
+let isReadyToEnterReorgThreshold = (crossChainState: t, ~batch) =>
+  !crossChainState.holdRealtime &&
+    crossChainState.chainStates
+    ->Dict.valuesToArray
+    ->Array.every(cs => cs->ChainState.isReadyToEnterReorgThresholdAfterBatch(~batch))
+
 let enterReorgThreshold = (crossChainState: t) => {
   Logging.info("Reorg threshold reached")
 
@@ -150,7 +199,10 @@ let applyBatchProgress = (crossChainState: t, ~batch: Batch.t, ~blockTimestampNa
   }
 
   crossChainState.isCaughtUp =
-    crossChainState.isCaughtUp || (crossChainState->nextItemIsNone && everyChainCaughtUp.contents)
+    crossChainState.isCaughtUp ||
+      (!crossChainState.holdRealtime &&
+      crossChainState->nextItemIsNone &&
+      everyChainCaughtUp.contents)
 }
 
 // Every chain has buffered up to its head (or endblock) with nothing
@@ -174,8 +226,13 @@ let isSettledAtHead = (crossChainState: t) => {
 }
 
 // Enter the FinalizingIndexes phase without a batch, for the resume above.
+// Not while the run holds this process back: the hold keeps the pre-threshold
+// lag in place, and a chain that has fetched to a lagged head it was never
+// going to get past reads as settled without having indexed anything. What a
+// held process may conclude about where it stands, it concludes from what was
+// persisted — see `markCaughtUpOnResume`, which the hold leaves alone.
 let markCaughtUpIfSettled = (crossChainState: t) =>
-  if crossChainState->isSettledAtHead {
+  if !crossChainState.holdRealtime && crossChainState->isSettledAtHead {
     crossChainState.isCaughtUp = true
   }
 

package/src/CrossChainState.res.mjs

@@ -20,19 +20,41 @@ function calculateTargetBufferSize() {
   }
 }
 
-function make(chainStates, isRealtime, targetBufferSizeOpt) {
+function make(chainStates, isRealtime, targetBufferSizeOpt, holdRealtimeOpt) {
   let targetBufferSize = targetBufferSizeOpt !== undefined ? targetBufferSizeOpt : (
       Env.targetBufferSize !== undefined ? Env.targetBufferSize : 100000
     );
+  let holdRealtime = holdRealtimeOpt !== undefined ? holdRealtimeOpt : false;
   return {
     chainStates: chainStates,
     chainIds: Object.values(chainStates).map(cs => ChainState.chainConfig(cs).id),
     isRealtime: isRealtime,
     isCaughtUp: isRealtime,
-    targetBufferSize: targetBufferSize
+    targetBufferSize: targetBufferSize,
+    holdRealtime: holdRealtime
   };
 }
 
+function releaseRealtime(crossChainState) {
+  crossChainState.holdRealtime = false;
+}
+
+function isHoldingRealtime(crossChainState) {
+  return crossChainState.holdRealtime;
+}
+
+function hasArrivedAtHead(crossChainState) {
+  if (crossChainState.isCaughtUp || crossChainState.isRealtime) {
+    return true;
+  }
+  let chainStates = Object.values(crossChainState.chainStates);
+  if (Utils.$$Array.notEmpty(chainStates)) {
+    return chainStates.every(ChainState.isReadyToEnterReorgThreshold);
+  } else {
+    return false;
+  }
+}
+
 function chainStates(crossChainState) {
   return crossChainState.chainStates;
 }
@@ -91,7 +113,15 @@ function getSafeCheckpointIdByChain(crossChainState, sequence, committedFrontier
 }
 
 function createBatch(crossChainState, config, frontier, batchSizeTarget) {
-  return Batch.make(config.checkpointSequence, frontier, Utils.Dict.mapValues(crossChainState.chainStates, ChainState.toChainBeforeBatch), batchSizeTarget, HistoryPolicy.decide(config, shouldSaveHistory(crossChainState)));
+  return Batch.make(config.checkpointSequence, frontier, Utils.Dict.mapValues(crossChainState.chainStates, none => ChainState.toChainBeforeBatch(none, crossChainState.isRealtime)), batchSizeTarget, HistoryPolicy.decide(config, shouldSaveHistory(crossChainState)));
+}
+
+function isReadyToEnterReorgThreshold(crossChainState, batch) {
+  if (crossChainState.holdRealtime) {
+    return false;
+  } else {
+    return Object.values(crossChainState.chainStates).every(cs => ChainState.isReadyToEnterReorgThresholdAfterBatch(cs, batch));
+  }
 }
 
 function enterReorgThreshold(crossChainState) {
@@ -111,7 +141,7 @@ function applyBatchProgress(crossChainState, batch, blockTimestampName) {
       everyChainCaughtUp = false;
     }
   }
-  crossChainState.isCaughtUp = crossChainState.isCaughtUp || nextItemIsNone(crossChainState) && everyChainCaughtUp;
+  crossChainState.isCaughtUp = crossChainState.isCaughtUp || !crossChainState.holdRealtime && nextItemIsNone(crossChainState) && everyChainCaughtUp;
 }
 
 function isSettledAtHead(crossChainState) {
@@ -125,7 +155,7 @@ function isSettledAtHead(crossChainState) {
 }
 
 function markCaughtUpIfSettled(crossChainState) {
-  if (isSettledAtHead(crossChainState)) {
+  if (!crossChainState.holdRealtime && isSettledAtHead(crossChainState)) {
     crossChainState.isCaughtUp = true;
     return;
   }
@@ -256,6 +286,10 @@ export {
   shouldSaveHistory,
   nextItemIsNone,
   getSafeCheckpointIdByChain,
+  releaseRealtime,
+  isHoldingRealtime,
+  hasArrivedAtHead,
+  isReadyToEnterReorgThreshold,
   createBatch,
   enterReorgThreshold,
   applyBatchProgress,

package/src/CrossChainState.resi

@@ -5,7 +5,12 @@ type t
 
 let calculateTargetBufferSize: unit => int
 
-let make: (~chainStates: dict<ChainState.t>, ~isRealtime: bool, ~targetBufferSize: int=?) => t
+let make: (
+  ~chainStates: dict<ChainState.t>,
+  ~isRealtime: bool,
+  ~targetBufferSize: int=?,
+  ~holdRealtime: bool=?,
+) => t
 
 // Accessors.
 let chainStates: t => dict<ChainState.t>
@@ -25,6 +30,10 @@ let getSafeCheckpointIdByChain: (
 ) => array<(ChainId.t, option<Internal.checkpointId>)>
 
 // Cross-chain transitions.
+let releaseRealtime: t => unit
+let isHoldingRealtime: t => bool
+let hasArrivedAtHead: t => bool
+let isReadyToEnterReorgThreshold: (t, ~batch: Batch.t) => bool
 let createBatch: (t, ~config: Config.t, ~frontier: Frontier.t, ~batchSizeTarget: int) => Batch.t
 let enterReorgThreshold: t => unit
 let applyBatchProgress: (t, ~batch: Batch.t, ~blockTimestampName: string) => unit

package/src/Env.res

@@ -127,6 +127,10 @@ module Db = {
     //the SSL modes should be provided as string otherwise as 'require' | 'allow' | 'prefer' | 'verify-full'
     ~devFallback=Bool(false),
   )
+  // The budget for the whole run, not for one process: a run that splits across
+  // workers divides it among them, and each caps its own pool to its share.
+  // The default buys a single worker, so a run splits only once the operator
+  // raises the budget it may spend.
   let maxConnections = envSafe->EnvSafe.get("ENVIO_PG_MAX_CONNECTIONS", S.int, ~fallback=2)
 }
 

package/src/FetchState.res

@@ -50,6 +50,22 @@ let makeSelection = (~onEventRegistrations, ~dependsOnAddresses, ~clientFiltered
   startBlock: ?deriveSelectionStartBlock(onEventRegistrations),
 }
 
+// A partition's frontier never sits below the block before its selection can
+// first match: the blocks below hold nothing for it, so they count as fetched
+// the same way the blocks before an address's start block do. The chain's
+// buffer frontier is its lowest partition frontier, so a partition left at the
+// chain start would hold every other partition's events back as unprocessable
+// and keep the chain's query target — sized from that frontier — short of
+// anything worth asking for. A start block the chain has not reached yet leaves
+// the partition waiting there, like an address partition does, rather than
+// scanning empty ranges up to it; bufferBlockNumber caps the chain's frontier at
+// the head meanwhile.
+let floorAtSelectionStart = (latestFetchedBlock, ~selection) =>
+  switch selection.startBlock {
+  | Some(startBlock) => Pervasives.max(latestFetchedBlock, startBlock - 1)
+  | None => latestFetchedBlock
+  }
+
 type pendingQuery = {
   fromBlock: int,
   toBlock: option<int>,
@@ -398,6 +414,10 @@ module OptimizedPartitions = {
     ~dynamicContracts: Utils.Set.t<string>,
     ~clientFilteredContracts: Utils.Set.t<string>,
   ) => {
+    let partitions = partitions->Array.map(p => {
+      let floored = p.latestFetchedBlock->floorAtSelectionStart(~selection=p.selection)
+      floored === p.latestFetchedBlock ? p : {...p, latestFetchedBlock: floored}
+    })
     let newPartitions = []
     let mergingPartitions = Dict.make()
     let nextPartitionIndexRef = ref(nextPartitionIndex)
@@ -847,28 +867,17 @@ type t = {
   clientFilterAddressThreshold: option<int>,
 }
 
+// The latest block whose items are all in the buffer: the lowest partition
+// frontier, held back by the onBlock pointer. Without onBlock registrations the
+// pointer tracks the known height, so this also caps the frontier at the head: a
+// partition can sit past it, on a response that reported a block the chain
+// hadn't heard of yet or on a start block the chain hasn't reached.
 @inline
 let bufferBlockNumber = ({latestOnBlockBlockNumber, optimizedPartitions}: t) => {
   switch optimizedPartitions->OptimizedPartitions.getLatestFullyFetchedBlock {
   | None => latestOnBlockBlockNumber
   | Some(latestFullyFetchedBlock) =>
-    latestOnBlockBlockNumber < latestFullyFetchedBlock
-      ? latestOnBlockBlockNumber
-      : latestFullyFetchedBlock
-  }
-}
-
-/**
-* Returns the latest block which is ready to be consumed
-*/
-@inline
-let bufferBlock = ({optimizedPartitions, latestOnBlockBlockNumber}: t) => {
-  switch optimizedPartitions->OptimizedPartitions.getLatestFullyFetchedBlock {
-  | None => latestOnBlockBlockNumber
-  | Some(latestFullyFetchedBlock) =>
-    latestOnBlockBlockNumber < latestFullyFetchedBlock
-      ? latestOnBlockBlockNumber
-      : latestFullyFetchedBlock
+    Pervasives.min(latestOnBlockBlockNumber, latestFullyFetchedBlock)
   }
 }
 
@@ -1138,14 +1147,20 @@ let updateInternal = (
     // Use maxOnBlockBufferSize to get the last target item in the buffer
     // (sorted, so this is the highest-block item within the buffer cap).
     // All this needed to prevent OOM when adding too many block items to the queue
-    let maxBlockNumber = switch base->Array.get(fetchState.maxOnBlockBufferSize - 1) {
-    | Some(item) => item->Internal.getItemBlockNumber
-    | None =>
-      switch optimizedPartitions->OptimizedPartitions.getLatestFullyFetchedBlock {
-      | None => knownHeight
-      | Some(latestFullyFetchedBlock) => latestFullyFetchedBlock
-      }
-    }
+    // Never past the head: a partition can sit there, on a start block the
+    // chain hasn't reached, and a response is applied before the height it
+    // reported, so its events can run past the height still known here.
+    let maxBlockNumber = Pervasives.min(
+      switch base->Array.get(fetchState.maxOnBlockBufferSize - 1) {
+      | Some(item) => item->Internal.getItemBlockNumber
+      | None =>
+        switch optimizedPartitions->OptimizedPartitions.getLatestFullyFetchedBlock {
+        | None => knownHeight
+        | Some(latestFullyFetchedBlock) => latestFullyFetchedBlock
+        }
+      },
+      knownHeight,
+    )
     appendOnBlockItems(
       ~mutItems=blockItems,
       ~onBlockRegistrations,
@@ -2165,27 +2180,11 @@ 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: cursor.contents,
         chunksUsedThisCall: chunksUsedThisCall.contents,
         inFlightCount,
         queryEndBlock,
@@ -2780,10 +2779,17 @@ let make = (
   // fetching, so without seeding the buffer here getNextQuery would return
   // NothingToQuery and the indexer would get stuck.
   let buffer = []
-  let latestOnBlockBlockNumber = if knownHeight > 0 && onBlockRegistrations->Utils.Array.notEmpty {
+  let latestOnBlockBlockNumber = switch onBlockRegistrations {
+  // As updateInternal keeps it: with nothing to generate per block the pointer
+  // is the head cap on the buffer frontier, and left at the progress block it
+  // would hold the frontier there until the first height update — below a
+  // partition that starts later, whose queries the chain sizes off that
+  // frontier and so never reaches.
+  | [] if knownHeight > 0 => knownHeight
+  | onBlockRegistrations if knownHeight > 0 =>
     let maxBlockNumber = switch optimizedPartitions->OptimizedPartitions.getLatestFullyFetchedBlock {
     | None => knownHeight
-    | Some(latestFullyFetchedBlock) => latestFullyFetchedBlock
+    | Some(latestFullyFetchedBlock) => Pervasives.min(latestFullyFetchedBlock, knownHeight)
     }
     appendOnBlockItems(
       ~mutItems=buffer,
@@ -2793,8 +2799,7 @@ let make = (
       ~maxBlockNumber,
       ~maxOnBlockBufferSize,
     )
-  } else {
-    progressBlockNumber
+  | _ => progressBlockNumber
   }
 
   let fetchState = {

package/src/FetchState.res.mjs

@@ -47,6 +47,15 @@ function makeSelection(onEventRegistrations, dependsOnAddresses, clientFilteredC
   };
 }
 
+function floorAtSelectionStart(latestFetchedBlock, selection) {
+  let startBlock = selection.startBlock;
+  if (startBlock !== undefined) {
+    return Primitive_int.max(latestFetchedBlock, startBlock - 1 | 0);
+  } else {
+    return latestFetchedBlock;
+  }
+}
+
 function withAddresses(p, addresses) {
   return {
     id: p.id,
@@ -305,6 +314,26 @@ function getAnchorSafeBlock(p) {
 }
 
 function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContracts, clientFilteredContracts) {
+  let partitions$1 = partitions.map(p => {
+    let floored = floorAtSelectionStart(p.latestFetchedBlock, p.selection);
+    if (floored === p.latestFetchedBlock) {
+      return p;
+    } else {
+      return {
+        id: p.id,
+        latestFetchedBlock: floored,
+        selection: p.selection,
+        addresses: p.addresses,
+        mergeBlock: p.mergeBlock,
+        dynamicContract: p.dynamicContract,
+        mutPendingQueries: p.mutPendingQueries,
+        sourceRangeCapacity: p.sourceRangeCapacity,
+        prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+        eventDensity: p.eventDensity,
+        latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
+      };
+    }
+  });
   let newPartitions = [];
   let mergingPartitions = {};
   let nextPartitionIndexRef = {
@@ -313,7 +342,7 @@ function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContrac
   let anchorSafeBlocks = {};
   let anchoredContractsSet = new Set();
   if (clientFilteredContracts.size > 0) {
-    partitions.forEach(p => {
+    partitions$1.forEach(p => {
       let match = p.mergeBlock;
       let match$1 = p.selection.clientFilteredContracts;
       if (match !== undefined) {
@@ -332,8 +361,8 @@ function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContrac
       });
     });
   }
-  for (let idx = 0, idx_finish = partitions.length; idx < idx_finish; ++idx) {
-    let p = partitions[idx];
+  for (let idx = 0, idx_finish = partitions$1.length; idx < idx_finish; ++idx) {
+    let p = partitions$1[idx];
     let mergeBlock = p.mergeBlock;
     if (mergeBlock !== undefined) {
       if (p.latestFetchedBlock < mergeBlock || isFetching(p)) {
@@ -676,20 +705,8 @@ function bufferBlockNumber(param) {
   let optimizedPartitions = param.optimizedPartitions;
   let id = optimizedPartitions.idsInAscOrder[0];
   let latestFullyFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
-  if (latestFullyFetchedBlock !== undefined && latestOnBlockBlockNumber >= latestFullyFetchedBlock) {
-    return latestFullyFetchedBlock;
-  } else {
-    return latestOnBlockBlockNumber;
-  }
-}
-
-function bufferBlock(param) {
-  let latestOnBlockBlockNumber = param.latestOnBlockBlockNumber;
-  let optimizedPartitions = param.optimizedPartitions;
-  let id = optimizedPartitions.idsInAscOrder[0];
-  let latestFullyFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
-  if (latestFullyFetchedBlock !== undefined && latestOnBlockBlockNumber >= latestFullyFetchedBlock) {
-    return latestFullyFetchedBlock;
+  if (latestFullyFetchedBlock !== undefined) {
+    return Primitive_int.min(latestOnBlockBlockNumber, latestFullyFetchedBlock);
   } else {
     return latestOnBlockBlockNumber;
   }
@@ -897,14 +914,15 @@ function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, mutItemsSo
   let latestOnBlockBlockNumber;
   if (onBlockRegistrations.length !== 0) {
     let item = base[fetchState.maxOnBlockBufferSize - 1 | 0];
-    let maxBlockNumber;
+    let tmp;
     if (item !== undefined) {
-      maxBlockNumber = item.blockNumber;
+      tmp = item.blockNumber;
     } else {
       let id = optimizedPartitions.idsInAscOrder[0];
       let latestFullyFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
-      maxBlockNumber = latestFullyFetchedBlock !== undefined ? latestFullyFetchedBlock : knownHeight;
+      tmp = latestFullyFetchedBlock !== undefined ? latestFullyFetchedBlock : knownHeight;
     }
+    let maxBlockNumber = Primitive_int.min(tmp, knownHeight);
     latestOnBlockBlockNumber = appendOnBlockItems(blockItems, onBlockRegistrations, fetchState.startBlock, fetchState.latestOnBlockBlockNumber, maxBlockNumber, fetchState.maxOnBlockBufferSize);
   } else {
     latestOnBlockBlockNumber = knownHeight;
@@ -1486,19 +1504,11 @@ function walkPartitionPending(p, partitionId, inFlightCount, candidates, headBlo
     }
     pqIdx = pqIdx + 1 | 0;
   };
-  let startBlock = p.selection.startBlock;
-  let cursor$1;
-  if (startBlock !== undefined && startBlock > cursor) {
-    let reachable = Utils.$$Math.minOptInt(headBlockNumber, queryEndBlock);
-    cursor$1 = reachable !== undefined && startBlock <= reachable ? startBlock : cursor;
-  } else {
-    cursor$1 = cursor;
-  }
   if (canContinue) {
     return {
       partitionId: partitionId,
       p: p,
-      cursor: cursor$1,
+      cursor: cursor,
       chunksUsedThisCall: chunksUsedThisCall,
       inFlightCount: inFlightCount,
       queryEndBlock: queryEndBlock,
@@ -1800,13 +1810,21 @@ function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addres
   }
   let buffer = [];
   let latestOnBlockBlockNumber;
-  if (knownHeight > 0 && Utils.$$Array.notEmpty(onBlockRegistrations)) {
-    let id = optimizedPartitions.idsInAscOrder[0];
-    let latestFullyFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
-    let maxBlockNumber = latestFullyFetchedBlock !== undefined ? latestFullyFetchedBlock : knownHeight;
-    latestOnBlockBlockNumber = appendOnBlockItems(buffer, onBlockRegistrations, startBlock, progressBlockNumber, maxBlockNumber, maxOnBlockBufferSize);
+  let exit = 0;
+  if (onBlockRegistrations.length !== 0 || knownHeight <= 0) {
+    exit = 1;
   } else {
-    latestOnBlockBlockNumber = progressBlockNumber;
+    latestOnBlockBlockNumber = knownHeight;
+  }
+  if (exit === 1) {
+    if (knownHeight > 0) {
+      let id = optimizedPartitions.idsInAscOrder[0];
+      let latestFullyFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
+      let maxBlockNumber = latestFullyFetchedBlock !== undefined ? Primitive_int.min(latestFullyFetchedBlock, knownHeight) : knownHeight;
+      latestOnBlockBlockNumber = appendOnBlockItems(buffer, onBlockRegistrations, startBlock, progressBlockNumber, maxBlockNumber, maxOnBlockBufferSize);
+    } else {
+      latestOnBlockBlockNumber = progressBlockNumber;
+    }
   }
   return {
     optimizedPartitions: optimizedPartitions,
@@ -2111,6 +2129,7 @@ let chunkRangeGrowthFactor = 1.8;
 export {
   deriveSelectionStartBlock,
   makeSelection,
+  floorAtSelectionStart,
   withAddresses,
   narrowSelectionToRange,
   densityItemsTarget,
@@ -2120,7 +2139,6 @@ export {
   getMinQueryRange,
   OptimizedPartitions,
   bufferBlockNumber,
-  bufferBlock,
   bufferReadyCount,
   getRegistrationIndex,
   comparePath,