dexbot 1.4.11 → 1.4.13

package/dist/modules/order/accounting.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * modules/order/accounting.ts - Accountant Engine
  *
@@ -75,51 +74,24 @@
  *
  * ===============================================================================
  */
-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 order_1 = require("./utils/order");
-const Format = __importStar(require("./format"));
-const fundRegistry = __importStar(require("../fund_registry"));
-const chainOrders = __importStar(require("../chain_orders"));
-const chain_orders_1 = require("../chain_orders");
-const math_1 = require("./utils/math");
-const processed_fill_store_1 = require("./processed_fill_store");
-const errors_1 = require("../utils/errors");
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+import { ORDER_TYPES, ORDER_STATES, PIPELINE_TIMING, TIMING, FEE_PARAMETERS } from '../constants.js';
+import { resolveAccountRef } from './utils/system.js';
+import { resolveSpreadOrderSide, parseSlotIndex } from './utils/order.js';
+import * as Format from './format.js';
+import * as fundRegistry from '../fund_registry.js';
+import * as chainOrders from '../chain_orders.js';
+import { readOpenOrdersGuarded } from '../chain_orders.js';
+import { calculateAvailableFundsValue, getAssetFees, blockchainToFloat, getPrecisionSlack, getBtsSide, countGapBandSpread } from './utils/math.js';
+import { PROCESSED_FILL_PERSISTENCE_MODES, resolveProcessedFillPersistenceMode } from './processed_fill_store.js';
+import { getErrorMessage } from '../utils/errors.js';
 const { toFiniteNumber } = Format;
+// Warn once per asset instead of once per fill/operation when the fee cache is
+// missing, so a cold/absent fee cache does not flood the logs while the bot
+// keeps running on fallback fees.
+const warnedBtsFeeScheduleFallback = new Set();
+const warnedFillFeeSymbols = new Set();
 /**
  * Accountant engine - Specialized handler for fund tracking and calculations
  * @class Accountant
@@ -144,7 +116,7 @@ class Accountant {
         this._pendingInvariantSnapshot = null; // Coalesces latest request while one is running
         this._logThrottleState = new Map();
     }
-    _logThrottled(key, message, level = 'warn', intervalMs = constants_1.TIMING.LOG_THROTTLE_INTERVAL_MS) {
+    _logThrottled(key, message, level = 'warn', intervalMs = TIMING.LOG_THROTTLE_INTERVAL_MS) {
         const now = Date.now();
         let state = this._logThrottleState.get(key);
         if (!state || (now - state.lastAt) >= intervalMs) {
@@ -169,7 +141,7 @@ class Accountant {
         }
     }
     _getBtsOrderType() {
-        return (0, math_1.getBtsSide)(this.manager.config?.assetA, this.manager.config?.assetB);
+        return getBtsSide(this.manager.config?.assetA, this.manager.config?.assetB);
     }
     _normalizeBtsFeeState(order) {
         const deferredFee = toFiniteNumber(order?.btsFeeState?.deferredFee, 0);
@@ -179,21 +151,24 @@ class Accountant {
     }
     _getBtsFeeSchedule() {
         try {
-            const fees = (0, math_1.getAssetFees)('BTS');
+            const fees = 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 ?? constants_1.FEE_PARAMETERS.MAKER_REFUND_PERCENT))
+                makerFeeDiscountPercent: Math.max(0, toFiniteNumber(fees?.makerFeeDiscountPercent, this.manager?.config?.feeParams?.MAKER_REFUND_PERCENT ?? FEE_PARAMETERS.MAKER_REFUND_PERCENT))
             };
         }
         catch (err) {
-            this.manager?.logger?.log?.(`[FEE] Failed to load BTS fee schedule: ${err?.message || err}; using fallback defaults`, 'warn');
+            if (!warnedBtsFeeScheduleFallback.has('BTS')) {
+                warnedBtsFeeScheduleFallback.add('BTS');
+                this.manager?.logger?.log?.(`[FEE] Failed to load BTS fee schedule: ${err?.message || err}; using fallback defaults`, 'warn');
+            }
             return {
                 createFee: 0,
                 updateFee: 0,
                 cancelFee: 0,
-                makerFeeDiscountPercent: this.manager?.config?.feeParams?.MAKER_REFUND_PERCENT ?? constants_1.FEE_PARAMETERS.MAKER_REFUND_PERCENT
+                makerFeeDiscountPercent: this.manager?.config?.feeParams?.MAKER_REFUND_PERCENT ?? FEE_PARAMETERS.MAKER_REFUND_PERCENT
             };
         }
     }
@@ -215,8 +190,8 @@ class Accountant {
     }
     _resolveBtsFeeLifecycle(oldOrder, newOrder, context, explicitFee) {
         const fee = Math.max(0, toFiniteNumber(explicitFee, 0));
-        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 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 oldDeferred = this._normalizeBtsFeeState(oldOrder).deferredFee;
         const sameChainOrder = oldActive && newActive && oldOrder.orderId === newOrder.orderId;
         const feeSchedule = this._getBtsFeeSchedule();
@@ -370,11 +345,11 @@ class Accountant {
         // SPREAD-type count would include every empty slot on both rails.
         // countGapBandSpread requires both SPREAD type and band geometry —
         // matching initialSpreadCount (gapSlots) set at grid load/creation.
-        mgr.currentSpreadCount = (0, math_1.countGapBandSpread)(mgr, orderSnapshot, (o) => (0, order_1.parseSlotIndex)(o.id));
+        mgr.currentSpreadCount = countGapBandSpread(mgr, orderSnapshot, (o) => parseSlotIndex(o.id));
         // STEP 1-4: Iterate all orders, classify, and aggregate by state
         for (const order of orderSnapshot) {
-            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 isActive = (order.state === ORDER_STATES.ACTIVE || order.state === ORDER_STATES.PARTIAL) && !!order.orderId;
+            const isVirtual = (order.state === ORDER_STATES.VIRTUAL);
             const size = toFiniteNumber(order.size);
             if (size <= 0)
                 continue;
@@ -383,8 +358,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 === constants_1.ORDER_TYPES.BUY || (order.type === constants_1.ORDER_TYPES.SPREAD && (0, order_1.resolveSpreadOrderSide)(order.price, mgr.config.startPrice) === constants_1.ORDER_TYPES.BUY);
-            const isSell = order.type === constants_1.ORDER_TYPES.SELL || (order.type === constants_1.ORDER_TYPES.SPREAD && (0, order_1.resolveSpreadOrderSide)(order.price, mgr.config.startPrice) === constants_1.ORDER_TYPES.SELL);
+            const isBuy = order.type === ORDER_TYPES.BUY || (order.type === ORDER_TYPES.SPREAD && resolveSpreadOrderSide(order.price, mgr.config.startPrice) === ORDER_TYPES.BUY);
+            const isSell = order.type === ORDER_TYPES.SELL || (order.type === ORDER_TYPES.SPREAD && resolveSpreadOrderSide(order.price, mgr.config.startPrice) === ORDER_TYPES.SELL);
             if (isBuy) {
                 if (isActive) {
                     gridBuy += size;
@@ -417,8 +392,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 = (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);
+        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);
         // Ensure percentage-based allocations are applied to the newly calculated totals
         if (typeof mgr.applyBotFundsAllocation === 'function') {
             mgr.applyBotFundsAllocation();
@@ -437,7 +412,7 @@ class Accountant {
                 this._isVerifyingInvariants = true;
                 this._verifyFundInvariants(mgr, nextSnapshot.chainFreeBuy, nextSnapshot.chainFreeSell, nextSnapshot.chainBuy, nextSnapshot.chainSell, nextSnapshot.actualBuy, nextSnapshot.actualSell)
                     .catch((err) => {
-                    mgr.logger?.log?.(`[RECOVERY] Verification error: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+                    mgr.logger?.log?.(`[RECOVERY] Verification error: ${getErrorMessage(err)}`, 'error');
                 })
                     .finally(() => {
                     this._isVerifyingInvariants = false;
@@ -493,8 +468,8 @@ class Accountant {
         if (!Number.isFinite(buyPrecision) || !Number.isFinite(sellPrecision)) {
             return; // Skip invariant check if precision not available
         }
-        const precisionSlackBuy = (0, math_1.getPrecisionSlack)(buyPrecision);
-        const precisionSlackSell = (0, math_1.getPrecisionSlack)(sellPrecision);
+        const precisionSlackBuy = getPrecisionSlack(buyPrecision);
+        const precisionSlackSell = 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
@@ -573,7 +548,7 @@ class Accountant {
                 }
             }
             catch (_err) {
-                mgr.logger?.log?.(`[INVARIANT] Cross-bot registry check skipped: ${(0, errors_1.getErrorMessage)(_err)}`, 'warn');
+                mgr.logger?.log?.(`[INVARIANT] Cross-bot registry check skipped: ${getErrorMessage(_err)}`, 'warn');
             }
         }
         // NEW: Attempt immediate recovery if violation detected
@@ -583,13 +558,13 @@ class Accountant {
                     await this._attemptFundRecovery(mgr, 'Fund invariant violation');
                 }
                 catch (err) {
-                    mgr.logger?.log?.(`[RECOVERY] Deferred recovery failed: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+                    mgr.logger?.log?.(`[RECOVERY] Deferred recovery failed: ${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: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+                    mgr.logger?.log?.(`[RECOVERY] Deferred recovery scheduling failed: ${getErrorMessage(err)}`, 'error');
                 });
             }
             else {
@@ -605,7 +580,7 @@ class Accountant {
      * @returns {Promise<Object>} - Validation result from validateGridStateForPersistence()
      */
     async _performStateRecovery(mgr) {
-        const accountRef = (0, system_1.resolveAccountRef)(mgr, '');
+        const accountRef = resolveAccountRef(mgr, '');
         if (!accountRef) {
             return {
                 isValid: false,
@@ -625,7 +600,7 @@ class Accountant {
         // ACTIVE/PARTIAL slots that are live on chain, after which the next
         // cycle re-creates them as duplicates. Skip the sync and defer to the
         // next reconcile cycle, mirroring the other recovery-read guards.
-        const openOrders = await (0, chain_orders_1.readOpenOrdersGuarded)(chainOrders, accountRef, {
+        const openOrders = await readOpenOrdersGuarded(chainOrders, accountRef, {
             log: (message, level) => mgr.logger?.log?.(message, level),
             label: 'RECOVERY',
             detail: 'during state recovery',
@@ -689,7 +664,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 || constants_1.PIPELINE_TIMING;
+        const pt = mgr.config?.pipelineTiming || PIPELINE_TIMING;
         const state = mgr._recoveryState;
         const now = Date.now();
         const retryIntervalMs = Math.max(0, Number(pt.RECOVERY_RETRY_INTERVAL_MS));
@@ -702,12 +677,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 ?? constants_1.PIPELINE_TIMING.RECOVERY_DECAY_FALLBACK_MS);
+        const decayMs = retryIntervalMs > 0 ? retryIntervalMs * 3 : (pt.RECOVERY_DECAY_FALLBACK_MS ?? 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) / constants_1.TIMING.MILLISECONDS_PER_SECOND)}s idle`, 'info');
+            mgr.logger?.log?.(`[RECOVERY] Attempt count decayed (${state.attemptCount} -> 0) after ${Math.round((now - state.lastFailureAt) / TIMING.MILLISECONDS_PER_SECOND)}s idle`, 'info');
             state.attemptCount = 0;
             state.lastFailureAt = 0;
         }
@@ -785,7 +760,7 @@ class Accountant {
                     })
                         .catch((err) => {
                         state.structuralResyncRequested = false;
-                        mgr.logger?.log?.(`[RECOVERY] Structural grid resync scheduling failed: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+                        mgr.logger?.log?.(`[RECOVERY] Structural grid resync scheduling failed: ${getErrorMessage(err)}`, 'error');
                     });
                 }
                 else {
@@ -797,7 +772,7 @@ class Accountant {
         }
         catch (err) {
             state.lastFailureAt = Date.now();
-            mgr.logger?.log?.(`[RECOVERY] State recovery error: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+            mgr.logger?.log?.(`[RECOVERY] State recovery error: ${getErrorMessage(err)}`, 'error');
             return false;
         }
         finally {
@@ -835,7 +810,7 @@ class Accountant {
      */
     async tryDeductFromChainFree(orderType, size, operation = 'move') {
         const mgr = this.manager;
-        const isBuy = orderType === constants_1.ORDER_TYPES.BUY;
+        const isBuy = orderType === ORDER_TYPES.BUY;
         const key = isBuy ? 'buyFree' : 'sellFree';
         if (!mgr.accountTotals || mgr.accountTotals[key] === undefined) {
             return { ok: false, reason: 'undefined' };
@@ -873,7 +848,7 @@ class Accountant {
      */
     async addToChainFree(orderType, size, operation = 'release') {
         const mgr = this.manager;
-        const isBuy = orderType === constants_1.ORDER_TYPES.BUY;
+        const isBuy = orderType === ORDER_TYPES.BUY;
         const key = isBuy ? 'buyFree' : 'sellFree';
         if (!mgr.accountTotals || mgr.accountTotals[key] === undefined)
             return false;
@@ -901,13 +876,13 @@ class Accountant {
             // Determine orientation
             if (paysAsset === assetA) {
                 // Bot paid assetA (Selling assetA, buying assetB)
-                this._adjustTotalBalanceLocked(constants_1.ORDER_TYPES.SELL, -paysAmount, `${context}-pays`);
-                this._adjustTotalBalanceLocked(constants_1.ORDER_TYPES.BUY, receivesAmount, `${context}-receives`);
+                this._adjustTotalBalanceLocked(ORDER_TYPES.SELL, -paysAmount, `${context}-pays`);
+                this._adjustTotalBalanceLocked(ORDER_TYPES.BUY, receivesAmount, `${context}-receives`);
             }
             else {
                 // Bot paid assetB (Buying assetA, selling assetB)
-                this._adjustTotalBalanceLocked(constants_1.ORDER_TYPES.BUY, -paysAmount, `${context}-pays`);
-                this._adjustTotalBalanceLocked(constants_1.ORDER_TYPES.SELL, receivesAmount, `${context}-receives`);
+                this._adjustTotalBalanceLocked(ORDER_TYPES.BUY, -paysAmount, `${context}-pays`);
+                this._adjustTotalBalanceLocked(ORDER_TYPES.SELL, receivesAmount, `${context}-receives`);
             }
         });
     }
@@ -918,7 +893,7 @@ class Accountant {
      */
     _adjustTotalBalanceLocked(orderType, delta, operation) {
         const mgr = this.manager;
-        const isBuy = (orderType === constants_1.ORDER_TYPES.BUY);
+        const isBuy = (orderType === ORDER_TYPES.BUY);
         const freeKey = isBuy ? 'buyFree' : 'sellFree';
         const totalKey = isBuy ? 'buy' : 'sell';
         if (!mgr.accountTotals)
@@ -952,10 +927,10 @@ class Accountant {
      * @returns {string|null} Normalized side or null if unrecognised
      */
     _normalizeSideHint(sideHint) {
-        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;
+        if (sideHint === ORDER_TYPES.BUY || sideHint === 'buy')
+            return ORDER_TYPES.BUY;
+        if (sideHint === ORDER_TYPES.SELL || sideHint === 'sell')
+            return ORDER_TYPES.SELL;
         return null;
     }
     /**
@@ -1011,8 +986,8 @@ class Accountant {
         // of deferring. Only the plain mutation runs under the lock.
         let preLockRefreshFailed = false;
         if (!skipAssetAccounting) {
-            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 oldIsActive = (oldOrder.state === ORDER_STATES.ACTIVE || oldOrder.state === ORDER_STATES.PARTIAL);
+            const newIsActive = (newOrder.state === ORDER_STATES.ACTIVE || newOrder.state === ORDER_STATES.PARTIAL);
             const willLock = (newIsActive ? toFiniteNumber(newOrder.size) : 0) - (oldIsActive ? toFiniteNumber(oldOrder.size) : 0) > 0;
             if (willLock) {
                 try {
@@ -1021,7 +996,7 @@ class Accountant {
                 }
                 catch (err) {
                     preLockRefreshFailed = true;
-                    mgr.logger?.log?.(`[ACCOUNTING] pre-lock accountTotals refresh error: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
+                    mgr.logger?.log?.(`[ACCOUNTING] pre-lock accountTotals refresh error: ${getErrorMessage(err)}`, 'warn');
                 }
             }
         }
@@ -1032,8 +1007,8 @@ class Accountant {
                 newOrder = { ...newOrder };
             }
             if (!skipAssetAccounting) {
-                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 oldIsActive = (oldOrder.state === ORDER_STATES.ACTIVE || oldOrder.state === ORDER_STATES.PARTIAL);
+                const newIsActive = (newOrder.state === ORDER_STATES.ACTIVE || newOrder.state === ORDER_STATES.PARTIAL);
                 const oldSize = toFiniteNumber(oldOrder.size);
                 const newSize = toFiniteNumber(newOrder.size);
                 // 1. Handle Capital Commitment (Moves between FREE and LOCKED)
@@ -1069,7 +1044,7 @@ class Accountant {
                         if (refresh.ok) {
                             result = await this.tryDeductFromChainFree(commitmentSide, commitmentDelta, `${context} (post-refresh retry)`);
                         }
-                        else {
+                        else if (mgr._rateLimitStaleTotalsWarn?.('refresh-failed') !== false) {
                             mgr.logger?.log?.(`[ACCOUNTING] accountTotals refresh failed (${refresh.reason}); cannot retry optimistic lock of ${Format.formatAmount8(commitmentDelta)} for ${commitmentSide}.`, 'warn');
                         }
                     }
@@ -1078,7 +1053,9 @@ class Accountant {
                         // refuse to re-run the blocking RPC under _fundLock. Fall
                         // through to the stale failure/recovery path below; the batch
                         // stays accounted for and recovery is scheduled.
-                        mgr.logger?.log?.(`[ACCOUNTING] Stale accountTotals during ${context}; pre-lock refresh failed, skipping in-lock refresh to avoid holding _fundLock across a blocking chain RPC.`, 'warn');
+                        if (mgr._rateLimitStaleTotalsWarn?.('pre-lock-refresh-failed') !== false) {
+                            mgr.logger?.log?.(`[ACCOUNTING] Stale accountTotals during ${context}; pre-lock refresh failed, skipping in-lock refresh to avoid holding _fundLock across a blocking chain RPC.`, 'warn');
+                        }
                     }
                     if (!result.ok) {
                         const failure = {
@@ -1091,7 +1068,9 @@ class Accountant {
                         };
                         mgr._lastAccountingFailure = failure;
                         if (result.reason === 'stale') {
-                            mgr.logger?.log?.(`[ACCOUNTING] Stale accountTotals: skipping optimistic lock of ${Format.formatAmount8(commitmentDelta)} for ${commitmentSide} during ${context}. Recovery scheduled.`, 'warn');
+                            if (mgr._rateLimitStaleTotalsWarn?.('skip-optimistic-lock') !== false) {
+                                mgr.logger?.log?.(`[ACCOUNTING] Stale accountTotals: skipping optimistic lock of ${Format.formatAmount8(commitmentDelta)} for ${commitmentSide} during ${context}. Recovery scheduled.`, 'warn');
+                            }
                             // Schedule recovery but DON'T throw — staleness is transient.
                             // The batch already confirmed on-chain; aborting the commit
                             // would orphan a successful broadcast from the grid state.
@@ -1110,7 +1089,7 @@ class Accountant {
                         if (!mgr._pendingRecovery) {
                             mgr._pendingRecovery = this._attemptFundRecovery(mgr, 'Optimistic commitment deduction failure')
                                 .catch((err) => {
-                                mgr.logger?.log?.(`[RECOVERY] Immediate recovery scheduling failed: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+                                mgr.logger?.log?.(`[RECOVERY] Immediate recovery scheduling failed: ${getErrorMessage(err)}`, 'error');
                                 mgr._recoveryState = { ...mgr._recoveryState, lastFailureAt: Date.now() };
                             })
                                 .finally(() => {
@@ -1135,7 +1114,9 @@ class Accountant {
             if (btsOrderType) {
                 const { balanceDelta } = this._resolveBtsFeeLifecycle(oldOrder, newOrder, context, fee);
                 if (Math.abs(balanceDelta) > 0) {
-                    await this.adjustTotalBalance(btsOrderType, balanceDelta, `${context}-fee`);
+                    // Caller already holds _fundLock, so use the locked body directly
+                    // (adjustTotalBalance would re-acquire the re-entrant lock).
+                    this._adjustTotalBalanceLocked(btsOrderType, balanceDelta, `${context}-fee`);
                 }
             }
         });
@@ -1156,7 +1137,7 @@ class Accountant {
         // happen inside _fundLock below so overlapping calls cannot double-deduct)
         if (!mgr.funds || !mgr.accountTotals)
             return;
-        const btsSide = (0, math_1.getBtsSide)(mgr.config?.assetA, mgr.config?.assetB);
+        const btsSide = getBtsSide(mgr.config?.assetA, mgr.config?.assetB);
         const normalizedRequestedSide = (requestedSide === 'buy' || requestedSide === 'sell') ? requestedSide : null;
         let side = btsSide || normalizedRequestedSide;
         if (normalizedRequestedSide && btsSide && normalizedRequestedSide !== btsSide) {
@@ -1173,7 +1154,7 @@ class Accountant {
             const fees = mgr.funds.btsFeesOwed;
             if (!fees || fees <= 0)
                 return;
-            const orderType = (side === 'buy') ? constants_1.ORDER_TYPES.BUY : constants_1.ORDER_TYPES.SELL;
+            const orderType = (side === 'buy') ? ORDER_TYPES.BUY : ORDER_TYPES.SELL;
             const freeKey = (side === 'buy') ? 'buyFree' : 'sellFree';
             const chainFree = mgr.accountTotals[freeKey] || 0;
             // SUFFICIENCY CHECK: Defer if insufficient funds
@@ -1216,18 +1197,18 @@ class Accountant {
             const size = toFiniteNumber(order.size);
             if (size <= 0)
                 continue;
-            if (order.type === constants_1.ORDER_TYPES.BUY) {
+            if (order.type === ORDER_TYPES.BUY) {
                 // Buy order uses Asset B (Quote)
                 requiredBuy += size;
             }
-            else if (order.type === constants_1.ORDER_TYPES.SELL) {
+            else if (order.type === ORDER_TYPES.SELL) {
                 // Sell order uses Asset A (Base)
                 requiredSell += size;
             }
         }
         // 2. Add Estimated BTS Fees (if BTS is one of the pairs)
         // Fees reduce the "Free" balance, so they compete with Order Capital
-        const btsSide = (0, math_1.getBtsSide)(mgr.config?.assetA, mgr.config?.assetB);
+        const btsSide = getBtsSide(mgr.config?.assetA, mgr.config?.assetB);
         if (btsSide && mgr.funds.btsFeesOwed > 0) {
             if (btsSide === 'buy')
                 requiredBuy += mgr.funds.btsFeesOwed;
@@ -1244,8 +1225,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 = (0, math_1.getPrecisionSlack)(mgr.assets?.assetB?.precision);
-        const slackSell = (0, math_1.getPrecisionSlack)(mgr.assets?.assetA?.precision);
+        const slackBuy = getPrecisionSlack(mgr.assets?.assetB?.precision);
+        const slackSell = 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;
@@ -1279,7 +1260,7 @@ 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 = (0, math_1.getAssetFees)(assetSymbol, rawAmount, isMaker);
+            const feeInfo = getAssetFees(assetSymbol, rawAmount, isMaker);
             const netProceeds = toFiniteNumber(feeInfo?.netProceeds, undefined);
             if (netProceeds === null) {
                 throw new Error('netProceeds is not finite');
@@ -1287,7 +1268,10 @@ class Accountant {
             return netProceeds;
         }
         catch (err) {
-            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');
+            if (!warnedFillFeeSymbols.has(assetSymbol)) {
+                warnedFillFeeSymbols.add(assetSymbol);
+                this.manager?.logger?.log?.(`[FILL-FEE] CRITICAL: Failed to compute fees for ${assetSymbol}: ${getErrorMessage(err)}. Using raw proceeds (${Format.formatAmount8(rawAmount)}) — fund tracking will over-credit by un-deducted fee.`, 'error');
+            }
             return rawAmount;
         }
     }
@@ -1305,7 +1289,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 = (0, processed_fill_store_1.resolveProcessedFillPersistenceMode)(options);
+        const persistenceMode = resolveProcessedFillPersistenceMode(options);
         const pays = fillOp?.pays;
         const receives = fillOp?.receives;
         if (!pays || !receives)
@@ -1331,22 +1315,22 @@ class Accountant {
         const assetASymbol = mgr.config?.assetA;
         const assetBSymbol = mgr.config?.assetB;
         if (pays.asset_id === assetAId) {
-            const amount = (0, math_1.blockchainToFloat)(pays.amount, assetAPrecision);
-            balanceAdjustments.push({ orderType: constants_1.ORDER_TYPES.SELL, delta: -amount, operation: 'fill-pays' });
+            const amount = blockchainToFloat(pays.amount, assetAPrecision);
+            balanceAdjustments.push({ orderType: ORDER_TYPES.SELL, delta: -amount, operation: 'fill-pays' });
         }
         else if (pays.asset_id === assetBId) {
-            const amount = (0, math_1.blockchainToFloat)(pays.amount, assetBPrecision);
-            balanceAdjustments.push({ orderType: constants_1.ORDER_TYPES.BUY, delta: -amount, operation: 'fill-pays' });
+            const amount = blockchainToFloat(pays.amount, assetBPrecision);
+            balanceAdjustments.push({ orderType: ORDER_TYPES.BUY, delta: -amount, operation: 'fill-pays' });
         }
         if (receives.asset_id === assetAId) {
-            const rawAmount = (0, math_1.blockchainToFloat)(receives.amount, assetAPrecision);
+            const rawAmount = blockchainToFloat(receives.amount, assetAPrecision);
             const netAmount = this._deductFeesFromProceeds(assetASymbol, rawAmount, isMaker);
-            balanceAdjustments.push({ orderType: constants_1.ORDER_TYPES.SELL, delta: netAmount, operation: 'fill-receives' });
+            balanceAdjustments.push({ orderType: ORDER_TYPES.SELL, delta: netAmount, operation: 'fill-receives' });
         }
         else if (receives.asset_id === assetBId) {
-            const rawAmount = (0, math_1.blockchainToFloat)(receives.amount, assetBPrecision);
+            const rawAmount = blockchainToFloat(receives.amount, assetBPrecision);
             const netAmount = this._deductFeesFromProceeds(assetBSymbol, rawAmount, isMaker);
-            balanceAdjustments.push({ orderType: constants_1.ORDER_TYPES.BUY, delta: netAmount, operation: 'fill-receives' });
+            balanceAdjustments.push({ orderType: ORDER_TYPES.BUY, delta: netAmount, operation: 'fill-receives' });
         }
         const btsRefundAdjustment = this._buildBtsDeferredRefundAdjustment(fillOp.order_id, isMaker);
         if (btsRefundAdjustment) {
@@ -1357,7 +1341,7 @@ class Accountant {
         if (fillKey) {
             processedAt = Date.now();
             const lastProcessed = tracker.get(fillKey);
-            if (lastProcessed !== undefined && (processedAt - lastProcessed) < constants_1.TIMING.FILL_RECORD_RETENTION_MS) {
+            if (lastProcessed !== undefined && (processedAt - lastProcessed) < 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;
             }
@@ -1369,10 +1353,10 @@ class Accountant {
         if (fillKey && processedFillStore) {
             try {
                 // Queue without flush — flush follows after balance adjustments succeed.
-                await processedFillStore.persist(fillKey, processedAt || Date.now(), { mode: processed_fill_store_1.PROCESSED_FILL_PERSISTENCE_MODES.MANUAL });
+                await processedFillStore.persist(fillKey, processedAt || Date.now(), { mode: PROCESSED_FILL_PERSISTENCE_MODES.MANUAL });
             }
             catch (err) {
-                mgr.logger?.log?.(`[FILL-DEDUP] Failed to queue fill ${fillKey}: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
+                mgr.logger?.log?.(`[FILL-DEDUP] Failed to queue fill ${fillKey}: ${getErrorMessage(err)}`, 'warn');
                 return false;
             }
         }
@@ -1382,7 +1366,7 @@ class Accountant {
         // key remains queued for the caller's batch flush.
         if (fillKey && processedFillStore) {
             try {
-                if (persistenceMode === processed_fill_store_1.PROCESSED_FILL_PERSISTENCE_MODES.IMMEDIATE) {
+                if (persistenceMode === PROCESSED_FILL_PERSISTENCE_MODES.IMMEDIATE) {
                     await processedFillStore.flush('fill-persist', { throwOnError: true });
                 }
             }
@@ -1400,7 +1384,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()) - constants_1.TIMING.FILL_RECORD_RETENTION_MS;
+                const cutoff = (processedAt || Date.now()) - TIMING.FILL_RECORD_RETENTION_MS;
                 for (const [k, ts] of tracker) {
                     if (ts < cutoff)
                         tracker.delete(k);
@@ -1410,5 +1394,5 @@ class Accountant {
         return true;
     }
 }
-exports.default = Accountant;
+export default Accountant;
 //# sourceMappingURL=accounting.js.map