dexbot 1.4.11 → 1.4.12

package/dist/modules/order/manager.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * modules/order/manager.ts - OrderManager Engine
  *
@@ -14,62 +13,24 @@
  * 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.COWRebalanceEngine = exports.OrderManager = void 0;
 // ===============================================================================
 // SECTION 1: EXTERNAL DEPENDENCIES
 // ===============================================================================
-const system_1 = require("./utils/system");
-const timeout_1 = require("./utils/timeout");
-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 order_1 = require("./utils/order");
-const errors_1 = require("../utils/errors");
+import { persistGridSnapshot, deepFreeze, cloneMap, withBlockchainRetry } from './utils/system.js';
+import { withTimeout } from './utils/timeout.js';
+import { WorkingGrid } from './working_grid.js';
+import Logger from './logger.js';
+import AsyncLock from './async_lock.js';
+import Accountant from './accounting.js';
+import StrategyEngine from './strategy.js';
+import SyncEngine from './sync_engine.js';
+import { calculateCurrentSpread, checkSpreadCondition, checkGridHealth } from './grid.js';
+import * as Format from './format.js';
+import { ORDER_TYPES, ORDER_STATES, REBALANCE_STATES, DEFAULT_CONFIG, TIMING, LOG_LEVEL, PIPELINE_TIMING, COW_PERFORMANCE, COW_ACTIONS } from '../constants.js';
+import { getMinAbsoluteOrderSize, computeChainFundTotals, hasValidAccountTotals, resolveConfigValueWithRegistry, isExplicitZeroAllocation, floatToBlockchainInt } from './utils/math.js';
+import { validateOrder, validateGridForPersistence, validateWorkingGridFunds, checkFundDrift, reconcileGrid, optimizeRebalanceActions, projectTargetToWorkingGrid, buildStateUpdates, buildAbortedResult, buildSuccessResult, evaluateCommit } from './utils/validate.js';
+import { resolveSpreadOrderSide, parseSlotIndex } from './utils/order.js';
+import { getErrorMessage } from '../utils/errors.js';
 const { toFiniteNumber } = Format;
 // ===============================================================================
 // SECTION 2: COW REBALANCE ENGINE
@@ -107,17 +68,17 @@ const { toFiniteNumber } = Format;
  * @returns {string|null} Drop reason for the log, or null to keep the action
  */
 function stalePlacementDropReason(action, planBoundary) {
-    const isPlacement = action?.type === constants_1.COW_ACTIONS.CREATE || action?.type === constants_1.COW_ACTIONS.UPDATE;
+    const isPlacement = action?.type === COW_ACTIONS.CREATE || action?.type === COW_ACTIONS.UPDATE;
     if (!isPlacement)
         return null;
-    const targetSlot = (0, order_1.parseSlotIndex)(action?.newGridId ?? action?.id);
+    const targetSlot = parseSlotIndex(action?.newGridId ?? action?.id);
     if (targetSlot === null)
         return null;
-    const kindWord = action.type === constants_1.COW_ACTIONS.UPDATE ? 'update' : 'create';
-    if (action?.order?.type === constants_1.ORDER_TYPES.BUY && targetSlot > planBoundary) {
+    const kindWord = action.type === COW_ACTIONS.UPDATE ? 'update' : 'create';
+    if (action?.order?.type === ORDER_TYPES.BUY && targetSlot > planBoundary) {
         return `BUY ${kindWord} for slot ${action.id}: slot ${targetSlot} > plan boundary ${planBoundary}`;
     }
-    if (action?.order?.type === constants_1.ORDER_TYPES.SELL && targetSlot < planBoundary) {
+    if (action?.order?.type === ORDER_TYPES.SELL && targetSlot < planBoundary) {
         return `SELL ${kindWord} for slot ${action.id}: slot ${targetSlot} < plan boundary ${planBoundary}`;
     }
     return null;
@@ -174,7 +135,7 @@ class COWRebalanceEngine {
     }
     async execute({ masterGrid, gridVersion, boundaryIdx, funds, fills = [], excludeIds = new Set() }) {
         const startTime = Date.now();
-        const workingGrid = new working_grid_1.WorkingGrid(masterGrid, { baseVersion: gridVersion });
+        const workingGrid = new WorkingGrid(masterGrid, { baseVersion: gridVersion });
         const strategyParams = {
             frozenMasterGrid: masterGrid,
             config: this.config,
@@ -186,14 +147,14 @@ class COWRebalanceEngine {
         };
         const { targetGrid, boundaryIdx: targetBoundary } = this.strategy.calculateTargetGrid(strategyParams);
         let dustThresholdPercent = this.config?.gridLimits?.PARTIAL_DUST_THRESHOLD_PERCENTAGE;
-        const reconcileResult = (0, validate_1.reconcileGrid)(masterGrid, targetGrid, targetBoundary, {
+        const reconcileResult = reconcileGrid(masterGrid, targetGrid, targetBoundary, {
             logger: (msg, level) => this.logger?.log(msg, level),
             dustThresholdPercent
         });
         if (reconcileResult.aborted) {
-            return (0, validate_1.buildAbortedResult)(reconcileResult.reason);
+            return buildAbortedResult(reconcileResult.reason);
         }
-        const optimizedActions = (0, validate_1.optimizeRebalanceActions)(reconcileResult.actions, masterGrid);
+        const optimizedActions = optimizeRebalanceActions(reconcileResult.actions, masterGrid);
         // Stale-placement guard: drop placements crossing the plan's own
         // boundary (see stalePlacementDropReason) — defer them to the next
         // cycle instead of filling immediately.
@@ -216,28 +177,28 @@ class COWRebalanceEngine {
             optimizedActions.length = 0;
             optimizedActions.push(...guarded);
         }
-        (0, validate_1.projectTargetToWorkingGrid)(workingGrid, targetGrid, { actions: optimizedActions });
+        projectTargetToWorkingGrid(workingGrid, targetGrid, { actions: optimizedActions });
         const precisions = {
             buyPrecision: this.assets?.assetB?.precision,
             sellPrecision: this.assets?.assetA?.precision
         };
-        const fundCheck = (0, validate_1.validateWorkingGridFunds)(workingGrid, funds, precisions, this.assets);
+        const fundCheck = validateWorkingGridFunds(workingGrid, funds, precisions, this.assets);
         if (!fundCheck.isValid) {
             this.logger?.log(`[COW] Fund validation failed: ${fundCheck.reason}`, 'warn');
-            return (0, validate_1.buildAbortedResult)(fundCheck.reason);
+            return 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 (0, validate_1.buildAbortedResult)(reason);
+            return buildAbortedResult(reason);
         }
-        const stateUpdates = (0, validate_1.buildStateUpdates)(optimizedActions, masterGrid);
+        const stateUpdates = buildStateUpdates(optimizedActions, masterGrid);
         const duration = Date.now() - startTime;
-        if (duration > 100) {
+        if (duration > COW_PERFORMANCE.MAX_REBALANCE_PLANNING_MS) {
             this.logger?.log(`[COW] Rebalance planning took ${duration}ms`, 'warn');
         }
         this.logger?.log(`[COW] Plan: Actions=${optimizedActions.length}, StateUpdates=${stateUpdates.length}`, 'info');
-        return (0, validate_1.buildSuccessResult)({
+        return buildSuccessResult({
             actions: optimizedActions,
             stateUpdates,
             workingGrid,
@@ -246,7 +207,6 @@ class COWRebalanceEngine {
         });
     }
 }
-exports.COWRebalanceEngine = COWRebalanceEngine;
 // ===============================================================================
 // SECTION 3: ORDER MANAGER CLASS
 // ===============================================================================
@@ -290,7 +250,7 @@ class OrderManager {
             return this._ordersByTypeCache;
         }
         const byType = {};
-        for (const key of [constants_1.ORDER_TYPES.BUY, constants_1.ORDER_TYPES.SELL, constants_1.ORDER_TYPES.SPREAD]) {
+        for (const key of [ORDER_TYPES.BUY, ORDER_TYPES.SELL, ORDER_TYPES.SPREAD]) {
             byType[key] = new Set();
         }
         for (const [id, o] of this.orders) {
@@ -314,7 +274,7 @@ class OrderManager {
             return this._ordersByStateCache;
         }
         const byState = {};
-        for (const key of [constants_1.ORDER_STATES.VIRTUAL, constants_1.ORDER_STATES.ACTIVE, constants_1.ORDER_STATES.PARTIAL]) {
+        for (const key of [ORDER_STATES.VIRTUAL, ORDER_STATES.ACTIVE, ORDER_STATES.PARTIAL]) {
             byState[key] = new Set();
         }
         for (const [id, o] of this.orders) {
@@ -368,6 +328,7 @@ class OrderManager {
     _orderIdAssignedAt;
     _gapSlots;
     _gridDirtyAt;
+    _lastStaleTotalsWarnAt;
     _orphanFillsCreditedAt;
     _pendingRecovery;
     _recentFillKeysSnapshot;
@@ -380,12 +341,12 @@ class OrderManager {
      * @param {Object} [config] - Configuration overrides
      */
     constructor(config = {}) {
-        this.config = { ...constants_1.DEFAULT_CONFIG, ...config };
+        this.config = { ...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_1.default('DEXBot', {
-            level: loggingConfig?.level ?? constants_1.LOG_LEVEL,
+        this.logger = new Logger('DEXBot', {
+            level: loggingConfig?.level ?? LOG_LEVEL,
             logFile,
             configOverride: loggingConfig?.config ?? undefined
         });
@@ -393,10 +354,10 @@ class OrderManager {
         this.orders = Object.freeze(new Map());
         this.boundaryIdx = null;
         this.targetGrid = null;
-        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.accountant = new Accountant(this);
+        this.strategy = new StrategyEngine(this);
+        this.sync = new SyncEngine(this);
+        this._rebalanceState = REBALANCE_STATES.NORMAL;
         this._bootstrapping = 0;
         this._broadcastingFlag = 0;
         this._broadcastingStartedAt = 0;
@@ -437,15 +398,14 @@ class OrderManager {
         //   Level 2: _syncLock         (sync operations — timeout-protected)
         //   Level 3: _gridLock         (grid mutations)
         //   Level 4: _fundLock         (fund operations — innermost)
-        // Note: AsyncLock IS re-entrant (acquire detects nested calls via _holding).
-        this._fillProcessingLock = new async_lock_1.default({ level: 0, timeout: constants_1.TIMING.SYNC_LOCK_TIMEOUT_MS });
-        this._divergenceLock = new async_lock_1.default({ level: 1 });
-        this._syncLock = new async_lock_1.default({ level: 2 });
-        this._gridLock = new async_lock_1.default({
-            level: 3,
+        // Note: AsyncLock IS re-entrant (acquire detects nested calls via context).
+        this._fillProcessingLock = new AsyncLock({ timeout: TIMING.SYNC_LOCK_TIMEOUT_MS });
+        this._divergenceLock = new AsyncLock();
+        this._syncLock = new AsyncLock();
+        this._gridLock = new AsyncLock({
             onContention: () => { this._metrics.gridLockContention++; }
         });
-        this._fundLock = new async_lock_1.default({ level: 4, timeout: 30000 });
+        this._fundLock = new AsyncLock({ timeout: 30000 });
         this._recentlyRotatedOrderIds = new Set();
         this._gridSidesUpdated = new Set();
         this._pauseFundRecalc = 0;
@@ -474,6 +434,7 @@ class OrderManager {
         this._orphanFillsCreditedAt = null;
         this._pendingRecovery = null;
         this._recentFillKeysSnapshot = null;
+        this._lastStaleTotalsWarnAt = {};
         this._metrics = {
             fundRecalcCount: 0,
             lockAcquisitions: 0,
@@ -503,8 +464,8 @@ class OrderManager {
     _clearWorkingGridRef() {
         this._currentWorkingGridStack.pop();
         this._rebalanceState = this._currentWorkingGridStack.length > 0
-            ? constants_1.REBALANCE_STATES.REBALANCING
-            : constants_1.REBALANCE_STATES.NORMAL;
+            ? REBALANCE_STATES.REBALANCING
+            : REBALANCE_STATES.NORMAL;
     }
     /**
      * Push a working grid onto the rebalance stack (LIFO), set the state to
@@ -518,7 +479,7 @@ class OrderManager {
      */
     _pushWorkingGridRef(workingGrid, result = null) {
         this._currentWorkingGridStack.push(workingGrid);
-        this._rebalanceState = constants_1.REBALANCE_STATES.REBALANCING;
+        this._rebalanceState = REBALANCE_STATES.REBALANCING;
         if (result) {
             result._workingGridPushed = true;
         }
@@ -560,20 +521,20 @@ class OrderManager {
     }
     _resetRebalanceStateToDepth() {
         this._rebalanceState = this._currentWorkingGridStack.length > 0
-            ? constants_1.REBALANCE_STATES.REBALANCING
-            : constants_1.REBALANCE_STATES.NORMAL;
+            ? REBALANCE_STATES.REBALANCING
+            : REBALANCE_STATES.NORMAL;
     }
     /**
      * @returns {boolean}
      */
     isRebalancing() {
-        return this._rebalanceState === constants_1.REBALANCE_STATES.REBALANCING;
+        return this._rebalanceState === REBALANCE_STATES.REBALANCING;
     }
     /**
      * @returns {boolean}
      */
     isBroadcasting() {
-        return this._rebalanceState === constants_1.REBALANCE_STATES.BROADCASTING;
+        return this._rebalanceState === REBALANCE_STATES.BROADCASTING;
     }
     /**
      * @returns {boolean}
@@ -693,19 +654,19 @@ class OrderManager {
     getChainFundsSnapshot() {
         let committedBuy = 0, committedSell = 0;
         for (const order of this.orders.values()) {
-            const isActive = (order.state === constants_1.ORDER_STATES.ACTIVE || order.state === constants_1.ORDER_STATES.PARTIAL) && !!order.orderId;
+            const isActive = (order.state === ORDER_STATES.ACTIVE || order.state === ORDER_STATES.PARTIAL) && !!order.orderId;
             if (!isActive)
                 continue;
             const size = toFiniteNumber(order.size);
             if (size <= 0)
                 continue;
-            const isBuy = order.type === constants_1.ORDER_TYPES.BUY || (order.type === constants_1.ORDER_TYPES.SPREAD && (0, order_1.resolveSpreadOrderSide)(order.price, this.config.startPrice) === constants_1.ORDER_TYPES.BUY);
+            const isBuy = order.type === ORDER_TYPES.BUY || (order.type === ORDER_TYPES.SPREAD && resolveSpreadOrderSide(order.price, this.config.startPrice) === ORDER_TYPES.BUY);
             if (isBuy)
                 committedBuy += size;
             else
                 committedSell += size;
         }
-        const totals = (0, math_1.computeChainFundTotals)(this.accountTotals, { buy: committedBuy, sell: committedSell });
+        const totals = computeChainFundTotals(this.accountTotals, { buy: committedBuy, sell: committedSell });
         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')
@@ -717,12 +678,12 @@ class OrderManager {
      * @param {number} [timeoutMs]
      * @returns {Promise<void>}
      */
-    async waitForAccountTotals(timeoutMs = constants_1.TIMING.ACCOUNT_TOTALS_TIMEOUT_MS) {
-        if ((0, math_1.hasValidAccountTotals)(this.accountTotals, true))
+    async waitForAccountTotals(timeoutMs = TIMING.ACCOUNT_TOTALS_TIMEOUT_MS) {
+        if (hasValidAccountTotals(this.accountTotals, true))
             return;
         let waitPromise = null;
         await this._fundLock.acquire(async () => {
-            if ((0, math_1.hasValidAccountTotals)(this.accountTotals, true))
+            if (hasValidAccountTotals(this.accountTotals, true))
                 return;
             if (!this._accountTotalsPromise) {
                 this._accountTotalsPromise = new Promise((resolve) => {
@@ -733,7 +694,7 @@ class OrderManager {
         });
         if (!waitPromise)
             return;
-        await (0, timeout_1.withTimeout)(waitPromise, timeoutMs, {
+        await withTimeout(waitPromise, timeoutMs, {
             onTimeout: 'resolve',
             defaultValue: undefined,
             onTimeoutCallback: () => this.logger.log('[FUND] Timeout waiting for account totals', 'warn'),
@@ -764,7 +725,7 @@ class OrderManager {
     async refreshAccountTotalsIfStale(options = {}) {
         const force = options?.force === true;
         const lastFetched = this.accountTotals?._lastFetchedAt || 0;
-        if (!force && Date.now() - lastFetched <= constants_1.TIMING.MAX_ACCOUNT_TOTALS_AGE_MS) {
+        if (!force && Date.now() - lastFetched <= TIMING.MAX_ACCOUNT_TOTALS_AGE_MS) {
             return { ok: true };
         }
         const fetchedBefore = lastFetched;
@@ -773,18 +734,35 @@ class OrderManager {
         // defer the whole fill batch to the next cycle. Only a genuinely
         // unreachable chain leaves the snapshot stale.
         try {
-            await (0, system_1.withBlockchainRetry)(() => this.fetchAccountTotals(this.accountId), 'refreshAccountTotalsIfStale', { logger: this.logger });
+            await withBlockchainRetry(() => this.fetchAccountTotals(this.accountId), 'refreshAccountTotalsIfStale', { logger: this.logger });
         }
         catch (err) {
-            this.logger?.log?.(`[SYNC] refreshAccountTotalsIfStale fetch failed: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
+            this.logger?.log?.(`[SYNC] refreshAccountTotalsIfStale fetch failed: ${getErrorMessage(err)}`, 'warn');
         }
         const fetchedAfter = this.accountTotals?._lastFetchedAt || 0;
         if (fetchedAfter <= fetchedBefore) {
-            this.logger?.log?.(`[SYNC] refreshAccountTotalsIfStale: accountTotals still stale after refresh (age=${Math.max(0, Date.now() - fetchedAfter)}ms).`, 'warn');
+            if (this._rateLimitStaleTotalsWarn('stale-refresh')) {
+                this.logger?.log?.(`[SYNC] refreshAccountTotalsIfStale: accountTotals still stale after refresh (age=${Math.max(0, Date.now() - fetchedAfter)}ms).`, 'warn');
+            }
             return { ok: false, reason: 'refresh-failed' };
         }
         return { ok: true };
     }
+    /**
+     * Rate-limit identical accountTotals-staleness warnings to once per
+     * STALE_TOTALS_WARN_RATE_LIMIT_MS per warning kind per manager, so a
+     * persistently unreachable chain reports each failure mode once without
+     * flooding the log on every fill batch.
+     * @param {string} kind - Warning kind key (e.g. 'stale-refresh', 're-anchor')
+     * @returns {boolean} true when the warning should be emitted now
+     */
+    _rateLimitStaleTotalsWarn(kind) {
+        const now = Date.now();
+        if (now - (this._lastStaleTotalsWarnAt[kind] || 0) < TIMING.STALE_TOTALS_WARN_RATE_LIMIT_MS)
+            return false;
+        this._lastStaleTotalsWarnAt[kind] = now;
+        return true;
+    }
     /**
      * Re-anchor accountTotals to authoritative on-chain values after a fill
      * batch has applied its optimistic accounting and grid mutation.
@@ -802,7 +780,9 @@ class OrderManager {
     async reanchorAccountTotals(label = 'fill-batch') {
         const result = await this.refreshAccountTotalsIfStale({ force: true });
         if (!result.ok) {
-            this.logger?.log?.(`[ACCOUNTING] ${label}: accountTotals re-anchor failed (${result.reason}); marking totals stale.`, 'warn');
+            if (this._rateLimitStaleTotalsWarn('re-anchor')) {
+                this.logger?.log?.(`[ACCOUNTING] ${label}: accountTotals re-anchor failed (${result.reason}); marking totals stale.`, 'warn');
+            }
             this.accountTotalsStale = true;
             return false;
         }
@@ -825,12 +805,12 @@ class OrderManager {
         if (!this.funds)
             await this.resetFunds();
         await this._recalculateFunds();
-        if ((0, math_1.hasValidAccountTotals)(this.accountTotals, true) && typeof this._accountTotalsResolve === 'function') {
+        if (hasValidAccountTotals(this.accountTotals, true) && typeof this._accountTotalsResolve === 'function') {
             try {
                 this._accountTotalsResolve();
             }
             catch (e) {
-                this.logger?.log?.(`Error resolving account totals promise: ${(0, errors_1.getErrorMessage)(e)}`, 'warn');
+                this.logger?.log?.(`Error resolving account totals promise: ${getErrorMessage(e)}`, 'warn');
             }
             this._accountTotalsPromise = null;
             this._accountTotalsResolve = null;
@@ -850,11 +830,11 @@ class OrderManager {
     applyBotFundsAllocation() {
         if (!this.config.botFunds || !this.accountTotals)
             return;
-        const { chainTotalBuy, chainTotalSell } = (0, math_1.computeChainFundTotals)(this.accountTotals, this.funds?.committed?.chain);
+        const { chainTotalBuy, chainTotalSell } = computeChainFundTotals(this.accountTotals, this.funds?.committed?.chain);
         const account = this.config.preferredAccount;
         const botName = this.config.botKey;
-        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');
+        const allocatedBuy = resolveConfigValueWithRegistry(this.config.botFunds.buy, chainTotalBuy, account, botName, 'buy');
+        const allocatedSell = 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();
@@ -864,8 +844,8 @@ class OrderManager {
                 this._triggerAccountTotalsFetchIfNeeded();
         }
         this.funds.allocated = { buy: allocatedBuy, sell: allocatedSell };
-        const shouldCapBuy = allocatedBuy > 0 || (0, math_1.isExplicitZeroAllocation)(this.config.botFunds.buy);
-        const shouldCapSell = allocatedSell > 0 || (0, math_1.isExplicitZeroAllocation)(this.config.botFunds.sell);
+        const shouldCapBuy = allocatedBuy > 0 || isExplicitZeroAllocation(this.config.botFunds.buy);
+        const shouldCapSell = allocatedSell > 0 || isExplicitZeroAllocation(this.config.botFunds.sell);
         if (shouldCapBuy)
             this.funds.available.buy = Math.min(this.funds.available.buy, Math.max(0, allocatedBuy));
         if (shouldCapSell)
@@ -920,10 +900,10 @@ class OrderManager {
                     this._pauseFundRecalc = 0;
                     this._pauseFundRecalcWatchdog = null;
                     this.recalculateFunds().catch((err) => {
-                        this.logger?.log?.(`[MANAGER] Watchdog recalc failed: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+                        this.logger?.log?.(`[MANAGER] Watchdog recalc failed: ${getErrorMessage(err)}`, 'error');
                     });
                 }
-            }, constants_1.TIMING.SAFETY_PAUSE_TIMEOUT_MS);
+            }, TIMING.SAFETY_PAUSE_TIMEOUT_MS);
         }
     }
     /**
@@ -961,10 +941,10 @@ class OrderManager {
             clearTimeout(this._pauseRecalcLoggingWatchdog);
         }
         this._pauseRecalcLoggingWatchdog = setTimeout(() => {
-            this.logger?.log?.(`[MANAGER] pauseRecalcLogging safety watchdog: forcing resume after ${constants_1.TIMING.SAFETY_PAUSE_TIMEOUT_MS}ms`, 'warn');
+            this.logger?.log?.(`[MANAGER] pauseRecalcLogging safety watchdog: forcing resume after ${TIMING.SAFETY_PAUSE_TIMEOUT_MS}ms`, 'warn');
             this._pauseRecalcLogging = false;
             this._pauseRecalcLoggingWatchdog = null;
-        }, constants_1.TIMING.SAFETY_PAUSE_TIMEOUT_MS);
+        }, TIMING.SAFETY_PAUSE_TIMEOUT_MS);
     }
     /**
      * Resume recalc debug logging.
@@ -1024,7 +1004,7 @@ class OrderManager {
     lockOrders(orderIds) {
         if (!orderIds)
             return;
-        const expiration = Date.now() + constants_1.TIMING.LOCK_TIMEOUT_MS;
+        const expiration = Date.now() + TIMING.LOCK_TIMEOUT_MS;
         for (const id of orderIds)
             if (id)
                 this.shadowOrderIds.set(id, expiration);
@@ -1089,7 +1069,7 @@ class OrderManager {
         const updateOptions = this._normalizeOrderUpdateOptions(options);
         const { skipAccounting, fee: normalizedFee } = updateOptions;
         const oldOrder = this.orders.get(order.id);
-        const validation = (0, validate_1.validateOrder)(order, oldOrder, context);
+        const validation = validateOrder(order, oldOrder, context);
         for (const warning of validation.warnings) {
             this.logger.log(warning.message, 'warn');
         }
@@ -1128,7 +1108,7 @@ class OrderManager {
         if (this.accountant) {
             await this.accountant.updateOptimisticFreeBalance(oldOrder, nextOrder, context, normalizedFee, accountingSkip);
         }
-        const updatedOrder = (0, system_1.deepFreeze)({ ...nextOrder });
+        const updatedOrder = deepFreeze({ ...nextOrder });
         const id = order.id;
         // Track when an orderId is first assigned to a slot. A freshly assigned
         // orderId (create/adopt broadcast still in flight, or not yet visible to
@@ -1142,13 +1122,13 @@ class OrderManager {
             // younger than SYNC_LOCK_TIMEOUT_MS), so keeping them would leak one
             // entry per orderId on a perpetual-turnover bot.
             for (const [orderId, assignedAt] of this._orderIdAssignedAt) {
-                if (Date.now() - assignedAt >= constants_1.TIMING.SYNC_LOCK_TIMEOUT_MS) {
+                if (Date.now() - assignedAt >= TIMING.SYNC_LOCK_TIMEOUT_MS) {
                     this._orderIdAssignedAt.delete(orderId);
                 }
             }
             this._orderIdAssignedAt.set(updatedOrder.orderId, Date.now());
         }
-        const newMap = (0, system_1.cloneMap)(this.orders);
+        const newMap = cloneMap(this.orders);
         newMap.set(id, updatedOrder);
         this.orders = Object.freeze(newMap);
         this._gridVersion++;
@@ -1185,8 +1165,8 @@ class OrderManager {
             wg.syncFromMaster(this.orders, orderId, this._gridVersion);
         }
         catch (syncErr) {
-            wg.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');
+            wg.markStale(`working-grid sync failure: ${getErrorMessage(syncErr)}`);
+            this.logger.log(`[COW] Failed to sync working grid for order ${orderId}: ${getErrorMessage(syncErr)}`, 'warn');
         }
     }
     /**
@@ -1299,7 +1279,7 @@ class OrderManager {
             rebalanceResult.excludeIds = excl || new Set();
             return rebalanceResult;
         }
-        const workingGrid = new working_grid_1.WorkingGrid(this.orders, { baseVersion: this._gridVersion });
+        const workingGrid = new WorkingGrid(this.orders, { baseVersion: this._gridVersion });
         return {
             actions: [],
             stateUpdates: [],
@@ -1319,28 +1299,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 = (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);
+        const minSellSize = getMinAbsoluteOrderSize(ORDER_TYPES.SELL, this.assets, minOrderSizeFactor);
+        const minBuySize = getMinAbsoluteOrderSize(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 = (0, math_1.floatToBlockchainInt)(minSellSize, sellPrecision);
-        const minBuySizeInt = (0, math_1.floatToBlockchainInt)(minBuySize, buyPrecision);
+        const minSellSizeInt = floatToBlockchainInt(minSellSize, sellPrecision);
+        const minBuySizeInt = floatToBlockchainInt(minBuySize, buyPrecision);
         // Get closest virtual sells (lowest prices first = closest to market), limit to sellCount
-        const vSells = this.getOrdersByTypeAndState(constants_1.ORDER_TYPES.SELL, constants_1.ORDER_STATES.VIRTUAL)
+        const vSells = this.getOrdersByTypeAndState(ORDER_TYPES.SELL, 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) => (0, math_1.floatToBlockchainInt)(o.size, sellPrecision) >= minSellSizeInt)
+            .filter((o) => 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(constants_1.ORDER_TYPES.BUY, constants_1.ORDER_STATES.VIRTUAL)
+        const vBuys = this.getOrdersByTypeAndState(ORDER_TYPES.BUY, 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) => (0, math_1.floatToBlockchainInt)(o.size, buyPrecision) >= minBuySizeInt)
+            .filter((o) => floatToBlockchainInt(o.size, buyPrecision) >= minBuySizeInt)
             .sort((a, b) => a.price - b.price);
         return [...validSells, ...validBuys];
     }
@@ -1413,29 +1393,29 @@ class OrderManager {
      * @returns {Promise<Object>}
      */
     async checkSpreadCondition(BitShares, batchCb) {
-        return await (0, grid_1.checkSpreadCondition)(this, BitShares, batchCb);
+        return await checkSpreadCondition(this, BitShares, batchCb);
     }
     /**
      * @param {Function} batchCb - Batch callback
      * @returns {Promise<Object>}
      */
     async checkGridHealth(batchCb) {
-        return await (0, grid_1.checkGridHealth)(this, batchCb);
+        return await checkGridHealth(this, batchCb);
     }
     /**
      * @returns {Object} Current spread calculation
      */
     calculateCurrentSpread() {
-        return (0, grid_1.calculateCurrentSpread)(this);
+        return calculateCurrentSpread(this);
     }
     /**
      * @returns {import('./types').DriftCheckResult}
      */
     checkFundDriftAfterFills() {
-        if (!this.assets || !(0, math_1.hasValidAccountTotals)(this.accountTotals)) {
+        if (!this.assets || !hasValidAccountTotals(this.accountTotals)) {
             return { isValid: true, reason: 'Skipped: missing assets or totals' };
         }
-        return (0, validate_1.checkFundDrift)(this.orders, this.accountTotals, this.assets, this.config?.gridLimits ?? null);
+        return checkFundDrift(this.orders, this.accountTotals, this.assets, this.config?.gridLimits ?? null);
     }
     /**
      * @param {Object|number} [pipelineSignals] - Pipeline state signals or queue length
@@ -1490,7 +1470,7 @@ class OrderManager {
         if (!this._pipelineBlockedSince)
             return false;
         const age = Date.now() - this._pipelineBlockedSince;
-        const timeoutMs = this.config?.pipelineTiming?.TIMEOUT_MS ?? constants_1.PIPELINE_TIMING.TIMEOUT_MS;
+        const timeoutMs = this.config?.pipelineTiming?.TIMEOUT_MS ?? PIPELINE_TIMING.TIMEOUT_MS;
         if (age < timeoutMs)
             return false;
         this.ordersNeedingPriceCorrection = [];
@@ -1503,7 +1483,7 @@ class OrderManager {
      * @returns {Object}
      */
     reconcileGrid(targetGrid, targetBoundary) {
-        return (0, validate_1.reconcileGrid)(this.orders, targetGrid, targetBoundary, {
+        return reconcileGrid(this.orders, targetGrid, targetBoundary, {
             logger: (msg, level) => this.logger.log(msg, level),
             dustThresholdPercent: this.config?.gridLimits?.PARTIAL_DUST_THRESHOLD_PERCENTAGE
         });
@@ -1522,9 +1502,9 @@ class OrderManager {
     async _applySafeRebalanceCOW(fills = [], excludeIds = new Set()) {
         const cowEngine = this._getCOWEngine();
         if (!cowEngine) {
-            return (0, validate_1.buildAbortedResult)('COW Engine not initialized (assets not available)');
+            return buildAbortedResult('COW Engine not initialized (assets not available)');
         }
-        this._setRebalanceState(constants_1.REBALANCE_STATES.REBALANCING);
+        this._setRebalanceState(REBALANCE_STATES.REBALANCING);
         const result = await cowEngine.execute({
             masterGrid: this.orders,
             gridVersion: this._gridVersion,
@@ -1597,11 +1577,11 @@ class OrderManager {
                 comparePrecisions = this._getCowComparePrecisions();
             }
             catch (precisionErr) {
-                this.logger.log(`[COW] ${(0, errors_1.getErrorMessage)(precisionErr)}`, 'error');
+                this.logger.log(`[COW] ${getErrorMessage(precisionErr)}`, 'error');
                 releaseStackEntry();
                 return false;
             }
-            const preCommitGuard = (0, validate_1.evaluateCommit)(workingGrid, {
+            const preCommitGuard = evaluateCommit(workingGrid, {
                 hasLock: false,
                 currentVersion: this._gridVersion,
                 masterGrid: this.orders,
@@ -1613,7 +1593,7 @@ class OrderManager {
                 return false;
             }
             await this._gridLock.acquire(async () => {
-                const lockCommitGuard = (0, validate_1.evaluateCommit)(workingGrid, {
+                const lockCommitGuard = evaluateCommit(workingGrid, {
                     hasLock: true,
                     currentVersion: this._gridVersion,
                     masterGrid: this.orders,
@@ -1631,7 +1611,7 @@ class OrderManager {
                 // Ensures COW immutability invariants are maintained for all grid entries.
                 for (const [, order] of finalMap.entries()) {
                     if (order && !Object.isFrozen(order)) {
-                        (0, system_1.deepFreeze)(order);
+                        deepFreeze(order);
                     }
                 }
                 this.orders = Object.freeze(finalMap);
@@ -1668,12 +1648,12 @@ class OrderManager {
                 }
                 const duration = Date.now() - startTime;
                 this.logger.log(`[COW] Grid committed in ${duration}ms`, 'debug');
-                if (stats.size > constants_1.COW_PERFORMANCE.GRID_MEMORY_WARNING) {
+                if (stats.size > 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: ${(0, errors_1.getErrorMessage)(recalcErr)}`, 'error');
+                this.logger.log(`[COW] Fund recalculation failed post-commit: ${getErrorMessage(recalcErr)}`, 'error');
                 this._recoveryState = { ...this._recoveryState, lastFailureAt: Date.now() };
                 // Re-throw to signal callers that the commit is incomplete
                 // (grid state committed, but fund state is stale).
@@ -1697,7 +1677,7 @@ class OrderManager {
      * @returns {import('./types').PersistenceValidationResult}
      */
     validateGridStateForPersistence(options = {}) {
-        const result = (0, validate_1.validateGridForPersistence)(this.orders, this.accountTotals);
+        const result = 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');
@@ -1753,7 +1733,7 @@ class OrderManager {
                 accountTotals: this.accountTotals,
             }));
         }
-        const persisted = await (0, system_1.persistGridSnapshot)(this, this.accountOrders, snapshotOrders, recentFillKeys, effectiveFundSnapshot);
+        const persisted = await persistGridSnapshot(this, this.accountOrders, snapshotOrders, recentFillKeys, effectiveFundSnapshot);
         if (persisted === false) {
             this.logger.log(`[PERSIST] Grid persistence FAILED (disk full / permissions / write error)`, 'error');
             // Keep the dirty flag set so the next flush retries.
@@ -1840,5 +1820,5 @@ class OrderManager {
         };
     }
 }
-exports.OrderManager = OrderManager;
+export { OrderManager, COWRebalanceEngine };
 //# sourceMappingURL=manager.js.map