dexbot 1.3.2 → 1.4.0

package/dist/modules/order/accounting.js

@@ -74,13 +74,49 @@
  *
  * ===============================================================================
  */
-const { ORDER_TYPES, ORDER_STATES, PIPELINE_TIMING, TIMING, FEE_PARAMETERS } = require('../constants');
-const { calculateAvailableFundsValue, getAssetFees, blockchainToFloat, getPrecisionSlack } = require('./utils/math');
-const { PROCESSED_FILL_PERSISTENCE_MODES, resolveProcessedFillPersistenceMode } = require('./processed_fill_store');
-const { resolveAccountRef } = require('./utils/system');
-const Format = require('./format');
+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 });
+const constants_1 = require("../constants");
+const system_1 = require("./utils/system");
+const Format = __importStar(require("./format"));
+const fundRegistry = __importStar(require("../fund_registry"));
+const chainOrders = __importStar(require("../chain_orders"));
+const math_1 = require("./utils/math");
+const processed_fill_store_1 = require("./processed_fill_store");
+const errors_1 = require("../utils/errors");
 const { toFiniteNumber } = Format;
-const fundRegistry = require('../fund_registry');
 /**
  * Accountant engine - Specialized handler for fund tracking and calculations
  * @class Accountant
@@ -105,7 +141,7 @@ class Accountant {
         this._pendingInvariantSnapshot = null; // Coalesces latest request while one is running
         this._logThrottleState = new Map();
     }
-    _logThrottled(key, message, level = 'warn', intervalMs = TIMING.LOG_THROTTLE_INTERVAL_MS) {
+    _logThrottled(key, message, level = 'warn', intervalMs = constants_1.TIMING.LOG_THROTTLE_INTERVAL_MS) {
         const now = Date.now();
         let state = this._logThrottleState.get(key);
         if (!state || (now - state.lastAt) >= intervalMs) {
@@ -131,7 +167,7 @@ class Accountant {
     }
     _getBtsOrderType() {
         const mgr = this.manager;
-        const btsSide = (mgr.config?.assetA === 'BTS') ? ORDER_TYPES.SELL : (mgr.config?.assetB === 'BTS') ? ORDER_TYPES.BUY : null;
+        const btsSide = (mgr.config?.assetA === 'BTS') ? constants_1.ORDER_TYPES.SELL : (mgr.config?.assetB === 'BTS') ? constants_1.ORDER_TYPES.BUY : null;
         return btsSide;
     }
     _normalizeBtsFeeState(order) {
@@ -142,12 +178,12 @@ class Accountant {
     }
     _getBtsFeeSchedule() {
         try {
-            const fees = getAssetFees('BTS');
+            const fees = (0, math_1.getAssetFees)('BTS');
             return {
                 createFee: Math.max(0, toFiniteNumber(fees?.createFee, 0)),
                 updateFee: Math.max(0, toFiniteNumber(fees?.updateFee, 0)),
                 cancelFee: Math.max(0, toFiniteNumber(fees?.cancelFee, 0)),
-                makerFeeDiscountPercent: Math.max(0, toFiniteNumber(fees?.makerFeeDiscountPercent, this.manager?.config?.feeParams?.MAKER_REFUND_PERCENT ?? FEE_PARAMETERS.MAKER_REFUND_PERCENT))
+                makerFeeDiscountPercent: Math.max(0, toFiniteNumber(fees?.makerFeeDiscountPercent, this.manager?.config?.feeParams?.MAKER_REFUND_PERCENT ?? constants_1.FEE_PARAMETERS.MAKER_REFUND_PERCENT))
             };
         }
         catch (err) {
@@ -156,7 +192,7 @@ class Accountant {
                 createFee: 0,
                 updateFee: 0,
                 cancelFee: 0,
-                makerFeeDiscountPercent: this.manager?.config?.feeParams?.MAKER_REFUND_PERCENT ?? FEE_PARAMETERS.MAKER_REFUND_PERCENT
+                makerFeeDiscountPercent: this.manager?.config?.feeParams?.MAKER_REFUND_PERCENT ?? constants_1.FEE_PARAMETERS.MAKER_REFUND_PERCENT
             };
         }
     }
@@ -178,8 +214,8 @@ class Accountant {
     }
     _resolveBtsFeeLifecycle(oldOrder, newOrder, context, explicitFee) {
         const fee = Math.max(0, toFiniteNumber(explicitFee, 0));
-        const oldActive = !!(oldOrder && (oldOrder.state === ORDER_STATES.ACTIVE || oldOrder.state === ORDER_STATES.PARTIAL) && oldOrder.orderId);
-        const newActive = !!(newOrder && (newOrder.state === ORDER_STATES.ACTIVE || newOrder.state === ORDER_STATES.PARTIAL) && newOrder.orderId);
+        const oldActive = !!(oldOrder && (oldOrder.state === constants_1.ORDER_STATES.ACTIVE || oldOrder.state === constants_1.ORDER_STATES.PARTIAL) && oldOrder.orderId);
+        const newActive = !!(newOrder && (newOrder.state === constants_1.ORDER_STATES.ACTIVE || newOrder.state === constants_1.ORDER_STATES.PARTIAL) && newOrder.orderId);
         const oldDeferred = this._normalizeBtsFeeState(oldOrder).deferredFee;
         const sameChainOrder = oldActive && newActive && oldOrder.orderId === newOrder.orderId;
         const feeSchedule = this._getBtsFeeSchedule();
@@ -317,11 +353,11 @@ class Accountant {
         let chainBuy = 0, chainSell = 0;
         let virtualBuy = 0, virtualSell = 0;
         // AUTO-SYNC SPREAD COUNT
-        mgr.currentSpreadCount = mgr._ordersByType[ORDER_TYPES.SPREAD]?.size || 0;
+        mgr.currentSpreadCount = mgr._ordersByType[constants_1.ORDER_TYPES.SPREAD]?.size || 0;
         // STEP 1-4: Iterate all orders, classify, and aggregate by state
         for (const order of orderSnapshot) {
-            const isActive = (order.state === ORDER_STATES.ACTIVE || order.state === ORDER_STATES.PARTIAL) && !!order.orderId;
-            const isVirtual = (order.state === ORDER_STATES.VIRTUAL);
+            const isActive = (order.state === constants_1.ORDER_STATES.ACTIVE || order.state === constants_1.ORDER_STATES.PARTIAL) && !!order.orderId;
+            const isVirtual = (order.state === constants_1.ORDER_STATES.VIRTUAL);
             const size = toFiniteNumber(order.size);
             if (size <= 0)
                 continue;
@@ -330,8 +366,8 @@ class Accountant {
             // - SPREAD type: derive from price relation to startPrice (market midpoint)
             //   * price < startPrice → BUY side (lower prices are bids)
             //   * price >= startPrice → SELL side (higher prices are asks)
-            const isBuy = order.type === ORDER_TYPES.BUY || (order.type === ORDER_TYPES.SPREAD && order.price < mgr.config.startPrice);
-            const isSell = order.type === ORDER_TYPES.SELL || (order.type === ORDER_TYPES.SPREAD && order.price >= mgr.config.startPrice);
+            const isBuy = order.type === constants_1.ORDER_TYPES.BUY || (order.type === constants_1.ORDER_TYPES.SPREAD && order.price < mgr.config.startPrice);
+            const isSell = order.type === constants_1.ORDER_TYPES.SELL || (order.type === constants_1.ORDER_TYPES.SPREAD && order.price >= mgr.config.startPrice);
             if (isBuy) {
                 if (isActive) {
                     gridBuy += size;
@@ -364,8 +400,8 @@ class Accountant {
         mgr.funds.total.grid = { buy: gridBuy + virtualBuy, sell: gridSell + virtualSell };
         // STEP 6: Calculate available funds (what we can spend right now)
         // Uses utils::calculateAvailableFundsValue which deducts committe amounts
-        mgr.funds.available.buy = calculateAvailableFundsValue('buy', mgr.accountTotals, mgr.funds, mgr.config.assetA, mgr.config.assetB, mgr.config.activeOrders, mgr.config.min_BTS_value, mgr.config?.feeParams ?? null);
-        mgr.funds.available.sell = calculateAvailableFundsValue('sell', mgr.accountTotals, mgr.funds, mgr.config.assetA, mgr.config.assetB, mgr.config.activeOrders, mgr.config.min_BTS_value, mgr.config?.feeParams ?? null);
+        mgr.funds.available.buy = (0, math_1.calculateAvailableFundsValue)('buy', mgr.accountTotals, mgr.funds, mgr.config.assetA, mgr.config.assetB, mgr.config.activeOrders, mgr.config.min_BTS_value, mgr.config?.feeParams ?? null);
+        mgr.funds.available.sell = (0, math_1.calculateAvailableFundsValue)('sell', mgr.accountTotals, mgr.funds, mgr.config.assetA, mgr.config.assetB, mgr.config.activeOrders, mgr.config.min_BTS_value, mgr.config?.feeParams ?? null);
         // Ensure percentage-based allocations are applied to the newly calculated totals
         if (typeof mgr.applyBotFundsAllocation === 'function') {
             mgr.applyBotFundsAllocation();
@@ -383,8 +419,8 @@ class Accountant {
             const runVerification = (nextSnapshot) => {
                 this._isVerifyingInvariants = true;
                 this._verifyFundInvariants(mgr, nextSnapshot.chainFreeBuy, nextSnapshot.chainFreeSell, nextSnapshot.chainBuy, nextSnapshot.chainSell)
-                    .catch(err => {
-                    mgr.logger?.log?.(`[RECOVERY] Verification error: ${err.message}`, 'error');
+                    .catch((err) => {
+                    mgr.logger?.log?.(`[RECOVERY] Verification error: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
                 })
                     .finally(() => {
                     this._isVerifyingInvariants = false;
@@ -427,8 +463,8 @@ class Accountant {
         if (!Number.isFinite(buyPrecision) || !Number.isFinite(sellPrecision)) {
             return; // Skip invariant check if precision not available
         }
-        const precisionSlackBuy = getPrecisionSlack(buyPrecision);
-        const precisionSlackSell = getPrecisionSlack(sellPrecision);
+        const precisionSlackBuy = (0, math_1.getPrecisionSlack)(buyPrecision);
+        const precisionSlackSell = (0, math_1.getPrecisionSlack)(sellPrecision);
         const PERCENT_TOLERANCE = (mgr.config?.gridLimits?.FUND_INVARIANT_PERCENT_TOLERANCE) / 100;
         // FIX 5: Widen tolerance when orphan fills were recently credited.
         // Orphan fill accounting adjusts mgr.accountTotals optimistically, but
@@ -509,7 +545,7 @@ class Accountant {
                 }
             }
             catch (_err) {
-                mgr.logger?.log?.(`[INVARIANT] Cross-bot registry check skipped: ${_err.message}`, 'warn');
+                mgr.logger?.log?.(`[INVARIANT] Cross-bot registry check skipped: ${(0, errors_1.getErrorMessage)(_err)}`, 'warn');
             }
         }
         // NEW: Attempt immediate recovery if violation detected
@@ -519,13 +555,13 @@ class Accountant {
                     await this._attemptFundRecovery(mgr, 'Fund invariant violation');
                 }
                 catch (err) {
-                    mgr.logger?.log?.(`[RECOVERY] Deferred recovery failed: ${err.message}`, 'error');
+                    mgr.logger?.log?.(`[RECOVERY] Deferred recovery failed: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
                     mgr._recoveryState = { ...mgr._recoveryState, lastFailureAt: Date.now() };
                 }
             };
             if (mgr._gridLock?.isLocked?.()) {
-                doRecovery().catch(err => {
-                    mgr.logger?.log?.(`[RECOVERY] Deferred recovery scheduling failed: ${err.message}`, 'error');
+                doRecovery().catch((err) => {
+                    mgr.logger?.log?.(`[RECOVERY] Deferred recovery scheduling failed: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
                 });
             }
             else {
@@ -541,7 +577,7 @@ class Accountant {
      * @returns {Promise<Object>} - Validation result from validateGridStateForPersistence()
      */
     async _performStateRecovery(mgr) {
-        const accountRef = resolveAccountRef(mgr);
+        const accountRef = (0, system_1.resolveAccountRef)(mgr, '');
         if (!accountRef) {
             return {
                 isValid: false,
@@ -555,7 +591,6 @@ class Accountant {
         // proceeds, so the temporary invariant tolerance is no longer needed.
         mgr._orphanFillsCreditedAt = null;
         // 2. Sync from open orders
-        const chainOrders = require('../chain_orders');
         const openOrders = await chainOrders.readOpenOrders(accountRef);
         // Recovery runs after fetchAccountTotals() has refreshed authoritative balances
         // from chain. During this pass we only want to reconcile grid structure/order
@@ -608,7 +643,7 @@ class Accountant {
         if (!mgr._recoveryState || typeof mgr._recoveryState !== 'object') {
             mgr._recoveryState = { attemptCount: 0, lastAttemptAt: 0, inFlight: false, lastFailureAt: 0, structuralResyncRequested: false };
         }
-        const pt = mgr.config?.pipelineTiming || PIPELINE_TIMING;
+        const pt = mgr.config?.pipelineTiming || constants_1.PIPELINE_TIMING;
         const state = mgr._recoveryState;
         const now = Date.now();
         const retryIntervalMs = Math.max(0, Number(pt.RECOVERY_RETRY_INTERVAL_MS));
@@ -621,12 +656,12 @@ class Accountant {
         // Decay: if enough time has passed since the last failure, treat this
         // as a fresh violation cycle to prevent stale counts from a previous
         // cycle permanently exhausting the attempt budget.
-        const decayMs = retryIntervalMs > 0 ? retryIntervalMs * 3 : (pt.RECOVERY_DECAY_FALLBACK_MS ?? PIPELINE_TIMING.RECOVERY_DECAY_FALLBACK_MS);
+        const decayMs = retryIntervalMs > 0 ? retryIntervalMs * 3 : (pt.RECOVERY_DECAY_FALLBACK_MS ?? constants_1.PIPELINE_TIMING.RECOVERY_DECAY_FALLBACK_MS);
         if (state.attemptCount > 0 && state.lastFailureAt > 0 && (now - state.lastFailureAt) > decayMs) {
             // Log at 'info' level so operators can monitor for repeated decay patterns
             // which may indicate a persistent issue that self-corrects just long enough
             // to trigger decay, then recurs. Pattern: repeated "decayed" messages.
-            mgr.logger?.log?.(`[RECOVERY] Attempt count decayed (${state.attemptCount} -> 0) after ${Math.round((now - state.lastFailureAt) / TIMING.MILLISECONDS_PER_SECOND)}s idle`, 'info');
+            mgr.logger?.log?.(`[RECOVERY] Attempt count decayed (${state.attemptCount} -> 0) after ${Math.round((now - state.lastFailureAt) / constants_1.TIMING.MILLISECONDS_PER_SECOND)}s idle`, 'info');
             state.attemptCount = 0;
             state.lastFailureAt = 0;
         }
@@ -689,9 +724,9 @@ class Accountant {
                             mgr.logger?.log?.(`[RECOVERY] Structural grid resync not scheduled: ${scheduleResult.reason || 'request skipped'}`, 'warn');
                         }
                     })
-                        .catch(err => {
+                        .catch((err) => {
                         state.structuralResyncRequested = false;
-                        mgr.logger?.log?.(`[RECOVERY] Structural grid resync scheduling failed: ${err.message}`, 'error');
+                        mgr.logger?.log?.(`[RECOVERY] Structural grid resync scheduling failed: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
                     });
                 }
                 else {
@@ -703,7 +738,7 @@ class Accountant {
         }
         catch (err) {
             state.lastFailureAt = Date.now();
-            mgr.logger?.log?.(`[RECOVERY] State recovery error: ${err.message}`, 'error');
+            mgr.logger?.log?.(`[RECOVERY] State recovery error: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
             return false;
         }
         finally {
@@ -741,7 +776,7 @@ class Accountant {
      */
     async tryDeductFromChainFree(orderType, size, operation = 'move') {
         const mgr = this.manager;
-        const isBuy = orderType === ORDER_TYPES.BUY;
+        const isBuy = orderType === constants_1.ORDER_TYPES.BUY;
         const key = isBuy ? 'buyFree' : 'sellFree';
         if (!mgr.accountTotals || mgr.accountTotals[key] === undefined) {
             return { ok: false, reason: 'undefined' };
@@ -779,7 +814,7 @@ class Accountant {
      */
     async addToChainFree(orderType, size, operation = 'release') {
         const mgr = this.manager;
-        const isBuy = orderType === ORDER_TYPES.BUY;
+        const isBuy = orderType === constants_1.ORDER_TYPES.BUY;
         const key = isBuy ? 'buyFree' : 'sellFree';
         if (!mgr.accountTotals || mgr.accountTotals[key] === undefined)
             return false;
@@ -800,21 +835,20 @@ class Accountant {
      * @param {string} [context='fill'] - Label for logging
      * @returns {Promise<void>}
      */
-    async recordFillBalances(paysAsset, paysAmount, receivesAsset, receivesAmount, context = 'fill') {
+    async recordFillBalances(paysAsset, paysAmount, _receivesAsset, receivesAmount, context = 'fill') {
         return await this.manager._fundLock.acquire(async () => {
             const mgr = this.manager;
             const assetA = mgr.config.assetA;
-            const assetB = mgr.config.assetB;
             // Determine orientation
             if (paysAsset === assetA) {
                 // Bot paid assetA (Selling assetA, buying assetB)
-                this.adjustTotalBalance(ORDER_TYPES.SELL, -paysAmount, `${context}-pays`);
-                this.adjustTotalBalance(ORDER_TYPES.BUY, receivesAmount, `${context}-receives`);
+                this.adjustTotalBalance(constants_1.ORDER_TYPES.SELL, -paysAmount, `${context}-pays`);
+                this.adjustTotalBalance(constants_1.ORDER_TYPES.BUY, receivesAmount, `${context}-receives`);
             }
             else {
                 // Bot paid assetB (Buying assetA, selling assetB)
-                this.adjustTotalBalance(ORDER_TYPES.BUY, -paysAmount, `${context}-pays`);
-                this.adjustTotalBalance(ORDER_TYPES.SELL, receivesAmount, `${context}-receives`);
+                this.adjustTotalBalance(constants_1.ORDER_TYPES.BUY, -paysAmount, `${context}-pays`);
+                this.adjustTotalBalance(constants_1.ORDER_TYPES.SELL, receivesAmount, `${context}-receives`);
             }
         });
     }
@@ -826,7 +860,7 @@ class Accountant {
      */
     adjustTotalBalance(orderType, delta, operation) {
         const mgr = this.manager;
-        const isBuy = (orderType === ORDER_TYPES.BUY);
+        const isBuy = (orderType === constants_1.ORDER_TYPES.BUY);
         const freeKey = isBuy ? 'buyFree' : 'sellFree';
         const totalKey = isBuy ? 'buy' : 'sell';
         if (!mgr.accountTotals)
@@ -850,10 +884,10 @@ class Accountant {
      * @returns {string|null} Normalized side or null if unrecognised
      */
     _normalizeSideHint(sideHint) {
-        if (sideHint === ORDER_TYPES.BUY || sideHint === 'buy')
-            return ORDER_TYPES.BUY;
-        if (sideHint === ORDER_TYPES.SELL || sideHint === 'sell')
-            return ORDER_TYPES.SELL;
+        if (sideHint === constants_1.ORDER_TYPES.BUY || sideHint === 'buy')
+            return constants_1.ORDER_TYPES.BUY;
+        if (sideHint === constants_1.ORDER_TYPES.SELL || sideHint === 'sell')
+            return constants_1.ORDER_TYPES.SELL;
         return null;
     }
     /**
@@ -907,8 +941,8 @@ class Accountant {
             newOrder = { ...newOrder };
         }
         if (!skipAssetAccounting) {
-            const oldIsActive = (oldOrder.state === ORDER_STATES.ACTIVE || oldOrder.state === ORDER_STATES.PARTIAL);
-            const newIsActive = (newOrder.state === ORDER_STATES.ACTIVE || newOrder.state === ORDER_STATES.PARTIAL);
+            const oldIsActive = (oldOrder.state === constants_1.ORDER_STATES.ACTIVE || oldOrder.state === constants_1.ORDER_STATES.PARTIAL);
+            const newIsActive = (newOrder.state === constants_1.ORDER_STATES.ACTIVE || newOrder.state === constants_1.ORDER_STATES.PARTIAL);
             const oldSize = toFiniteNumber(oldOrder.size);
             const newSize = toFiniteNumber(newOrder.size);
             // 1. Handle Capital Commitment (Moves between FREE and LOCKED)
@@ -922,8 +956,8 @@ class Accountant {
             if (mgr.logger && mgr.logger.level === 'debug') {
                 mgr.logger.log(`[ACCOUNTING] updateOptimisticFreeBalance: id=${newOrder.id}, type=${newOrder.type}, ` +
                     `state=${oldOrder.state}->${newOrder.state}, ` +
-                    `size=${Format.formatSizeByOrderType(oldSize, sideForPrecision, mgr.assets)}->${Format.formatSizeByOrderType(newSize, sideForPrecision, mgr.assets)}, ` +
-                    `delta=${Format.formatSizeByOrderType(commitmentDelta, sideForPrecision, mgr.assets)}, context=${context}`, 'debug');
+                    `size=${Format.formatSizeByOrderType(oldSize, sideForPrecision ?? '', mgr.assets)}->${Format.formatSizeByOrderType(newSize, sideForPrecision ?? '', mgr.assets)}, ` +
+                    `delta=${Format.formatSizeByOrderType(commitmentDelta, sideForPrecision ?? '', mgr.assets)}, context=${context}`, 'debug');
             }
             if (commitmentDelta > 0) {
                 // Lock capital: move from Free to Committed
@@ -958,8 +992,8 @@ class Accountant {
                     // attempting new deductions, reducing redundant recovery cycles.
                     if (!mgr._pendingRecovery) {
                         mgr._pendingRecovery = this._attemptFundRecovery(mgr, 'Optimistic commitment deduction failure')
-                            .catch(err => {
-                            mgr.logger?.log?.(`[RECOVERY] Immediate recovery scheduling failed: ${err.message}`, 'error');
+                            .catch((err) => {
+                            mgr.logger?.log?.(`[RECOVERY] Immediate recovery scheduling failed: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
                             mgr._recoveryState = { ...mgr._recoveryState, lastFailureAt: Date.now() };
                         })
                             .finally(() => {
@@ -1015,7 +1049,7 @@ class Accountant {
         if (!side)
             return;
         const fees = mgr.funds.btsFeesOwed;
-        const orderType = (side === 'buy') ? ORDER_TYPES.BUY : ORDER_TYPES.SELL;
+        const orderType = (side === 'buy') ? constants_1.ORDER_TYPES.BUY : constants_1.ORDER_TYPES.SELL;
         const freeKey = (side === 'buy') ? 'buyFree' : 'sellFree';
         const chainFree = mgr.accountTotals[freeKey] || 0;
         // SUFFICIENCY CHECK: Defer if insufficient funds
@@ -1054,11 +1088,11 @@ class Accountant {
             const size = toFiniteNumber(order.size);
             if (size <= 0)
                 continue;
-            if (order.type === ORDER_TYPES.BUY) {
+            if (order.type === constants_1.ORDER_TYPES.BUY) {
                 // Buy order uses Asset B (Quote)
                 requiredBuy += size;
             }
-            else if (order.type === ORDER_TYPES.SELL) {
+            else if (order.type === constants_1.ORDER_TYPES.SELL) {
                 // Sell order uses Asset A (Base)
                 requiredSell += size;
             }
@@ -1082,8 +1116,8 @@ class Accountant {
         if (mgr.assets?.assetB?.precision === undefined || mgr.assets?.assetA?.precision === undefined) {
             throw new Error(`CRITICAL: Asset precision unavailable for slack calculation`);
         }
-        const slackBuy = getPrecisionSlack(mgr.assets?.assetB?.precision);
-        const slackSell = getPrecisionSlack(mgr.assets?.assetA?.precision);
+        const slackBuy = (0, math_1.getPrecisionSlack)(mgr.assets?.assetB?.precision);
+        const slackSell = (0, math_1.getPrecisionSlack)(mgr.assets?.assetA?.precision);
         const buyShortfall = Math.max(0, requiredBuy - (totalBuy + slackBuy));
         const sellShortfall = Math.max(0, requiredSell - (totalSell + slackSell));
         const isValid = buyShortfall === 0 && sellShortfall === 0;
@@ -1117,15 +1151,15 @@ class Accountant {
         // For other assets: apply normal fee calculation (market fee %)
         // Fail-safe: if fee cache is missing/stale, do not crash fill processing.
         try {
-            const feeInfo = getAssetFees(assetSymbol, rawAmount, isMaker);
-            const netProceeds = toFiniteNumber(feeInfo?.netProceeds, null);
+            const feeInfo = (0, math_1.getAssetFees)(assetSymbol, rawAmount, isMaker);
+            const netProceeds = toFiniteNumber(feeInfo?.netProceeds, undefined);
             if (netProceeds === null) {
                 throw new Error('netProceeds is not finite');
             }
             return netProceeds;
         }
         catch (err) {
-            this.manager?.logger?.log?.(`[FILL-FEE] CRITICAL: Failed to compute fees for ${assetSymbol}: ${err.message}. Using raw proceeds (${Format.formatAmount8(rawAmount)}) — fund tracking will over-credit by un-deducted fee.`, 'error');
+            this.manager?.logger?.log?.(`[FILL-FEE] CRITICAL: Failed to compute fees for ${assetSymbol}: ${(0, errors_1.getErrorMessage)(err)}. Using raw proceeds (${Format.formatAmount8(rawAmount)}) — fund tracking will over-credit by un-deducted fee.`, 'error');
             return rawAmount;
         }
     }
@@ -1143,7 +1177,7 @@ class Accountant {
         // Persistence is durable by default. Callers that process many fills under
         // the fill lock can opt into deferred persistence and close the window with
         // one explicit batch flush before leaving the processing cycle.
-        const persistenceMode = resolveProcessedFillPersistenceMode(options);
+        const persistenceMode = (0, processed_fill_store_1.resolveProcessedFillPersistenceMode)(options);
         const pays = fillOp?.pays;
         const receives = fillOp?.receives;
         if (!pays || !receives)
@@ -1169,22 +1203,22 @@ class Accountant {
         const assetASymbol = mgr.config?.assetA;
         const assetBSymbol = mgr.config?.assetB;
         if (pays.asset_id === assetAId) {
-            const amount = blockchainToFloat(pays.amount, assetAPrecision, true);
-            balanceAdjustments.push({ orderType: ORDER_TYPES.SELL, delta: -amount, operation: 'fill-pays' });
+            const amount = (0, math_1.blockchainToFloat)(pays.amount, assetAPrecision);
+            balanceAdjustments.push({ orderType: constants_1.ORDER_TYPES.SELL, delta: -amount, operation: 'fill-pays' });
         }
         else if (pays.asset_id === assetBId) {
-            const amount = blockchainToFloat(pays.amount, assetBPrecision, true);
-            balanceAdjustments.push({ orderType: ORDER_TYPES.BUY, delta: -amount, operation: 'fill-pays' });
+            const amount = (0, math_1.blockchainToFloat)(pays.amount, assetBPrecision);
+            balanceAdjustments.push({ orderType: constants_1.ORDER_TYPES.BUY, delta: -amount, operation: 'fill-pays' });
         }
         if (receives.asset_id === assetAId) {
-            const rawAmount = blockchainToFloat(receives.amount, assetAPrecision, true);
+            const rawAmount = (0, math_1.blockchainToFloat)(receives.amount, assetAPrecision);
             const netAmount = this._deductFeesFromProceeds(assetASymbol, rawAmount, isMaker);
-            balanceAdjustments.push({ orderType: ORDER_TYPES.SELL, delta: netAmount, operation: 'fill-receives' });
+            balanceAdjustments.push({ orderType: constants_1.ORDER_TYPES.SELL, delta: netAmount, operation: 'fill-receives' });
         }
         else if (receives.asset_id === assetBId) {
-            const rawAmount = blockchainToFloat(receives.amount, assetBPrecision, true);
+            const rawAmount = (0, math_1.blockchainToFloat)(receives.amount, assetBPrecision);
             const netAmount = this._deductFeesFromProceeds(assetBSymbol, rawAmount, isMaker);
-            balanceAdjustments.push({ orderType: ORDER_TYPES.BUY, delta: netAmount, operation: 'fill-receives' });
+            balanceAdjustments.push({ orderType: constants_1.ORDER_TYPES.BUY, delta: netAmount, operation: 'fill-receives' });
         }
         const btsRefundAdjustment = this._buildBtsDeferredRefundAdjustment(fillOp.order_id, isMaker);
         if (btsRefundAdjustment) {
@@ -1195,7 +1229,7 @@ class Accountant {
         if (fillKey) {
             processedAt = Date.now();
             const lastProcessed = tracker.get(fillKey);
-            if (lastProcessed !== undefined && (processedAt - lastProcessed) < TIMING.FILL_RECORD_RETENTION_MS) {
+            if (lastProcessed !== undefined && (processedAt - lastProcessed) < constants_1.TIMING.FILL_RECORD_RETENTION_MS) {
                 this.manager?.logger?.log(`[FILL-DEDUP] Skipping duplicate credit for fill ${fillKey} (processed ${processedAt - lastProcessed}ms ago)`, 'warn');
                 return false;
             }
@@ -1209,12 +1243,12 @@ class Accountant {
                 await processedFillStore.persist(fillKey, processedAt || Date.now(), { mode: persistenceMode });
             }
             catch (err) {
-                if (persistenceMode === PROCESSED_FILL_PERSISTENCE_MODES.IMMEDIATE) {
+                if (persistenceMode === processed_fill_store_1.PROCESSED_FILL_PERSISTENCE_MODES.IMMEDIATE) {
                     // Clean up any pending write that the flush error handler re-queued.
                     processedFillStore.discard(fillKey, processedAt || Date.now());
                     throw err;
                 }
-                mgr.logger?.log?.(`[FILL-DEDUP] Failed to persist fill ${fillKey}: ${err.message}`, 'warn');
+                mgr.logger?.log?.(`[FILL-DEDUP] Failed to persist fill ${fillKey}: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
             }
         }
         this._applyBalanceAdjustments(balanceAdjustments);
@@ -1222,7 +1256,7 @@ class Accountant {
             tracker.set(fillKey, processedAt || Date.now());
             // Prune entries beyond the retention horizon to prevent unbounded growth.
             if (tracker.size > 500) {
-                const cutoff = (processedAt || Date.now()) - TIMING.FILL_RECORD_RETENTION_MS;
+                const cutoff = (processedAt || Date.now()) - constants_1.TIMING.FILL_RECORD_RETENTION_MS;
                 for (const [k, ts] of tracker) {
                     if (ts < cutoff)
                         tracker.delete(k);
@@ -1232,5 +1266,6 @@ class Accountant {
         return true;
     }
 }
+exports.default = Accountant;
 module.exports = Accountant;
 //# sourceMappingURL=accounting.js.map