dexbot 1.4.9 → 1.4.11

package/dist/modules/order/grid.js

@@ -385,9 +385,13 @@ function createOrderGrid(config) {
     if (!Number.isFinite(incrementPercent)) {
         throw new Error(`Invalid incrementPercent: ${incrementPercent}. Must be a finite number.`);
     }
-    const minPercent = config.incrementBounds?.MIN_PERCENT;
-    const maxPercent = config.incrementBounds?.MAX_PERCENT;
-    if (incrementPercent < minPercent || incrementPercent > maxPercent) {
+    // Fall back to the canonical INCREMENT_BOUNDS when the config omits
+    // incrementBounds. Without this, a non-positive incrementPercent (e.g. 0)
+    // silently passes validation and the geometric loop below spins forever.
+    const incrementBounds = config.incrementBounds || constants_1.INCREMENT_BOUNDS;
+    const minPercent = incrementBounds.MIN_PERCENT;
+    const maxPercent = incrementBounds.MAX_PERCENT;
+    if (incrementPercent <= 0 || incrementPercent < minPercent || incrementPercent > maxPercent) {
         throw new Error(`Invalid incrementPercent: ${incrementPercent}. Must be between ` +
             `${minPercent} and ${maxPercent} (inclusive).`);
     }
@@ -544,6 +548,25 @@ async function loadGrid(manager, grid, boundaryIdx = null) {
                     : (i >= sellStartIdx)
                         ? constants_1.ORDER_TYPES.SELL
                         : constants_1.ORDER_TYPES.SPREAD;
+                // DEFENSIVE BACKSTOP: a VIRTUAL slot with no orderId and
+                // zero size is side-neutral — it is a reusable placeholder
+                // that may be activated on either rail.  Storing a stale
+                // BUY/SELL type here misleads candidate-selection code
+                // (e.g. spread-correction orphaned filters and reconcile
+                // activation), which pick by stored type instead of boundary
+                // geometry.  Force SPREAD so the stored type can never
+                // pre-bias which side reuses the slot.  The VIRTUAL +
+                // !orderId + size-0 combination already implies not on-chain
+                // (on-chain requires ACTIVE/PARTIAL and an orderId).  This is
+                // a defensive backstop for legacy persisted grids; the
+                // boundary-shift and strategy re-plan paths use
+                // assignGridRoles (order.ts) with assignOnChain, where
+                // geometry-based typing wins.
+                if ((0, order_1.isEmptyGridSlot)(slot, slot, { allowNullType: true })) {
+                    if (slot.type !== constants_1.ORDER_TYPES.SPREAD)
+                        reassignCount++;
+                    return { ...slot, type: constants_1.ORDER_TYPES.SPREAD };
+                }
                 if (slot.type !== correctType) {
                     let newType = correctType;
                     // On-chain slots must never be reassigned to SPREAD:
@@ -606,8 +629,20 @@ async function loadGrid(manager, grid, boundaryIdx = null) {
                 }
                 await manager._applyOrderUpdate(currentOrder, 'grid-load', { skipAccounting: true });
             }
-            const spreadCount = grid.filter((o) => o.type === constants_1.ORDER_TYPES.SPREAD).length;
-            manager.targetSpreadCount = spreadCount;
+            // Gap-band occupancy for the spread metric.  Empty slots are
+            // normalized to SPREAD (side-neutral) above, so a raw
+            // `type === SPREAD` count would include every empty slot on both
+            // rails.  countGapBandSpread requires both SPREAD type and band
+            // geometry (target = gapSlots).
+            // Index resolution: prefer the parsed slot id (price-monotonic
+            // at creation) so the count is order-independent, matching the
+            // accountant (accounting.ts).  Fall back to array position only
+            // for ids that are not grid slot ids.
+            const spreadCount = (0, math_1.countGapBandSpread)(manager, grid, (o, i) => {
+                const idx = (0, order_1.parseSlotIndex)(o?.id);
+                return idx === null ? i : idx;
+            });
+            manager.initialSpreadCount = spreadCount;
             manager.currentSpreadCount = spreadCount;
         }
         finally {
@@ -617,12 +652,21 @@ async function loadGrid(manager, grid, boundaryIdx = null) {
         manager.logger?.log?.(`Loaded ${manager.orders.size} orders from persisted grid.`, 'info');
     });
 }
+function resolveMinScaleSlots(primary, secondary) {
+    const p = Number(primary);
+    if (Number.isFinite(p))
+        return Math.max(0, Math.floor(p));
+    const s = Number(secondary);
+    if (Number.isFinite(s))
+        return Math.max(0, Math.floor(s));
+    return constants_1.MARKET_ADAPTER.ASYMMETRIC_BOUNDS_MIN_SCALE_SLOTS;
+}
 /**
- * Initialize the order grid with blockchain-aware sizing.
- * @param {import('./types').OrderManager} manager - The manager instance.
- * @returns {Promise<void>}
- * @throws {Error} If initialization fails or account totals are missing.
- */
+     * Initialize and orchestrate the order grid.
+     *
+     * @return {Promise<void>}
+     * @throws {Error} If initialization fails or account totals are missing.
+     */
 async function initializeGrid(manager) {
     if (!manager)
         throw new Error('initializeGrid requires a manager instance');
@@ -723,6 +767,8 @@ async function initializeGrid(manager) {
     let resolvedMinP = minP;
     let resolvedMaxP = maxP;
     let rangeScalingFactor = null;
+    let appliedTrend = null;
+    let minScaleSlots = null;
     if (gpSource === 'ama' && Number.isFinite(minP) && Number.isFinite(maxP)
         && isGridRangeScalingWhitelisted) {
         const dw = amaSnapshot?.dynamicWeights;
@@ -747,6 +793,8 @@ async function initializeGrid(manager) {
                 resolvedMinP = adjustment.resolvedMinPrice;
                 resolvedMaxP = adjustment.resolvedMaxPrice;
                 rangeScalingFactor = Number(adjustment.appliedAsymmetryFactor);
+                appliedTrend = (dw?.trend === 'UP' || dw?.trend === 'DOWN') ? dw.trend : null;
+                minScaleSlots = resolveMinScaleSlots(manager.config.asymmetricBounds?.minScaleSlots, dw?.minScaleSlots);
                 manager.logger?.log?.(`[BOUND-ASYMMETRY] trend=${dw.trend} slopeOffset=${dw.slopeOffset.toFixed(4)} `
                     + `raw=${((adjustment.rawAsymmetryFactor ?? 0) * 100).toFixed(1)}% `
                     + `cap=${((maxAsymmetryFactor ?? 0) * 100).toFixed(0)}% `
@@ -768,6 +816,8 @@ async function initializeGrid(manager) {
                 resolvedMaxP = gp * ((maxP / gp) * (1 + asymmetry));
             }
             rangeScalingFactor = asymmetry;
+            appliedTrend = rootTrend;
+            minScaleSlots = resolveMinScaleSlots(manager.config.asymmetricBounds?.minScaleSlots, rootBounds.minScaleSlots);
             manager.logger?.log?.(`[BOUND-ASYMMETRY] trend=${rootTrend} `
                 + `asymmetry=${(asymmetry * 100).toFixed(1)}% `
                 + `(root-level) min ${(minP ?? 0).toFixed(8)}→${(resolvedMinP ?? 0).toFixed(8)} `
@@ -796,6 +846,35 @@ async function initializeGrid(manager) {
             gridStartPrice = clamped;
         }
     }
+    // Narrowing-side slot guard: range scaling tightens one bound toward the
+    // center. Without a floor this can collapse that side into a near-center
+    // sliver holding few or zero active orders. Guarantee at least
+    // minScaleSlots price levels remain between the grid center and the
+    // tightened bound (in multiples of incrementPercent). The widened side
+    // still extends freely.
+    if (appliedTrend && Number.isFinite(gridStartPrice) && gridStartPrice > 0) {
+        const inc = Number(manager.config.incrementPercent);
+        const mss = Number.isFinite(minScaleSlots) ? Math.floor(Number(minScaleSlots)) : 0;
+        if (Number.isFinite(inc) && inc > 0 && mss > 0) {
+            const stepMult = 1 + (inc / 100);
+            if (appliedTrend === 'DOWN' && resolvedMaxP != null) {
+                const keepAbove = gridStartPrice * Math.pow(stepMult, mss);
+                if (resolvedMaxP < keepAbove) {
+                    manager.logger?.log?.(`[BOUND-ASYMMETRY] narrowing-side guard: max ${resolvedMaxP.toFixed(8)} collapses ` +
+                        `${mss} levels; holding at ${keepAbove.toFixed(8)}`, 'info');
+                    resolvedMaxP = keepAbove;
+                }
+            }
+            else if (appliedTrend === 'UP' && resolvedMinP != null) {
+                const belowMin = gridStartPrice * Math.pow(1 - (inc / 100), mss);
+                if (resolvedMinP > belowMin) {
+                    manager.logger?.log?.(`[BOUND-ASYMMETRY] narrowing-side guard would pull min ${resolvedMinP.toFixed(8)} ` +
+                        `short of ${mss} levels; holding at ${belowMin.toFixed(8)}`, 'info');
+                    resolvedMinP = belowMin;
+                }
+            }
+        }
+    }
     manager.config.minPrice = resolvedMinP;
     manager.config.maxPrice = resolvedMaxP;
     manager._lastGridPricingContext = {
@@ -882,9 +961,14 @@ async function initializeGrid(manager) {
             await manager.resumeFundRecalc();
             manager.resumeRecalcLogging();
         }
-        // RC-6: Spread count updates protected by grid lock
-        manager.targetSpreadCount = initialSpreadCount.buy + initialSpreadCount.sell;
-        manager.currentSpreadCount = manager.targetSpreadCount;
+        // RC-6: Spread count updates protected by grid lock.
+        // initializeGrid always sets initialSpreadCount = gapSlots (theoretical
+        // value for a fresh grid).  loadGrid uses the actual SPREAD-typed slot
+        // count in the gap band, which may be lower after promotions absorbed
+        // gap slots into a rail.  Both are correct for their context; callers
+        // should not assume the two paths agree.
+        manager.initialSpreadCount = initialSpreadCount.buy + initialSpreadCount.sell;
+        manager.currentSpreadCount = manager.initialSpreadCount;
     });
     // FIX: Use consistent optional chaining pattern for all logger calls
     manager.logger?.log?.(`Initialized grid with ${orders.length} orders.`, 'info');
@@ -1113,6 +1197,19 @@ async function _recalculateGridOrderSizesFromBlockchain(manager, orderType, opti
     // correct side's size calculation — using manager.orders here would
     // filter by stale pre-shift types and miss the crossers, producing a
     // budget allocation that doesn't match the post-shift grid structure.
+    //
+    // Empty (size-0 VIRTUAL) slots are stored SPREAD (side-neutral) after
+    // normalization and are deliberately NOT included in the side's
+    // ideal-size denominator here: a SPREAD slot cannot carry a size
+    // (validateOrder forces SPREAD size back to 0), so including it would
+    // only dilute the budget without giving the slot a usable size.
+    // Activation sizing for empties is handled where re-typing happens:
+    // spread-correction (prepareSpreadCorrectionOrders) and startup
+    // reconcile (_deriveBudgetedSideSizes) both compute the full in-rail
+    // 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.
     const orderSource = collectActions ? workingGrid : manager.orders;
     const allSideSlots = Array.from(orderSource.values())
         .filter((o) => o.type === orderType)
@@ -1903,6 +2000,36 @@ function determineOrderSideByFunds(manager, currentMarketPrice) {
     }
     return { side, reason: side ? `Choosing ${side}` : 'Insufficient funds or committed inventory' };
 }
+// Collect contiguous empty gap-band slots adjacent to a rail edge for boundary
+// promotion.  BUY walks upward from the boundary into the gap, SELL walks
+// downward from the sell start; both stop at the first unavailable slot.
+// Mirrors are collapsed into one directional walk (step +/- 1).
+//
+// NOTE: the promotion cap is the OPPOSITE RAIL's span, NOT the gap-band size.
+// SELL promotion moves the boundary down by the promoted count (boundary =
+// buyEndIdx - count), so capping at buyEndIdx keeps it >= 0.  BUY promotion
+// moves the boundary up; capping at the SELL rail size (maxIdx+1-sellStartIdx)
+// keeps the promoted boundary at or below the last placed slot.  The walk's
+// own idx < sellStartIdx / idx > buyEndIdx bounds already limit promotion to
+// the band, so this cap only binds when the opposite rail is smaller than the
+// band — i.e. an empty opposite rail (cap 0) blocks promotion entirely.
+function _collectPromotableBoundarySlots(allSlotsByPrice, railType, buyEndIdx, sellStartIdx, quota) {
+    const isBuy = railType === constants_1.ORDER_TYPES.BUY;
+    const maxIdx = allSlotsByPrice.length - 1;
+    const maxPromotable = isBuy
+        ? Math.max(0, maxIdx + 1 - sellStartIdx)
+        : Math.max(0, buyEndIdx);
+    const promotionQuota = Math.min(quota, maxPromotable);
+    const promoted = [];
+    const step = isBuy ? 1 : -1;
+    for (let idx = isBuy ? buyEndIdx + 1 : sellStartIdx - 1; promoted.length < promotionQuota && (isBuy ? idx < sellStartIdx : idx > buyEndIdx); idx += step) {
+        const slot = allSlotsByPrice[idx];
+        if (!slot || !(0, order_1.isSlotAvailable)(slot))
+            break;
+        promoted.push(slot);
+    }
+    return promoted;
+}
 /**
  * Prepares one or more orders to correct a wide spread.
  * @param {import('./types').OrderManager} manager - The OrderManager instance.
@@ -1941,15 +2068,22 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide, outOfSpread
         .filter((o) => o.price != null && Number.isFinite(o.price))
         .sort((a, b) => a.price - b.price);
     const slotIndexMap = new Map(allSlotsByPrice.map((o, i) => [o.id, i]));
-    const gapSlots = manager._gapSlots ?? calculateGapSlots(manager.config?.incrementPercent, manager.config?.targetSpreadPercent, manager.config?.gridLimits);
     // Use the committed boundary for slot classification — never a speculative
     // value from syncBoundaryToFunds that hasn't been persisted through the COW
     // pipeline.  If the boundary shifts later via _commitWorkingGrid, the next
     // spread correction cycle will re-classify with the updated committed value.
     // This prevents TOCTOU-style inconsistency where slot types are chosen
     // against a boundary that was never atomically committed to manager.orders.
-    const buyEndIdx = manager.boundaryIdx ?? 0;
-    const sellStartIdx = (0, math_1.getSellStartIdx)(manager.boundaryIdx, gapSlots);
+    const resolved = (0, math_1.resolveGapBand)(manager);
+    const gapSlots = resolved.gapSlots;
+    const boundaryKnown = resolved.boundaryIdx !== null && resolved.sellStartIdx !== null;
+    // NOTE: `?? 0` keeps the legacy classification fallback (boundary not
+    // restored yet → treat as bottom of the rail) so the correction can still
+    // act on concrete BUY/SELL candidates.  Boundary PROMOTION is gated on
+    // `boundaryKnown` below: deriving a new boundary from a fabricated 0 would
+    // silently commit a boundary that was never real.
+    const buyEndIdx = resolved.boundaryIdx ?? 0;
+    const sellStartIdx = resolved.sellStartIdx ?? (0, math_1.getSellStartIdx)(buyEndIdx, gapSlots);
     const getSlotCorrectType = (slot) => {
         const idx = slotIndexMap.get(slot.id);
         if (idx === undefined)
@@ -1979,30 +2113,68 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide, outOfSpread
         && getSlotCorrectType(o) === railType)
         .sort((a, b) => railType === constants_1.ORDER_TYPES.BUY ? a.price - b.price : b.price - a.price)
         .slice(0, missingSlots);
-    // Secondary candidates: orphaned virtual slots of the correct side-type that have
-    // lost their order (e.g. stale-cleaned after a race condition during a crash).
-    // These sit inside the active window and are invisible to the SPREAD-type filter above.
+    // Secondary candidates: orphaned virtual slots that have lost their
+    // order (e.g. stale-cleaned after a race condition during a crash).
+    // These sit inside the active window and are invisible to the
+    // gap-band SPREAD filter above.
     //
-    // IMPORTANT: Filter by boundary-correct type so that filled-then-virtualized slots
-    // whose boundary position has moved into the spread or opposite zone are NOT
-    // re-activated on the stale side — doing so would compound inventory at prices
-    // where the bot already traded.  The boundary-correct type is computed from the
-    // current boundary index and the slot's price position in the sorted rail.
+    // Empty slots are stored SPREAD (side-neutral) after normalization, so
+    // the stored type can be railType OR SPREAD — what matters is that the
+    // boundary-correct type (geometry) matches the rail being corrected.
+    // Filter by boundary-correct type so that filled-then-virtualized slots
+    // whose boundary position has moved into the spread or opposite zone are
+    // NOT re-activated on the stale side — doing so would compound inventory
+    // at prices where the bot already traded.
     const orphanedVirtualCandidates = allOrders
-        .filter((o) => o.type === railType
+        .filter((o) => (o.type === railType || o.type === constants_1.ORDER_TYPES.SPREAD)
         && o.state === constants_1.ORDER_STATES.VIRTUAL
         && !o.orderId
         && Number(o.size || 0) === 0
         && getSlotCorrectType(o) === railType)
         .sort((a, b) => railType === constants_1.ORDER_TYPES.BUY ? b.price - a.price : a.price - b.price)
         .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
+    // empty gap slots from that rail edge so correction can repair the
+    // boundary and place orders in one atomic COW commit.
+    //
+    // Requires a KNOWN committed boundary: with a null/unknown boundary the
+    // rail edges are fabricated (buyEndIdx=0), so promotion would place
+    // orders at arbitrary prices and return a boundary derived from that
+    // fiction.  Without promotion there is nothing to commit, so falling
+    // back to the pre-existing candidate paths is safe.
+    const promotedCandidates = [];
+    if (boundaryKnown && orphanedVirtualCandidates.length + typedSpreadCandidates.length < missingSlots) {
+        const rawQuota = missingSlots - orphanedVirtualCandidates.length - typedSpreadCandidates.length;
+        promotedCandidates.push(..._collectPromotableBoundarySlots(allSlotsByPrice, railType, buyEndIdx, sellStartIdx, rawQuota));
+        if (promotedCandidates.length > 0) {
+            manager.logger?.log?.(`[SPREAD-CORRECTION] ${promotedCandidates.length} gap slot(s) available for boundary promotion on ${sideName}`, 'info');
+        }
+    }
     // Merge: prefer orphaned virtuals (they already occupy correct grid positions) then
     // fall back to SPREAD slots for any remaining quota.
     const remainingQuota = Math.max(0, missingSlots - orphanedVirtualCandidates.length);
     let spreadCandidates = [
         ...orphanedVirtualCandidates,
-        ...typedSpreadCandidates.slice(0, remainingQuota)
+        ...typedSpreadCandidates.slice(0, remainingQuota),
+        ...promotedCandidates
     ];
+    // Dedupe by slot id: an empty in-rail slot typed SPREAD (normalized) now
+    // qualifies for BOTH orphanedVirtualCandidates and typedSpreadCandidates
+    // (both accept SPREAD type + rail geometry), so a single slot can be
+    // planned twice.  Duplicate CREATEs would inflate the sizing denominator
+    // (diluting every order), mislead the plan counts, and get dropped by the
+    // COW same-batch collision filter anyway.  Keep the first occurrence
+    // (orphaned-priority — those already occupy correct grid positions).
+    {
+        const seenSlotIds = new Set();
+        spreadCandidates = spreadCandidates.filter((c) => {
+            if (!c?.id || seenSlotIds.has(c.id))
+                return false;
+            seenSlotIds.add(c.id);
+            return true;
+        });
+    }
     // P2: Filter out candidates whose price already has a placed order from any slot.
     // This prevents creating a duplicate order at the same price when a prior cycle's
     // order was not properly cleaned up (e.g. uncertain broadcast).
@@ -2135,6 +2307,43 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide, outOfSpread
         });
         remainingBudget -= createSize;
     }
+    let boundaryIdx;
+    const placedPromotedIds = new Set(ordersToPlace
+        .filter((order) => promotedCandidates.some((slot) => slot.id === order.id))
+        .map((order) => order.id));
+    if (placedPromotedIds.size > 0) {
+        // Derive boundary from the placed promoted set's extremes (via
+        // slotIndexMap), not the contiguous prefix.  Any promoted-but-
+        // unplaced slots sit in-rail or in-band as normal empty slots.
+        let maxDist = 0;
+        for (const id of placedPromotedIds) {
+            const idx = slotIndexMap.get(id);
+            if (idx === undefined)
+                continue;
+            const dist = railType === constants_1.ORDER_TYPES.BUY
+                ? idx - buyEndIdx
+                : sellStartIdx - idx;
+            if (dist > maxDist)
+                maxDist = dist;
+        }
+        if (maxDist > 0) {
+            boundaryIdx = railType === constants_1.ORDER_TYPES.BUY
+                ? buyEndIdx + maxDist
+                : buyEndIdx - maxDist;
+            const maxIdx = allSlotsByPrice.length - 1;
+            const clamped = Math.max(0, Math.min(maxIdx, boundaryIdx));
+            if (clamped !== boundaryIdx) {
+                manager.logger?.log?.(`[SPREAD-CORRECTION] Boundary promotion clamped on ${sideName}: ` +
+                    `${boundaryIdx} -> ${clamped}`, 'warn');
+                boundaryIdx = clamped;
+            }
+            manager.logger?.log?.(`[SPREAD-CORRECTION] Boundary promotion on ${sideName}: ` +
+                `${buyEndIdx} -> ${boundaryIdx} (${placedPromotedIds.size} placed, maxDist ${maxDist})`, 'info');
+        }
+        else {
+            boundaryIdx = undefined;
+        }
+    }
     const combinedUpdates = [...redistributionUpdates];
     for (const plannedUpdate of ordersToUpdate) {
         const id = plannedUpdate?.partialOrder?.id || plannedUpdate?.id;
@@ -2157,6 +2366,6 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide, outOfSpread
     if (combinedUpdates.length > 0 || ordersToPlace.length > 0) {
         manager.logger?.log?.(`[SPREAD-CORRECTION] Prepared updates=${combinedUpdates.length}, creates=${ordersToPlace.length}, remainingBudget=${Format.formatSizeByOrderType(Math.max(0, remainingBudget), railType, manager.assets)}`, 'debug');
     }
-    return { ordersToPlace, ordersToUpdate: combinedUpdates };
+    return { ordersToPlace, ordersToUpdate: combinedUpdates, ...(boundaryIdx === undefined ? {} : { boundaryIdx }) };
 }
 //# sourceMappingURL=grid.js.map