dexbot 1.4.11 → 1.4.13

package/dist/modules/dexbot_class.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * modules/dexbot_class.ts - DEXBot Core Engine
  *
@@ -53,60 +52,25 @@
  *
  * ===============================================================================
  */
-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 });
-const client = __importStar(require("./bitshares_client"));
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+import * as client from './bitshares_client.js';
 const { BitShares } = client;
-const chainKeys = __importStar(require("./chain_keys"));
-const chainOrders = __importStar(require("./chain_orders"));
-const fundRegistry = __importStar(require("./fund_registry"));
-const DexbotFillRuntime = __importStar(require("./dexbot_fill_runtime"));
-const dexbot_maintenance_runtime_1 = __importDefault(require("./dexbot_maintenance_runtime"));
-const DexbotStateRecovery = __importStar(require("./dexbot_state_recovery"));
-const DexbotStartupRuntime = __importStar(require("./dexbot_startup_runtime"));
-const credit_runtime_1 = __importDefault(require("./credit_runtime"));
-const paths_1 = require("./paths");
-const Format = __importStar(require("./order/format"));
-const dexbot_cow_runtime_1 = __importDefault(require("./dexbot_cow_runtime"));
-const processed_fill_store_1 = require("./order/processed_fill_store");
-const constants_1 = require("./constants");
-const bot_settings_1 = require("./bot_settings");
-const errors_1 = require("./utils/errors");
+import * as chainKeys from './chain_keys.js';
+import * as chainOrders from './chain_orders.js';
+import * as fundRegistry from './fund_registry.js';
+import * as DexbotFillRuntime from './dexbot_fill_runtime.js';
+import DexbotMaintenanceRuntime from './dexbot_maintenance_runtime.js';
+import * as DexbotStateRecovery from './dexbot_state_recovery.js';
+import * as DexbotStartupRuntime from './dexbot_startup_runtime.js';
+import CreditRuntime from './credit_runtime.js';
+import { PATHS } from './paths.js';
+import * as Format from './order/format.js';
+import cowRuntime from './dexbot_cow_runtime.js';
+import { ProcessedFillStore, PROCESSED_FILL_PERSISTENCE_MODES } from './order/processed_fill_store.js';
+import { TIMING, FILL_PROCESSING, DAEMON_CODES, } from './constants.js';
+import { normalizeBotEntry } from './bot_settings.js';
+import { getErrorMessage } from './utils/errors.js';
 function waitForConnected(...args) { return require('./bitshares_client').waitForConnected(...args); }
 function getKeyStore(...args) { return require('./key_store').getKeyStore(...args); }
 function hasExecutableActions(...args) { return require('./order/utils/validate').hasExecutableActions(...args); }
@@ -155,6 +119,7 @@ class DEXBot {
     _creditRuntime;
     _creditWatchdogInterval;
     _batchInFlight;
+    _cowBroadcastInFlight;
     _recoverySyncInFlight;
     _lastTargetedDriftSyncAt;
     _lightweightSyncCheckAt;
@@ -201,9 +166,9 @@ class DEXBot {
         this.config.logging = rs.logging;
         this._fillDedupeWindowMs = this.config.timing.FILL_DEDUPE_WINDOW_MS;
         this._fillRecordRetentionMs = this.config.timing.FILL_RECORD_RETENTION_MS;
-        this._processedFillPersistBatchMs = constants_1.TIMING.PROCESSED_FILL_PERSIST_BATCH_MS;
-        this._processedFillPersistBatchSize = constants_1.TIMING.PROCESSED_FILL_PERSIST_BATCH_SIZE;
-        this._processedFillStore = new processed_fill_store_1.ProcessedFillStore({
+        this._processedFillPersistBatchMs = TIMING.PROCESSED_FILL_PERSIST_BATCH_MS;
+        this._processedFillPersistBatchSize = TIMING.PROCESSED_FILL_PERSIST_BATCH_SIZE;
+        this._processedFillStore = new ProcessedFillStore({
             batchMs: this._processedFillPersistBatchMs,
             batchSize: this._processedFillPersistBatchSize,
             warn: (message) => this._warn(message)
@@ -247,6 +212,12 @@ class DEXBot {
         this._creditWatchdogInterval = null;
         // Pipeline state flags (used by maintenance gating)
         this._batchInFlight = 0;
+        // Single-flight COW broadcast guard: set while a COW batch is actually
+        // broadcasting/committing so no second batch can broadcast concurrently
+        // (two overlapping broadcasts would collide on the base grid version at
+        // commit time, forcing a commit refusal + snapshot reload that can drop
+        // placed orders and produce orphan fills).
+        this._cowBroadcastInFlight = false;
         this._recoverySyncInFlight = 0;
         this._lastTargetedDriftSyncAt = 0;
         this._lightweightSyncCheckAt = 0;
@@ -367,7 +338,7 @@ class DEXBot {
      * @returns {{incomingFillQueueLength: number, shadowLocks: number, batchInFlight: boolean, recoveryInFlight: boolean, broadcasting: boolean}}
      */
     _getPipelineSignals() {
-        return dexbot_maintenance_runtime_1.default.getPipelineSignals(this);
+        return DexbotMaintenanceRuntime.getPipelineSignals(this);
     }
     /**
      * Mark that grid activity occurred (updates idle timer).
@@ -375,7 +346,7 @@ class DEXBot {
      * @returns {void}
      */
     _markGridActivity(reason = 'activity') {
-        return dexbot_maintenance_runtime_1.default.markGridActivity(this, reason);
+        return DexbotMaintenanceRuntime.markGridActivity(this, reason);
     }
     /**
      * Trigger a full state recovery sync (fetch chain + sync from open orders + persist).
@@ -544,7 +515,7 @@ class DEXBot {
     /**
      * Apply replay-safe fill accounting using a provided fill key.
      * @param {Object} fill - Fill event object
-     * @param {import('./types').FillOperationData} fillOp - Fill operation data
+     * @param {import('./types.js').FillOperationData} fillOp - Fill operation data
      * @param {Object} [options={}] - Options
      * @param {string} [options.missingKeyMessage]
      * @param {string} [options.fallbackKeyMessage]
@@ -556,9 +527,9 @@ class DEXBot {
      * @param {string} [options.replayLevel='debug']
      * @param {string} [options.persistenceMode='immediate']
      * @param {boolean} [options.allowOrphanFallbackKey=false]
-     * @returns {Promise<import('./types').ReplaySafeFillResult>}
+     * @returns {Promise<import('./types.js').ReplaySafeFillResult>}
      */
-    async _applyReplaySafeFillAccounting(fill, fillOp, { missingKeyMessage, fallbackKeyMessage, replayMessage, errorMessage, logger = this.manager?.logger, missingKeyLevel = 'warn', fallbackKeyLevel = 'warn', replayLevel = 'debug', persistenceMode = processed_fill_store_1.PROCESSED_FILL_PERSISTENCE_MODES.IMMEDIATE, allowOrphanFallbackKey = false } = {}) {
+    async _applyReplaySafeFillAccounting(fill, fillOp, { missingKeyMessage, fallbackKeyMessage, replayMessage, errorMessage, logger = this.manager?.logger, missingKeyLevel = 'warn', fallbackKeyLevel = 'warn', replayLevel = 'debug', persistenceMode = PROCESSED_FILL_PERSISTENCE_MODES.IMMEDIATE, allowOrphanFallbackKey = false } = {}) {
         return DexbotFillRuntime.applyReplaySafeFillAccounting(this, fill, fillOp, {
             missingKeyMessage,
             fallbackKeyMessage,
@@ -575,15 +546,15 @@ class DEXBot {
     /**
      * Apply replay-safe fill accounting for tracked fills (those with a valid grid order).
      * @param {Object} fill - Fill event object
-     * @param {import('./types').FillOperationData} fillOp - Fill operation data
+     * @param {import('./types.js').FillOperationData} fillOp - Fill operation data
      * @param {Object} [options={}]
      * @param {string} [options.context]
      * @param {Object} [options.logger]
      * @param {string} [options.replayMessage]
      * @param {string} [options.persistenceMode='batched']
-     * @returns {Promise<import('./types').ReplaySafeFillResult>}
+     * @returns {Promise<import('./types.js').ReplaySafeFillResult>}
      */
-    async _applyReplaySafeTrackedFillAccounting(fill, fillOp, { context, logger = this.manager?.logger, replayMessage, persistenceMode = processed_fill_store_1.PROCESSED_FILL_PERSISTENCE_MODES.BATCHED } = {}) {
+    async _applyReplaySafeTrackedFillAccounting(fill, fillOp, { context, logger = this.manager?.logger, replayMessage, persistenceMode = PROCESSED_FILL_PERSISTENCE_MODES.BATCHED } = {}) {
         return DexbotFillRuntime.applyReplaySafeTrackedFillAccounting(this, fill, fillOp, {
             context,
             logger,
@@ -594,15 +565,15 @@ class DEXBot {
     /**
      * Apply replay-safe fill accounting for orphan fills (grid order not found).
      * @param {Object} fill - Fill event object
-     * @param {import('./types').FillOperationData} fillOp - Fill operation data
+     * @param {import('./types.js').FillOperationData} fillOp - Fill operation data
      * @param {Object} [options={}]
      * @param {string} [options.context]
      * @param {Object} [options.logger]
      * @param {string} [options.replayMessage]
      * @param {string} [options.persistenceMode='batched']
-     * @returns {Promise<import('./types').ReplaySafeFillResult>}
+     * @returns {Promise<import('./types.js').ReplaySafeFillResult>}
      */
-    async _applyReplaySafeOrphanFillAccounting(fill, fillOp, { context, logger = this.manager?.logger, replayMessage, persistenceMode = processed_fill_store_1.PROCESSED_FILL_PERSISTENCE_MODES.BATCHED } = {}) {
+    async _applyReplaySafeOrphanFillAccounting(fill, fillOp, { context, logger = this.manager?.logger, replayMessage, persistenceMode = PROCESSED_FILL_PERSISTENCE_MODES.BATCHED } = {}) {
         return DexbotFillRuntime.applyReplaySafeOrphanFillAccounting(this, fill, fillOp, {
             context,
             logger,
@@ -613,10 +584,10 @@ class DEXBot {
     /**
      * Refresh dynamic weight distribution from market adapter.
      * @param {string} [context='runtime'] - Context label for logging
-     * @returns {import('./types').DynamicWeightRefreshResult|null}
+     * @returns {import('./types.js').DynamicWeightRefreshResult|null}
      */
     _refreshDynamicWeightDistribution(context = 'runtime') {
-        return dexbot_maintenance_runtime_1.default.refreshDynamicWeightDistribution(this, context);
+        return DexbotMaintenanceRuntime.refreshDynamicWeightDistribution(this, context);
     }
     /**
      * Finalize the bot startup after account and initial grid sync are complete.
@@ -644,7 +615,7 @@ class DEXBot {
      * @returns {Promise<{syncResult: Object|null, aborted: boolean, hasUnmatched: number, openOrders: Array|null}>}
      */
     async _syncOpenOrdersAndProcessFills(tag) {
-        return dexbot_maintenance_runtime_1.default.syncOpenOrdersAndProcessFills(this, tag);
+        return DexbotMaintenanceRuntime.syncOpenOrdersAndProcessFills(this, tag);
     }
     _maxConsecutiveFillConsumerFailures() {
         return DexbotFillRuntime.maxConsecutiveFillConsumerFailures(this);
@@ -724,7 +695,7 @@ class DEXBot {
      * @throws {Error} If initialization fails or preferredAccount is missing.
      */
     async initialize(vaultSecret = null) {
-        await waitForConnected(constants_1.TIMING.CONNECTION_TIMEOUT_MS);
+        await waitForConnected(TIMING.CONNECTION_TIMEOUT_MS);
         if (this.config && this.config.preferredAccount) {
             try {
                 let privateKey = null;
@@ -734,7 +705,7 @@ class DEXBot {
                 catch (err) {
                     if (vaultSecret)
                         throw err;
-                    this._warn(`Credential daemon probe failed: ${(0, errors_1.getErrorMessage)(err)}. Falling back to interactive authentication.`);
+                    this._warn(`Credential daemon probe failed: ${getErrorMessage(err)}. Falling back to interactive authentication.`);
                 }
                 if (!privateKey) {
                     const unlockSecret = await chainKeys.authenticate();
@@ -747,7 +718,7 @@ class DEXBot {
                 if (chainKeys.isMasterPasswordFailure(err)) {
                     throw err;
                 }
-                this._warn(`Auto-selection of preferredAccount failed: ${(0, errors_1.getErrorMessage)(err)}`);
+                this._warn(`Auto-selection of preferredAccount failed: ${getErrorMessage(err)}`);
                 // dexbot.ts has fallback to selectAccount, bot.ts throws
                 if (typeof chainOrders.selectAccount === 'function') {
                     const accountData = await chainOrders.selectAccount();
@@ -776,7 +747,7 @@ class DEXBot {
      * @returns {Array<Array<Object>>} Grouped order arrays
      */
     _buildOutsideInPairGroupsForOrders(orders) {
-        return dexbot_cow_runtime_1.default.buildOutsideInPairGroupsForOrders(orders);
+        return cowRuntime.buildOutsideInPairGroupsForOrders(orders);
     }
     /**
      * Build outside-in pair groups for create entry contexts.
@@ -784,14 +755,14 @@ class DEXBot {
      * @returns {Array<Array<Object>>} Grouped entry arrays
      */
     _buildOutsideInPairGroupsForCreateEntries(createEntries) {
-        return dexbot_cow_runtime_1.default.buildOutsideInPairGroupsForCreateEntries(createEntries);
+        return cowRuntime.buildOutsideInPairGroupsForCreateEntries(createEntries);
     }
     /**
      * Resolve the centralized fill batch cap.
      * @returns {number} Positive maximum number of fill-driven rotations per broadcast cycle
      */
     _getMaxFillBatchSize() {
-        return Math.max(1, this.config.fillProcessing?.MAX_FILL_BATCH_SIZE ?? constants_1.FILL_PROCESSING.MAX_FILL_BATCH_SIZE);
+        return Math.max(1, this.config.fillProcessing?.MAX_FILL_BATCH_SIZE ?? FILL_PROCESSING.MAX_FILL_BATCH_SIZE);
     }
     /**
      * Extract operation results from a batch transaction result.
@@ -800,7 +771,7 @@ class DEXBot {
      * @returns {Array} Array of operation result entries
      */
     _extractOperationResults(result, warnContext = '') {
-        return dexbot_cow_runtime_1.default.extractOperationResults(result, warnContext, this.manager?.logger?.log?.bind(this.manager?.logger));
+        return cowRuntime.extractOperationResults(result, warnContext, this.manager?.logger?.log?.bind(this.manager?.logger));
     }
     /**
      * Find CREATE operation contexts whose broadcast result did not include a chain order id.
@@ -810,7 +781,7 @@ class DEXBot {
      * @returns {Array<{index:number, ctx:Object}>} Missing create result contexts.
      */
     _findMissingCreateResultContexts(operationResults, opContexts) {
-        return dexbot_cow_runtime_1.default.findMissingCreateResultContexts(operationResults, opContexts);
+        return cowRuntime.findMissingCreateResultContexts(operationResults, opContexts);
     }
     /**
      * Run an immediate chain sync after a successful CREATE broadcast returned incomplete ids.
@@ -824,7 +795,7 @@ class DEXBot {
      * @returns {Promise<void>}
      */
     async _recoverAfterMissingCreateResults(reason = 'missing create operation results') {
-        return dexbot_cow_runtime_1.default.recoverAfterMissingCreateResults(this, reason);
+        return cowRuntime.recoverAfterMissingCreateResults(this, reason);
     }
     /**
      * Restore unresolved missing-create blockers after recovery if sync did not adopt them.
@@ -834,7 +805,7 @@ class DEXBot {
      * @returns {void}
      */
     _preserveMissingCreateBlockersAfterRecovery(blockers, recoveryResult) {
-        return dexbot_cow_runtime_1.default.preserveMissingCreateBlockersAfterRecovery(this, blockers, recoveryResult);
+        return cowRuntime.preserveMissingCreateBlockersAfterRecovery(this, blockers, recoveryResult);
     }
     /**
      * Merge missing CREATE result contexts into manager._lastUnmatchedChainOrders.
@@ -848,7 +819,7 @@ class DEXBot {
      * @returns {void}
      */
     _markMissingCreateResultsAsStructuralBlocker(missingCreateResults) {
-        return dexbot_cow_runtime_1.default.markMissingCreateResultsAsStructuralBlocker(this, missingCreateResults);
+        return cowRuntime.markMissingCreateResultsAsStructuralBlocker(this, missingCreateResults);
     }
     /**
      * Format an unmatched chain order/blocker for COW logs.
@@ -857,7 +828,7 @@ class DEXBot {
      * @returns {string} Compact human-readable diagnostic.
      */
     _formatUnmatchedChainOrderForLog(order) {
-        return dexbot_cow_runtime_1.default.formatUnmatchedChainOrderForLog(order);
+        return cowRuntime.formatUnmatchedChainOrderForLog(order);
     }
     /**
      * Record a pending CREATE broadcast on the manager.
@@ -880,7 +851,7 @@ class DEXBot {
      * @returns {void}
      */
     _recordPendingBroadcast(entry) {
-        return dexbot_cow_runtime_1.default.recordPendingBroadcast(this, entry);
+        return cowRuntime.recordPendingBroadcast(this, entry);
     }
     /**
      * Clear the pending-broadcast cache.
@@ -891,7 +862,7 @@ class DEXBot {
      * _reconcileAfterUncertainBroadcast before calling this).
      */
     _clearPendingBroadcasts() {
-        return dexbot_cow_runtime_1.default.clearPendingBroadcasts(this.manager?._pendingBroadcasts);
+        return cowRuntime.clearPendingBroadcasts(this.manager?._pendingBroadcasts);
     }
     /**
      * Build a fingerprint for an on-chain order so it can be matched against
@@ -902,7 +873,7 @@ class DEXBot {
      * @returns {string|null} Fingerprint or null on bad input
      */
     _buildChainOrderFingerprint(chainOrder, slotId) {
-        return dexbot_cow_runtime_1.default.buildChainOrderFingerprint(this, chainOrder, slotId);
+        return cowRuntime.buildChainOrderFingerprint(this, chainOrder, slotId);
     }
     /**
      * Normalize raw BitShares limit_order_object data into the integer tuple
@@ -916,7 +887,7 @@ class DEXBot {
      * @returns {{side: string, assetA: string, assetB: string, sellInt: number, receiveInt: number}|null}
      */
     _normalizeChainOrderForPendingMatch(chainOrder) {
-        return dexbot_cow_runtime_1.default.normalizeChainOrderForPendingMatch(this, chainOrder);
+        return cowRuntime.normalizeChainOrderForPendingMatch(this, chainOrder);
     }
     /**
      * Find a chain order that matches a planned slot using price+size proximity.
@@ -934,7 +905,7 @@ class DEXBot {
      * @returns {Object|null} Matching chain order, or null
      */
     _findChainOrderForSlot(chainOrders, slotId, planned) {
-        return dexbot_cow_runtime_1.default.findChainOrderForSlot(this, chainOrders, slotId, planned);
+        return cowRuntime.findChainOrderForSlot(this, chainOrders, slotId, planned);
     }
     /**
      * Reconcile a broadcast whose chain state is unknown.
@@ -963,10 +934,10 @@ class DEXBot {
      * @returns {Promise<Object>} Result object compatible with batch return shape
      */
     async _reconcileAfterUncertainBroadcast(err, opContexts, options = {}) {
-        return dexbot_cow_runtime_1.default.reconcileAfterUncertainBroadcast(this, err, opContexts, options);
+        return cowRuntime.reconcileAfterUncertainBroadcast(this, err, opContexts, options);
     }
     async _reconcileAfterUncertainBroadcastImpl(err, opContexts, options) {
-        return dexbot_cow_runtime_1.default.reconcileAfterUncertainBroadcastImpl(this, err, opContexts, options);
+        return cowRuntime.reconcileAfterUncertainBroadcastImpl(this, err, opContexts, options);
     }
     /**
      * Auto-cancel a price-drift orphan from the unmatched-order snapshot.
@@ -994,7 +965,7 @@ class DEXBot {
      * @returns {Promise<{cancelled: boolean, orderId?: string, reason?: string}>}
      */
     async _autoCancelOneUnmatchedOrphan() {
-        return dexbot_cow_runtime_1.default.autoCancelOneUnmatchedOrphan(this);
+        return cowRuntime.autoCancelOneUnmatchedOrphan(this);
     }
     // Pair mode applies only when create contexts include both BUY and SELL.
     // Single-side create batches intentionally remain a single executeBatch.
@@ -1004,7 +975,7 @@ class DEXBot {
      * @returns {boolean} True if pair mode should be used
      */
     _shouldExecuteCreatePairMode(opContexts) {
-        return dexbot_cow_runtime_1.default.shouldExecuteCreatePairMode(this, opContexts);
+        return cowRuntime.shouldExecuteCreatePairMode(this, opContexts);
     }
     /**
      * Execute operations with retry on BroadcastUncertainError.
@@ -1020,16 +991,16 @@ class DEXBot {
      * the full operations array would duplicate those creates on chain.
      */
     async _executeWithRetryOnUncertain(operations, opContexts) {
-        return dexbot_cow_runtime_1.default.executeWithRetryOnUncertain(this, operations, opContexts);
+        return cowRuntime.executeWithRetryOnUncertain(this, operations, opContexts);
     }
     /**
      * Execute blockchain operations with appropriate strategy (single batch or pair mode).
-     * @param {Array<import('./types').CreatedOperation>} operations - Array of operation objects
+     * @param {Array<import('./types.js').CreatedOperation>} operations - Array of operation objects
      * @param {Array<Object>} opContexts - Array of operation context metadata (1:1 with operations)
      * @returns {Promise<{result: Object, opContexts: Array}>} Execution result with contexts
      */
     async _executeOperationsWithStrategy(operations, opContexts) {
-        return dexbot_cow_runtime_1.default.executeOperationsWithStrategy(this, operations, opContexts);
+        return cowRuntime.executeOperationsWithStrategy(this, operations, opContexts);
     }
     /**
      * Validate that operations can be executed with available funds before broadcasting.
@@ -1041,7 +1012,7 @@ class DEXBot {
      * @private
      */
     _validateOperationFunds(operations, assetA, assetB) {
-        return dexbot_cow_runtime_1.default.validateOperationFunds(this, operations, assetA, assetB);
+        return cowRuntime.validateOperationFunds(this, operations, assetA, assetB);
     }
     /**
      * Resolve the ideal size from an order-like object with fallback.
@@ -1050,7 +1021,7 @@ class DEXBot {
      * @returns {number|null} Resolved size or null
      */
     _resolveIdealSizeForValidation(orderLike, fallbackSize = null) {
-        return dexbot_cow_runtime_1.default.resolveIdealSizeForValidation(this, orderLike, fallbackSize);
+        return cowRuntime.resolveIdealSizeForValidation(this, orderLike, fallbackSize);
     }
     /**
      * Validate that an order size is safe to execute (above minimum dust thresholds).
@@ -1058,10 +1029,10 @@ class DEXBot {
      * @param {string} type - ORDER_TYPES.BUY or ORDER_TYPES.SELL
      * @param {Object|null} [orderLike=null] - Optional order-like object for ideal size comparison
      * @param {number|null} [fallbackSize=null] - Fallback ideal size
-     * @returns {import('./types').OrderValidationResult}
+     * @returns {import('./types.js').OrderValidationResult}
      */
     _validateOrderSizeForExecution(size, type, orderLike = null, fallbackSize = null) {
-        return dexbot_cow_runtime_1.default.validateOrderSizeForExecution(this, size, type, orderLike, fallbackSize);
+        return cowRuntime.validateOrderSizeForExecution(this, size, type, orderLike, fallbackSize);
     }
     /**
      * Execute a batch of order operations if the rebalance result has executable actions.
@@ -1082,7 +1053,7 @@ class DEXBot {
             // outputs, updateOrdersOnChainPlan cowResults, reconcileGridOrders
             // null results) must NOT pop the stack — an unmatched pop could steal
             // a nested grid's entry.
-            dexbot_cow_runtime_1.default.popPushedWorkingGrid(this, rebalanceResult);
+            cowRuntime.popPushedWorkingGrid(this, rebalanceResult);
             // Persist master grid mutations that may have occurred outside COW
             // broadcast (e.g., partial-fill size updates applied directly by the
             // sync engine). Without this, a partial fill that does not trigger a
@@ -1232,17 +1203,17 @@ class DEXBot {
         }
         try {
             if (this.privateKey && getKeyStore().isDaemonSigningKey(this.privateKey)) {
-                await chainKeys.pingDaemon(this.privateKey.accountName, Math.min(constants_1.TIMING.DAEMON_PING_TIMEOUT_MS, constants_1.TIMING.DAEMON_STARTUP_TIMEOUT_MS), { socketPath: this.privateKey.socketPath });
+                await chainKeys.pingDaemon(this.privateKey.accountName, Math.min(TIMING.DAEMON_PING_TIMEOUT_MS, TIMING.DAEMON_STARTUP_TIMEOUT_MS), { socketPath: this.privateKey.socketPath });
             }
         }
         catch (err) {
-            const message = `Credential daemon unavailable before ${contextLabel}: ${(0, errors_1.getErrorMessage)(err)}`;
+            const message = `Credential daemon unavailable before ${contextLabel}: ${getErrorMessage(err)}`;
             this._credentialDaemonDown = true;
             this._credentialRecoveryNeeded = true;
             this._suspendGridPersistenceForCredentialOutage(message);
             this.manager?.logger?.log?.(`[CREDENTIAL] ${message}. Write operations paused; re-unlock with dexbot pm2.`, 'error');
             const wrapped = new Error(message);
-            wrapped.code = constants_1.DAEMON_CODES.CREDENTIAL_DAEMON_UNAVAILABLE;
+            wrapped.code = DAEMON_CODES.CREDENTIAL_DAEMON_UNAVAILABLE;
             wrapped.cause = err;
             throw wrapped;
         }
@@ -1255,9 +1226,9 @@ class DEXBot {
     _isCredentialDaemonError(err) {
         if (!err)
             return false;
-        if (err.code === constants_1.DAEMON_CODES.CREDENTIAL_DAEMON_UNAVAILABLE)
+        if (err.code === DAEMON_CODES.CREDENTIAL_DAEMON_UNAVAILABLE)
             return true;
-        const message = String((0, errors_1.getErrorMessage)(err) || '');
+        const message = String(getErrorMessage(err) || '');
         return /Credential daemon|Daemon connection failed|daemon .*unavailable|dexbot-cred-daemon\.sock|ECONNREFUSED|ENOENT/.test(message);
     }
     /**
@@ -1274,7 +1245,7 @@ class DEXBot {
                 this._credentialRecoveryDeferredTimer = setTimeout(() => {
                     this._credentialRecoveryDeferredTimer = null;
                     this._runCredentialRecoveryAfterDaemonRestored().catch((err) => {
-                        this.manager?.logger?.log?.(`[CREDENTIAL] Deferred recovery failed: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+                        this.manager?.logger?.log?.(`[CREDENTIAL] Deferred recovery failed: ${getErrorMessage(err)}`, 'error');
                         if (this.manager) {
                             this.manager._recoveryState = { ...this.manager._recoveryState, lastFailureAt: Date.now() };
                         }
@@ -1302,8 +1273,8 @@ class DEXBot {
         }
         catch (err) {
             this._credentialRecoveryNeeded = true;
-            this._suspendGridPersistenceForCredentialOutage(`credential recovery failed: ${(0, errors_1.getErrorMessage)(err)}`);
-            this.manager?.logger?.log?.(`[CREDENTIAL] Credential recovery sync failed: ${(0, errors_1.getErrorMessage)(err)}. Writes remain guarded by preflight.`, 'error');
+            this._suspendGridPersistenceForCredentialOutage(`credential recovery failed: ${getErrorMessage(err)}`);
+            this.manager?.logger?.log?.(`[CREDENTIAL] Credential recovery sync failed: ${getErrorMessage(err)}. Writes remain guarded by preflight.`, 'error');
         }
         finally {
             this._credentialRecoveryInFlight = false;
@@ -1322,7 +1293,7 @@ class DEXBot {
             this._credentialDaemonDown = false;
             return;
         }
-        const intervalMs = Math.max(constants_1.TIMING.DAEMON_PING_TIMEOUT_MS, constants_1.TIMING.CREDENTIAL_DAEMON_WATCHDOG_MS);
+        const intervalMs = Math.max(TIMING.DAEMON_PING_TIMEOUT_MS, TIMING.CREDENTIAL_DAEMON_WATCHDOG_MS);
         const probe = async () => {
             if (this._shuttingDown || !this._isCredentialDaemonWriteRequired())
                 return;
@@ -1346,7 +1317,7 @@ class DEXBot {
                 }
                 catch (err) {
                     if (!this._credentialDaemonDown) {
-                        const errMsg = String((0, errors_1.getErrorMessage)(err) || '');
+                        const errMsg = String(getErrorMessage(err) || '');
                         let hint = '';
                         if (errMsg.includes('ENOENT')) {
                             hint = `Socket file missing at ${token.socketPath}. The credential daemon process may have been killed (e.g. by stray Ctrl-C). Restart it with: dexbot pm2 restart dexbot-cred. If the problem persists, check the daemon log: profiles/logs/dexbot-cred.log`;
@@ -1360,10 +1331,10 @@ class DEXBot {
                         else {
                             hint = `Write operations will remain paused until re-unlocked with dexbot pm2.`;
                         }
-                        this.manager?.logger?.log?.(`[CREDENTIAL] Credential daemon watchdog failed: ${(0, errors_1.getErrorMessage)(err)}. ${hint}`, 'error');
+                        this.manager?.logger?.log?.(`[CREDENTIAL] Credential daemon watchdog failed: ${getErrorMessage(err)}. ${hint}`, 'error');
                     }
                     this._credentialDaemonDown = true;
-                    this._suspendGridPersistenceForCredentialOutage(`credential daemon watchdog failed: ${(0, errors_1.getErrorMessage)(err)}`);
+                    this._suspendGridPersistenceForCredentialOutage(`credential daemon watchdog failed: ${getErrorMessage(err)}`);
                 }
             }
             finally {
@@ -1372,14 +1343,14 @@ class DEXBot {
         };
         this._credentialDaemonWatchdogInterval = setInterval(() => {
             probe().catch((err) => {
-                this.manager?.logger?.log?.(`[CREDENTIAL] Credential daemon watchdog error: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
+                this.manager?.logger?.log?.(`[CREDENTIAL] Credential daemon watchdog error: ${getErrorMessage(err)}`, 'warn');
             });
         }, intervalMs);
         if (typeof this._credentialDaemonWatchdogInterval.unref === 'function') {
             this._credentialDaemonWatchdogInterval.unref();
         }
         void probe();
-        this._log(`Credential daemon watchdog started (${Math.round(intervalMs / constants_1.TIMING.MILLISECONDS_PER_SECOND)}s interval)`);
+        this._log(`Credential daemon watchdog started (${Math.round(intervalMs / TIMING.MILLISECONDS_PER_SECOND)}s interval)`);
     }
     /**
      * Stop the credential daemon watchdog interval.
@@ -1421,25 +1392,25 @@ class DEXBot {
      * @returns {Array<{type: string, id: string, order?: Object, orderId?: string, newSize?: number, newPrice?: number, newGridId?: string}>}
      */
     _buildActionsFromPlan(plan) {
-        return dexbot_cow_runtime_1.default.buildActionsFromPlan(this, plan);
+        return cowRuntime.buildActionsFromPlan(this, plan);
     }
     /**
      * Build a COW result object (workingGrid + actions) from a simple plan.
      * @param {Object|Array} plan - Plan object or array of ordersToPlace
-     * @returns {{workingGrid: import('./types').WorkingGrid, workingIndexes: Object, workingBoundary: number, actions: Array}}
+     * @returns {{workingGrid: import('./types.js').WorkingGrid, workingIndexes: Object, workingBoundary: number, actions: Array}}
      */
     _buildCowResultFromPlan(plan) {
-        return dexbot_cow_runtime_1.default.buildCowResultFromPlan(this, plan);
+        return cowRuntime.buildCowResultFromPlan(this, plan);
     }
     /**
      * Restore skipped update slots in the working grid to master state.
-     * @param {import('./types').WorkingGrid} workingGrid - Working grid to restore slots into
+     * @param {import('./types.js').WorkingGrid} workingGrid - Working grid to restore slots into
      * @param {Set<string>} skippedSlotIds - Set of slot IDs that were skipped
      * @param {number} [skippedCount=0] - Count of skipped actions for logging
      * @returns {void}
      */
     _restoreSkippedUpdateSlotsInWorkingGrid(workingGrid, skippedSlotIds, skippedCount = 0) {
-        return dexbot_cow_runtime_1.default.restoreSkippedUpdateSlotsInWorkingGrid(this, workingGrid, skippedSlotIds, skippedCount);
+        return cowRuntime.restoreSkippedUpdateSlotsInWorkingGrid(this, workingGrid, skippedSlotIds, skippedCount);
     }
     /**
      * COW broadcast: Execute blockchain operations and commit working grid on success.
@@ -1449,10 +1420,10 @@ class DEXBot {
      * @private
      */
     async _updateOrdersOnChainBatchCOW(cowResult, options = {}) {
-        return dexbot_cow_runtime_1.default.updateOrdersOnChainBatchCOW(this, cowResult, options);
+        return cowRuntime.updateOrdersOnChainBatchCOW(this, cowResult, options);
     }
     async _processBatchResults(result, opContexts) {
-        return dexbot_cow_runtime_1.default.processBatchResults(this, result, opContexts);
+        return cowRuntime.processBatchResults(this, result, opContexts);
     }
     /**
      * Perform grid recalculation triggered by trigger file.
@@ -1463,7 +1434,7 @@ class DEXBot {
      * @private
      */
     async _performGridResync(options = {}) {
-        return dexbot_maintenance_runtime_1.default.performGridResync(this, options);
+        return DexbotMaintenanceRuntime.performGridResync(this, options);
     }
     /**
      * Handle any pending trigger file reset at startup.
@@ -1472,7 +1443,7 @@ class DEXBot {
      * @private
      */
     async _handlePendingTriggerReset() {
-        return dexbot_maintenance_runtime_1.default.handlePendingTriggerReset(this);
+        return DexbotMaintenanceRuntime.handlePendingTriggerReset(this);
     }
     /**
      * Setup trigger file detection for grid reset.
@@ -1480,7 +1451,7 @@ class DEXBot {
      * @private
      */
     async _setupTriggerFileDetection() {
-        return dexbot_maintenance_runtime_1.default.setupTriggerFileDetection(this);
+        return DexbotMaintenanceRuntime.setupTriggerFileDetection(this);
     }
     /**
      * Starts the bot's operation.
@@ -1499,14 +1470,14 @@ class DEXBot {
      */
     async startWithPrivateKey(privateKey) {
         // Initialize account data with provided private key
-        await waitForConnected(constants_1.TIMING.CONNECTION_TIMEOUT_MS);
+        await waitForConnected(TIMING.CONNECTION_TIMEOUT_MS);
         if (this.config && this.config.preferredAccount) {
             try {
                 this.privateKey = privateKey;
                 await this._setupAccountContext(this.config.preferredAccount);
             }
             catch (err) {
-                this._warn(`Auto-selection of preferredAccount failed: ${(0, errors_1.getErrorMessage)(err)}`);
+                this._warn(`Auto-selection of preferredAccount failed: ${getErrorMessage(err)}`);
                 throw err;
             }
         }
@@ -1529,7 +1500,7 @@ class DEXBot {
             await this._finishStartupSequence(startupState);
         }
         catch (err) {
-            this._warn(`Error during grid initialization: ${(0, errors_1.getErrorMessage)(err)}`);
+            this._warn(`Error during grid initialization: ${getErrorMessage(err)}`);
             await this.shutdown();
             throw err;
         }
@@ -1552,10 +1523,10 @@ class DEXBot {
      * @private
      */
     async _performPeriodicGridChecks() {
-        return dexbot_maintenance_runtime_1.default.performPeriodicGridChecks(this);
+        return DexbotMaintenanceRuntime.performPeriodicGridChecks(this);
     }
     _isOpenOrdersSyncLoopEnabled() {
-        return dexbot_maintenance_runtime_1.default.isOpenOrdersSyncLoopEnabled(this);
+        return DexbotMaintenanceRuntime.isOpenOrdersSyncLoopEnabled(this);
     }
     /**
      * Start the open-orders watchdog sync loop.
@@ -1563,14 +1534,14 @@ class DEXBot {
      * @private
      */
     _startOpenOrdersSyncLoop() {
-        return dexbot_maintenance_runtime_1.default.startOpenOrdersSyncLoop(this);
+        return DexbotMaintenanceRuntime.startOpenOrdersSyncLoop(this);
     }
     /**
      * Stop the open-orders watchdog sync loop.
      * @private
      */
     async _stopOpenOrdersSyncLoop() {
-        return dexbot_maintenance_runtime_1.default.stopOpenOrdersSyncLoop(this);
+        return DexbotMaintenanceRuntime.stopOpenOrdersSyncLoop(this);
     }
     /**
      * Set up periodic blockchain account balance fetch interval.
@@ -1578,21 +1549,21 @@ class DEXBot {
      * @private
      */
     _setupBlockchainFetchInterval() {
-        return dexbot_maintenance_runtime_1.default.setupBlockchainFetchInterval(this);
+        return DexbotMaintenanceRuntime.setupBlockchainFetchInterval(this);
     }
     /**
      * Stop the periodic blockchain fetch interval.
      * @private
      */
     _stopBlockchainFetchInterval() {
-        return dexbot_maintenance_runtime_1.default.stopBlockchainFetchInterval(this);
+        return DexbotMaintenanceRuntime.stopBlockchainFetchInterval(this);
     }
     async _releaseMarketAdapterRuntime(context = 'shutdown') {
-        return dexbot_maintenance_runtime_1.default.releaseMarketAdapterRuntime(this, this.config?.botKey || this.config?.name, context);
+        return DexbotMaintenanceRuntime.releaseMarketAdapterRuntime(this, this.config?.botKey || this.config?.name, context);
     }
     /**
      * Get or create the credit runtime for debt policy management.
-     * @returns {import('./credit_runtime').CreditRuntime|null}
+     * @returns {import('./credit_runtime.js').CreditRuntime|null}
      */
     _getCreditRuntime() {
         const lending = this.config?.debtPolicy?.lending;
@@ -1604,15 +1575,15 @@ class DEXBot {
             return null;
         }
         if (!this._creditRuntime) {
-            this._creditRuntime = new credit_runtime_1.default(this, {
-                stateDir: paths_1.PATHS.CREDIT_RUNTIME_DIR,
+            this._creditRuntime = new CreditRuntime(this, {
+                stateDir: PATHS.CREDIT_RUNTIME_DIR,
             });
         }
         return this._creditRuntime;
     }
     /**
      * Set up the credit runtime by loading its persisted state.
-     * @returns {Promise<import('./credit_runtime').CreditRuntime|null>}
+     * @returns {Promise<import('./credit_runtime.js').CreditRuntime|null>}
      */
     async _setupCreditRuntime() {
         const runtime = this._getCreditRuntime();
@@ -1634,7 +1605,7 @@ class DEXBot {
             await runtime.refreshState();
         }
         catch (err) {
-            this._warn(`Credit runtime refresh/sync failed: ${(0, errors_1.getErrorMessage)(err)}`);
+            this._warn(`Credit runtime refresh/sync failed: ${getErrorMessage(err)}`);
         }
     }
     /**
@@ -1659,7 +1630,7 @@ class DEXBot {
         if (!runtime) {
             return;
         }
-        const intervalMin = Number(this.config?.TIMING?.CREDIT_DEAL_CHECK_INTERVAL_MIN ?? constants_1.TIMING.CREDIT_DEAL_CHECK_INTERVAL_MIN);
+        const intervalMin = Number(this.config?.TIMING?.CREDIT_DEAL_CHECK_INTERVAL_MIN ?? TIMING.CREDIT_DEAL_CHECK_INTERVAL_MIN);
         if (!Number.isFinite(intervalMin) || intervalMin <= 0) {
             this._log('Credit deal watchdog disabled by configuration (TIMING.CREDIT_DEAL_CHECK_INTERVAL_MIN <= 0)');
             return;
@@ -1668,13 +1639,13 @@ class DEXBot {
             clearInterval(this._creditWatchdogInterval);
             this._creditWatchdogInterval = null;
         }
-        const intervalMs = intervalMin * 60 * constants_1.TIMING.MILLISECONDS_PER_SECOND;
+        const intervalMs = intervalMin * 60 * TIMING.MILLISECONDS_PER_SECOND;
         this._creditWatchdogInterval = setInterval(async () => {
             try {
                 await runtime.runCreditWatchdog();
             }
             catch (err) {
-                this._warn(`Credit watchdog error: ${(0, errors_1.getErrorMessage)(err)}`);
+                this._warn(`Credit watchdog error: ${getErrorMessage(err)}`);
             }
         }, intervalMs);
         if (typeof this._creditWatchdogInterval?.unref === 'function') {
@@ -1693,17 +1664,17 @@ class DEXBot {
         }
     }
     async requestGridReset(reason = 'structural change', options = {}) {
-        return dexbot_maintenance_runtime_1.default.requestGridReset(this, reason, options);
+        return DexbotMaintenanceRuntime.requestGridReset(this, reason, options);
     }
     _wireStructuralGridResyncRequest() {
-        return dexbot_maintenance_runtime_1.default.wireStructuralGridResyncRequest(this);
+        return DexbotMaintenanceRuntime.wireStructuralGridResyncRequest(this);
     }
     /**
      * Get current metrics for monitoring and debugging.
      * @returns {Object} Metrics snapshot
      */
     getMetrics() {
-        return dexbot_maintenance_runtime_1.default.getMetrics(this);
+        return DexbotMaintenanceRuntime.getMetrics(this);
     }
     /**
      * Execute grid maintenance checks in strict order with pipeline consensus.
@@ -1737,7 +1708,7 @@ class DEXBot {
      * @private
      */
     async _executeMaintenanceLogic(context) {
-        return dexbot_maintenance_runtime_1.default.executeMaintenanceLogic(this, context);
+        return DexbotMaintenanceRuntime.executeMaintenanceLogic(this, context);
     }
     /**
      * Cancel dust partial orders immediately — no maps, no timers, no delay.
@@ -1748,7 +1719,7 @@ class DEXBot {
      * @private
      */
     async _cancelDustOrders({ buy: buyDust = [], sell: sellDust = [] } = {}) {
-        return dexbot_maintenance_runtime_1.default.cancelDustOrders(this, { buy: buyDust, sell: sellDust });
+        return DexbotMaintenanceRuntime.cancelDustOrders(this, { buy: buyDust, sell: sellDust });
     }
     /**
      * Run a single dust health check cycle: inspect grid for partials below the
@@ -1758,7 +1729,7 @@ class DEXBot {
      * @private
      */
     async _runDustHealthCheck() {
-        return dexbot_maintenance_runtime_1.default.runDustHealthCheck(this);
+        return DexbotMaintenanceRuntime.runDustHealthCheck(this);
     }
     /**
      * Set up the periodic dust health check interval.
@@ -1768,7 +1739,7 @@ class DEXBot {
      * @private
      */
     _setupDustHealthCheckInterval() {
-        return dexbot_maintenance_runtime_1.default.setupDustHealthCheckInterval(this);
+        return DexbotMaintenanceRuntime.setupDustHealthCheckInterval(this);
     }
     /**
      * Perform grid maintenance: fund thresholds, spread condition, grid health, divergence.
@@ -1795,7 +1766,7 @@ class DEXBot {
      * @private
      */
     async _runGridMaintenance(context = 'periodic', options = {}) {
-        return dexbot_maintenance_runtime_1.default.runGridMaintenance(this, context, options);
+        return DexbotMaintenanceRuntime.runGridMaintenance(this, context, options);
     }
     /**
      * Gracefully shutdown the bot.
@@ -1852,7 +1823,7 @@ class DEXBot {
                 await this._creditRuntime.shutdown();
             }
             catch (err) {
-                this._warn(`Failed to persist credit runtime state: ${(0, errors_1.getErrorMessage)(err)}`);
+                this._warn(`Failed to persist credit runtime state: ${getErrorMessage(err)}`);
             }
         }
         if (this._triggerWatcher && typeof this._triggerWatcher.close === 'function') {
@@ -1860,7 +1831,7 @@ class DEXBot {
                 this._triggerWatcher.close();
             }
             catch (err) {
-                this._warn(`Failed to close trigger watcher: ${(0, errors_1.getErrorMessage)(err)}`);
+                this._warn(`Failed to close trigger watcher: ${getErrorMessage(err)}`);
             }
             finally {
                 this._triggerWatcher = null;
@@ -1871,7 +1842,7 @@ class DEXBot {
                 await this._fillsUnsubscribe();
             }
             catch (err) {
-                this._warn(`Failed to unsubscribe fill listener: ${(0, errors_1.getErrorMessage)(err)}`);
+                this._warn(`Failed to unsubscribe fill listener: ${getErrorMessage(err)}`);
             }
             finally {
                 this._fillsUnsubscribe = null;
@@ -1882,7 +1853,7 @@ class DEXBot {
                 this._reconnectUnregister();
             }
             catch (err) {
-                this._warn(`Error unregistering reconnect callback: ${(0, errors_1.getErrorMessage)(err)}`);
+                this._warn(`Error unregistering reconnect callback: ${getErrorMessage(err)}`);
             }
             this._reconnectUnregister = null;
         }
@@ -1890,13 +1861,13 @@ class DEXBot {
             await this._stopOpenOrdersSyncLoop();
         }
         catch (err) {
-            this._warn(`Error while stopping open-orders sync loop: ${(0, errors_1.getErrorMessage)(err)}`);
+            this._warn(`Error while stopping open-orders sync loop: ${getErrorMessage(err)}`);
         }
         try {
             await this._releaseMarketAdapterRuntime('shutdown');
         }
         catch (err) {
-            this._warn(`Error while releasing market adapter runtime: ${(0, errors_1.getErrorMessage)(err)}`);
+            this._warn(`Error while releasing market adapter runtime: ${getErrorMessage(err)}`);
         }
         // Wait for current fill processing to complete
         try {
@@ -1934,7 +1905,7 @@ class DEXBot {
                                 this._log('Final grid snapshot persisted');
                             }
                             catch (err) {
-                                this._warn(`Failed to persist final state: ${(0, errors_1.getErrorMessage)(err)}`);
+                                this._warn(`Failed to persist final state: ${getErrorMessage(err)}`);
                             }
                         }
                     }).then(() => 'acquired'),
@@ -1973,12 +1944,12 @@ class DEXBot {
                                 this._log('Final grid snapshot persisted (best-effort, lock not held)');
                             }
                             catch (err) {
-                                this._warn(`Failed to persist final state (best-effort): ${(0, errors_1.getErrorMessage)(err)}`);
+                                this._warn(`Failed to persist final state (best-effort): ${getErrorMessage(err)}`);
                             }
                         }
                     }
                     catch (err) {
-                        this._warn(`Best-effort flush during shutdown failed: ${(0, errors_1.getErrorMessage)(err)}`);
+                        this._warn(`Best-effort flush during shutdown failed: ${getErrorMessage(err)}`);
                     }
                 }
                 // Always reset the fill-consumer watchdog on shutdown completion,
@@ -1988,14 +1959,14 @@ class DEXBot {
             }
         }
         catch (err) {
-            this._warn(`Error during shutdown lock acquisition: ${(0, errors_1.getErrorMessage)(err)}`);
+            this._warn(`Error during shutdown lock acquisition: ${getErrorMessage(err)}`);
         }
         // Release fund registry allocation
         if (this.config?.preferredAccount) {
             const botName = this.config.botKey;
             if (botName) {
                 fundRegistry.releaseAllocation(this.config.preferredAccount, botName).catch((err) => {
-                    this._warn(`Failed to release fund allocation for ${botName}: ${(0, errors_1.getErrorMessage)(err)}`);
+                    this._warn(`Failed to release fund allocation for ${botName}: ${getErrorMessage(err)}`);
                 });
             }
         }
@@ -2012,7 +1983,6 @@ class DEXBot {
         await this.manager?.logger?.flush();
     }
 }
-DEXBot.normalizeBotEntry = bot_settings_1.normalizeBotEntry;
-exports.default = DEXBot;
-module.exports = DEXBot;
+DEXBot.normalizeBotEntry = normalizeBotEntry;
+export default DEXBot;
 //# sourceMappingURL=dexbot_class.js.map