dexbot 1.5.3 → 1.6.1

package/dist/modules/order/grid.js

@@ -111,7 +111,7 @@ function _snapshotFundState(manager) {
     };
 }
 import { floatToBlockchainInt, getPrecisionByOrderType, getPrecisionsForManager, calculateOrderCreationFees, calculateOrderSizes, calculateRotationOrderSizes, calculateAvailableFundsValue, calculateGridSideDivergenceMetric, getPrecisionSlack, getMinOrderSize, getSingleDustThreshold, getGridBestPrices, calculateSpreadFromOrders, allocateFundsByWeights, calculateGapSlots as _mathGapSlots, priceSlotEqual, getBtsSide, getSellStartIdx, resolveGapBand, countGapBandSpread, validatePersistedBoundary, adjustBudgetForBtsFees, clamp, buildGenesisFromPriceLevels, assertSlotPriceInvariant, hashPriceLevels, } from './utils/math.js';
-import { filterOrdersByType, checkSizesBeforeMinimum, checkSizeThreshold, resolveConfiguredPriceBound, shouldFlagOutOfSpread, isOrderHealthy, isPhantomOrder, isSlotAvailable, isOrderOnChain, isOrderPlaced, hasOnChainId, isEmptyGridSlot, parseSlotIndex, calculateIdealBoundary, assignGridRoles, resolveOnChainRetypeType } from './utils/order.js';
+import { filterOrdersByType, checkSizesBeforeMinimum, checkSizeThreshold, resolveConfiguredPriceBound, shouldFlagOutOfSpread, isOrderHealthy, isPhantomOrder, isSlotAvailable, isOrderOnChain, isOrderPlaced, hasOnChainId, isEmptyGridSlot, parseSlotIndex, calculateIdealBoundary, assignGridRoles, resolveOnChainRetypeType, resolveReserveCount, reserveEdgeIdSet, resolveLiveReserveEdgeAnchorPrice } from './utils/order.js';
 import { loadAmaCenterPrice, loadAmaCenterSnapshot, withBlockchainRetry } from './utils/system.js';
 import * as MathUtils from './utils/math.js';
 import { derivePriceWithPoolRef } from './utils/withPoolRef.js';
@@ -226,8 +226,8 @@ export async function _getSizingContext(manager, side, { skipRecalc = false } =
     // BTS fees are paid for ALL order operations regardless of side, so the
     // BTS-holding side reserves fees for both buy and sell target counts.
     if (budget > 0) {
-        const targetBuy = Math.max(0, manager.config.activeOrders?.buy ?? 1);
-        const targetSell = Math.max(0, manager.config.activeOrders?.sell ?? 1);
+        const targetBuy = Math.max(0, manager.config.activeOrders?.buy ?? 1) + resolveReserveCount(manager.config, 'buy');
+        const targetSell = Math.max(0, manager.config.activeOrders?.sell ?? 1) + resolveReserveCount(manager.config, 'sell');
         const totalTarget = targetBuy + targetSell;
         const btsOrderType = getBtsSide(manager.config?.assetA, manager.config?.assetB);
         const isBtsSide = isBuy ? (btsOrderType === ORDER_TYPES.BUY) : (btsOrderType === ORDER_TYPES.SELL);
@@ -680,6 +680,21 @@ export async function loadGrid(manager, grid, boundaryIdx = null, genesisInput =
                     manager.logger?.log?.(`[GRID-LOAD] Could not re-derive a safe boundary; continuing without one. ` +
                         `The next sync cycle will reconcile grid geometry against the chain.`, 'error');
                 }
+                // The rejected value must not survive: storeMasterGrid
+                // never persists a null boundary, so without an explicit
+                // erase the poison re-arms this rejection on every boot
+                // (Sep-9: boundary=96 rejected identically 3 restarts in
+                // a row). Best-effort — load continues boundary-less
+                // either way and the next fill batch re-anchors live.
+                try {
+                    const acct = manager?.accountOrders;
+                    if (acct && typeof acct.clearPersistedBoundary === 'function') {
+                        await acct.clearPersistedBoundary();
+                        manager.logger?.log?.(`[GRID-LOAD] Erased poisoned persisted boundary (${boundaryIdx}); ` +
+                            `restart will load boundary-less instead of re-rejecting.`, 'warn');
+                    }
+                }
+                catch { /* load continues boundary-less either way */ }
             }
         }
         // Restore boundary index for StrategyEngine
@@ -1080,6 +1095,65 @@ export async function initializeGrid(manager) {
             `short of ${Math.floor(Number(minScaleSlots))} levels; holding at ${guard.minPrice.toFixed(8)}`, 'info');
         resolvedMinP = guard.minPrice;
     }
+    // P4 / unanchored rebuild anchor: when the new generation is centered
+    // on a static config value (not a live market source), owed fill
+    // crawls carry the only fresh market direction — fold their net
+    // direction into the rebuild center before the ladder is generated.
+    // A live center already contains the movement, so its owed crawls are
+    // dropped as a stale generation (see the clear below).
+    const owedCrawls = Array.isArray(manager._pendingFillCrawls)
+        ? manager._pendingFillCrawls
+        : [];
+    // Whether the ladder CENTER already reflects current market movement.
+    // gpSource describes the gridPrice/bounds reference, NOT the center:
+    // the center is gridStartPrice, built from mp (config.startPrice).
+    // Only a derived startPrice (a non-numeric mode like "pool"/"book"
+    // resolved to a fresh number above) or an AMA-driven center is live:
+    // with gpSource === "ama" the center itself is still mp * (1 +
+    // offset), but the offset comes from the live AMA snapshot, so the
+    // center moves with the market. A numeric startPrice with a live
+    // gridPrice still has a static center — a live gridPrice (bounds
+    // reference only) does not make that static center fresh.
+    const startPriceWasDerived = typeof mpRaw !== 'number' || Number.isNaN(Number(mpRaw));
+    const centerIsLive = startPriceWasDerived || gpSource === 'ama';
+    if (owedCrawls.length > 0 && !centerIsLive) {
+        // Reserve fills never crawl (static insurance). Classify them
+        // against the OLD generation (manager.orders is replaced below)
+        // with the same live anchors the runtime derivation uses, so the
+        // fold can never be driven by a reserve fill.
+        const oldSlots = Array.from(manager.orders?.values?.() ?? []);
+        const edgeAnchors = {
+            buy: resolveLiveReserveEdgeAnchorPrice(manager, 'buy'),
+            sell: resolveLiveReserveEdgeAnchorPrice(manager, 'sell')
+        };
+        const reserveBuyIds = reserveEdgeIdSet(oldSlots, manager.config, ORDER_TYPES.BUY, edgeAnchors.buy);
+        const reserveSellIds = reserveEdgeIdSet(oldSlots, manager.config, ORDER_TYPES.SELL, edgeAnchors.sell);
+        let netShift = 0;
+        for (const e of owedCrawls) {
+            if (e?.side === ORDER_TYPES.BUY && reserveBuyIds?.has(e.slotId))
+                continue;
+            if (e?.side === ORDER_TYPES.SELL && reserveSellIds?.has(e.slotId))
+                continue;
+            if (e?.side === ORDER_TYPES.SELL)
+                netShift++;
+            else if (e?.side === ORDER_TYPES.BUY)
+                netShift--;
+        }
+        const stepPct = Number(manager.config?.incrementPercent);
+        if (netShift !== 0 && Number.isFinite(stepPct) && stepPct > 0) {
+            // One crawl moves the boundary one slot; the geometric ladder
+            // step is incrementPercent, so shift the center by netShift steps.
+            const folded = gridStartPrice * Math.pow(1 + stepPct / 100, netShift);
+            // Re-clamp to the post-guard resolved bounds so a fold cannot
+            // push the center outside the rail it is about to generate.
+            const clampMin = Number.isFinite(Number(resolvedMinP)) ? Number(resolvedMinP) : rMinP;
+            const clampMax = Number.isFinite(Number(resolvedMaxP)) ? Number(resolvedMaxP) : rMaxP;
+            gridStartPrice = Math.max(clampMin, Math.min(clampMax, folded));
+            manager.config.startPrice = gridStartPrice;
+            manager.logger?.log?.(`[BOUNDARY] Folded ${owedCrawls.length} owed fill crawl(s) (net ${netShift}) into ` +
+                `static grid center -> ${gridStartPrice.toFixed(8)}`, 'info');
+        }
+    }
     manager.config.minPrice = resolvedMinP;
     manager.config.maxPrice = resolvedMaxP;
     manager._lastGridPricingContext = {
@@ -1112,6 +1186,12 @@ export async function initializeGrid(manager) {
     manager._gapSlots = gapSlots;
     if (genesis)
         manager._genesis = genesis;
+    // A rebuilt grid is a NEW generation: the boundary below is re-derived
+    // absolutely from the fresh price ladder, so owed fill crawls recorded
+    // against the previous generation must not survive — their relative
+    // deltas would shift the new anchor again for movement it already
+    // contains (and their slot ids now name different prices).
+    manager._clearPendingFillCrawls?.('grid rebuild');
     // RC-8: Update boundary with notification to dependent systems
     // Persist master boundary for StrategyEngine
     if (manager.boundaryIdx !== boundaryIdx) {
@@ -1309,11 +1389,17 @@ export async function recalculateGrid(manager, opts) {
  * @returns {any}
  */
 export function checkAndUpdateGridIfNeeded(manager) {
-    const threshold = manager.config?.gridLimits?.GRID_REGENERATION_PERCENTAGE;
+    const rawThreshold = manager.config?.gridLimits?.GRID_REGENERATION_PERCENTAGE;
+    // NOTE: a configured 0 (or non-numeric) falls back to the global default
+    // instead of disabling. 0 never worked as "disable" (ratio >= 0 is always
+    // true, i.e. constant regen), so no working configuration is broken by this.
+    const threshold = (Number.isFinite(Number(rawThreshold)) && Number(rawThreshold) > 0)
+        ? Number(rawThreshold)
+        : GRID_LIMITS.GRID_REGENERATION_PERCENTAGE;
     const chainSnap = manager.getChainFundsSnapshot();
     const gridBuy = Number(manager.funds?.total?.grid?.buy || 0);
     const gridSell = Number(manager.funds?.total?.grid?.sell || 0);
-    const result = { buyUpdated: false, sellUpdated: false };
+    const result = { buyUpdated: false, sellUpdated: false, buyShrink: false, sellShrink: false };
     const sides = [
         { name: 'buy', grid: gridBuy, orderType: ORDER_TYPES.BUY },
         { name: 'sell', grid: gridSell, orderType: ORDER_TYPES.SELL }
@@ -1321,21 +1407,50 @@ export function checkAndUpdateGridIfNeeded(manager) {
     for (const s of sides) {
         if (s.grid <= 0)
             continue;
-        const availableFunds = calculateAvailableFundsValue(s.name, manager.accountTotals, manager.funds, manager.config.assetA, manager.config.assetB, manager.config.activeOrders, manager.config.min_BTS_value, manager.config.feeParams ?? null);
+        const feeActiveOrders = manager.config.activeOrders && typeof manager.config.activeOrders === 'object'
+            ? {
+                ...manager.config.activeOrders,
+                buy: Math.max(0, Number(manager.config.activeOrders.buy) || 0) + resolveReserveCount(manager.config, 'buy'),
+                sell: Math.max(0, Number(manager.config.activeOrders.sell) || 0) + resolveReserveCount(manager.config, 'sell'),
+            }
+            : manager.config.activeOrders;
+        const availableFunds = calculateAvailableFundsValue(s.name, manager.accountTotals, manager.funds, manager.config.assetA, manager.config.assetB, feeActiveOrders, manager.config.min_BTS_value, manager.config.feeParams ?? null);
         // Denominator: side's allocated capital (or chain total fallback).
         const allocated = s.name === 'buy' ? chainSnap.allocatedBuy : chainSnap.allocatedSell;
         const denominator = (allocated > 0) ? allocated : (s.grid + availableFunds);
         const ratio = (denominator > 0) ? (availableFunds / denominator) * 100 : 0;
-        manager.logger?.log?.(`[DIVERGENCE] ${s.name.toUpperCase()} ratio check: availableFunds=${availableFunds.toFixed(5)}, allocated=${allocated.toFixed(5)}, ratio=${ratio.toFixed(4)}% (threshold=${threshold}%) → ${ratio >= threshold ? 'TRIGGER' : 'no trigger'}`, 'debug');
-        if (ratio >= threshold) {
+        // DOWNSIDE: grid-tracked size exceeds the (botFunds-capped) allocation,
+        // so the side must shrink toward the new budget via the same resize path.
+        // s.grid is funds.total.grid (ACTIVE + PARTIAL + VIRTUAL — planned size,
+        // not just on-chain committed). Deliberately NOT based on per-side
+        // chain-total drops: a normal fill moves value across sides (pays one
+        // asset, receives the other), so one side's total routinely drops >=3%
+        // on ordinary fills — and the fill pipeline already re-sizes from the
+        // post-fill budget. External removal is caught here because the
+        // committed/planned grid stays put while the allocation sinks.
+        // NOTE: with an explicit 0 allocation the shared fallback denominator
+        // yields overAlloc ≈ +100%, i.e. a 0%-funded side holding size always
+        // triggers — which is the desired unwind (zero budget sizes everything
+        // to 0 and the correction pass cancels the surplus; self-clearing).
+        const overAlloc = (denominator > 0) ? ((s.grid - allocated) / denominator) * 100 : 0;
+        const growTrigger = ratio >= threshold;
+        const shrinkTrigger = overAlloc >= threshold;
+        manager.logger?.log?.(`[DIVERGENCE] ${s.name.toUpperCase()} ratio check: availableFunds=${availableFunds.toFixed(5)}, allocated=${allocated.toFixed(5)}, ratio=${ratio.toFixed(4)}% (threshold=${threshold}%) → ${growTrigger ? 'TRIGGER-GROW' : 'no trigger'} | overAlloc=${overAlloc.toFixed(4)}% → ${shrinkTrigger ? 'TRIGGER-SHRINK' : 'no trigger'}`, 'debug');
+        if (growTrigger || shrinkTrigger) {
             // RC-3: Use Set for automatic duplicate prevention
             if (!(manager._gridSidesUpdated instanceof Set))
                 manager._gridSidesUpdated = new Set();
             manager._gridSidesUpdated.add(s.orderType);
-            if (s.name === 'buy')
+            if (s.name === 'buy') {
                 result.buyUpdated = true;
-            else
+                if (shrinkTrigger)
+                    result.buyShrink = true;
+            }
+            else {
                 result.sellUpdated = true;
+                if (shrinkTrigger)
+                    result.sellShrink = true;
+            }
         }
     }
     return result;
@@ -1428,7 +1543,11 @@ export async function _recalculateGridOrderSizesFromBlockchain(manager, orderTyp
     // geometric progression including empties, then re-type the picked slot
     // to BUY/SELL before placement.  The COW boundary-shift path re-types
     // the working grid by geometry first, so crossers stay in the correct
-    // side's denominator.
+    // side's denominator.  Reserve edge slots are deliberately excluded from
+    // that startup re-derivation: they activate only with the size the
+    // target-grid sizing pipeline has already written (exact values, one
+    // sizing rule), and an unsized reserve waits for that pipeline instead
+    // of being placed with a locally guessed size.
     const orderSource = collectActions ? workingGrid : manager.orders;
     const allSideSlots = Array.from(orderSource.values())
         .filter((o) => o.type === orderType)
@@ -1447,6 +1566,15 @@ export async function _recalculateGridOrderSizesFromBlockchain(manager, orderTyp
         // Apply new sizes to all slots on the side
         for (let i = 0; i < allSideSlots.length; i++) {
             const slot = allSideSlots[i];
+            // Shelf/manual orders (non-slot-N ids, e.g. fork-kept deep-*
+            // below the rail) sit outside window accounting: geometric
+            // ideals must never resize them on-chain. Same gate as reserve
+            // classification and startup cancel candidates (issue #27
+            // follow-up). No-op upstream (grids only mint slot-N).
+            // NB: they stay in the denominator above (budget math
+            // unchanged); only the per-slot mutation below is skipped.
+            if (parseSlotIndex(slot?.id) === null)
+                continue;
             let newSize = newSizes[i] || 0;
             // FUND CAPPING FOR COMMITTED (ON-CHAIN) ORDERS:
             // Only ACTIVE/PARTIAL orders are constrained by available funds.
@@ -1744,8 +1872,8 @@ export async function monitorDivergence(manager, calculatedGrid, persistedGrid)
         const { getOrderTypeFromUpdatedFlags } = require('./utils/order');
         return {
             needsUpdate: true,
-            buy: { updated: ratioResult.buyUpdated, ratio: ratioResult.buyUpdated, rms: false, metric: 0 },
-            sell: { updated: ratioResult.sellUpdated, ratio: ratioResult.sellUpdated, rms: false, metric: 0 },
+            buy: { updated: ratioResult.buyUpdated, ratio: ratioResult.buyUpdated, rms: false, metric: 0, shrink: ratioResult.buyShrink === true },
+            sell: { updated: ratioResult.sellUpdated, ratio: ratioResult.sellUpdated, rms: false, metric: 0, shrink: ratioResult.sellShrink === true },
             orderType: getOrderTypeFromUpdatedFlags(ratioResult.buyUpdated, ratioResult.sellUpdated)
         };
     }
@@ -1756,8 +1884,8 @@ export async function monitorDivergence(manager, calculatedGrid, persistedGrid)
     const { getOrderTypeFromUpdatedFlags } = require('./utils/order');
     return {
         needsUpdate: buyUpdated || sellUpdated,
-        buy: { updated: buyUpdated, ratio: ratioResult.buyUpdated, rms: rmsResult.buy.updated, metric: rmsResult.buy.metric },
-        sell: { updated: sellUpdated, ratio: ratioResult.sellUpdated, rms: rmsResult.sell.updated, metric: rmsResult.sell.metric },
+        buy: { updated: buyUpdated, ratio: ratioResult.buyUpdated, rms: rmsResult.buy.updated, metric: rmsResult.buy.metric, shrink: ratioResult.buyShrink === true },
+        sell: { updated: sellUpdated, ratio: ratioResult.sellUpdated, rms: rmsResult.sell.updated, metric: rmsResult.sell.metric, shrink: ratioResult.sellShrink === true },
         orderType: getOrderTypeFromUpdatedFlags(buyUpdated, sellUpdated)
     };
 }
@@ -1768,14 +1896,21 @@ export async function monitorDivergence(manager, calculatedGrid, persistedGrid)
  * @returns {{onChainBuys: Array<import('./types').Order>, onChainSells: Array<import('./types').Order>}}
  */
 function _getOnChainOrders(manager) {
+    // Slot-N gated: fork-kept shelf/manual orders (non-slot-N ids, e.g.
+    // deep-*) sit outside window accounting — same gate as reserve
+    // classification and startup cancel candidates (issue #27 follow-up).
+    // Without this, a live shelf masks an empty window side (oneSideEmpty
+    // stays false) and skews the spread inputs. No-op on grids that only
+    // mint slot-N ids.
+    const isGridSlot = (o) => o?.orderId && Number(o?.size || 0) > 0 && parseSlotIndex(o?.id) !== null;
     const onChainBuys = [
         ...manager.getOrdersByTypeAndState(ORDER_TYPES.BUY, ORDER_STATES.ACTIVE),
         ...manager.getOrdersByTypeAndState(ORDER_TYPES.BUY, ORDER_STATES.PARTIAL)
-    ].filter((o) => o?.orderId && Number(o?.size || 0) > 0);
+    ].filter(isGridSlot);
     const onChainSells = [
         ...manager.getOrdersByTypeAndState(ORDER_TYPES.SELL, ORDER_STATES.ACTIVE),
         ...manager.getOrdersByTypeAndState(ORDER_TYPES.SELL, ORDER_STATES.PARTIAL)
-    ].filter((o) => o?.orderId && Number(o?.size || 0) > 0);
+    ].filter(isGridSlot);
     return { onChainBuys, onChainSells };
 }
 /**
@@ -1847,11 +1982,11 @@ export async function checkSpreadCondition(manager, _BitShares, updateOrdersOnCh
         const toleranceSteps = 0.5;
         const buyCount = manager.getOrdersByTypeAndState(ORDER_TYPES.BUY, ORDER_STATES.ACTIVE)
             .concat(manager.getOrdersByTypeAndState(ORDER_TYPES.BUY, ORDER_STATES.PARTIAL))
-            .filter((o) => o?.orderId && Number(o?.size || 0) > 0)
+            .filter((o) => o?.orderId && Number(o?.size || 0) > 0 && parseSlotIndex(o?.id) !== null)
             .length;
         const sellCount = manager.getOrdersByTypeAndState(ORDER_TYPES.SELL, ORDER_STATES.ACTIVE)
             .concat(manager.getOrdersByTypeAndState(ORDER_TYPES.SELL, ORDER_STATES.PARTIAL))
-            .filter((o) => o?.orderId && Number(o?.size || 0) > 0)
+            .filter((o) => o?.orderId && Number(o?.size || 0) > 0 && parseSlotIndex(o?.id) !== null)
             .length;
         manager.outOfSpread = shouldFlagOutOfSpread(currentSpread, nominalSpread, toleranceSteps, buyCount, sellCount, manager.config.incrementPercent);
         if (manager.outOfSpread === 0)
@@ -1890,7 +2025,12 @@ export async function checkSpreadCondition(manager, _BitShares, updateOrdersOnCh
         }
         // Limit spread = nominal + half increment tolerance (0.5 steps).
         const limitSpread = nominalSpread + (manager.config.incrementPercent * toleranceSteps);
-        manager.logger?.log?.(`Spread too wide (${Format.formatPercent(currentSpread)} > ${Format.formatPercent(limitSpread)}), correcting with ${manager.outOfSpread} extra slot(s)...`, 'warn');
+        // One-sided book: currentSpread is Infinity (no opposing quote), so
+        // log the empty side instead of a bogus "0% > limit" comparison.
+        const spreadDesc = oneSideEmpty
+            ? `one-sided (${onChainBuys.length === 0 ? 'no buys' : 'no sells'})`
+            : `${Format.formatPercent(currentSpread)} > ${Format.formatPercent(limitSpread)}`;
+        manager.logger?.log?.(`Spread too wide (${spreadDesc}), correcting with ${manager.outOfSpread} extra slot(s)...`, 'warn');
         // Refresh funds before the side decision below: the top-of-tick recalc may
         // predate fills processed since, and determineOrderSideByFunds reads
         // manager.funds/accountTotals directly (not via _getSizingContext). No-op
@@ -2384,11 +2524,16 @@ export async function prepareSpreadCorrectionOrders(manager, preferredSide, outO
     const missingSlots = configuredMissingSlots > 0
         ? Math.floor(configuredMissingSlots)
         : 1;
-    // STRATEGY: Edge-Based Correction (Safe Bridging)
+    // STRATEGY: Window-Contiguous Correction (Safe Bridging)
     // Instead of calculating a "mid-price" (which can be dangerous in wide gaps),
-    // we strictly target the orders closest to the spread gap.
+    // we extend the live window contiguously so a fund-constrained correction
+    // never leaves an interior hole.
     // 1. Priority: Update existing PARTIAL orders at the edge (Highest Buy / Lowest Sell).
-    // 2. Fallback: Activate SPREAD slots at the edge (Lowest Spread for Buy / Highest Spread for Sell).
+    // 2. Fallback: Activate empty slots window-contiguous-first (Lowest Buy-rail /
+    //    Highest Sell-rail, adjacent to the live window top).  A rail with no
+    //    live orders has no window to extend, so it falls back to
+    //    spread-edge-first (Highest Buy / Lowest Sell) to close the spread
+    //    near market first.
     const allOrders = Array.from(manager.orders.values());
     // Boundary-correct type computation — hoisted before edge-partial and
     // candidate filters so all call sites (including the edge-partial filter
@@ -2441,11 +2586,30 @@ export async function prepareSpreadCorrectionOrders(manager, preferredSide, outO
     // boundary-correct type so a SPREAD slot that, after a boundary shift, now sits
     // in the BUY or SELL zone is excluded — it would otherwise be placed on the
     // correction side at a price the grid already considers the opposite side.
+    // Candidate ordering: window-contiguous-first when the rail has live
+    // orders to extend (BUY lowest first, SELL highest first, both adjacent
+    // to the live window top).  A fully-empty rail has no window anchor —
+    // "lowest buy" would be the rail bottom, placing deep orders while the
+    // near-market gap stays open — so it falls back to spread-edge-first
+    // (BUY highest, SELL lowest) to close the spread near market first.
+    // The gap-band promotion path below stays edge-first by necessity
+    // (boundary derivation requires contiguity), so under fund shortage
+    // in-rail holes heal before band slots.
+    const railHasLiveOrders = allOrders.some((o) => getSlotCorrectType(o) === railType && isOrderPlaced(o));
+    const sortCandidates = (a, b) => {
+        const edgeFirst = railType === ORDER_TYPES.BUY
+            ? b.price - a.price
+            : a.price - b.price;
+        const windowFirst = railType === ORDER_TYPES.BUY
+            ? a.price - b.price
+            : b.price - a.price;
+        return railHasLiveOrders ? windowFirst : edgeFirst;
+    };
     const typedSpreadCandidates = allOrders
         .filter((o) => o.type === ORDER_TYPES.SPREAD
         && isSlotAvailable(o)
         && getSlotCorrectType(o) === railType)
-        .sort((a, b) => railType === ORDER_TYPES.BUY ? a.price - b.price : b.price - a.price)
+        .sort(sortCandidates)
         .slice(0, missingSlots);
     // Secondary candidates: orphaned virtual slots that have lost their
     // order (e.g. stale-cleaned after a race condition during a crash, or a
@@ -2477,7 +2641,7 @@ export async function prepareSpreadCorrectionOrders(manager, preferredSide, outO
         && o.state === ORDER_STATES.VIRTUAL
         && !o.orderId
         && getSlotCorrectType(o) === railType)
-        .sort((a, b) => railType === ORDER_TYPES.BUY ? b.price - a.price : a.price - b.price)
+        .sort(sortCandidates)
         .slice(0, missingSlots);
     // If the funded rail is full, the spread itself may be stale: the
     // nearest empty slots are still in the gap band. Promote contiguous