dexbot 1.3.3 → 1.4.1

package/dist/modules/order/grid.js

@@ -95,6 +95,39 @@
  *
  * ===============================================================================
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateGapSlots = calculateGapSlots;
 exports.isGridBloated = isGridBloated;
@@ -120,10 +153,10 @@ exports.getDustOrders = getDustOrders;
 exports.determineOrderSideByFunds = determineOrderSideByFunds;
 exports.calculateGeometricSizeForSpreadCorrection = calculateGeometricSizeForSpreadCorrection;
 exports.prepareSpreadCorrectionOrders = prepareSpreadCorrectionOrders;
-const { ORDER_TYPES, ORDER_STATES, COW_ACTIONS, DEFAULT_CONFIG, GRID_LIMITS, TIMING, MARKET_ADAPTER } = require('../constants');
-const { GRID_COMPARISON } = GRID_LIMITS;
-const Format = require('./format');
-const { resolveMaxAsymmetryFactor, applyAsymmetricBounds, } = require('../../market_adapter/core/asymmetric_bounds');
+const constants_1 = require("../constants");
+const { GRID_COMPARISON } = constants_1.GRID_LIMITS;
+const Format = __importStar(require("./format"));
+const asymmetric_bounds_1 = require("../../market_adapter/core/asymmetric_bounds");
 // FIX: Extract magic numbers to named constants for maintainability
 const GRID_CONSTANTS = {
     RMS_PERCENTAGE_SCALE: 100, // Convert RMS percentage threshold from percent to decimal
@@ -136,12 +169,13 @@ function _snapshotFundState(manager) {
         sellLocked: Number(manager.accountTotals?.sellLocked || 0),
     };
 }
-const { floatToBlockchainInt, blockchainToFloat, getPrecisionByOrderType, getPrecisionsForManager, calculateOrderCreationFees, calculateOrderSizes, calculateRotationOrderSizes, calculateAvailableFundsValue, calculateGridSideDivergenceMetric, getPrecisionSlack, getMinAbsoluteOrderSize, getSingleDustThreshold, getGridBestPrices, calculateSpreadFromOrders, allocateFundsByWeights, calculateGapSlots: _mathGapSlots, calculatePriceTolerance } = require('./utils/math');
-const { adjustBudgetForBtsFees, filterOrdersByType, checkSizesBeforeMinimum, checkSizeThreshold, resolveConfiguredPriceBound, shouldFlagOutOfSpread, isOrderHealthy, isPhantomOrder, isSlotAvailable, isOrderOnChain, hasOnChainId, calculateIdealBoundary, assignGridRoles } = require('./utils/order');
-const { derivePrice, loadAmaCenterPrice, loadAmaCenterSnapshot } = require('./utils/system');
-const { getWhitelistFlags } = require('../market_adapter_whitelist');
+const math_1 = require("./utils/math");
+const order_1 = require("./utils/order");
+const system_1 = require("./utils/system");
+const market_adapter_whitelist_1 = require("../market_adapter_whitelist");
+const errors_1 = require("../utils/errors");
 function calculateGapSlots(incrementPercent, targetSpreadPercent, gridLimitsOverride) {
-    return _mathGapSlots(incrementPercent, targetSpreadPercent, gridLimitsOverride ?? GRID_LIMITS);
+    return (0, math_1.calculateGapSlots)(incrementPercent, targetSpreadPercent, gridLimitsOverride ?? constants_1.GRID_LIMITS);
 }
 function isGridBloated(manager, orders) {
     const gridSize = Array.isArray(orders) ? orders.length : orders.size;
@@ -153,11 +187,11 @@ function isGridBloated(manager, orders) {
         return { bloated: false };
     const targetSpreadPct = config.targetSpreadPercent || incPct * 2;
     const orderList = Array.isArray(orders) ? orders : Array.from(orders.values());
-    const numBuyActive = orderList.filter((o) => o.type === ORDER_TYPES.BUY &&
-        (o.state === ORDER_STATES.ACTIVE || o.state === ORDER_STATES.PARTIAL) &&
+    const numBuyActive = orderList.filter((o) => o.type === constants_1.ORDER_TYPES.BUY &&
+        (o.state === constants_1.ORDER_STATES.ACTIVE || o.state === constants_1.ORDER_STATES.PARTIAL) &&
         o.orderId).length;
-    const numSellActive = orderList.filter((o) => o.type === ORDER_TYPES.SELL &&
-        (o.state === ORDER_STATES.ACTIVE || o.state === ORDER_STATES.PARTIAL) &&
+    const numSellActive = orderList.filter((o) => o.type === constants_1.ORDER_TYPES.SELL &&
+        (o.state === constants_1.ORDER_STATES.ACTIVE || o.state === constants_1.ORDER_STATES.PARTIAL) &&
         o.orderId).length;
     const placedCount = numBuyActive + numSellActive;
     if (!placedCount)
@@ -188,7 +222,7 @@ function isGridBloated(manager, orders) {
         }
     }
     const railEstimate = Math.max(expectedTotal, placedCount);
-    const buffer = (config.gridLimits?.MIN_SPREAD_ORDERS ?? GRID_LIMITS.MIN_SPREAD_ORDERS);
+    const buffer = (config.gridLimits?.MIN_SPREAD_ORDERS ?? constants_1.GRID_LIMITS.MIN_SPREAD_ORDERS);
     const maxAllowed = railEstimate + gapSlots + buffer;
     return {
         bloated: gridSize > maxAllowed,
@@ -209,7 +243,7 @@ function isGridBloated(manager, orders) {
  * @returns {{active: boolean, elapsed: number, graceMs: number}}
  */
 function isGridBloatGraceActive(manager) {
-    const graceMs = Number(TIMING?.GRID_BLOAT_RESYNC_GRACE_MS) || TIMING.GRID_BLOAT_RESYNC_GRACE_MS;
+    const graceMs = Number(constants_1.TIMING?.GRID_BLOAT_RESYNC_GRACE_MS) || constants_1.TIMING.GRID_BLOAT_RESYNC_GRACE_MS;
     if (!manager._gridBloatDetectedAt) {
         return { active: false, elapsed: 0, graceMs };
     }
@@ -253,7 +287,7 @@ async function _getSizingContext(manager, side, { skipRecalc = false } = {}) {
     }
     const snap = manager.getChainFundsSnapshot ? manager.getChainFundsSnapshot() : {};
     const isBuy = side === 'buy';
-    const type = isBuy ? ORDER_TYPES.BUY : ORDER_TYPES.SELL;
+    const type = isBuy ? constants_1.ORDER_TYPES.BUY : constants_1.ORDER_TYPES.SELL;
     // 2. Determine base budget: Always use ALLOCATED funds (respects botFunds %)
     // This ensures the bot only "thinks" about the capital it is allowed to use.
     let budget = isBuy ? (snap.allocatedBuy || 0) : (snap.allocatedSell || 0);
@@ -265,13 +299,13 @@ async function _getSizingContext(manager, side, { skipRecalc = false } = {}) {
         const targetSell = Math.max(0, manager.config.activeOrders?.sell ?? 1);
         const totalTarget = targetBuy + targetSell;
         const isBtsSide = (isBuy && manager.config.assetB === 'BTS') || (!isBuy && manager.config.assetA === 'BTS');
-        const formulaBudget = calculateOrderCreationFees(manager.config.assetA, manager.config.assetB, totalTarget, manager.config?.feeParams?.BTS_RESERVATION_MULTIPLIER);
-        budget = adjustBudgetForBtsFees(budget, isBtsSide, formulaBudget, manager.config.min_BTS_value || 0, Format.toFiniteNumber(manager.funds?.btsBalance?.free, 0), Format.toFiniteNumber(isBuy ? (snap.allocatedBuy || 0) : (snap.allocatedSell || 0)), Format.toFiniteNumber(snap.allocatedBuy || 0)
+        const formulaBudget = (0, math_1.calculateOrderCreationFees)(manager.config.assetA, manager.config.assetB, totalTarget, manager.config?.feeParams?.BTS_RESERVATION_MULTIPLIER);
+        budget = (0, order_1.adjustBudgetForBtsFees)(budget, isBtsSide, formulaBudget, manager.config.min_BTS_value || 0, Format.toFiniteNumber(manager.funds?.btsBalance?.free, 0), Format.toFiniteNumber(isBuy ? (snap.allocatedBuy || 0) : (snap.allocatedSell || 0)), Format.toFiniteNumber(snap.allocatedBuy || 0)
             + Format.toFiniteNumber(snap.allocatedSell || 0));
     }
     return {
         budget,
-        precision: getPrecisionByOrderType(manager.assets, type),
+        precision: (0, math_1.getPrecisionByOrderType)(manager.assets, type),
         config: manager.config
     };
 }
@@ -401,7 +435,7 @@ function createOrderGrid(config) {
     // Determine the boundary and assign roles (BUY/SPREAD/SELL) to each slot.
     //
     // STRATEGY: Center the spread gap around startPrice
-    const boundaryIdx = calculateIdealBoundary(priceLevels.map(p => ({ price: p })), startPrice, gapSlots);
+    const boundaryIdx = (0, order_1.calculateIdealBoundary)(priceLevels.map((p) => ({ price: p })), startPrice, gapSlots);
     // ================================================================================
     // STEP 4: CREATE ORDER OBJECTS
     // ================================================================================
@@ -410,12 +444,12 @@ function createOrderGrid(config) {
         id: `slot-${i}`,
         price,
         type: null, // assigned below
-        state: ORDER_STATES.VIRTUAL,
+        state: constants_1.ORDER_STATES.VIRTUAL,
         size: 0
     }));
-    const updatedOrders = assignGridRoles(orders, boundaryIdx, gapSlots, ORDER_TYPES, ORDER_STATES);
-    const buyCount = updatedOrders.filter(o => o.type === ORDER_TYPES.BUY).length;
-    const sellCount = updatedOrders.filter(o => o.type === ORDER_TYPES.SELL).length;
+    const updatedOrders = (0, order_1.assignGridRoles)(orders, boundaryIdx, gapSlots, constants_1.ORDER_TYPES, constants_1.ORDER_STATES);
+    const buyCount = updatedOrders.filter((o) => o.type === constants_1.ORDER_TYPES.BUY).length;
+    const sellCount = updatedOrders.filter((o) => o.type === constants_1.ORDER_TYPES.SELL).length;
     if (buyCount === 0 || sellCount === 0) {
         throw new Error(`Grid generation produced an imbalanced rail (buy=${buyCount}, sell=${sellCount}) for ` +
             `startPrice=${startPrice}, bounds=[${minPrice}, ${maxPrice}], incrementPercent=${incrementPercent}, ` +
@@ -468,7 +502,7 @@ async function loadGrid(manager, grid, boundaryIdx = null) {
             await manager._initializeAssets();
         }
         catch (e) {
-            manager.logger?.log?.(`Asset initialization failed during grid load: ${e.message}`, 'warn');
+            manager.logger?.log?.(`Asset initialization failed during grid load: ${(0, errors_1.getErrorMessage)(e)}`, 'warn');
         }
         // RC-2: Use logic helper
         _clearOrderCachesLogic(manager);
@@ -491,12 +525,12 @@ async function loadGrid(manager, grid, boundaryIdx = null) {
             const sellStartIdx = boundaryIdx + gapSlots + 1;
             let reassignCount = 0;
             grid = grid.map((slot, i) => {
-                if (slot.state === ORDER_STATES.VIRTUAL && !slot.orderId) {
+                if (slot.state === constants_1.ORDER_STATES.VIRTUAL && !slot.orderId) {
                     const correctType = (i <= buyEndIdx)
-                        ? ORDER_TYPES.BUY
+                        ? constants_1.ORDER_TYPES.BUY
                         : (i >= sellStartIdx)
-                            ? ORDER_TYPES.SELL
-                            : ORDER_TYPES.SPREAD;
+                            ? constants_1.ORDER_TYPES.SELL
+                            : constants_1.ORDER_TYPES.SPREAD;
                     if (slot.type !== correctType) {
                         reassignCount++;
                         return { ...slot, type: correctType };
@@ -525,7 +559,7 @@ async function loadGrid(manager, grid, boundaryIdx = null) {
                 manager._gridBloatDetectedAt = Date.now();
                 if (typeof manager.requestStructuralGridResync === 'function') {
                     manager.requestStructuralGridResync('grid-bloat-detected', { reason: `Grid size ${d.gridSize} exceeds maximum ${d.maxAllowed}` }).catch((err) => {
-                        manager.logger?.log?.(`[GRID-BLOAT] Structural resync request failed: ${err.message}`, 'error');
+                        manager.logger?.log?.(`[GRID-BLOAT] Structural resync request failed: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
                     });
                 }
             }
@@ -536,13 +570,13 @@ async function loadGrid(manager, grid, boundaryIdx = null) {
             // RC-2: Use applyOrderUpdate (PRIVATE/UNLOCKED)
             for (const order of grid) {
                 let currentOrder = order;
-                if (isPhantomOrder(order)) {
+                if ((0, order_1.isPhantomOrder)(order)) {
                     manager.logger?.log?.(`Sanitizing corrupted order ${order.id}: ACTIVE/PARTIAL without orderId -> VIRTUAL`, 'warn');
-                    currentOrder = { ...order, state: ORDER_STATES.VIRTUAL };
+                    currentOrder = { ...order, state: constants_1.ORDER_STATES.VIRTUAL };
                 }
                 await manager._applyOrderUpdate(currentOrder, 'grid-load', { skipAccounting: true });
             }
-            const spreadCount = grid.filter(o => o.type === ORDER_TYPES.SPREAD).length;
+            const spreadCount = grid.filter((o) => o.type === constants_1.ORDER_TYPES.SPREAD).length;
             manager.targetSpreadCount = spreadCount;
             manager.currentSpreadCount = spreadCount;
         }
@@ -576,7 +610,7 @@ async function initializeGrid(manager) {
     if (typeof mpRaw !== 'number' || isNaN(mpRaw)) {
         try {
             const { BitShares } = require('../bitshares_client');
-            const derived = await derivePrice(BitShares, manager.config.assetA, manager.config.assetB, manager.config.priceMode || 'auto');
+            const derived = await (0, system_1.derivePrice)(BitShares, manager.config.assetA, manager.config.assetB, manager.config.priceMode || 'auto');
             if (derived) {
                 manager.logger?.log?.(`[DIAGNOSTIC] initializeGrid: Derived new startPrice=${derived.toFixed(8)} (mode=${manager.config.priceMode || 'auto'})`, 'info');
                 manager.config.startPrice = Number(derived);
@@ -586,11 +620,10 @@ async function initializeGrid(manager) {
             }
         }
         catch (err) {
-            manager.logger?.log?.(`Failed to derive market price: ${err.message}`, 'warn');
+            manager.logger?.log?.(`Failed to derive market price: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
             throw err; // Re-throw to prevent "pool" string reaching numeric math
         }
     }
-    const configuredStartPrice = manager.config.startPrice;
     const configuredMinPrice = manager.config.minPrice;
     const configuredMaxPrice = manager.config.maxPrice;
     const mp = Number(manager.config.startPrice);
@@ -603,7 +636,7 @@ async function initializeGrid(manager) {
     let gp = mp;
     let gpSource = 'startPrice';
     let amaSnapshot = null;
-    const whitelistFlags = getWhitelistFlags(manager.config.botKey);
+    const whitelistFlags = (0, market_adapter_whitelist_1.getWhitelistFlags)(manager.config.botKey);
     const isGridRangeScalingWhitelisted = whitelistFlags.asymmetricBounds === true;
     let gridPriceOffsetPct = 0;
     const gpRaw = manager.config.gridPrice;
@@ -616,7 +649,7 @@ async function initializeGrid(manager) {
     else if (gpMode === 'pool' || gpMode === 'book') {
         try {
             const { BitShares } = require('../bitshares_client');
-            const derived = await derivePrice(BitShares, manager.config.assetA, manager.config.assetB, gpMode);
+            const derived = await (0, system_1.derivePrice)(BitShares, manager.config.assetA, manager.config.assetB, gpMode);
             if (derived) {
                 gp = Number(derived);
                 gpSource = gpMode;
@@ -627,12 +660,12 @@ async function initializeGrid(manager) {
             }
         }
         catch (err) {
-            manager.logger?.log?.(`initializeGrid: ${gpMode} gridPrice derivation failed: ${err.message}`, 'warn');
+            manager.logger?.log?.(`initializeGrid: ${gpMode} gridPrice derivation failed: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
         }
     }
     else if (/^ama(?:[1-4])?$/.test(gpMode || '')) {
-        amaSnapshot = loadAmaCenterSnapshot(manager.config.botKey);
-        const amaCenter = amaSnapshot?.gridCenterPrice ?? loadAmaCenterPrice(manager.config.botKey);
+        amaSnapshot = (0, system_1.loadAmaCenterSnapshot)(manager.config.botKey);
+        const amaCenter = amaSnapshot?.gridCenterPrice ?? (0, system_1.loadAmaCenterPrice)(manager.config.botKey);
         if (Number.isFinite(amaCenter) && amaCenter > 0) {
             gp = amaCenter;
             gpSource = 'ama';
@@ -647,8 +680,8 @@ async function initializeGrid(manager) {
             manager.logger?.log?.(`initializeGrid: AMA center unavailable for gridPrice, falling back to startPrice`, 'warn');
         }
     }
-    const minP = resolveConfiguredPriceBound(manager.config.minPrice, DEFAULT_CONFIG.minPrice, gp, 'min');
-    const maxP = resolveConfiguredPriceBound(manager.config.maxPrice, DEFAULT_CONFIG.maxPrice, gp, 'max');
+    const minP = (0, order_1.resolveConfiguredPriceBound)(manager.config.minPrice, constants_1.DEFAULT_CONFIG.minPrice, gp, 'min');
+    const maxP = (0, order_1.resolveConfiguredPriceBound)(manager.config.maxPrice, constants_1.DEFAULT_CONFIG.maxPrice, gp, 'max');
     // Asymmetric bound adjustment: widen the bound in the AMA trend direction
     // and tighten the opposite side, giving the grid more room when the center
     // trails price. Uses slope data from the dynamicgrid.json snapshot.
@@ -665,8 +698,8 @@ async function initializeGrid(manager) {
             ? amaSnapshot.asymmetricBounds
             : null;
         if (dw) {
-            const maxAsymmetryFactor = resolveMaxAsymmetryFactor(manager.config.asymmetricBounds?.maxAsymmetryFactor, dw?.maxAsymmetryFactor, MARKET_ADAPTER.ASYMMETRIC_BOUNDS_MAX_ASYMMETRY_FACTOR);
-            const adjustment = applyAsymmetricBounds({
+            const maxAsymmetryFactor = (0, asymmetric_bounds_1.resolveMaxAsymmetryFactor)(manager.config.asymmetricBounds?.maxAsymmetryFactor, dw?.maxAsymmetryFactor, constants_1.MARKET_ADAPTER.ASYMMETRIC_BOUNDS_MAX_ASYMMETRY_FACTOR);
+            const adjustment = (0, asymmetric_bounds_1.applyAsymmetricBounds)({
                 centerPrice: gp,
                 minPrice: minP,
                 maxPrice: maxP,
@@ -680,11 +713,11 @@ async function initializeGrid(manager) {
                 resolvedMaxP = adjustment.resolvedMaxPrice;
                 rangeScalingFactor = Number(adjustment.appliedAsymmetryFactor);
                 manager.logger?.log?.(`[BOUND-ASYMMETRY] trend=${dw.trend} slopeOffset=${dw.slopeOffset.toFixed(4)} `
-                    + `raw=${(adjustment.rawAsymmetryFactor * 100).toFixed(1)}% `
-                    + `cap=${(maxAsymmetryFactor * 100).toFixed(0)}% `
-                    + `asymmetry=${(adjustment.appliedAsymmetryFactor * 100).toFixed(1)}% `
-                    + `min ${minP.toFixed(8)}→${resolvedMinP.toFixed(8)} `
-                    + `max ${maxP.toFixed(8)}→${resolvedMaxP.toFixed(8)}`, 'info');
+                    + `raw=${((adjustment.rawAsymmetryFactor ?? 0) * 100).toFixed(1)}% `
+                    + `cap=${((maxAsymmetryFactor ?? 0) * 100).toFixed(0)}% `
+                    + `asymmetry=${((adjustment.appliedAsymmetryFactor ?? 0) * 100).toFixed(1)}% `
+                    + `min ${(minP ?? 0).toFixed(8)}→${(resolvedMinP ?? 0).toFixed(8)} `
+                    + `max ${(maxP ?? 0).toFixed(8)}→${(resolvedMaxP ?? 0).toFixed(8)}`, 'info');
             }
         }
         else if (rootBounds && Number.isFinite(rootBounds.appliedAsymmetryFactor)
@@ -702,8 +735,8 @@ async function initializeGrid(manager) {
             rangeScalingFactor = asymmetry;
             manager.logger?.log?.(`[BOUND-ASYMMETRY] trend=${rootTrend} `
                 + `asymmetry=${(asymmetry * 100).toFixed(1)}% `
-                + `(root-level) min ${minP.toFixed(8)}→${resolvedMinP.toFixed(8)} `
-                + `max ${maxP.toFixed(8)}→${resolvedMaxP.toFixed(8)}`, 'info');
+                + `(root-level) min ${(minP ?? 0).toFixed(8)}→${(resolvedMinP ?? 0).toFixed(8)} `
+                + `max ${(maxP ?? 0).toFixed(8)}→${(resolvedMaxP ?? 0).toFixed(8)}`, 'info');
         }
     }
     let gridStartPrice = mp;
@@ -715,14 +748,16 @@ async function initializeGrid(manager) {
         gridStartPrice = adjustedMarketPrice;
         offsetAdjustedStartPrice = adjustedMarketPrice;
     }
-    if (!(gridStartPrice >= resolvedMinP && gridStartPrice <= resolvedMaxP)) {
-        if (Number.isFinite(gp) && gp > 0 && gp >= resolvedMinP && gp <= resolvedMaxP) {
+    const rMinP = resolvedMinP ?? 0;
+    const rMaxP = resolvedMaxP ?? 0;
+    if (!(gridStartPrice >= rMinP && gridStartPrice <= rMaxP)) {
+        if (Number.isFinite(gp) && gp > 0 && gp >= rMinP && gp <= rMaxP) {
             gridStartPrice = gp;
-            manager.logger?.log?.(`initializeGrid: startPrice (${mp}) outside bounds [${resolvedMinP}, ${resolvedMaxP}]; using gridPrice center ${gp}`, 'warn');
+            manager.logger?.log?.(`initializeGrid: startPrice (${mp}) outside bounds [${rMinP}, ${rMaxP}]; using gridPrice center ${gp}`, 'warn');
         }
         else {
-            const clamped = Math.min(resolvedMaxP, Math.max(resolvedMinP, gridStartPrice));
-            manager.logger?.log?.(`initializeGrid: startPrice (${mp}) outside bounds [${resolvedMinP}, ${resolvedMaxP}]; clamping to ${clamped}`, 'warn');
+            const clamped = Math.min(rMaxP, Math.max(rMinP, gridStartPrice));
+            manager.logger?.log?.(`initializeGrid: startPrice (${mp}) outside bounds [${rMinP}, ${rMaxP}]; clamping to ${clamped}`, 'warn');
             gridStartPrice = clamped;
         }
     }
@@ -740,14 +775,14 @@ async function initializeGrid(manager) {
     // Ensure percentage-based funds are resolved before sizing
     try {
         if (manager.accountId && !manager.accountTotals) {
-            await manager.waitForAccountTotals(TIMING.ACCOUNT_TOTALS_TIMEOUT_MS);
+            await manager.waitForAccountTotals(constants_1.TIMING.ACCOUNT_TOTALS_TIMEOUT_MS);
         }
     }
     catch (e) {
-        manager.logger?.log?.(`Failed to load account totals: ${e.message}`, 'warn');
+        manager.logger?.log?.(`Failed to load account totals: ${(0, errors_1.getErrorMessage)(e)}`, 'warn');
         // FIX: Add error handling - cannot proceed with grid initialization without account totals
         // Continuing would create grid with 0 fund allocation, rendering it non-functional
-        throw new Error(`Cannot initialize grid without account totals: ${e.message}`);
+        throw new Error(`Cannot initialize grid without account totals: ${(0, errors_1.getErrorMessage)(e)}`);
     }
     const { orders, boundaryIdx, initialSpreadCount } = createOrderGrid({
         ...manager.config,
@@ -765,13 +800,13 @@ async function initializeGrid(manager) {
                 manager.notifyBoundaryUpdate(boundaryIdx);
             }
             catch (err) {
-                manager.logger?.log?.(`Error notifying boundary update: ${err.message}`, 'warn');
+                manager.logger?.log?.(`Error notifying boundary update: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
             }
         }
     }
-    const minSellSize = getMinAbsoluteOrderSize(ORDER_TYPES.SELL, manager.assets);
-    const minBuySize = getMinAbsoluteOrderSize(ORDER_TYPES.BUY, manager.assets);
-    const { A: precA, B: precB } = getPrecisionsForManager(manager.assets);
+    const minSellSize = (0, math_1.getMinAbsoluteOrderSize)(constants_1.ORDER_TYPES.SELL, manager.assets);
+    const minBuySize = (0, math_1.getMinAbsoluteOrderSize)(constants_1.ORDER_TYPES.BUY, manager.assets);
+    const { A: precA, B: precB } = (0, math_1.getPrecisionsForManager)(manager.assets);
     // Use centralized sizing context for both sides.
     // Resolve funds once upfront so both contexts share the same snapshot,
     // avoiding a redundant recalculateFunds inside the second _getSizingContext call.
@@ -780,17 +815,17 @@ async function initializeGrid(manager) {
     const buyCtx = await _getSizingContext(manager, 'buy', { skipRecalc: true });
     if (!sellCtx || !buyCtx)
         throw new Error('Failed to retrieve sizing context for grid initialization');
-    let sizedOrders = calculateOrderSizes(orders, manager.config, sellCtx.budget, buyCtx.budget, minSellSize, minBuySize, precA, precB);
+    let sizedOrders = (0, math_1.calculateOrderSizes)(orders, manager.config, sellCtx.budget, buyCtx.budget, minSellSize, minBuySize, precA, precB);
     // Verification of sizes
-    const sells = filterOrdersByType(sizedOrders, ORDER_TYPES.SELL).map(o => Number(o.size || 0));
-    const buys = filterOrdersByType(sizedOrders, ORDER_TYPES.BUY).map(o => Number(o.size || 0));
-    if (checkSizesBeforeMinimum(sells, minSellSize, precA) || checkSizesBeforeMinimum(buys, minBuySize, precB)) {
+    const sells = (0, order_1.filterOrdersByType)(sizedOrders, constants_1.ORDER_TYPES.SELL).map((o) => Number(o.size || 0));
+    const buys = (0, order_1.filterOrdersByType)(sizedOrders, constants_1.ORDER_TYPES.BUY).map((o) => Number(o.size || 0));
+    if ((0, order_1.checkSizesBeforeMinimum)(sells, minSellSize, precA) || (0, order_1.checkSizesBeforeMinimum)(buys, minBuySize, precB)) {
         throw new Error('Calculated orders fall below minimum allowable size.');
     }
     // Check for warning if orders are near minimal size (regression fix)
-    const warningSellSize = minSellSize > 0 ? getMinAbsoluteOrderSize(ORDER_TYPES.SELL, manager.assets, 100) : 0;
-    const warningBuySize = minBuySize > 0 ? getMinAbsoluteOrderSize(ORDER_TYPES.BUY, manager.assets, 100) : 0;
-    if (checkSizeThreshold(sells, warningSellSize, precA, false) || checkSizeThreshold(buys, warningBuySize, precB, false)) {
+    const warningSellSize = minSellSize > 0 ? (0, math_1.getMinAbsoluteOrderSize)(constants_1.ORDER_TYPES.SELL, manager.assets, 100) : 0;
+    const warningBuySize = minBuySize > 0 ? (0, math_1.getMinAbsoluteOrderSize)(constants_1.ORDER_TYPES.BUY, manager.assets, 100) : 0;
+    if ((0, order_1.checkSizeThreshold)(sells, warningSellSize, precA, false) || (0, order_1.checkSizeThreshold)(buys, warningBuySize, precB, false)) {
         manager.logger?.log?.("WARNING: Order grid contains orders near minimum size. To ensure the bot runs properly, consider increasing the funds of your bot.", "warn");
     }
     // RC-2: Wrap atomic changes in grid lock
@@ -832,32 +867,48 @@ async function recalculateGrid(manager, opts) {
     const { readOpenOrdersFn, chainOrders, account, privateKey } = opts;
     // Suppress invariant warnings during full resync
     manager.startBootstrap();
-    try {
-        // FIX: Use consistent optional chaining pattern for logger calls
+    // Total timeout across all steps — prevents indefinite hang even if
+    // an individual withBlockchainRetry step pins the event loop.
+    const totalTimeoutMs = constants_1.PIPELINE_TIMING.TIMEOUT_MS * 2; // 10 min
+    const work = (async () => {
         manager.logger?.log?.('Starting full resync...', 'info');
+        // #1: Initialize assets (returns immediately if already loaded)
         await manager._initializeAssets();
-        await manager.fetchAccountTotals();
-        const chainOpenOrders = await readOpenOrdersFn();
+        // #2: Fetch account totals with timeout + retry + node failover
+        await (0, system_1.withBlockchainRetry)(() => manager.fetchAccountTotals(), 'fetchAccountTotals', { logger: manager.logger });
+        // #3: Read open orders with timeout + retry + node failover
+        const chainOpenOrders = await (0, system_1.withBlockchainRetry)(() => readOpenOrdersFn(), 'readOpenOrders', { logger: manager.logger });
         if (!Array.isArray(chainOpenOrders))
             return;
-        // CRITICAL: Filter out PARTIAL orders before synchronizing - they're from old grid
-        // and shouldn't be part of the fresh regenerated grid structure
-        const activeOrders = chainOpenOrders.filter(o => o.state !== ORDER_STATES.PARTIAL);
-        await manager.syncFromOpenOrders(activeOrders, { skipAccounting: true });
+        await (0, system_1.withBlockchainRetry)(() => manager.syncFromOpenOrders(chainOpenOrders, { skipAccounting: true }), 'syncFromOpenOrders', { logger: manager.logger });
         manager.resetFunds();
         await manager.persistGrid();
         await initializeGrid(manager);
         const { reconcileGridOrders } = require('./grid_reconcile');
-        // FIX: Add error context for debugging grid recalculation issues
+        // #5: Reconcile grid orders with timeout + retry + node failover
         try {
-            await reconcileGridOrders({ manager, config: manager.config, account, privateKey, chainOrders, chainOpenOrders });
+            await (0, system_1.withBlockchainRetry)(() => reconcileGridOrders({ manager, config: manager.config, account, privateKey, chainOrders, chainOpenOrders }), 'reconcileGridOrders', 
+            // 5 min: Phase 2 of reconcile does sequential creates (~3s each);
+            // the default 30s timeout would kill mid-batch and cause duplicate-
+            // accumulation death spirals. PIPELINE_TIMING.TIMEOUT_MS gives enough
+            // headroom for all pending creates+updates to finish in one shot.
+            { logger: manager.logger, timeoutMs: constants_1.PIPELINE_TIMING.TIMEOUT_MS });
         }
         catch (err) {
-            manager.logger?.log?.(`Error during startup order reconciliation: ${err.message}`, 'error');
-            throw new Error(`Grid recalculation failed during order reconciliation: ${err.message}`);
+            manager.logger?.log?.(`Error during startup order reconciliation: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+            throw new Error(`Grid recalculation failed during order reconciliation: ${(0, errors_1.getErrorMessage)(err)}`);
         }
-        // FIX: Use consistent optional chaining pattern for logger calls
         manager.logger?.log?.('Full resync complete.', 'info');
+    })();
+    try {
+        // Swallow late rejection if timeout wins the race
+        Promise.resolve(work).catch(() => { });
+        return await Promise.race([
+            work,
+            new Promise((_, reject) => {
+                setTimeout(() => reject(new Error(`recalculateGrid timed out after ${totalTimeoutMs}ms`)), totalTimeoutMs);
+            })
+        ]);
     }
     finally {
         manager.finishBootstrap();
@@ -876,13 +927,13 @@ function checkAndUpdateGridIfNeeded(manager) {
     const gridSell = Number(manager.funds?.total?.grid?.sell || 0);
     const result = { buyUpdated: false, sellUpdated: false };
     const sides = [
-        { name: 'buy', grid: gridBuy, orderType: ORDER_TYPES.BUY },
-        { name: 'sell', grid: gridSell, orderType: ORDER_TYPES.SELL }
+        { name: 'buy', grid: gridBuy, orderType: constants_1.ORDER_TYPES.BUY },
+        { name: 'sell', grid: gridSell, orderType: constants_1.ORDER_TYPES.SELL }
     ];
     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 availableFunds = (0, math_1.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);
         // 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);
@@ -961,7 +1012,7 @@ async function _recalculateGridOrderSizesFromBlockchain(manager, orderType, opti
         return options?.workingGrid ? { actions: [], changed: false } : undefined;
     const workingGrid = options?.workingGrid || null;
     const collectActions = !!workingGrid;
-    const isBuy = orderType === ORDER_TYPES.BUY;
+    const isBuy = orderType === constants_1.ORDER_TYPES.BUY;
     const sideName = isBuy ? 'buy' : 'sell';
     // Use centralized sizing context (respects botFunds % allocation)
     const ctx = await _getSizingContext(manager, sideName);
@@ -971,12 +1022,12 @@ async function _recalculateGridOrderSizesFromBlockchain(manager, orderType, opti
     // SELL: sorted ASC (Market to Edge)
     // BUY: sorted ASC (Edge to Market)
     const allSideSlots = Array.from(manager.orders.values())
-        .filter(o => o.type === orderType)
+        .filter((o) => o.type === orderType)
         .sort((a, b) => a.price - b.price);
     if (allSideSlots.length === 0)
         return collectActions ? { actions: [], changed: false } : undefined;
     // Calculate geometric sizes for the ENTIRE rail
-    const newSizes = calculateRotationOrderSizes(ctx.budget, 0, allSideSlots.length, orderType, manager.config, 0, ctx.precision);
+    const newSizes = (0, math_1.calculateRotationOrderSizes)(ctx.budget, 0, allSideSlots.length, orderType, manager.config, 0, ctx.precision);
     const actions = [];
     let changed = false;
     const freeKey = isBuy ? 'buyFree' : 'sellFree';
@@ -995,7 +1046,7 @@ async function _recalculateGridOrderSizesFromBlockchain(manager, orderType, opti
             // NOTE: BTS update fees are paid from BTS balance (separate from asset balance),
             // so they don't affect this asset-side size cap. Fee budgets are tracked in
             // funds.btsFeesOwed and reserved separately via btsFeesReservation.
-            const isCommitted = isOrderOnChain(slot);
+            const isCommitted = (0, order_1.isOrderOnChain)(slot);
             if (isCommitted) {
                 const currentSize = Number(slot.size || 0);
                 const delta = newSize - currentSize;
@@ -1015,8 +1066,8 @@ async function _recalculateGridOrderSizesFromBlockchain(manager, orderType, opti
                 }
             }
             // Use integer comparison to avoid redundant updates from float noise
-            const currentSizeInt = floatToBlockchainInt(slot.size || 0, ctx.precision);
-            const newSizeInt = floatToBlockchainInt(newSize, ctx.precision);
+            const currentSizeInt = (0, math_1.floatToBlockchainInt)(slot.size || 0, ctx.precision);
+            const newSizeInt = (0, math_1.floatToBlockchainInt)(newSize, ctx.precision);
             if (slot.size === undefined || currentSizeInt !== newSizeInt) {
                 changed = true;
                 if (collectActions) {
@@ -1024,9 +1075,9 @@ async function _recalculateGridOrderSizesFromBlockchain(manager, orderType, opti
                         ...slot,
                         size: newSize
                     });
-                    if (isCommitted && hasOnChainId(slot)) {
+                    if (isCommitted && (0, order_1.hasOnChainId)(slot)) {
                         actions.push({
-                            type: COW_ACTIONS.UPDATE,
+                            type: constants_1.COW_ACTIONS.UPDATE,
                             id: slot.id,
                             orderId: slot.orderId,
                             newGridId: slot.id,
@@ -1083,13 +1134,13 @@ async function updateGridFromBlockchainSnapshot(manager, orderType = 'both', fro
     const allActions = [];
     let hasWorkingChanges = false;
     // Calculate size updates for each side (via existing sizing function in COW mode)
-    if (orderType === ORDER_TYPES.BUY || orderType === 'both') {
-        const buyResult = await _recalculateGridOrderSizesFromBlockchain(manager, ORDER_TYPES.BUY, { workingGrid });
+    if (orderType === constants_1.ORDER_TYPES.BUY || orderType === 'both') {
+        const buyResult = await _recalculateGridOrderSizesFromBlockchain(manager, constants_1.ORDER_TYPES.BUY, { workingGrid });
         allActions.push(...buyResult.actions);
         hasWorkingChanges = hasWorkingChanges || buyResult.changed;
     }
-    if (orderType === ORDER_TYPES.SELL || orderType === 'both') {
-        const sellResult = await _recalculateGridOrderSizesFromBlockchain(manager, ORDER_TYPES.SELL, { workingGrid });
+    if (orderType === constants_1.ORDER_TYPES.SELL || orderType === 'both') {
+        const sellResult = await _recalculateGridOrderSizesFromBlockchain(manager, constants_1.ORDER_TYPES.SELL, { workingGrid });
         allActions.push(...sellResult.actions);
         hasWorkingChanges = hasWorkingChanges || sellResult.changed;
     }
@@ -1100,9 +1151,9 @@ async function updateGridFromBlockchainSnapshot(manager, orderType = 'both', fro
     if (overrideBoundaryIdx !== null && overrideBoundaryIdx !== manager.boundaryIdx) {
         const gapSlots = calculateGapSlots(manager.config.incrementPercent, manager.config.targetSpreadPercent, manager.config.gridLimits);
         const allSlots = Array.from(workingGrid.values())
-            .filter(s => s.price != null)
+            .filter((s) => s.price != null)
             .sort((a, b) => a.price - b.price);
-        const updatedSlots = assignGridRoles(allSlots, newBoundary, gapSlots, ORDER_TYPES, ORDER_STATES);
+        const updatedSlots = (0, order_1.assignGridRoles)(allSlots, newBoundary, gapSlots, constants_1.ORDER_TYPES, constants_1.ORDER_STATES);
         for (const slot of updatedSlots) {
             workingGrid.set(slot.id, slot);
         }
@@ -1173,14 +1224,14 @@ async function compareGrids(calculatedGrid, persistedGrid, manager = null) {
     // they are instead handled by the available-funds ratio check or follow-up correction.
     // Must be sorted ASC for calculateRotationOrderSizes to match geometric weight distribution
     const filterForRms = (orders, type) => {
-        const result = Array.isArray(orders) ? orders.filter(o => o && o.type === type && o.state === ORDER_STATES.ACTIVE) : [];
+        const result = Array.isArray(orders) ? orders.filter((o) => o && o.type === type && o.state === constants_1.ORDER_STATES.ACTIVE) : [];
         return result
             .sort((a, b) => (a.price ?? 0) - (b.price ?? 0));
     };
-    const calculatedBuys = filterForRms(calculatedSnap, ORDER_TYPES.BUY);
-    const calculatedSells = filterForRms(calculatedSnap, ORDER_TYPES.SELL);
-    const persistedBuys = filterForRms(persistedSnap, ORDER_TYPES.BUY);
-    const persistedSells = filterForRms(persistedSnap, ORDER_TYPES.SELL);
+    const calculatedBuys = filterForRms(calculatedSnap, constants_1.ORDER_TYPES.BUY);
+    const calculatedSells = filterForRms(calculatedSnap, constants_1.ORDER_TYPES.SELL);
+    const persistedBuys = filterForRms(persistedSnap, constants_1.ORDER_TYPES.BUY);
+    const persistedSells = filterForRms(persistedSnap, constants_1.ORDER_TYPES.SELL);
     // Calculate ideal sizes for each order based on current available budget.
     // The sizing context (which includes recalculateFunds) is resolved once per side up front
     // so both buy and sell metrics share a single fund snapshot. This avoids the previous
@@ -1192,18 +1243,18 @@ async function compareGrids(calculatedGrid, persistedGrid, manager = null) {
         // Identify ALL slots currently assigned to this side.
         // Ideal sizing must use the full slot count to determine geometric share per slot.
         const sideSlots = Array.from(manager.orders.values())
-            .filter(o => o.type === type)
+            .filter((o) => o.type === type)
             .sort((a, b) => (a.price ?? 0) - (b.price ?? 0));
         if (sideSlots.length === 0)
             return activeOrders;
         // Calculate geometric ideals for the ENTIRE side (all slots)
         try {
-            const allIdealSizes = calculateRotationOrderSizes(ctx.budget, 0, sideSlots.length, type, manager.config, 0, ctx.precision);
+            const allIdealSizes = (0, math_1.calculateRotationOrderSizes)(ctx.budget, 0, sideSlots.length, type, manager.config, 0, ctx.precision);
             // Map Ideal sizes to IDs for quick lookup
             const idealMap = new Map();
             sideSlots.forEach((slot, i) => idealMap.set(slot.id, allIdealSizes[i]));
             // Return the activeOrders subset with their true geometric ideal sizes
-            return activeOrders.map(o => ({ ...o, size: idealMap.get(o.id) ?? 0 }));
+            return activeOrders.map((o) => ({ ...o, size: idealMap.get(o.id) ?? 0 }));
         }
         catch (e) {
             return activeOrders;
@@ -1220,11 +1271,11 @@ async function compareGrids(calculatedGrid, persistedGrid, manager = null) {
     const sellCtx = needsSell
         ? await _getSizingContext(manager, 'sell', { skipRecalc: true })
         : null;
-    const buyIdeals = computeSideIdeals(calculatedBuys, ORDER_TYPES.BUY, buyCtx);
-    const sellIdeals = computeSideIdeals(calculatedSells, ORDER_TYPES.SELL, sellCtx);
+    const buyIdeals = computeSideIdeals(calculatedBuys, constants_1.ORDER_TYPES.BUY, buyCtx);
+    const sellIdeals = computeSideIdeals(calculatedSells, constants_1.ORDER_TYPES.SELL, sellCtx);
     // Calculate RMS divergence metric for each side
-    const buyMetric = calculateGridSideDivergenceMetric(buyIdeals, persistedBuys, 'buy');
-    const sellMetric = calculateGridSideDivergenceMetric(sellIdeals, persistedSells, 'sell');
+    const buyMetric = (0, math_1.calculateGridSideDivergenceMetric)(buyIdeals, persistedBuys, 'buy');
+    const sellMetric = (0, math_1.calculateGridSideDivergenceMetric)(sellIdeals, persistedSells, 'sell');
     // Check if metrics exceed threshold and flag sides for regeneration
     // Set RMS_PERCENTAGE to 0 to disable RMS divergence checks
     let buyUpdated = false, sellUpdated = false;
@@ -1234,14 +1285,14 @@ async function compareGrids(calculatedGrid, persistedGrid, manager = null) {
             // RC-3: Use Set for automatic duplicate prevention
             if (!(manager._gridSidesUpdated instanceof Set))
                 manager._gridSidesUpdated = new Set();
-            manager._gridSidesUpdated.add(ORDER_TYPES.BUY);
+            manager._gridSidesUpdated.add(constants_1.ORDER_TYPES.BUY);
             buyUpdated = true;
         }
         if (sellMetric > limit) {
             // RC-3: Use Set for automatic duplicate prevention
             if (!(manager._gridSidesUpdated instanceof Set))
                 manager._gridSidesUpdated = new Set();
-            manager._gridSidesUpdated.add(ORDER_TYPES.SELL);
+            manager._gridSidesUpdated.add(constants_1.ORDER_TYPES.SELL);
             sellUpdated = true;
         }
     }
@@ -1292,13 +1343,13 @@ async function monitorDivergence(manager, calculatedGrid, persistedGrid) {
  */
 function _getOnChainOrders(manager) {
     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);
+        ...manager.getOrdersByTypeAndState(constants_1.ORDER_TYPES.BUY, constants_1.ORDER_STATES.ACTIVE),
+        ...manager.getOrdersByTypeAndState(constants_1.ORDER_TYPES.BUY, constants_1.ORDER_STATES.PARTIAL)
+    ].filter((o) => o?.orderId && Number(o?.size || 0) > 0);
     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);
+        ...manager.getOrdersByTypeAndState(constants_1.ORDER_TYPES.SELL, constants_1.ORDER_STATES.ACTIVE),
+        ...manager.getOrdersByTypeAndState(constants_1.ORDER_TYPES.SELL, constants_1.ORDER_STATES.PARTIAL)
+    ].filter((o) => o?.orderId && Number(o?.size || 0) > 0);
     return { onChainBuys, onChainSells };
 }
 /**
@@ -1308,7 +1359,7 @@ function _getOnChainOrders(manager) {
  */
 function calculateCurrentSpread(manager) {
     const { onChainBuys, onChainSells } = _getOnChainOrders(manager);
-    return calculateSpreadFromOrders(onChainBuys, onChainSells);
+    return (0, math_1.calculateSpreadFromOrders)(onChainBuys, onChainSells);
 }
 /**
  * Proactive spread correction check.
@@ -1333,7 +1384,7 @@ function calculateCurrentSpread(manager) {
  * @param {Function|null} [updateOrdersOnChainBatch=null] - Optional batch update function
  * @returns {Promise<import('./types').SpreadCheckResult>}
  */
-async function checkSpreadCondition(manager, BitShares, updateOrdersOnChainBatch = null) {
+async function checkSpreadCondition(manager, _BitShares, updateOrdersOnChainBatch = null) {
     // CRITICAL: Acquire corrections lock to serialize spread correction operations
     // This prevents concurrent fill processing from modifying funds while we're making decisions
     let correction = null;
@@ -1343,7 +1394,7 @@ async function checkSpreadCondition(manager, BitShares, updateOrdersOnChainBatch
     // Mid between best bid and best ask is the most current price the bot has.
     // Falls back to config.startPrice when either side is empty (e.g. at startup).
     const { onChainBuys, onChainSells } = _getOnChainOrders(manager);
-    const { bestBuy, bestSell } = getGridBestPrices(onChainBuys, onChainSells);
+    const { bestBuy, bestSell } = (0, math_1.getGridBestPrices)(onChainBuys, onChainSells);
     const lastPrice = (bestBuy !== null && bestSell !== null)
         ? (bestBuy + bestSell) / 2
         : Number(manager.config.startPrice) || 0;
@@ -1361,18 +1412,18 @@ async function checkSpreadCondition(manager, BitShares, updateOrdersOnChainBatch
         const currentSpread = calculateCurrentSpread(manager);
         // Nominal spread is the configured target spread percentage.
         // Keep this fixed: doubled-side flags are fill/replacement mechanics only.
-        const nominalSpread = manager.config.targetSpreadPercent ?? DEFAULT_CONFIG.targetSpreadPercent;
+        const nominalSpread = manager.config.targetSpreadPercent ?? constants_1.DEFAULT_CONFIG.targetSpreadPercent;
         // Fixed tolerance: 0.5 steps = half increment (tighter spread check).
         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)
+        const buyCount = manager.getOrdersByTypeAndState(constants_1.ORDER_TYPES.BUY, constants_1.ORDER_STATES.ACTIVE)
+            .concat(manager.getOrdersByTypeAndState(constants_1.ORDER_TYPES.BUY, constants_1.ORDER_STATES.PARTIAL))
+            .filter((o) => o?.orderId && Number(o?.size || 0) > 0)
             .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)
+        const sellCount = manager.getOrdersByTypeAndState(constants_1.ORDER_TYPES.SELL, constants_1.ORDER_STATES.ACTIVE)
+            .concat(manager.getOrdersByTypeAndState(constants_1.ORDER_TYPES.SELL, constants_1.ORDER_STATES.PARTIAL))
+            .filter((o) => o?.orderId && Number(o?.size || 0) > 0)
             .length;
-        manager.outOfSpread = shouldFlagOutOfSpread(currentSpread, nominalSpread, toleranceSteps, buyCount, sellCount, manager.config.incrementPercent);
+        manager.outOfSpread = (0, order_1.shouldFlagOutOfSpread)(currentSpread, nominalSpread, toleranceSteps, buyCount, sellCount, manager.config.incrementPercent);
         if (manager.outOfSpread === 0)
             return false;
         // Check whether the empty side is caused by boundary-at-rail-edge.
@@ -1402,7 +1453,7 @@ async function checkSpreadCondition(manager, BitShares, updateOrdersOnChainBatch
                     `Requesting structural grid resync to re-center.`, 'warn');
                 if (typeof manager.requestStructuralGridResync === 'function') {
                     manager.requestStructuralGridResync('boundary-at-rail-edge', { reason: `Boundary ${manager.boundaryIdx} leaves ${buySideCount} buy / ${sellSideCount} sell slots` }).catch((err) => {
-                        manager.logger?.log?.(`[SPREAD] Structural resync request failed: ${err.message}`, 'error');
+                        manager.logger?.log?.(`[SPREAD] Structural resync request failed: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
                     });
                 }
             }
@@ -1427,7 +1478,7 @@ async function checkSpreadCondition(manager, BitShares, updateOrdersOnChainBatch
         shouldApplyCorrection = await manager._gridLock.acquire(executeSpreadCheck);
     }
     catch (err) {
-        manager.logger?.log?.(`Error checking spread condition: ${err.message}`, 'warn');
+        manager.logger?.log?.(`Error checking spread condition: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
         return { ordersPlaced: 0, partialsMoved: 0 };
     }
     // FIX: Apply blockchain operations OUTSIDE the lock to reduce lock contention
@@ -1444,22 +1495,32 @@ async function checkSpreadCondition(manager, BitShares, updateOrdersOnChainBatch
             // Instead of silently aborting, re-plan with fresh funds so the
             // correction still applies on this cycle.  The pre-flight check
             // still guards against placing orders based on stale fund snapshots.
-            const decision = determineOrderSideByFunds(manager, lastPrice);
-            if (decision.side) {
-                correction = await prepareSpreadCorrectionOrders(manager, decision.side);
-                if (correction && ((correction.ordersToPlace?.length || 0) + (correction.ordersToUpdate?.length || 0) > 0)) {
-                    fundSnapshot = currentFunds;
-                    manager.logger?.log?.(`[SPREAD] Fund state changed between lock release and broadcast — ` +
-                        `re-planned with updated funds: ${correction.ordersToPlace?.length || 0} creates, ` +
-                        `${correction.ordersToUpdate?.length || 0} updates`, 'info');
-                }
-                else {
-                    manager.logger?.log?.(`[SPREAD] Fund state changed; re-plan produced no viable orders. Skipping cycle.`, 'warn');
-                    return { ordersPlaced: 0, partialsMoved: 0 };
-                }
+            // Re-acquire _gridLock for the re-plan to ensure consistent grid
+            // state (the lock is re-entrant for this call chain — the outer
+            // acquire's callback completed before we reach here, so there is
+            // no nested lock to recurse into).  If determineOrderSideByFunds
+            // or prepareSpreadCorrectionOrders grow to hold the lock for
+            // heavy work, hoist the result to avoid serial re-execution.
+            const rePlanResult = await manager._gridLock.acquire(async () => {
+                const decision = determineOrderSideByFunds(manager, lastPrice);
+                if (!decision.side)
+                    return { side: false };
+                const c = await prepareSpreadCorrectionOrders(manager, decision.side);
+                return { side: true, correction: c };
+            });
+            if (!rePlanResult.side) {
+                manager.logger?.log?.(`[SPREAD] Fund state changed; no side has sufficient funds for re-plan. Skipping cycle.`, 'warn');
+                return { ordersPlaced: 0, partialsMoved: 0 };
+            }
+            correction = rePlanResult.correction;
+            if (correction && ((correction.ordersToPlace?.length || 0) + (correction.ordersToUpdate?.length || 0) > 0)) {
+                fundSnapshot = currentFunds;
+                manager.logger?.log?.(`[SPREAD] Fund state changed between lock release and broadcast — ` +
+                    `re-planned with updated funds: ${correction.ordersToPlace?.length || 0} creates, ` +
+                    `${correction.ordersToUpdate?.length || 0} updates`, 'info');
             }
             else {
-                manager.logger?.log?.(`[SPREAD] Fund state changed; no side has sufficient funds for re-plan. Skipping cycle.`, 'warn');
+                manager.logger?.log?.(`[SPREAD] Fund state changed; re-plan produced no viable orders. Skipping cycle.`, 'warn');
                 return { ordersPlaced: 0, partialsMoved: 0 };
             }
         }
@@ -1475,7 +1536,7 @@ async function checkSpreadCondition(manager, BitShares, updateOrdersOnChainBatch
             return { ordersPlaced: placed + updated, partialsMoved: updated };
         }
         catch (err) {
-            manager.logger?.log?.(`Error applying spread correction on-chain: ${err.message}`, 'warn');
+            manager.logger?.log?.(`Error applying spread correction on-chain: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
             return { ordersPlaced: 0, partialsMoved: 0 };
         }
     }
@@ -1494,7 +1555,7 @@ async function checkSpreadCondition(manager, BitShares, updateOrdersOnChainBatch
  * @param {Function|null} [updateOrdersOnChainBatch=null] - Optional batch update function.
  * @returns {Promise<import('./types').DustCheckResult>}
  */
-async function checkGridHealth(manager, updateOrdersOnChainBatch = null) {
+async function checkGridHealth(manager, _updateOrdersOnChainBatch = null) {
     if (!manager)
         return { buyDust: false, sellDust: false, buyDustOrders: [], sellDustOrders: [] };
     // Skip health checks during bootstrap to prevent spamming warnings
@@ -1529,16 +1590,16 @@ async function checkWindowDust(manager) {
     if (!manager)
         return { buyDust: false, sellDust: false, buyDustOrders: [], sellDustOrders: [] };
     const allOrders = Array.from(manager.orders.values());
-    const isLiveOrder = order => order &&
+    const isLiveOrder = (order) => order &&
         order.orderId &&
         order.price != null &&
-        (order.state === ORDER_STATES.ACTIVE || order.state === ORDER_STATES.PARTIAL);
+        (order.state === constants_1.ORDER_STATES.ACTIVE || order.state === constants_1.ORDER_STATES.PARTIAL);
     // Identify top-of-window orders (closest to market per side).
     const topBuyOrder = allOrders
-        .filter(o => o.type === ORDER_TYPES.BUY && isLiveOrder(o))
+        .filter((o) => o.type === constants_1.ORDER_TYPES.BUY && isLiveOrder(o))
         .sort((a, b) => b.price - a.price)[0];
     const topSellOrder = allOrders
-        .filter(o => o.type === ORDER_TYPES.SELL && isLiveOrder(o))
+        .filter((o) => o.type === constants_1.ORDER_TYPES.SELL && isLiveOrder(o))
         .sort((a, b) => a.price - b.price)[0];
     // Check if an order has a duplicate price level — an active sibling at the
     // same price within tolerance. If so, cancelling won't create a grid gap.
@@ -1546,25 +1607,17 @@ async function checkWindowDust(manager) {
     // sibling, neither qualifies and the gap is left to the rebalancer.
     // Uses the LARGER size of the two orders for tolerance calculation to prevent
     // a tiny dust order from inflating the tolerance window.
-    const hasDuplicatePriceLevel = (order, assets) => allOrders.some(o => {
-        if (o.id === order.id || o.type !== order.type)
-            return false;
-        if (o.state !== ORDER_STATES.ACTIVE || !o.orderId || o.price == null)
-            return false;
-        const toleranceSize = Math.max(order.size, o.size);
-        const tolerance = calculatePriceTolerance(Math.min(order.price, o.price), toleranceSize, order.type, assets);
-        return tolerance != null && Math.abs(o.price - order.price) <= tolerance;
-    });
+    const hasDuplicatePriceLevel = (order, assets) => (0, math_1.findPriceCollision)(allOrders, order.id, order.price, order.size, order.type, assets, (o) => o.type === order.type && o.state === constants_1.ORDER_STATES.ACTIVE && !!o.orderId && o.price != null) != null;
     const assets = manager.assets;
-    const allPartials = allOrders.filter((o) => isLiveOrder(o) && o.state === ORDER_STATES.PARTIAL);
+    const allPartials = allOrders.filter((o) => isLiveOrder(o) && o.state === constants_1.ORDER_STATES.PARTIAL);
     const isTopBuy = (o) => topBuyOrder && o.id === topBuyOrder.id;
     const isTopSell = (o) => topSellOrder && o.id === topSellOrder.id;
     // Safety filter: top-of-window partials always qualify; interior partials
     // only qualify if they have a duplicate price level (no gap risk).
-    const eligibleBuyPartials = allPartials.filter((o) => o.type === ORDER_TYPES.BUY && (isTopBuy(o) || hasDuplicatePriceLevel(o, assets)));
-    const eligibleSellPartials = allPartials.filter((o) => o.type === ORDER_TYPES.SELL && (isTopSell(o) || hasDuplicatePriceLevel(o, assets)));
-    const buyDustOrders = await _getDustOrders(manager, eligibleBuyPartials, ORDER_TYPES.BUY);
-    const sellDustOrders = await _getDustOrders(manager, eligibleSellPartials, ORDER_TYPES.SELL);
+    const eligibleBuyPartials = allPartials.filter((o) => o.type === constants_1.ORDER_TYPES.BUY && (isTopBuy(o) || hasDuplicatePriceLevel(o, assets)));
+    const eligibleSellPartials = allPartials.filter((o) => o.type === constants_1.ORDER_TYPES.SELL && (isTopSell(o) || hasDuplicatePriceLevel(o, assets)));
+    const buyDustOrders = await _getDustOrders(manager, eligibleBuyPartials, constants_1.ORDER_TYPES.BUY);
+    const sellDustOrders = await _getDustOrders(manager, eligibleSellPartials, constants_1.ORDER_TYPES.SELL);
     return {
         buyDust: buyDustOrders.length > 0,
         sellDust: sellDustOrders.length > 0,
@@ -1585,27 +1638,27 @@ async function checkWindowDust(manager) {
 async function _getDustOrders(manager, partials, type) {
     if (!partials || partials.length === 0)
         return [];
-    const side = type === ORDER_TYPES.BUY ? 'buy' : 'sell';
+    const side = type === constants_1.ORDER_TYPES.BUY ? 'buy' : 'sell';
     const ctx = await _getSizingContext(manager, side);
     const dustThresholdPercent = manager.config?.gridLimits?.PARTIAL_DUST_THRESHOLD_PERCENTAGE;
     const sideSlots = Array.from(manager.orders.values())
-        .filter(o => o.type === type)
+        .filter((o) => o.type === type)
         .sort((a, b) => a.price - b.price);
     if (sideSlots.length === 0)
         return [];
     const idealSizes = ctx && ctx.budget > 0
-        ? allocateFundsByWeights(ctx.budget, sideSlots.length, manager.config.weightDistribution[side], manager.config.incrementPercent / 100, type === ORDER_TYPES.BUY, 0, ctx.precision)
+        ? (0, math_1.allocateFundsByWeights)(ctx.budget, sideSlots.length, manager.config.weightDistribution[side], manager.config.incrementPercent / 100, type === constants_1.ORDER_TYPES.BUY, 0, ctx.precision)
         : [];
     // When no budget is available, idealSizes becomes [] so every
     // partial's threshold collapses to 0 — no order qualifies as dust.
     // We still run the filter for uniformity so the threshold logic
     // stays consistent regardless of budget state.
-    return partials.filter(p => {
-        const idx = sideSlots.findIndex(s => s.id === p.id);
+    return partials.filter((p) => {
+        const idx = sideSlots.findIndex((s) => s.id === p.id);
         if (idx === -1)
             return false;
         const threshold = idealSizes.length > idx && idealSizes[idx] > 0
-            ? getSingleDustThreshold(idealSizes[idx], dustThresholdPercent)
+            ? (0, math_1.getSingleDustThreshold)(idealSizes[idx], dustThresholdPercent)
             : 0;
         return p.size < threshold;
     });
@@ -1629,7 +1682,7 @@ async function _hasAnyDust(manager, partials, type) {
  * @returns {Promise<boolean>}
  */
 async function hasAnyDust(manager, partials, side) {
-    const type = side === 'buy' ? ORDER_TYPES.BUY : side === 'sell' ? ORDER_TYPES.SELL : null;
+    const type = side === 'buy' ? constants_1.ORDER_TYPES.BUY : side === 'sell' ? constants_1.ORDER_TYPES.SELL : null;
     if (!type)
         return false;
     return await _hasAnyDust(manager, partials, type);
@@ -1643,7 +1696,7 @@ async function hasAnyDust(manager, partials, side) {
  * @returns {Promise<Array<import('./types').GridOrderSlot>>}
  */
 async function getDustOrders(manager, partials, side) {
-    const type = side === 'buy' ? ORDER_TYPES.BUY : side === 'sell' ? ORDER_TYPES.SELL : null;
+    const type = side === 'buy' ? constants_1.ORDER_TYPES.BUY : side === 'sell' ? constants_1.ORDER_TYPES.SELL : null;
     if (!type)
         return [];
     return await _getDustOrders(manager, partials, type);
@@ -1677,13 +1730,35 @@ function determineOrderSideByFunds(manager, currentMarketPrice) {
         const sellInBuyUnits = (Number.isFinite(marketPrice) && marketPrice > 0)
             ? sellAvailable * marketPrice
             : sellAvailable;
-        side = buyAvailable >= sellInBuyUnits ? ORDER_TYPES.BUY : ORDER_TYPES.SELL;
+        // Determine market direction from current price vs grid center price.
+        // When the market is below the grid center, the bot should prefer SELL
+        // (to narrow the spread from above — sells are too high). When the market
+        // is above the grid center, prefer BUY (buys are too low). This prevents
+        // spread correction from placing orders on the retreating side, which would
+        // compound inventory in the wrong direction after a batch of fill-induced
+        // boundary shifts.
+        const centerPrice = manager._lastGridPricingContext?.startPrice
+            ?? Number(manager.config.startPrice)
+            ?? null;
+        const hasDirection = Number.isFinite(marketPrice)
+            && marketPrice > 0
+            && Number.isFinite(centerPrice)
+            && centerPrice > 0;
+        if (hasDirection && marketPrice < centerPrice) {
+            side = constants_1.ORDER_TYPES.SELL;
+        }
+        else if (hasDirection && marketPrice > centerPrice) {
+            side = constants_1.ORDER_TYPES.BUY;
+        }
+        else {
+            side = buyAvailable >= sellInBuyUnits ? constants_1.ORDER_TYPES.BUY : constants_1.ORDER_TYPES.SELL;
+        }
     }
     else if (buyViable) {
-        side = ORDER_TYPES.BUY;
+        side = constants_1.ORDER_TYPES.BUY;
     }
     else if (sellViable) {
-        side = ORDER_TYPES.SELL;
+        side = constants_1.ORDER_TYPES.SELL;
     }
     if (!side) {
         const committedBuy = Math.max(0, Number(manager.funds?.committed?.chain?.buy || 0));
@@ -1694,17 +1769,17 @@ function determineOrderSideByFunds(manager, currentMarketPrice) {
             if (hasValidPrice) {
                 const buyComparable = committedBuy;
                 const sellComparable = committedSell * marketPrice;
-                side = buyComparable >= sellComparable ? ORDER_TYPES.BUY : ORDER_TYPES.SELL;
+                side = buyComparable >= sellComparable ? constants_1.ORDER_TYPES.BUY : constants_1.ORDER_TYPES.SELL;
             }
             else if (committedBuy > buyMinUnit && committedSell <= sellMinUnit) {
-                side = ORDER_TYPES.BUY;
+                side = constants_1.ORDER_TYPES.BUY;
             }
             else if (committedSell > sellMinUnit && committedBuy <= buyMinUnit) {
-                side = ORDER_TYPES.SELL;
+                side = constants_1.ORDER_TYPES.SELL;
             }
             else {
                 // Deterministic fallback when both sides hold inventory but market valuation is unavailable.
-                side = ORDER_TYPES.BUY;
+                side = constants_1.ORDER_TYPES.BUY;
             }
             manager.logger?.log?.(`Spread correction using redistribution fallback on ${side} ` +
                 `(free buy=${Format.formatAmount8(buyAvailable)}, free sell=${Format.formatAmount8(sellAvailable)}, ` +
@@ -1724,13 +1799,13 @@ function determineOrderSideByFunds(manager, currentMarketPrice) {
  * @returns {Promise<number|null>} The calculated geometric size.
  */
 async function calculateGeometricSizeForSpreadCorrection(manager, targetType) {
-    const side = targetType === ORDER_TYPES.BUY ? 'buy' : 'sell';
+    const side = targetType === constants_1.ORDER_TYPES.BUY ? 'buy' : 'sell';
     // Count only on-chain orders (ACTIVE+PARTIAL) to avoid diluting the
     // spread-correction order size across hundreds of virtual slots on a
     // full-rail grid.  Virtual slots have their capital tracked separately
     // in funds.virtual and should not compete for the free budget.
     const slotsCount = Array.from(manager.orders.values())
-        .filter(o => o.type === targetType && (o.state === ORDER_STATES.ACTIVE || o.state === ORDER_STATES.PARTIAL))
+        .filter((o) => o.type === targetType && (o.state === constants_1.ORDER_STATES.ACTIVE || o.state === constants_1.ORDER_STATES.PARTIAL))
         .length + 1;
     // Use centralized sizing context (respects botFunds % allocation)
     const ctx = await _getSizingContext(manager, side);
@@ -1739,7 +1814,7 @@ async function calculateGeometricSizeForSpreadCorrection(manager, targetType) {
     // ALLOW slotsCount === 1 to enable spread correction even if a side is completely missing
     const dummy = Array.from({ length: slotsCount }, () => ({ type: targetType }));
     try {
-        const sized = calculateOrderSizes(dummy, manager.config, side === 'sell' ? ctx.budget : 0, side === 'buy' ? ctx.budget : 0, 0, 0, ctx.precision, ctx.precision);
+        const sized = (0, math_1.calculateOrderSizes)(dummy, manager.config, side === 'sell' ? ctx.budget : 0, side === 'buy' ? ctx.budget : 0, 0, 0, ctx.precision, ctx.precision);
         if (!Array.isArray(sized) || sized.length === 0) {
             manager.logger?.log?.(`calculateOrderSizes returned invalid result for spread correction`, 'warn');
             return null;
@@ -1747,7 +1822,7 @@ async function calculateGeometricSizeForSpreadCorrection(manager, targetType) {
         return side === 'sell' ? sized[0].size : sized[sized.length - 1].size;
     }
     catch (e) {
-        manager.logger?.log?.(`Error calculating geometric size for spread correction: ${e.message}`, 'warn');
+        manager.logger?.log?.(`Error calculating geometric size for spread correction: ${(0, errors_1.getErrorMessage)(e)}`, 'warn');
         return null;
     }
 }
@@ -1760,13 +1835,13 @@ async function calculateGeometricSizeForSpreadCorrection(manager, targetType) {
  */
 async function prepareSpreadCorrectionOrders(manager, preferredSide) {
     // FIX: Validate preferredSide parameter to prevent silent logic errors
-    if (preferredSide !== ORDER_TYPES.BUY && preferredSide !== ORDER_TYPES.SELL) {
-        throw new Error(`Invalid preferredSide: ${preferredSide}. Must be '${ORDER_TYPES.BUY}' or '${ORDER_TYPES.SELL}'.`);
+    if (preferredSide !== constants_1.ORDER_TYPES.BUY && preferredSide !== constants_1.ORDER_TYPES.SELL) {
+        throw new Error(`Invalid preferredSide: ${preferredSide}. Must be '${constants_1.ORDER_TYPES.BUY}' or '${constants_1.ORDER_TYPES.SELL}'.`);
     }
     const ordersToPlace = [];
     const ordersToUpdate = [];
     const railType = preferredSide;
-    const sideName = railType === ORDER_TYPES.BUY ? 'buy' : 'sell';
+    const sideName = railType === constants_1.ORDER_TYPES.BUY ? 'buy' : 'sell';
     const configuredMissingSlots = Number(manager.outOfSpread || 0);
     const missingSlots = configuredMissingSlots > 0
         ? Math.floor(configuredMissingSlots)
@@ -1779,31 +1854,90 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide) {
     const allOrders = Array.from(manager.orders.values());
     let edgePartial = null;
     const partials = allOrders
-        .filter(o => o.type === railType && o.state === ORDER_STATES.PARTIAL)
-        .sort((a, b) => railType === ORDER_TYPES.BUY ? b.price - a.price : a.price - b.price);
+        .filter((o) => o.type === railType && o.state === constants_1.ORDER_STATES.PARTIAL)
+        .sort((a, b) => railType === constants_1.ORDER_TYPES.BUY ? b.price - a.price : a.price - b.price);
     if (partials.length > 0) {
         edgePartial = partials[0];
         manager.logger?.log?.(`[SPREAD-CORRECTION] Identified partial order at ${edgePartial.price} for update`, 'debug');
     }
-    // Primary candidates: SPREAD-type slots adjacent to the gap.
+    // Boundary-correct type computation.  Used by both candidate pools below to ensure
+    // spread correction does not re-activate slots whose current boundary position
+    // places them on the wrong side or in the spread zone — doing so would compound
+    // inventory at prices where the bot already traded.
+    //
+    // The natural type of a slot is derived from its position in the price-sorted rail
+    // relative to boundaryIdx + gapSlots: indices in [0, boundaryIdx] are BUY, indices
+    // in [boundaryIdx + gapSlots + 1, N-1] are SELL, the middle band is SPREAD.
+    const allSlotsByPrice = allOrders
+        .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 = calculateGapSlots(manager.config?.incrementPercent, manager.config?.targetSpreadPercent, manager.config?.gridLimits);
+    const bIdx = manager.boundaryIdx ?? 0;
+    const buyEndIdx = bIdx;
+    const sellStartIdx = bIdx + Number(gapSlots) + 1;
+    const getSlotCorrectType = (slot) => {
+        const idx = slotIndexMap.get(slot.id);
+        if (idx === undefined)
+            return slot.type;
+        if (idx <= buyEndIdx)
+            return constants_1.ORDER_TYPES.BUY;
+        if (idx >= sellStartIdx)
+            return constants_1.ORDER_TYPES.SELL;
+        return constants_1.ORDER_TYPES.SPREAD;
+    };
+    // Primary candidates: SPREAD-type slots adjacent to the gap.  Filter by
+    // 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.
     const typedSpreadCandidates = allOrders
-        .filter(o => o.type === ORDER_TYPES.SPREAD && isSlotAvailable(o))
-        .sort((a, b) => railType === ORDER_TYPES.BUY ? a.price - b.price : b.price - a.price)
+        .filter((o) => o.type === constants_1.ORDER_TYPES.SPREAD
+        && (0, order_1.isSlotAvailable)(o)
+        && 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.
+    //
+    // 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.
     const orphanedVirtualCandidates = allOrders
-        .filter(o => o.type === railType && o.state === ORDER_STATES.VIRTUAL && !o.orderId && Number(o.size || 0) === 0)
-        .sort((a, b) => railType === ORDER_TYPES.BUY ? b.price - a.price : a.price - b.price)
+        .filter((o) => o.type === railType
+        && 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);
     // 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);
-    const spreadCandidates = [
+    let spreadCandidates = [
         ...orphanedVirtualCandidates,
         ...typedSpreadCandidates.slice(0, remainingQuota)
     ];
+    // 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).
+    if (spreadCandidates.length > 0) {
+        const preFilter = spreadCandidates.length;
+        spreadCandidates = spreadCandidates.filter((c) => {
+            if (c.price == null)
+                return false;
+            // Resolve candidate size: if zero/missing, use minimum so tolerance
+            // doesn't collapse to zero (calculatePriceTolerance returns null for size <= 0).
+            const cs = (c.size && c.size > 0) ? c.size : (0, math_1.getMinAbsoluteOrderSize)(railType, manager.assets);
+            return !(0, math_1.findPriceCollision)(allOrders, c.id, c.price, cs, railType, manager.assets, (o) => (0, order_1.isOrderPlaced)(o) && o.price != null);
+        });
+        const filteredCount = preFilter - spreadCandidates.length;
+        if (filteredCount > 0) {
+            manager.logger?.log?.(`[SPREAD-CORRECTION] Filtered ${filteredCount}/${preFilter} candidate(s) with duplicate price levels`, 'warn');
+        }
+    }
     if (spreadCandidates.length > 0) {
         manager.logger?.log?.(`[SPREAD-CORRECTION] Identified ${spreadCandidates.length}/${missingSlots} slot(s) for activation on ${sideName} (orphaned=${orphanedVirtualCandidates.length}, spread=${spreadCandidates.length - orphanedVirtualCandidates.length})`, 'debug');
     }
@@ -1811,26 +1945,26 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide) {
         manager.logger?.log?.(`[SPREAD-CORRECTION] No suitable partials, orphaned virtual slots, or spread slots found. Skipping.`, 'warn');
         return { ordersToPlace: [], ordersToUpdate: [] };
     }
-    const orphanedIds = new Set(orphanedVirtualCandidates.map(o => o.id));
+    const orphanedIds = new Set(orphanedVirtualCandidates.map((o) => o.id));
     const sideSlots = allOrders
-        .filter(o => o.type === railType && !orphanedIds.has(o.id))
+        .filter((o) => o.type === railType && !orphanedIds.has(o.id))
         .sort((a, b) => a.price - b.price);
     const syntheticSideSlots = [
         ...sideSlots,
-        ...spreadCandidates.map(slot => ({ ...slot, type: railType }))
+        ...spreadCandidates.map((slot) => ({ ...slot, type: railType }))
     ].sort((a, b) => a.price - b.price);
     const ctx = await _getSizingContext(manager, sideName);
     if (!ctx || ctx.budget <= 0 || syntheticSideSlots.length === 0) {
         return { ordersToPlace: [], ordersToUpdate: [] };
     }
-    const precisionEpsilon = getPrecisionSlack(ctx.precision, 1);
-    const idealSizes = allocateFundsByWeights(ctx.budget, syntheticSideSlots.length, manager.config.weightDistribution[sideName], manager.config.incrementPercent / 100, railType === ORDER_TYPES.BUY, 0, ctx.precision);
+    const precisionEpsilon = (0, math_1.getPrecisionSlack)(ctx.precision, 1);
+    const idealSizes = (0, math_1.allocateFundsByWeights)(ctx.budget, syntheticSideSlots.length, manager.config.weightDistribution[sideName], manager.config.incrementPercent / 100, railType === constants_1.ORDER_TYPES.BUY, 0, ctx.precision);
     const idealById = new Map();
     syntheticSideSlots.forEach((slot, idx) => {
         idealById.set(slot.id, Number(idealSizes[idx] || 0));
     });
     const availableFund = Math.max(0, Math.min(Number(manager.funds?.available?.[sideName] || 0), Number(sideName === 'buy' ? manager.accountTotals?.buyFree : manager.accountTotals?.sellFree) || 0));
-    const minAbsoluteSize = getMinAbsoluteOrderSize(railType, manager.assets);
+    const minAbsoluteSize = (0, math_1.getMinAbsoluteOrderSize)(railType, manager.assets);
     const prioritizedTargets = [];
     if (edgePartial && edgePartial.id) {
         const ideal = Number(idealById.get(edgePartial.id) || 0);
@@ -1866,9 +2000,9 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide) {
     if (totalNeeded > availableFund + precisionEpsilon) {
         let shortfall = totalNeeded - availableFund;
         const donors = sideSlots
-            .filter(o => hasOnChainId(o) && (o.state === ORDER_STATES.ACTIVE || o.state === ORDER_STATES.PARTIAL))
-            .filter(o => !edgePartial || o.id !== edgePartial.id)
-            .sort((a, b) => railType === ORDER_TYPES.BUY ? a.price - b.price : b.price - a.price);
+            .filter((o) => (0, order_1.hasOnChainId)(o) && (o.state === constants_1.ORDER_STATES.ACTIVE || o.state === constants_1.ORDER_STATES.PARTIAL))
+            .filter((o) => !edgePartial || o.id !== edgePartial.id)
+            .sort((a, b) => railType === constants_1.ORDER_TYPES.BUY ? a.price - b.price : b.price - a.price);
         for (const donor of donors) {
             if (shortfall <= precisionEpsilon)
                 break;
@@ -1882,7 +2016,7 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide) {
             const donorNext = donorCurrent - reduction;
             if (donorNext <= precisionEpsilon)
                 continue;
-            if (!isOrderHealthy(donorNext, railType, manager.assets, donorIdeal || donorNext))
+            if (!(0, order_1.isOrderHealthy)(donorNext, railType, manager.assets, donorIdeal || donorNext))
                 continue;
             redistributionUpdates.push({ partialOrder: { ...donor }, newSize: donorNext });
             recoveredBudget += reduction;
@@ -1899,7 +2033,7 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide) {
         if (target.kind === 'partial-topup') {
             const topUp = Math.min(target.needed, remainingBudget);
             const newSize = target.current + topUp;
-            if (newSize > target.current + precisionEpsilon && isOrderHealthy(newSize, railType, manager.assets, target.ideal)) {
+            if (newSize > target.current + precisionEpsilon && (0, order_1.isOrderHealthy)(newSize, railType, manager.assets, target.ideal)) {
                 ordersToUpdate.push({ partialOrder: { ...target.order }, newSize });
                 remainingBudget -= topUp;
             }
@@ -1908,13 +2042,13 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide) {
         const createSize = Math.min(target.ideal, remainingBudget);
         if (createSize <= precisionEpsilon)
             continue;
-        if (!isOrderHealthy(createSize, railType, manager.assets, target.ideal))
+        if (!(0, order_1.isOrderHealthy)(createSize, railType, manager.assets, target.ideal))
             continue;
         ordersToPlace.push({
             ...target.order,
             type: railType,
             size: createSize,
-            state: ORDER_STATES.VIRTUAL
+            state: constants_1.ORDER_STATES.VIRTUAL
         });
         remainingBudget -= createSize;
     }
@@ -1923,7 +2057,7 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide) {
         const id = plannedUpdate?.partialOrder?.id || plannedUpdate?.id;
         if (!id)
             continue;
-        const existingIdx = combinedUpdates.findIndex(u => (u?.partialOrder?.id || u?.id) === id);
+        const existingIdx = combinedUpdates.findIndex((u) => (u?.partialOrder?.id || u?.id) === id);
         if (existingIdx >= 0) {
             combinedUpdates[existingIdx] = plannedUpdate;
         }