dexbot 1.3.2 → 1.4.0

package/dist/modules/order/manager.js

@@ -14,23 +14,61 @@
  * SECTION 3: ORDER MANAGER CLASS
  * ===============================================================================
  */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderManager = void 0;
 // ===============================================================================
 // SECTION 1: EXTERNAL DEPENDENCIES
 // ===============================================================================
-const { ORDER_TYPES, ORDER_STATES, REBALANCE_STATES, COW_ACTIONS, DEFAULT_CONFIG, TIMING, LOG_LEVEL, PIPELINE_TIMING, COW_PERFORMANCE } = require('../constants');
-const { getMinAbsoluteOrderSize, computeChainFundTotals, hasValidAccountTotals, resolveConfigValue, resolveConfigValueWithRegistry, isExplicitZeroAllocation, floatToBlockchainInt, getPrecisionSlack } = require('./utils/math');
-const { isOrderOnChain, isPhantomOrder, hasOnChainId, convertToSpreadPlaceholder } = require('./utils/order');
-const { persistGridSnapshot, deepFreeze, cloneMap } = require('./utils/system');
-const { validateOrder, validateGridForPersistence, calculateRequiredFunds, validateWorkingGridFunds, checkFundDrift, reconcileGrid, optimizeRebalanceActions, summarizeActions, projectTargetToWorkingGrid, buildStateUpdates, buildAbortedResult, buildSuccessResult, evaluateCommit } = require('./utils/validate');
-const { WorkingGrid } = require('./working_grid');
-const Logger = require('./logger');
-const AsyncLock = require('./async_lock');
-const Accountant = require('./accounting');
-const StrategyEngine = require('./strategy');
-const SyncEngine = require('./sync_engine');
-const { calculateCurrentSpread, checkSpreadCondition, checkGridHealth } = require('./grid');
-const Format = require('./format');
-const { toFiniteNumber, isValidNumber } = Format;
+const system_1 = require("./utils/system");
+const working_grid_1 = require("./working_grid");
+const logger_1 = __importDefault(require("./logger"));
+const async_lock_1 = __importDefault(require("./async_lock"));
+const accounting_1 = __importDefault(require("./accounting"));
+const strategy_1 = __importDefault(require("./strategy"));
+const sync_engine_1 = __importDefault(require("./sync_engine"));
+const grid_1 = require("./grid");
+const Format = __importStar(require("./format"));
+const constants_1 = require("../constants");
+const math_1 = require("./utils/math");
+const validate_1 = require("./utils/validate");
+const errors_1 = require("../utils/errors");
+const { toFiniteNumber } = Format;
 // ===============================================================================
 // SECTION 2: COW REBALANCE ENGINE
 // ===============================================================================
@@ -86,7 +124,7 @@ class COWRebalanceEngine {
     }
     async execute({ masterGrid, gridVersion, boundaryIdx, funds, fills = [], excludeIds = new Set() }) {
         const startTime = Date.now();
-        const workingGrid = new WorkingGrid(masterGrid, { baseVersion: gridVersion });
+        const workingGrid = new working_grid_1.WorkingGrid(masterGrid, { baseVersion: gridVersion });
         const strategyParams = {
             frozenMasterGrid: masterGrid,
             config: this.config,
@@ -98,36 +136,36 @@ class COWRebalanceEngine {
         };
         const { targetGrid, boundaryIdx: targetBoundary } = this.strategy.calculateTargetGrid(strategyParams);
         let dustThresholdPercent = this.config?.gridLimits?.PARTIAL_DUST_THRESHOLD_PERCENTAGE;
-        const reconcileResult = reconcileGrid(masterGrid, targetGrid, targetBoundary, {
+        const reconcileResult = (0, validate_1.reconcileGrid)(masterGrid, targetGrid, targetBoundary, {
             logger: (msg, level) => this.logger?.log(msg, level),
             dustThresholdPercent
         });
         if (reconcileResult.aborted) {
-            return buildAbortedResult(reconcileResult.reason);
+            return (0, validate_1.buildAbortedResult)(reconcileResult.reason);
         }
-        const optimizedActions = optimizeRebalanceActions(reconcileResult.actions, masterGrid);
-        projectTargetToWorkingGrid(workingGrid, targetGrid, { actions: optimizedActions });
+        const optimizedActions = (0, validate_1.optimizeRebalanceActions)(reconcileResult.actions, masterGrid);
+        (0, validate_1.projectTargetToWorkingGrid)(workingGrid, targetGrid, { actions: optimizedActions });
         const precisions = {
             buyPrecision: this.assets?.assetB?.precision,
             sellPrecision: this.assets?.assetA?.precision
         };
-        const fundCheck = validateWorkingGridFunds(workingGrid, funds, precisions, this.assets);
+        const fundCheck = (0, validate_1.validateWorkingGridFunds)(workingGrid, funds, precisions, this.assets);
         if (!fundCheck.isValid) {
             this.logger?.log(`[COW] Fund validation failed: ${fundCheck.reason}`, 'warn');
-            return buildAbortedResult(fundCheck.reason);
+            return (0, validate_1.buildAbortedResult)(fundCheck.reason);
         }
         if (workingGrid.isStale()) {
             const reason = workingGrid.getStaleReason() || 'Master grid changed during planning';
             this.logger?.log(`[COW] Rebalance plan invalidated: ${reason}`, 'warn');
-            return buildAbortedResult(reason);
+            return (0, validate_1.buildAbortedResult)(reason);
         }
-        const stateUpdates = buildStateUpdates(optimizedActions, masterGrid);
+        const stateUpdates = (0, validate_1.buildStateUpdates)(optimizedActions, masterGrid);
         const duration = Date.now() - startTime;
         if (duration > 100) {
             this.logger?.log(`[COW] Rebalance planning took ${duration}ms`, 'warn');
         }
         this.logger?.log(`[COW] Plan: Actions=${optimizedActions.length}, StateUpdates=${stateUpdates.length}`, 'info');
-        return buildSuccessResult({
+        return (0, validate_1.buildSuccessResult)({
             actions: optimizedActions,
             stateUpdates,
             workingGrid,
@@ -206,12 +244,12 @@ class OrderManager {
      * @param {Object} [config] - Configuration overrides
      */
     constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.config = { ...constants_1.DEFAULT_CONFIG, ...config };
         this.marketName = this.config.market || (this.config.assetA && this.config.assetB ? `${this.config.assetA}/${this.config.assetB}` : null);
         const logFile = config.logFile || undefined;
         const loggingConfig = this.config.logging;
-        this.logger = new Logger('DEXBot', {
-            level: loggingConfig?.level ?? LOG_LEVEL,
+        this.logger = new logger_1.default('DEXBot', {
+            level: loggingConfig?.level ?? constants_1.LOG_LEVEL,
             logFile,
             configOverride: loggingConfig?.config ?? undefined
         });
@@ -219,10 +257,10 @@ class OrderManager {
         this.orders = Object.freeze(new Map());
         this.boundaryIdx = null;
         this.targetGrid = null;
-        this.accountant = new Accountant(this);
-        this.strategy = new StrategyEngine(this);
-        this.sync = new SyncEngine(this);
-        this._rebalanceState = REBALANCE_STATES.NORMAL;
+        this.accountant = new accounting_1.default(this);
+        this.strategy = new strategy_1.default(this);
+        this.sync = new sync_engine_1.default(this);
+        this._rebalanceState = constants_1.REBALANCE_STATES.NORMAL;
         this._bootstrapping = false;
         this._broadcastingFlag = false;
         this._broadcastingStartedAt = 0;
@@ -243,14 +281,14 @@ class OrderManager {
         // These are private implementation details and must NOT be mutated directly
         // All external code must go through the COW pipeline
         this._ordersByState = {
-            [ORDER_STATES.VIRTUAL]: new Set(),
-            [ORDER_STATES.ACTIVE]: new Set(),
-            [ORDER_STATES.PARTIAL]: new Set()
+            [constants_1.ORDER_STATES.VIRTUAL]: new Set(),
+            [constants_1.ORDER_STATES.ACTIVE]: new Set(),
+            [constants_1.ORDER_STATES.PARTIAL]: new Set()
         };
         this._ordersByType = {
-            [ORDER_TYPES.BUY]: new Set(),
-            [ORDER_TYPES.SELL]: new Set(),
-            [ORDER_TYPES.SPREAD]: new Set()
+            [constants_1.ORDER_TYPES.BUY]: new Set(),
+            [constants_1.ORDER_TYPES.SELL]: new Set(),
+            [constants_1.ORDER_TYPES.SPREAD]: new Set()
         };
         this.resetFunds();
         this.btsBalance = { free: 0, total: 0, locked: 0 };
@@ -274,14 +312,14 @@ class OrderManager {
         //   Level 3: _syncLock         (sync operations)
         //   Level 4: _fundLock         (fund operations — innermost)
         // Note: AsyncLock IS re-entrant (acquire detects nested calls via _holding).
-        this._divergenceLock = new AsyncLock({ level: 0 });
-        this._fillProcessingLock = new AsyncLock({ level: 1 });
-        this._gridLock = new AsyncLock({
+        this._divergenceLock = new async_lock_1.default({ level: 0 });
+        this._fillProcessingLock = new async_lock_1.default({ level: 1 });
+        this._gridLock = new async_lock_1.default({
             level: 2,
             onContention: () => { this._metrics.gridLockContention++; }
         });
-        this._syncLock = new AsyncLock({ level: 3 });
-        this._fundLock = new AsyncLock({ level: 4, timeout: 30000 });
+        this._syncLock = new async_lock_1.default({ level: 3 });
+        this._fundLock = new async_lock_1.default({ level: 4, timeout: 30000 });
         this._recentlyRotatedOrderIds = new Set();
         this._gridSidesUpdated = new Set();
         this._pauseFundRecalc = 0;
@@ -329,7 +367,7 @@ class OrderManager {
     }
     _clearWorkingGridRef() {
         this._currentWorkingGrid = null;
-        this._rebalanceState = REBALANCE_STATES.NORMAL;
+        this._rebalanceState = constants_1.REBALANCE_STATES.NORMAL;
     }
     _setRebalanceState(state) {
         this._rebalanceState = state;
@@ -339,13 +377,13 @@ class OrderManager {
      * @returns {boolean}
      */
     isRebalancing() {
-        return this._rebalanceState === REBALANCE_STATES.REBALANCING;
+        return this._rebalanceState === constants_1.REBALANCE_STATES.REBALANCING;
     }
     /**
      * @returns {boolean}
      */
     isBroadcasting() {
-        return this._rebalanceState === REBALANCE_STATES.BROADCASTING;
+        return this._rebalanceState === constants_1.REBALANCE_STATES.BROADCASTING;
     }
     /**
      * @returns {boolean}
@@ -451,7 +489,7 @@ class OrderManager {
      * @returns {import('./types').ChainFundsSnapshot}
      */
     getChainFundsSnapshot() {
-        const totals = computeChainFundTotals(this.accountTotals, this.funds?.committed?.chain);
+        const totals = (0, math_1.computeChainFundTotals)(this.accountTotals, this.funds?.committed?.chain);
         const allocatedBuy = toFiniteNumber(this.funds?.allocated?.buy, totals.chainTotalBuy);
         const allocatedSell = toFiniteNumber(this.funds?.allocated?.sell, totals.chainTotalSell);
         const btsBalance = (this.config.assetA !== 'BTS' && this.config.assetB !== 'BTS')
@@ -463,12 +501,12 @@ class OrderManager {
      * @param {number} [timeoutMs]
      * @returns {Promise<void>}
      */
-    async waitForAccountTotals(timeoutMs = TIMING.ACCOUNT_TOTALS_TIMEOUT_MS) {
-        if (hasValidAccountTotals(this.accountTotals, true))
+    async waitForAccountTotals(timeoutMs = constants_1.TIMING.ACCOUNT_TOTALS_TIMEOUT_MS) {
+        if ((0, math_1.hasValidAccountTotals)(this.accountTotals, true))
             return;
         let waitPromise = null;
         await this._fundLock.acquire(async () => {
-            if (hasValidAccountTotals(this.accountTotals, true))
+            if ((0, math_1.hasValidAccountTotals)(this.accountTotals, true))
                 return;
             if (!this._accountTotalsPromise) {
                 this._accountTotalsPromise = new Promise((resolve) => {
@@ -515,12 +553,12 @@ class OrderManager {
         if (!this.funds)
             this.resetFunds();
         await this._recalculateFunds();
-        if (hasValidAccountTotals(this.accountTotals, true) && typeof this._accountTotalsResolve === 'function') {
+        if ((0, math_1.hasValidAccountTotals)(this.accountTotals, true) && typeof this._accountTotalsResolve === 'function') {
             try {
                 this._accountTotalsResolve();
             }
             catch (e) {
-                this.logger?.log?.(`Error resolving account totals promise: ${e.message}`, 'warn');
+                this.logger?.log?.(`Error resolving account totals promise: ${(0, errors_1.getErrorMessage)(e)}`, 'warn');
             }
             this._accountTotalsPromise = null;
             this._accountTotalsResolve = null;
@@ -540,11 +578,11 @@ class OrderManager {
     applyBotFundsAllocation() {
         if (!this.config.botFunds || !this.accountTotals)
             return;
-        const { chainTotalBuy, chainTotalSell } = computeChainFundTotals(this.accountTotals, this.funds?.committed?.chain);
+        const { chainTotalBuy, chainTotalSell } = (0, math_1.computeChainFundTotals)(this.accountTotals, this.funds?.committed?.chain);
         const account = this.config.preferredAccount;
         const botName = this.config.botKey;
-        const allocatedBuy = resolveConfigValueWithRegistry(this.config.botFunds.buy, chainTotalBuy, account, botName, 'buy');
-        const allocatedSell = resolveConfigValueWithRegistry(this.config.botFunds.sell, chainTotalSell, account, botName, 'sell');
+        const allocatedBuy = (0, math_1.resolveConfigValueWithRegistry)(this.config.botFunds.buy, chainTotalBuy, account, botName, 'buy');
+        const allocatedSell = (0, math_1.resolveConfigValueWithRegistry)(this.config.botFunds.sell, chainTotalSell, account, botName, 'sell');
         if (allocatedBuy === 0 && typeof this.config.botFunds.buy === 'string' && this.config.botFunds.buy.trim().endsWith('%')) {
             if (chainTotalBuy === 0)
                 this._triggerAccountTotalsFetchIfNeeded();
@@ -554,8 +592,8 @@ class OrderManager {
                 this._triggerAccountTotalsFetchIfNeeded();
         }
         this.funds.allocated = { buy: allocatedBuy, sell: allocatedSell };
-        const shouldCapBuy = allocatedBuy > 0 || isExplicitZeroAllocation(this.config.botFunds.buy);
-        const shouldCapSell = allocatedSell > 0 || isExplicitZeroAllocation(this.config.botFunds.sell);
+        const shouldCapBuy = allocatedBuy > 0 || (0, math_1.isExplicitZeroAllocation)(this.config.botFunds.buy);
+        const shouldCapSell = allocatedSell > 0 || (0, math_1.isExplicitZeroAllocation)(this.config.botFunds.sell);
         if (shouldCapBuy)
             this.funds.available.buy = Math.min(this.funds.available.buy, Math.max(0, allocatedBuy));
         if (shouldCapSell)
@@ -610,10 +648,10 @@ class OrderManager {
                     this._pauseFundRecalc = 0;
                     this._pauseFundRecalcWatchdog = null;
                     this._recalculateFunds().catch((err) => {
-                        this.logger?.log?.(`[MANAGER] Watchdog recalc failed: ${err.message}`, 'error');
+                        this.logger?.log?.(`[MANAGER] Watchdog recalc failed: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
                     });
                 }
-            }, TIMING.SAFETY_PAUSE_TIMEOUT_MS);
+            }, constants_1.TIMING.SAFETY_PAUSE_TIMEOUT_MS);
         }
     }
     /**
@@ -651,10 +689,10 @@ class OrderManager {
             clearTimeout(this._pauseRecalcLoggingWatchdog);
         }
         this._pauseRecalcLoggingWatchdog = setTimeout(() => {
-            this.logger?.log?.(`[MANAGER] pauseRecalcLogging safety watchdog: forcing resume after ${TIMING.SAFETY_PAUSE_TIMEOUT_MS}ms`, 'warn');
+            this.logger?.log?.(`[MANAGER] pauseRecalcLogging safety watchdog: forcing resume after ${constants_1.TIMING.SAFETY_PAUSE_TIMEOUT_MS}ms`, 'warn');
             this._pauseRecalcLogging = false;
             this._pauseRecalcLoggingWatchdog = null;
-        }, TIMING.SAFETY_PAUSE_TIMEOUT_MS);
+        }, constants_1.TIMING.SAFETY_PAUSE_TIMEOUT_MS);
     }
     /**
      * Resume recalc debug logging.
@@ -715,7 +753,7 @@ class OrderManager {
     lockOrders(orderIds) {
         if (!orderIds)
             return;
-        const expiration = Date.now() + TIMING.LOCK_TIMEOUT_MS;
+        const expiration = Date.now() + constants_1.TIMING.LOCK_TIMEOUT_MS;
         for (const id of orderIds)
             if (id)
                 this.shadowOrderIds.set(id, expiration);
@@ -780,12 +818,12 @@ class OrderManager {
         const updateOptions = this._normalizeOrderUpdateOptions(options);
         const { skipAccounting, fee: normalizedFee } = updateOptions;
         const oldOrder = this.orders.get(order.id);
-        const validation = validateOrder(order, oldOrder, context);
+        const validation = (0, validate_1.validateOrder)(order, oldOrder, context);
         for (const warning of validation.warnings) {
             this.logger.log(warning.message, 'warn');
         }
         if (!validation.isValid && validation.errors.length > 0) {
-            const fatalError = validation.errors.find(e => e.isFatal || e.code === 'ILLEGAL_SPREAD_STATE');
+            const fatalError = validation.errors.find((e) => e.isFatal || e.code === 'ILLEGAL_SPREAD_STATE');
             if (fatalError) {
                 this.logger.log(fatalError.message, 'error');
                 this._lastIllegalState = {
@@ -806,24 +844,24 @@ class OrderManager {
         // and _resolveBtsFeeLifecycle mutates btsFeeState on the order object.
         let nextOrder = { ...validation.normalizedOrder };
         // Apply phantom order auto-correction to the normalized order
-        const phantomError = validation.errors.find(e => e.code === 'PHANTOM_ORDER');
+        const phantomError = validation.errors.find((e) => e.code === 'PHANTOM_ORDER');
         if (phantomError && phantomError.autoCorrect) {
             nextOrder = { ...nextOrder, ...phantomError.autoCorrect };
         }
         if (this.accountant) {
             await this.accountant.updateOptimisticFreeBalance(oldOrder, nextOrder, context, normalizedFee, skipAccounting);
         }
-        const updatedOrder = deepFreeze({ ...nextOrder });
+        const updatedOrder = (0, system_1.deepFreeze)({ ...nextOrder });
         const id = order.id;
-        Object.values(this._ordersByState).forEach(set => set.delete(id));
-        Object.values(this._ordersByType).forEach(set => set.delete(id));
+        Object.values(this._ordersByState).forEach((set) => set.delete(id));
+        Object.values(this._ordersByType).forEach((set) => set.delete(id));
         if (this._ordersByState[updatedOrder.state]) {
             this._ordersByState[updatedOrder.state].add(id);
         }
         if (this._ordersByType[updatedOrder.type]) {
             this._ordersByType[updatedOrder.type].add(id);
         }
-        const newMap = cloneMap(this.orders);
+        const newMap = (0, system_1.cloneMap)(this.orders);
         newMap.set(id, updatedOrder);
         this.orders = Object.freeze(newMap);
         this._gridVersion++;
@@ -843,8 +881,8 @@ class OrderManager {
             this._currentWorkingGrid.syncFromMaster(this.orders, orderId, this._gridVersion);
         }
         catch (syncErr) {
-            this._currentWorkingGrid.markStale(`working-grid sync failure: ${syncErr.message}`);
-            this.logger.log(`[COW] Failed to sync working grid for order ${orderId}: ${syncErr.message}`, 'warn');
+            this._currentWorkingGrid.markStale(`working-grid sync failure: ${(0, errors_1.getErrorMessage)(syncErr)}`);
+            this.logger.log(`[COW] Failed to sync working grid for order ${orderId}: ${(0, errors_1.getErrorMessage)(syncErr)}`, 'warn');
         }
     }
     /**
@@ -936,17 +974,17 @@ class OrderManager {
      * @param {Object} [options]
      * @returns {Promise<import('./types').CowRebalanceResult>}
      */
-    async processFilledOrders(orders, excl, options) {
+    async processFilledOrders(orders, excl, _options) {
         // Step 1: Handle Fills (Accounting & State Updates)
         await this.strategy.processFillsOnly(orders, excl);
         // Step 2: Trigger Safe Rebalance only for actual fills.
-        const triggerFills = orders.filter(f => !f.isPartial || f.isDelayedRotationTrigger);
+        const triggerFills = orders.filter((f) => !f.isPartial || f.isDelayedRotationTrigger);
         const shouldRebalance = triggerFills.length > 0;
         if (shouldRebalance) {
             const rebalanceResult = await this.performSafeRebalance(orders, excl);
             return rebalanceResult;
         }
-        const workingGrid = new WorkingGrid(this.orders, { baseVersion: this._gridVersion });
+        const workingGrid = new working_grid_1.WorkingGrid(this.orders, { baseVersion: this._gridVersion });
         return {
             actions: [],
             stateUpdates: [],
@@ -966,28 +1004,28 @@ class OrderManager {
         const buyCount = Math.max(0, toFiniteNumber(this.config.activeOrders?.buy, 1));
         // Get minimum sizes for validation
         const minOrderSizeFactor = this.config?.gridLimits?.MIN_ORDER_SIZE_FACTOR;
-        const minSellSize = getMinAbsoluteOrderSize(ORDER_TYPES.SELL, this.assets, minOrderSizeFactor);
-        const minBuySize = getMinAbsoluteOrderSize(ORDER_TYPES.BUY, this.assets, minOrderSizeFactor);
+        const minSellSize = (0, math_1.getMinAbsoluteOrderSize)(constants_1.ORDER_TYPES.SELL, this.assets, minOrderSizeFactor);
+        const minBuySize = (0, math_1.getMinAbsoluteOrderSize)(constants_1.ORDER_TYPES.BUY, this.assets, minOrderSizeFactor);
         // Use integer arithmetic for size comparisons to match blockchain behavior
         const sellPrecision = this.assets?.assetA?.precision;
         const buyPrecision = this.assets?.assetB?.precision;
-        const minSellSizeInt = floatToBlockchainInt(minSellSize, sellPrecision);
-        const minBuySizeInt = floatToBlockchainInt(minBuySize, buyPrecision);
+        const minSellSizeInt = (0, math_1.floatToBlockchainInt)(minSellSize, sellPrecision);
+        const minBuySizeInt = (0, math_1.floatToBlockchainInt)(minBuySize, buyPrecision);
         // Get closest virtual sells (lowest prices first = closest to market), limit to sellCount
-        const vSells = this.getOrdersByTypeAndState(ORDER_TYPES.SELL, ORDER_STATES.VIRTUAL)
+        const vSells = this.getOrdersByTypeAndState(constants_1.ORDER_TYPES.SELL, constants_1.ORDER_STATES.VIRTUAL)
             .sort((a, b) => a.price - b.price)
             .slice(0, sellCount);
         // Filter by minimum size, then reverse for placement order (highest first)
         const validSells = vSells
-            .filter(o => floatToBlockchainInt(o.size, sellPrecision) >= minSellSizeInt)
+            .filter((o) => (0, math_1.floatToBlockchainInt)(o.size, sellPrecision) >= minSellSizeInt)
             .sort((a, b) => b.price - a.price);
         // Get closest virtual buys (highest prices first = closest to market), limit to buyCount
-        const vBuys = this.getOrdersByTypeAndState(ORDER_TYPES.BUY, ORDER_STATES.VIRTUAL)
+        const vBuys = this.getOrdersByTypeAndState(constants_1.ORDER_TYPES.BUY, constants_1.ORDER_STATES.VIRTUAL)
             .sort((a, b) => b.price - a.price)
             .slice(0, buyCount);
         // Filter by minimum size, then reverse for placement order (lowest first)
         const validBuys = vBuys
-            .filter(o => floatToBlockchainInt(o.size, buyPrecision) >= minBuySizeInt)
+            .filter((o) => (0, math_1.floatToBlockchainInt)(o.size, buyPrecision) >= minBuySizeInt)
             .sort((a, b) => a.price - b.price);
         return [...validSells, ...validBuys];
     }
@@ -1018,7 +1056,7 @@ class OrderManager {
      * @returns {Array<import('./types').Order>}
      */
     getPartialOrdersOnSide(type) {
-        return this.getOrdersByTypeAndState(type, ORDER_STATES.PARTIAL);
+        return this.getOrdersByTypeAndState(type, constants_1.ORDER_STATES.PARTIAL);
     }
     /**
      * @returns {boolean}
@@ -1077,14 +1115,14 @@ class OrderManager {
     _repairIndices() {
         try {
             const rebuiltByState = {
-                [ORDER_STATES.VIRTUAL]: new Set(),
-                [ORDER_STATES.ACTIVE]: new Set(),
-                [ORDER_STATES.PARTIAL]: new Set()
+                [constants_1.ORDER_STATES.VIRTUAL]: new Set(),
+                [constants_1.ORDER_STATES.ACTIVE]: new Set(),
+                [constants_1.ORDER_STATES.PARTIAL]: new Set()
             };
             const rebuiltByType = {
-                [ORDER_TYPES.BUY]: new Set(),
-                [ORDER_TYPES.SELL]: new Set(),
-                [ORDER_TYPES.SPREAD]: new Set()
+                [constants_1.ORDER_TYPES.BUY]: new Set(),
+                [constants_1.ORDER_TYPES.SELL]: new Set(),
+                [constants_1.ORDER_TYPES.SPREAD]: new Set()
             };
             for (const [id, order] of this.orders) {
                 if (order && order.state && order.type) {
@@ -1105,7 +1143,7 @@ class OrderManager {
             return false;
         }
         catch (e) {
-            this.logger.log(`Index repair failed with exception: ${e.message}`, 'error');
+            this.logger.log(`Index repair failed with exception: ${(0, errors_1.getErrorMessage)(e)}`, 'error');
             return false;
         }
     }
@@ -1131,29 +1169,29 @@ class OrderManager {
      * @returns {Promise<Object>}
      */
     async checkSpreadCondition(BitShares, batchCb) {
-        return await checkSpreadCondition(this, BitShares, batchCb);
+        return await (0, grid_1.checkSpreadCondition)(this, BitShares, batchCb);
     }
     /**
      * @param {Function} batchCb - Batch callback
      * @returns {Promise<Object>}
      */
     async checkGridHealth(batchCb) {
-        return await checkGridHealth(this, batchCb);
+        return await (0, grid_1.checkGridHealth)(this, batchCb);
     }
     /**
      * @returns {Object} Current spread calculation
      */
     calculateCurrentSpread() {
-        return calculateCurrentSpread(this);
+        return (0, grid_1.calculateCurrentSpread)(this);
     }
     /**
      * @returns {import('./types').DriftCheckResult}
      */
     checkFundDriftAfterFills() {
-        if (!this.assets || !hasValidAccountTotals(this.accountTotals)) {
+        if (!this.assets || !(0, math_1.hasValidAccountTotals)(this.accountTotals)) {
             return { isValid: true, reason: 'Skipped: missing assets or totals' };
         }
-        return checkFundDrift(this.orders, this.accountTotals, this.assets, this.config?.gridLimits ?? null);
+        return (0, validate_1.checkFundDrift)(this.orders, this.accountTotals, this.assets, this.config?.gridLimits ?? null);
     }
     /**
      * @param {Object|number} [pipelineSignals] - Pipeline state signals or queue length
@@ -1210,7 +1248,7 @@ class OrderManager {
         if (!this._pipelineBlockedSince)
             return false;
         const age = Date.now() - this._pipelineBlockedSince;
-        const timeoutMs = this.config?.pipelineTiming?.TIMEOUT_MS ?? PIPELINE_TIMING.TIMEOUT_MS;
+        const timeoutMs = this.config?.pipelineTiming?.TIMEOUT_MS ?? constants_1.PIPELINE_TIMING.TIMEOUT_MS;
         if (age < timeoutMs)
             return false;
         this.ordersNeedingPriceCorrection = [];
@@ -1224,7 +1262,7 @@ class OrderManager {
         const blockedDuration = this._pipelineBlockedSince
             ? Date.now() - this._pipelineBlockedSince
             : 0;
-        const timeoutMs = this.config?.pipelineTiming?.TIMEOUT_MS ?? PIPELINE_TIMING.TIMEOUT_MS;
+        const timeoutMs = this.config?.pipelineTiming?.TIMEOUT_MS ?? constants_1.PIPELINE_TIMING.TIMEOUT_MS;
         return {
             isBlocked: this._pipelineBlockedSince !== null,
             blockedDurationMs: blockedDuration,
@@ -1240,7 +1278,7 @@ class OrderManager {
      * @returns {Object}
      */
     reconcileGrid(targetGrid, targetBoundary) {
-        return reconcileGrid(this.orders, targetGrid, targetBoundary, {
+        return (0, validate_1.reconcileGrid)(this.orders, targetGrid, targetBoundary, {
             logger: (msg, level) => this.logger.log(msg, level),
             dustThresholdPercent: this.config?.gridLimits?.PARTIAL_DUST_THRESHOLD_PERCENTAGE
         });
@@ -1259,9 +1297,9 @@ class OrderManager {
     async _applySafeRebalanceCOW(fills = [], excludeIds = new Set()) {
         const cowEngine = this._getCOWEngine();
         if (!cowEngine) {
-            return buildAbortedResult('COW Engine not initialized (assets not available)');
+            return (0, validate_1.buildAbortedResult)('COW Engine not initialized (assets not available)');
         }
-        this._setRebalanceState(REBALANCE_STATES.REBALANCING);
+        this._setRebalanceState(constants_1.REBALANCE_STATES.REBALANCING);
         const result = await cowEngine.execute({
             masterGrid: this.orders,
             gridVersion: this._gridVersion,
@@ -1281,22 +1319,22 @@ class OrderManager {
         const result = this.reconcileGrid(targetGrid, targetBoundary);
         if (result.aborted)
             return result;
-        const actions = optimizeRebalanceActions(result.actions || [], this.orders);
-        projectTargetToWorkingGrid(workingGrid, targetGrid, { actions });
+        const actions = (0, validate_1.optimizeRebalanceActions)(result.actions || [], this.orders);
+        (0, validate_1.projectTargetToWorkingGrid)(workingGrid, targetGrid, { actions });
         return {
             ...result,
             actions,
-            ...summarizeActions(actions)
+            ...(0, validate_1.summarizeActions)(actions)
         };
     }
     _validateWorkingGridFunds(workingGrid, projectedFunds) {
-        return validateWorkingGridFunds(workingGrid, projectedFunds, {
+        return (0, validate_1.validateWorkingGridFunds)(workingGrid, projectedFunds, {
             buyPrecision: this.assets?.assetB?.precision,
             sellPrecision: this.assets?.assetA?.precision
         }, this.assets);
     }
     _calculateRequiredFundsFromGrid(workingGrid, precisions = {}) {
-        return calculateRequiredFunds(workingGrid, {
+        return (0, validate_1.calculateRequiredFunds)(workingGrid, {
             buyPrecision: precisions.buyPrecision || this.assets?.assetB?.precision,
             sellPrecision: precisions.sellPrecision || this.assets?.assetA?.precision
         });
@@ -1326,12 +1364,12 @@ class OrderManager {
         };
     }
     _buildStateUpdates(actions, masterGrid) {
-        return buildStateUpdates(actions, masterGrid);
+        return (0, validate_1.buildStateUpdates)(actions, masterGrid);
     }
     _buildAbortedCOWResult(reason) {
-        return buildAbortedResult(reason);
+        return (0, validate_1.buildAbortedResult)(reason);
     }
-    async _commitWorkingGrid(workingGrid, workingIndexes, workingBoundary, options = {}) {
+    async _commitWorkingGrid(workingGrid, _workingIndexes, workingBoundary, options = {}) {
         const { skipRecalc } = this._normalizeCommitOptions(options);
         const startTime = Date.now();
         const stats = workingGrid.getMemoryStats();
@@ -1341,11 +1379,11 @@ class OrderManager {
             comparePrecisions = this._getCowComparePrecisions();
         }
         catch (precisionErr) {
-            this.logger.log(`[COW] ${precisionErr.message}`, 'error');
+            this.logger.log(`[COW] ${(0, errors_1.getErrorMessage)(precisionErr)}`, 'error');
             this._clearWorkingGridRef();
             return false;
         }
-        const preCommitGuard = evaluateCommit(workingGrid, {
+        const preCommitGuard = (0, validate_1.evaluateCommit)(workingGrid, {
             hasLock: false,
             currentVersion: this._gridVersion,
             masterGrid: this.orders,
@@ -1357,7 +1395,7 @@ class OrderManager {
             return false;
         }
         await this._gridLock.acquire(async () => {
-            const lockCommitGuard = evaluateCommit(workingGrid, {
+            const lockCommitGuard = (0, validate_1.evaluateCommit)(workingGrid, {
                 hasLock: true,
                 currentVersion: this._gridVersion,
                 masterGrid: this.orders,
@@ -1372,9 +1410,9 @@ class OrderManager {
             const finalMap = workingGrid.toMap();
             // RC-4: Deep-freeze all modified orders before committing to master state
             // Ensures COW immutability invariants are maintained for all grid entries.
-            for (const [id, order] of finalMap.entries()) {
+            for (const [, order] of finalMap.entries()) {
                 if (order && !Object.isFrozen(order)) {
-                    deepFreeze(order);
+                    (0, system_1.deepFreeze)(order);
                 }
             }
             this.orders = Object.freeze(finalMap);
@@ -1386,7 +1424,7 @@ class OrderManager {
             // avoid the intermediate empty state that clear() creates — a crash
             // during clear()+repopulate would lose all committed IDs.
             const newCommittedIds = new Set();
-            for (const [id, order] of finalMap.entries()) {
+            for (const [, order] of finalMap.entries()) {
                 if (order.orderId)
                     newCommittedIds.add(order.orderId);
             }
@@ -1394,14 +1432,14 @@ class OrderManager {
             this._committedOrderIdsBuiltAt = Date.now();
             const freshIndexes = workingGrid.getIndexes();
             this._ordersByState = {
-                [ORDER_STATES.VIRTUAL]: freshIndexes[ORDER_STATES.VIRTUAL] || new Set(),
-                [ORDER_STATES.ACTIVE]: freshIndexes[ORDER_STATES.ACTIVE] || new Set(),
-                [ORDER_STATES.PARTIAL]: freshIndexes[ORDER_STATES.PARTIAL] || new Set()
+                [constants_1.ORDER_STATES.VIRTUAL]: freshIndexes[constants_1.ORDER_STATES.VIRTUAL] || new Set(),
+                [constants_1.ORDER_STATES.ACTIVE]: freshIndexes[constants_1.ORDER_STATES.ACTIVE] || new Set(),
+                [constants_1.ORDER_STATES.PARTIAL]: freshIndexes[constants_1.ORDER_STATES.PARTIAL] || new Set()
             };
             this._ordersByType = {
-                [ORDER_TYPES.BUY]: freshIndexes[ORDER_TYPES.BUY] || new Set(),
-                [ORDER_TYPES.SELL]: freshIndexes[ORDER_TYPES.SELL] || new Set(),
-                [ORDER_TYPES.SPREAD]: freshIndexes[ORDER_TYPES.SPREAD] || new Set()
+                [constants_1.ORDER_TYPES.BUY]: freshIndexes[constants_1.ORDER_TYPES.BUY] || new Set(),
+                [constants_1.ORDER_TYPES.SELL]: freshIndexes[constants_1.ORDER_TYPES.SELL] || new Set(),
+                [constants_1.ORDER_TYPES.SPREAD]: freshIndexes[constants_1.ORDER_TYPES.SPREAD] || new Set()
             };
         });
         if (!committed) {
@@ -1421,12 +1459,12 @@ class OrderManager {
             }
             const duration = Date.now() - startTime;
             this.logger.log(`[COW] Grid committed in ${duration}ms`, 'debug');
-            if (stats.size > COW_PERFORMANCE.GRID_MEMORY_WARNING) {
+            if (stats.size > constants_1.COW_PERFORMANCE.GRID_MEMORY_WARNING) {
                 this.logger.log(`[COW] Warning: Large grid size (${stats.size} orders). Peak memory: ~${Math.round(stats.estimatedBytes / 1024)}KB`, 'warn');
             }
         }
         catch (recalcErr) {
-            this.logger.log(`[COW] Fund recalculation failed post-commit: ${recalcErr.message}`, 'error');
+            this.logger.log(`[COW] Fund recalculation failed post-commit: ${(0, errors_1.getErrorMessage)(recalcErr)}`, 'error');
             this._recoveryState = { ...this._recoveryState, lastFailureAt: Date.now() };
         }
         finally {
@@ -1440,7 +1478,7 @@ class OrderManager {
      * @returns {import('./types').PersistenceValidationResult}
      */
     validateGridStateForPersistence(options = {}) {
-        const result = validateGridForPersistence(this.orders, this.accountTotals);
+        const result = (0, validate_1.validateGridForPersistence)(this.orders, this.accountTotals);
         const allowBootstrapTransient = options.allowBootstrapTransient !== false;
         if (!result.isValid && allowBootstrapTransient && this._bootstrapping) {
             this.logger.log(`[BOOTSTRAP] Transient state (expected): ${result.reason}`, 'debug');
@@ -1483,7 +1521,7 @@ class OrderManager {
             this.logger.log(`[PERSISTENCE-GATE] Skipping persistence of corrupted state: ${validation.reason}`, 'warn');
             return validation;
         }
-        await persistGridSnapshot(this, this.accountOrders, snapshotOrders, recentFillKeys);
+        await (0, system_1.persistGridSnapshot)(this, this.accountOrders, snapshotOrders, recentFillKeys);
         // On a successful live-grid persist (the default — no explicit
         // snapshotOrders was passed in), clear the dirty flag so that
         // a subsequent end-of-tick flushGridDirty() call sees the grid
@@ -1514,10 +1552,10 @@ class OrderManager {
         };
     }
     _projectTargetToWorkingGrid(workingGrid, targetGrid) {
-        return projectTargetToWorkingGrid(workingGrid, targetGrid);
+        return (0, validate_1.projectTargetToWorkingGrid)(workingGrid, targetGrid);
     }
     _summarizeCowActions(actions) {
-        return summarizeActions(actions);
+        return (0, validate_1.summarizeActions)(actions);
     }
     _evaluateWorkingGridCommit(workingGrid, hasLock = false) {
         let comparePrecisions;
@@ -1527,11 +1565,11 @@ class OrderManager {
         catch (precisionErr) {
             return {
                 canCommit: false,
-                reason: precisionErr.message,
+                reason: (0, errors_1.getErrorMessage)(precisionErr),
                 level: 'error'
             };
         }
-        return evaluateCommit(workingGrid, {
+        return (0, validate_1.evaluateCommit)(workingGrid, {
             hasLock,
             currentVersion: this._gridVersion,
             masterGrid: this.orders,
@@ -1590,5 +1628,5 @@ class OrderManager {
         };
     }
 }
-module.exports = { OrderManager };
+exports.OrderManager = OrderManager;
 //# sourceMappingURL=manager.js.map