dexbot 1.4.11 → 1.4.12

package/dist/modules/chain_orders.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * modules/chain_orders.ts - Blockchain Interaction Layer
  *
@@ -106,86 +105,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 });
-exports.BroadcastUncertainError = exports.FILL_PROCESSING_MODE = void 0;
-exports.selectAccount = selectAccount;
-exports.setPreferredAccount = setPreferredAccount;
-exports.resolveAccountId = resolveAccountId;
-exports.resolveAccountName = resolveAccountName;
-exports.readOpenOrders = readOpenOrders;
-exports.readOpenOrdersWithMeta = readOpenOrdersWithMeta;
-exports.readOpenOrdersWithMetaSafe = readOpenOrdersWithMetaSafe;
-exports.readOpenOrdersGuarded = readOpenOrdersGuarded;
-exports.readSingleOrder = readSingleOrder;
-exports.batchReadOrders = batchReadOrders;
-exports.listenForFills = listenForFills;
-exports.updateOrder = updateOrder;
-exports.createOrder = createOrder;
-exports.cancelOrder = cancelOrder;
-exports.getOnChainAssetBalances = getOnChainAssetBalances;
-exports.getFillProcessingMode = getFillProcessingMode;
-exports.buildUpdateOrderOp = buildUpdateOrderOp;
-exports.buildCreateOrderOp = buildCreateOrderOp;
-exports.buildCancelOrderOp = buildCancelOrderOp;
-exports.buildLiquidityPoolExchangeOp = buildLiquidityPoolExchangeOp;
-exports.executeBatch = executeBatch;
-exports.wasRecentlyOwnCancelled = wasRecentlyOwnCancelled;
-exports.recordOwnCancel = recordOwnCancel;
-exports.broadcastTxWithClassification = broadcastTxWithClassification;
-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, createAccountClient, waitForConnected, withTimeout } = client;
-const math_1 = require("./order/utils/math");
-const constants_1 = require("./constants");
-const Format = __importStar(require("./order/format"));
-const async_lock_1 = __importDefault(require("./order/async_lock"));
-const system_1 = require("./order/utils/system");
-const chainKeys = __importStar(require("./chain_keys"));
-const key_store_1 = require("./key_store");
-const dexbot_credential_client_1 = require("./dexbot_credential_client");
-Object.defineProperty(exports, "BroadcastUncertainError", { enumerable: true, get: function () { return dexbot_credential_client_1.BroadcastUncertainError; } });
-const broadcast_failure_1 = require("./broadcast_failure");
-const logger_1 = __importDefault(require("./logger"));
-const errors_1 = require("./utils/errors");
+import { floatToBlockchainInt, blockchainToFloat, normalizeInt, validateOrderAmountsWithinLimits } from './order/utils/math.js';
+import { FILL_PROCESSING, TIMING, NATIVE_CLIENT, DAEMON_CODES } from './constants.js';
+import * as Format from './order/format.js';
+import AsyncLock from './order/async_lock.js';
+import { readInput } from './order/utils/system.js';
+import * as chainKeys from './chain_keys.js';
+import { getKeyStore } from './key_store.js';
+import { BroadcastUncertainError } from './dexbot_credential_client.js';
+import { classifyBroadcastFailure } from './broadcast_failure.js';
+import Logger from './logger.js';
+import { getErrorMessage } from './utils/errors.js';
 function getNodeManager() { return require('./bitshares_client').getNodeManager(); }
 const { toFiniteNumber } = Format;
-const chainOrdersLogger = new logger_1.default('ChainOrders');
-const { ORDER_EVENTS } = constants_1.NATIVE_CLIENT;
+const chainOrdersLogger = new Logger('ChainOrders');
+const { ORDER_EVENTS } = NATIVE_CLIENT;
 // Ring buffer of order ids the local process just cancelled.
 // Used by the fill consumer to ignore a fill/cancel-history entry that is
 // really just the propagation of the bot's own broadcast cancel op. Entries
@@ -232,15 +170,14 @@ function wasRecentlyOwnCancelled(orderId) {
  * - 'history': Use fill event data directly to match order_id with account_orders (preferred, faster)
  * - 'open': Fetch open orders from blockchain and sync (backup method, more API calls)
  */
-const FILL_PROCESSING_MODE = constants_1.FILL_PROCESSING.MODE;
-exports.FILL_PROCESSING_MODE = FILL_PROCESSING_MODE;
+const FILL_PROCESSING_MODE = FILL_PROCESSING.MODE;
 // AsyncLock instances for preventing race conditions
 // _subscriptionLock: Serializes access to accountSubscriptions map
 // _preferredAccountLock: Serializes access to preferredAccount global state
 // _resolutionLock: Serializes account resolution calls and caching
-const _subscriptionLock = new async_lock_1.default();
-const _preferredAccountLock = new async_lock_1.default();
-const _resolutionLock = new async_lock_1.default();
+const _subscriptionLock = new AsyncLock();
+const _preferredAccountLock = new AsyncLock();
+const _resolutionLock = new AsyncLock();
 // Cache for account resolutions (name -> id and id -> name)
 const _accountResolutionCache = new Map();
 /**
@@ -270,7 +207,7 @@ async function _getAssetPrecision(assetRef) {
         }
     }
     catch (e) {
-        throw new Error(`CRITICAL: Could not resolve precision for asset ${assetRef}. Halting operation to prevent scaling errors. Cause: ${(0, errors_1.getErrorMessage)(e)}`);
+        throw new Error(`CRITICAL: Could not resolve precision for asset ${assetRef}. Halting operation to prevent scaling errors. Cause: ${getErrorMessage(e)}`);
     }
     throw new Error(`CRITICAL: Could not resolve precision for asset ${assetRef}. Halting operation to prevent scaling errors. Cause: asset not found or precision missing.`);
 }
@@ -416,7 +353,7 @@ async function _ensureAccountSubscriber(accountName, userCallback = null) {
             // Filter for fill-related operations
             const fills = updates.filter((update) => {
                 const op = update.op;
-                return op && op[0] === constants_1.FILL_PROCESSING.OPERATION_TYPE; // operation type for fill_order
+                return op && op[0] === FILL_PROCESSING.OPERATION_TYPE; // operation type for fill_order
             });
             if (fills.length > 0) {
                 // Call each registered user callback with the fills array
@@ -427,18 +364,18 @@ async function _ensureAccountSubscriber(accountName, userCallback = null) {
                     }
                     catch (e) {
                         failures.push(e);
-                        chainOrdersLogger.error(`chain_orders listener error ${(0, errors_1.getErrorMessage)(e)}`);
+                        chainOrdersLogger.error(`chain_orders listener error ${getErrorMessage(e)}`);
                     }
                 }
                 if (failures.length > 0) {
-                    const err = new Error(`Fill listener delivery failed for ${failures.length} callback(s): ${failures.map((e) => (0, errors_1.getErrorMessage)(e) || String(e)).join('; ')}`);
+                    const err = new Error(`Fill listener delivery failed for ${failures.length} callback(s): ${failures.map((e) => getErrorMessage(e) || String(e)).join('; ')}`);
                     err.causes = failures;
                     throw err;
                 }
             }
         };
         try {
-            await withTimeout(BitShares.subscribe('account', bsCallback, accountName), constants_1.NATIVE_CLIENT.SUBSCRIPTIONS.SUBSCRIBE_TIMEOUT_MS, 'BitShares.subscribe');
+            await withTimeout(BitShares.subscribe('account', bsCallback, accountName), NATIVE_CLIENT.SUBSCRIPTIONS.SUBSCRIBE_TIMEOUT_MS, 'BitShares.subscribe');
         }
         catch (subscribeErr) {
             // Roll back any partial native-subscription state set up before the
@@ -453,7 +390,7 @@ async function _ensureAccountSubscriber(accountName, userCallback = null) {
                 }
                 catch (rollbackErr) {
                     chainOrdersLogger.warn(`Failed to roll back partial subscription for ${accountName} after error: ` +
-                        `${(0, errors_1.getErrorMessage)(rollbackErr)}`);
+                        `${getErrorMessage(rollbackErr)}`);
                 }
             }
             throw subscribeErr;
@@ -480,7 +417,7 @@ async function selectAccount() {
     accountNames.forEach((name, index) => {
         console.log(`${index + 1}. ${name}`);
     });
-    const choiceStr = await (0, system_1.readInput)('Select account number: ');
+    const choiceStr = await readInput('Select account number: ');
     const choice = parseInt(choiceStr, 10) - 1;
     if (choice < 0 || choice >= accountNames.length) {
         throw new Error('Invalid account selection.');
@@ -499,7 +436,7 @@ async function selectAccount() {
         }
     }
     catch (e) {
-        console.error(`Failed to resolve account ID for ${selectedAccount}: ${(0, errors_1.getErrorMessage)(e)}`);
+        console.error(`Failed to resolve account ID for ${selectedAccount}: ${getErrorMessage(e)}`);
     }
     if (selectedId) {
         await setPreferredAccount(selectedId, selectedAccount);
@@ -514,14 +451,14 @@ async function selectAccount() {
  * @returns {boolean} True if value is a daemon signing token
  */
 function isDaemonSigningToken(value) {
-    return (0, key_store_1.getKeyStore)().isDaemonSigningKey(value);
+    return getKeyStore().isDaemonSigningKey(value);
 }
 /**
  * Execute blockchain operations via the credential daemon.
  * @param {string} accountName - Account name
  * @param {Object} signingToken - Daemon signing token with socketPath, sessionId, botHmacSecret
- * @param {Array<import('./types').CreatedOperation>} operations - Array of operation objects
- * @returns {Promise<import('./types').BroadcastResult>} Broadcast result
+ * @param {Array<import('./types.js').CreatedOperation>} operations - Array of operation objects
+ * @returns {Promise<import('./types.js').BroadcastResult>} Broadcast result
  */
 async function executeViaDaemonToken(accountName, signingToken, operations, extraOptions = {}) {
     const nodeManager = getNodeManager();
@@ -531,9 +468,9 @@ async function executeViaDaemonToken(accountName, signingToken, operations, extr
     if (healthyNodes.length > 0 && nodeManager && !opts.fallbackNodes && !opts.nodeUrl) {
         opts.nodeUrl = healthyNodes[0];
         opts.fallbackNodes = fallbackNodes;
-        opts.onNodeFailed = (nodeUrl) => nodeManager.reportNodeFailure(nodeUrl, 'BROADCAST_DEADLINE', 'broadcast');
+        opts.onNodeFailed = (nodeUrl) => nodeManager.reportNodeFailure(nodeUrl, DAEMON_CODES.BROADCAST_DEADLINE, 'broadcast');
     }
-    return (0, key_store_1.getKeyStore)().executeOperations(accountName, operations, signingToken, opts);
+    return getKeyStore().executeOperations(accountName, operations, signingToken, opts);
 }
 /**
  * Fetch a single limit order by id from the blockchain.
@@ -560,7 +497,7 @@ async function executeViaDaemonToken(accountName, signingToken, operations, extr
  * @returns {Promise<Object|null>} Raw chain order object, or null if not found
  * @throws {Error} On connection or RPC failure
  */
-async function readSingleOrder(orderId, timeoutMs = constants_1.TIMING.CONNECTION_TIMEOUT_MS) {
+async function readSingleOrder(orderId, timeoutMs = TIMING.CONNECTION_TIMEOUT_MS) {
     if (!orderId || typeof orderId !== 'string')
         return null;
     await waitForConnected(timeoutMs);
@@ -589,7 +526,7 @@ async function readSingleOrder(orderId, timeoutMs = constants_1.TIMING.CONNECTIO
  * @param {number} [timeoutMs] - Connection timeout in milliseconds
  * @returns {Promise<Map<string, Object|null>>} Map of orderId → raw order or null
  */
-async function batchReadOrders(orderIds, timeoutMs = constants_1.TIMING.CONNECTION_TIMEOUT_MS) {
+async function batchReadOrders(orderIds, timeoutMs = TIMING.CONNECTION_TIMEOUT_MS) {
     if (!Array.isArray(orderIds) || orderIds.length === 0)
         return new Map();
     const uniqueIds = [...new Set(orderIds.filter((id) => id && typeof id === 'string'))];
@@ -623,7 +560,7 @@ async function batchReadOrders(orderIds, timeoutMs = constants_1.TIMING.CONNECTI
  * @param {boolean} suppress_log - Whether to suppress the log
  * @returns {Promise<Array>} Array of raw order objects from chain
  */
-async function readOpenOrders(accountId = null, timeoutMs = constants_1.TIMING.CONNECTION_TIMEOUT_MS, suppress_log = true) {
+async function readOpenOrders(accountId = null, timeoutMs = TIMING.CONNECTION_TIMEOUT_MS, suppress_log = true) {
     const { orders } = await readOpenOrdersWithMeta(accountId, timeoutMs, suppress_log);
     return orders;
 }
@@ -638,7 +575,7 @@ async function readOpenOrders(accountId = null, timeoutMs = constants_1.TIMING.C
  * @param {boolean} [suppress_log] - Whether to suppress the log
  * @returns {Promise<{orders: Array, truncated: boolean}>} Raw order objects plus truncation flag
  */
-async function readOpenOrdersWithMetaSafe(chainOrdersModule, accountId = null, timeoutMs = constants_1.TIMING.CONNECTION_TIMEOUT_MS, suppress_log = true) {
+async function readOpenOrdersWithMetaSafe(chainOrdersModule, accountId = null, timeoutMs = TIMING.CONNECTION_TIMEOUT_MS, suppress_log = true) {
     if (chainOrdersModule && typeof chainOrdersModule.readOpenOrdersWithMeta === 'function') {
         return await chainOrdersModule.readOpenOrdersWithMeta(accountId, timeoutMs, suppress_log);
     }
@@ -698,7 +635,7 @@ async function readOpenOrdersGuarded(chainOrdersModule, accountId = null, option
  * @param {boolean} suppress_log - Whether to suppress the log
  * @returns {Promise<{orders: Array, truncated: boolean}>} Raw order objects plus truncation flag
  */
-async function readOpenOrdersWithMeta(accountId = null, timeoutMs = constants_1.TIMING.CONNECTION_TIMEOUT_MS, suppress_log = true) {
+async function readOpenOrdersWithMeta(accountId = null, timeoutMs = TIMING.CONNECTION_TIMEOUT_MS, suppress_log = true) {
     await waitForConnected(timeoutMs);
     try {
         let accId = accountId;
@@ -724,7 +661,7 @@ async function readOpenOrdersWithMeta(accountId = null, timeoutMs = constants_1.
         return { orders, truncated };
     }
     catch (error) {
-        chainOrdersLogger.error(`Error reading open orders: ${(0, errors_1.getErrorMessage)(error)}`);
+        chainOrdersLogger.error(`Error reading open orders: ${getErrorMessage(error)}`);
         throw error;
     }
 }
@@ -769,7 +706,7 @@ async function listenForFills(accountRef, callback) {
         accountId = await resolveAccountId(accountName);
     }
     if (accountId) {
-        readOpenOrders(accountId, 30000, true).catch((error) => chainOrdersLogger.error(`Error loading account for listening: ${(0, errors_1.getErrorMessage)(error)}`));
+        readOpenOrders(accountId, TIMING.CONNECTION_TIMEOUT_MS, true).catch((error) => chainOrdersLogger.error(`Error loading account for listening: ${getErrorMessage(error)}`));
     }
     else {
         chainOrdersLogger.warn('Unable to derive account id before listening for fills; skipping open-order prefetch.');
@@ -798,14 +735,14 @@ async function listenForFills(accountRef, callback) {
                         }
                     }
                     catch (e) {
-                        chainOrdersLogger.warn(`Unsubscribe failed: ${(0, errors_1.getErrorMessage)(e)}`);
+                        chainOrdersLogger.warn(`Unsubscribe failed: ${getErrorMessage(e)}`);
                     }
                     accountSubscriptions.delete(accountName);
                 }
             });
         }
         catch (e) {
-            chainOrdersLogger.error(`Error unsubscribing listenForFills ${(0, errors_1.getErrorMessage)(e)}`);
+            chainOrdersLogger.error(`Error unsubscribing listenForFills ${getErrorMessage(e)}`);
         }
     };
 }
@@ -840,7 +777,7 @@ async function buildUpdateOrderOp(accountName, orderId, newParams, cachedOrder =
     const sellPrecision = await _getAssetPrecision(sellAssetId);
     const receivePrecision = await _getAssetPrecision(receiveAssetId);
     const currentSellInt = toFiniteNumber(order.for_sale);
-    const currentSellFloat = (0, math_1.blockchainToFloat)(currentSellInt, sellPrecision);
+    const currentSellFloat = blockchainToFloat(currentSellInt, sellPrecision);
     const priceRatioBase = order.sell_price.base.amount;
     const priceRatioQuote = order.sell_price.quote.amount;
     const currentReceiveInt = Math.round((currentSellInt * priceRatioQuote) / priceRatioBase);
@@ -851,12 +788,12 @@ async function buildUpdateOrderOp(accountName, orderId, newParams, cachedOrder =
     let newSellFloat;
     if (newParams.amountToSell !== undefined && newParams.amountToSell !== null) {
         newSellFloat = newParams.amountToSell;
-        newSellInt = (0, math_1.floatToBlockchainInt)(newSellFloat, sellPrecision);
+        newSellInt = floatToBlockchainInt(newSellFloat, sellPrecision);
     }
     else {
         // Keep current amount exactly as-is on-chain, bypassing float conversion
         newSellInt = currentSellInt;
-        newSellFloat = (0, math_1.blockchainToFloat)(currentSellInt, sellPrecision);
+        newSellFloat = blockchainToFloat(currentSellInt, sellPrecision);
     }
     // Determine an initial receive amount for price-change detection.
     // Policy:
@@ -865,7 +802,7 @@ async function buildUpdateOrderOp(accountName, orderId, newParams, cachedOrder =
     // - Else: keep the existing on-chain price by scaling receive with sell.
     let candidateReceiveInt;
     if (newParams.minToReceive !== undefined && newParams.minToReceive !== null) {
-        candidateReceiveInt = (0, math_1.floatToBlockchainInt)(newParams.minToReceive, receivePrecision);
+        candidateReceiveInt = floatToBlockchainInt(newParams.minToReceive, receivePrecision);
     }
     else if (newParams.newPrice !== undefined && newParams.newPrice !== null) {
         const price = toFiniteNumber(newParams.newPrice);
@@ -873,14 +810,14 @@ async function buildUpdateOrderOp(accountName, orderId, newParams, cachedOrder =
         const receiveFloat = (newParams.orderType === 'sell')
             ? (sellFloat * price)
             : (sellFloat / price);
-        candidateReceiveInt = (0, math_1.floatToBlockchainInt)(receiveFloat, receivePrecision);
+        candidateReceiveInt = floatToBlockchainInt(receiveFloat, receivePrecision);
     }
     else {
         candidateReceiveInt = Math.round((newSellInt * priceRatioQuote) / priceRatioBase);
     }
     // Validate amounts before converting to blockchain integers / computing deltas
-    const candidateReceiveFloat = (0, math_1.blockchainToFloat)(candidateReceiveInt, receivePrecision);
-    if (!(0, math_1.validateOrderAmountsWithinLimits)(newSellFloat, candidateReceiveFloat, sellPrecision, receivePrecision)) {
+    const candidateReceiveFloat = blockchainToFloat(candidateReceiveInt, receivePrecision);
+    if (!validateOrderAmountsWithinLimits(newSellFloat, candidateReceiveFloat, sellPrecision, receivePrecision)) {
         throw new Error(`Cannot update order: calculated amounts exceed blockchain limits. ` +
             `Sell: ${newSellFloat}, Receive: ${candidateReceiveFloat}. ` +
             `This typically happens with extreme price values or mixed absolute/relative price bounds that diverge too far. ` +
@@ -895,8 +832,8 @@ async function buildUpdateOrderOp(accountName, orderId, newParams, cachedOrder =
     // This happens when newAmountToSell was rounded, causing floatToBlockchainInt
     // to produce a different value than what's currently on-chain.
     if (Math.abs(deltaSellInt) === 1 && newParams.amountToSell !== undefined && newParams.amountToSell !== null) {
-        const roundedNewSellInt = (0, math_1.normalizeInt)(newSellInt, sellPrecision);
-        const roundedCurrentSellInt = (0, math_1.normalizeInt)(currentSellInt, sellPrecision);
+        const roundedNewSellInt = normalizeInt(newSellInt, sellPrecision);
+        const roundedCurrentSellInt = normalizeInt(currentSellInt, sellPrecision);
         // If they match after rounding to precision, use the current amount (delta = 0)
         if (roundedNewSellInt === roundedCurrentSellInt || Math.abs(roundedNewSellInt - roundedCurrentSellInt) <= 1) {
             newSellInt = currentSellInt;
@@ -906,14 +843,14 @@ async function buildUpdateOrderOp(accountName, orderId, newParams, cachedOrder =
     // First, compute the receive amount with the current delta (not adjusted yet)
     let newReceiveInt;
     if (newParams.minToReceive !== undefined && newParams.minToReceive !== null) {
-        newReceiveInt = (0, math_1.floatToBlockchainInt)(newParams.minToReceive, receivePrecision);
+        newReceiveInt = floatToBlockchainInt(newParams.minToReceive, receivePrecision);
     }
     else if (newParams.newPrice !== undefined && newParams.newPrice !== null) {
         const price = toFiniteNumber(newParams.newPrice);
         const receiveFloat = (newParams.orderType === 'sell')
             ? (newSellFloat * price)
             : (newSellFloat / price);
-        newReceiveInt = (0, math_1.floatToBlockchainInt)(receiveFloat, receivePrecision);
+        newReceiveInt = floatToBlockchainInt(receiveFloat, receivePrecision);
     }
     else {
         // Keep existing on-chain price ratio.
@@ -949,23 +886,23 @@ async function buildUpdateOrderOp(accountName, orderId, newParams, cachedOrder =
     const adjustedSellInt = currentSellInt + deltaSellInt;
     // Recompute the final receive amount with the adjusted sell amount
     if (newParams.minToReceive !== undefined && newParams.minToReceive !== null) {
-        newReceiveInt = (0, math_1.floatToBlockchainInt)(newParams.minToReceive, receivePrecision);
+        newReceiveInt = floatToBlockchainInt(newParams.minToReceive, receivePrecision);
     }
     else if (newParams.newPrice !== undefined && newParams.newPrice !== null) {
         const price = toFiniteNumber(newParams.newPrice);
-        const adjustedSellFloat = (0, math_1.blockchainToFloat)(adjustedSellInt, sellPrecision);
+        const adjustedSellFloat = blockchainToFloat(adjustedSellInt, sellPrecision);
         const receiveFloat = (newParams.orderType === 'sell')
             ? (adjustedSellFloat * price)
             : (adjustedSellFloat / price);
-        newReceiveInt = (0, math_1.floatToBlockchainInt)(receiveFloat, receivePrecision);
+        newReceiveInt = floatToBlockchainInt(receiveFloat, receivePrecision);
     }
     else {
         // Keep existing on-chain price ratio.
         newReceiveInt = Math.round((adjustedSellInt * priceRatioQuote) / priceRatioBase);
     }
-    const adjustedSellFloat = (0, math_1.blockchainToFloat)(adjustedSellInt, sellPrecision);
-    const finalReceiveFloat = (0, math_1.blockchainToFloat)(newReceiveInt, receivePrecision);
-    if (!(0, math_1.validateOrderAmountsWithinLimits)(adjustedSellFloat, finalReceiveFloat, sellPrecision, receivePrecision)) {
+    const adjustedSellFloat = blockchainToFloat(adjustedSellInt, sellPrecision);
+    const finalReceiveFloat = blockchainToFloat(newReceiveInt, receivePrecision);
+    if (!validateOrderAmountsWithinLimits(adjustedSellFloat, finalReceiveFloat, sellPrecision, receivePrecision)) {
         throw new Error(`Cannot update order: calculated amounts exceed blockchain limits. ` +
             `Sell: ${adjustedSellFloat}, Receive: ${finalReceiveFloat}. ` +
             `Consider adjusting minPrice/maxPrice configuration.`);
@@ -974,7 +911,7 @@ async function buildUpdateOrderOp(accountName, orderId, newParams, cachedOrder =
         op: {
             op_name: 'limit_order_update',
             op_data: {
-                fee: { amount: 0, asset_id: constants_1.NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
+                fee: { amount: 0, asset_id: NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
                 seller: accId,
                 order: orderId,
                 new_price: {
@@ -1015,8 +952,8 @@ async function broadcastTxWithClassification(tx, accountName, operations = []) {
         return await tx.broadcast();
     }
     catch (err) {
-        if ((0, broadcast_failure_1.classifyBroadcastFailure)(err) === 'uncertain') {
-            throw new dexbot_credential_client_1.BroadcastUncertainError(`Direct-key broadcast uncertain for ${accountName}: ${(0, errors_1.getErrorMessage)(err)}`, { operations: operations.length > 0 ? operations : null, accountName, timeoutMs: null });
+        if (classifyBroadcastFailure(err) === 'uncertain') {
+            throw new BroadcastUncertainError(`Direct-key broadcast uncertain for ${accountName}: ${getErrorMessage(err)}`, { operations: operations.length > 0 ? operations : null, accountName, timeoutMs: null });
         }
         throw err;
     }
@@ -1058,7 +995,7 @@ async function updateOrder(accountName, privateKey, orderId, newParams, extraOpt
         return { success: true, orderId };
     }
     catch (error) {
-        chainOrdersLogger.error(`Error updating order: ${(0, errors_1.getErrorMessage)(error)}`);
+        chainOrdersLogger.error(`Error updating order: ${getErrorMessage(error)}`);
         throw error;
     }
 }
@@ -1084,13 +1021,13 @@ async function buildCreateOrderOp(accountName, amountToSell, sellAssetId, minToR
     }
     const sellPrecision = await _getAssetPrecision(sellAssetId);
     const receivePrecision = await _getAssetPrecision(receiveAssetId);
-    const amountToSellInt = (0, math_1.floatToBlockchainInt)(amountToSell, sellPrecision);
-    const minToReceiveInt = (0, math_1.floatToBlockchainInt)(minToReceive, receivePrecision);
+    const amountToSellInt = floatToBlockchainInt(amountToSell, sellPrecision);
+    const minToReceiveInt = floatToBlockchainInt(minToReceive, receivePrecision);
     // CRITICAL: Validate order amounts before creating operation
     // This prevents "Assert Exception: min_to_receive.amount > 0" errors from BitShares
     // when order sizes are too small and round to 0 after precision conversion
     // Returns null instead of throwing to allow caller to skip invalid orders gracefully
-    if (!(0, math_1.validateOrderAmountsWithinLimits)(amountToSell, minToReceive, sellPrecision, receivePrecision)) {
+    if (!validateOrderAmountsWithinLimits(amountToSell, minToReceive, sellPrecision, receivePrecision)) {
         chainOrdersLogger.warn(`Order skipped: amounts would round to 0 on blockchain\n` +
             `  Float values: sell=${amountToSell}, receive=${minToReceive}\n` +
             `  Blockchain integers: sell=${amountToSellInt} (prec ${sellPrecision}), receive=${minToReceiveInt} (prec ${receivePrecision})\n` +
@@ -1100,7 +1037,7 @@ async function buildCreateOrderOp(accountName, amountToSell, sellAssetId, minToR
     const op = {
         op_name: 'limit_order_create',
         op_data: {
-            fee: { amount: 0, asset_id: constants_1.NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
+            fee: { amount: 0, asset_id: NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
             seller: accId,
             amount_to_sell: { amount: amountToSellInt, asset_id: sellAssetId },
             min_to_receive: { amount: minToReceiveInt, asset_id: receiveAssetId },
@@ -1152,7 +1089,7 @@ async function createOrder(accountName, privateKey, amountToSell, sellAssetId, m
         return result;
     }
     catch (error) {
-        chainOrdersLogger.error(`Error creating limit order: ${(0, errors_1.getErrorMessage)(error)}`);
+        chainOrdersLogger.error(`Error creating limit order: ${getErrorMessage(error)}`);
         throw error;
     }
 }
@@ -1170,7 +1107,7 @@ async function buildCancelOrderOp(accountName, orderId) {
     return {
         op_name: 'limit_order_cancel',
         op_data: {
-            fee: { amount: 0, asset_id: constants_1.NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
+            fee: { amount: 0, asset_id: NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
             fee_paying_account: accId,
             order: orderId
         }
@@ -1212,7 +1149,7 @@ async function cancelOrder(accountName, privateKey, orderId, extraOptions = {})
     catch (error) {
         if (accountId) {
             try {
-                const { orders: openOrders, truncated } = await readOpenOrdersWithMeta(accountId, constants_1.TIMING.CONNECTION_TIMEOUT_MS, true);
+                const { orders: openOrders, truncated } = await readOpenOrdersWithMeta(accountId, TIMING.CONNECTION_TIMEOUT_MS, true);
                 // Only a NON-EMPTY, NON-TRUNCATED read is authoritative: the
                 // order being absent from a live account snapshot confirms the
                 // cancellation landed. An empty read is ambiguous (the node may
@@ -1233,7 +1170,7 @@ async function cancelOrder(accountName, privateKey, orderId, extraOptions = {})
                     // cancelled order was the account's only order) without
                     // trusting a lagging node's empty window.
                     try {
-                        const probe = await readSingleOrder(String(orderId), constants_1.TIMING.CONNECTION_TIMEOUT_MS);
+                        const probe = await readSingleOrder(String(orderId), TIMING.CONNECTION_TIMEOUT_MS);
                         if (probe === null)
                             confirmedAbsent = true;
                     }
@@ -1258,7 +1195,7 @@ async function cancelOrder(accountName, privateKey, orderId, extraOptions = {})
                 // Fall through to the original error.
             }
         }
-        chainOrdersLogger.error(`Error cancelling order: ${(0, errors_1.getErrorMessage)(error)}`);
+        chainOrdersLogger.error(`Error cancelling order: ${getErrorMessage(error)}`);
         throw error;
     }
 }
@@ -1310,7 +1247,7 @@ async function executeBatch(accountName, privateKey, operations, extraOptions =
         };
     }
     catch (error) {
-        chainOrdersLogger.error(`Error executing batch transaction: ${(0, errors_1.getErrorMessage)(error)}`);
+        chainOrdersLogger.error(`Error executing batch transaction: ${getErrorMessage(error)}`);
         throw error;
     }
 }
@@ -1384,7 +1321,7 @@ async function getOnChainAssetBalances(accountRef, assets, options = {}) {
                 }
             }
             catch (dealErr) {
-                chainOrdersLogger.warn(`getOnChainAssetBalances: failed to fetch credit deals for ${accountRef}: ${(0, errors_1.getErrorMessage)(dealErr)}`);
+                chainOrdersLogger.warn(`getOnChainAssetBalances: failed to fetch credit deals for ${accountRef}: ${getErrorMessage(dealErr)}`);
             }
         }
         // If assets omitted, build list from balances and limit_orders
@@ -1414,7 +1351,7 @@ async function getOnChainAssetBalances(accountRef, assets, options = {}) {
                 }
             }
             catch (e) {
-                chainOrdersLogger.warn(`lookup_asset_symbols failed for ${a}: ${(0, errors_1.getErrorMessage)(e)}`);
+                chainOrdersLogger.warn(`lookup_asset_symbols failed for ${a}: ${getErrorMessage(e)}`);
             }
             // try to get precision and symbol
             let precision = null;
@@ -1427,7 +1364,7 @@ async function getOnChainAssetBalances(accountRef, assets, options = {}) {
                 }
             }
             catch (e) {
-                chainOrdersLogger.warn(`Failed to fetch asset data for ${aid}: ${(0, errors_1.getErrorMessage)(e)}`);
+                chainOrdersLogger.warn(`Failed to fetch asset data for ${aid}: ${getErrorMessage(e)}`);
             }
             if (precision === null) {
                 chainOrdersLogger.error(`CRITICAL: Could not determine precision for asset ${aid}. Skipping balance entry to prevent massive scaling errors.`);
@@ -1435,14 +1372,14 @@ async function getOnChainAssetBalances(accountRef, assets, options = {}) {
             }
             const freeRaw = freeInt.get(String(aid)) || 0;
             const lockedRaw = lockedInt.get(String(aid)) || 0;
-            const free = (0, math_1.blockchainToFloat)(freeRaw, precision);
-            const locked = (0, math_1.blockchainToFloat)(lockedRaw, precision);
+            const free = blockchainToFloat(freeRaw, precision);
+            const locked = blockchainToFloat(lockedRaw, precision);
             out[String(a)] = { assetId: String(aid), symbol, precision, freeRaw, lockedRaw, free, locked, total: free + locked };
         }
         return out;
     }
     catch (err) {
-        chainOrdersLogger.error(`getOnChainAssetBalances failed: ${(0, errors_1.getErrorMessage)(err)}`);
+        chainOrdersLogger.error(`getOnChainAssetBalances failed: ${getErrorMessage(err)}`);
         return {};
     }
 }
@@ -1460,7 +1397,7 @@ function buildLiquidityPoolExchangeOp(accountId, poolId, sellAmountInt, sellAsse
     return {
         op_name: 'liquidity_pool_exchange',
         op_data: {
-            fee: { amount: 0, asset_id: constants_1.NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
+            fee: { amount: 0, asset_id: NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
             account: accountId,
             pool: poolId,
             amount_to_sell: { amount: sellAmountInt, asset_id: sellAssetId },
@@ -1476,5 +1413,5 @@ function buildLiquidityPoolExchangeOp(accountId, poolId, sellAmountInt, sellAsse
 function getFillProcessingMode() {
     return FILL_PROCESSING_MODE;
 }
-module.exports = { selectAccount, setPreferredAccount, resolveAccountId, resolveAccountName, readOpenOrders, readOpenOrdersWithMeta, readOpenOrdersWithMetaSafe, readOpenOrdersGuarded, readSingleOrder, batchReadOrders, listenForFills, updateOrder, createOrder, cancelOrder, getOnChainAssetBalances, getFillProcessingMode, FILL_PROCESSING_MODE, buildUpdateOrderOp, buildCreateOrderOp, buildCancelOrderOp, buildLiquidityPoolExchangeOp, executeBatch, wasRecentlyOwnCancelled, recordOwnCancel, BroadcastUncertainError: dexbot_credential_client_1.BroadcastUncertainError, broadcastTxWithClassification };
+export { selectAccount, setPreferredAccount, resolveAccountId, resolveAccountName, readOpenOrders, readOpenOrdersWithMeta, readOpenOrdersWithMetaSafe, readOpenOrdersGuarded, readSingleOrder, batchReadOrders, listenForFills, updateOrder, createOrder, cancelOrder, getOnChainAssetBalances, getFillProcessingMode, FILL_PROCESSING_MODE, buildUpdateOrderOp, buildCreateOrderOp, buildCancelOrderOp, buildLiquidityPoolExchangeOp, executeBatch, wasRecentlyOwnCancelled, recordOwnCancel, BroadcastUncertainError, broadcastTxWithClassification };
 //# sourceMappingURL=chain_orders.js.map