dexbot 1.3.2 → 1.4.0

package/dist/modules/chain_orders.js

@@ -106,19 +106,81 @@
  *
  * ===============================================================================
  */
-const { BitShares, createAccountClient, waitForConnected, withTimeout } = require('./bitshares_client');
-const { floatToBlockchainInt, blockchainToFloat, normalizeInt, validateOrderAmountsWithinLimits } = require('./order/utils/math');
-const { FILL_PROCESSING, TIMING, NATIVE_CLIENT } = require('./constants');
-const Format = require('./order/format');
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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.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;
+const client = __importStar(require("./bitshares_client"));
+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 logger_1 = __importDefault(require("./logger"));
+const errors_1 = require("./utils/errors");
+function getNodeManager() { return require('./bitshares_client').getNodeManager(); }
 const { toFiniteNumber } = Format;
-const AsyncLock = require('./order/async_lock');
-const { readInput } = require('./order/utils/system');
-const chainKeys = require('./chain_keys');
-const { getKeyStore } = require('./key_store');
-const { BroadcastUncertainError } = require('./dexbot_credential_client');
-const Logger = require('./logger');
-const chainOrdersLogger = new Logger('ChainOrders');
-const { ORDER_EVENTS } = NATIVE_CLIENT;
+const chainOrdersLogger = new logger_1.default('ChainOrders');
+const { ORDER_EVENTS } = constants_1.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
@@ -165,14 +227,15 @@ 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 = FILL_PROCESSING.MODE;
+const FILL_PROCESSING_MODE = constants_1.FILL_PROCESSING.MODE;
+exports.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 AsyncLock();
-const _preferredAccountLock = new AsyncLock();
-const _resolutionLock = new AsyncLock();
+const _subscriptionLock = new async_lock_1.default();
+const _preferredAccountLock = new async_lock_1.default();
+const _resolutionLock = new async_lock_1.default();
 // Cache for account resolutions (name -> id and id -> name)
 const _accountResolutionCache = new Map();
 /**
@@ -202,7 +265,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: ${e.message}`);
+        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: asset not found or precision missing.`);
 }
@@ -346,9 +409,9 @@ async function _ensureAccountSubscriber(accountName, userCallback = null) {
         // BitShares callback that receives raw updates and dispatches to user callbacks
         const bsCallback = async (updates) => {
             // Filter for fill-related operations
-            const fills = updates.filter(update => {
+            const fills = updates.filter((update) => {
                 const op = update.op;
-                return op && op[0] === FILL_PROCESSING.OPERATION_TYPE; // operation type for fill_order
+                return op && op[0] === constants_1.FILL_PROCESSING.OPERATION_TYPE; // operation type for fill_order
             });
             if (fills.length > 0) {
                 // Call each registered user callback with the fills array
@@ -359,18 +422,18 @@ async function _ensureAccountSubscriber(accountName, userCallback = null) {
                     }
                     catch (e) {
                         failures.push(e);
-                        chainOrdersLogger.error(`chain_orders listener error ${e.message}`);
+                        chainOrdersLogger.error(`chain_orders listener error ${(0, errors_1.getErrorMessage)(e)}`);
                     }
                 }
                 if (failures.length > 0) {
-                    const err = new Error(`Fill listener delivery failed for ${failures.length} callback(s): ${failures.map(e => e.message || String(e)).join('; ')}`);
+                    const err = new Error(`Fill listener delivery failed for ${failures.length} callback(s): ${failures.map((e) => (0, errors_1.getErrorMessage)(e) || String(e)).join('; ')}`);
                     err.causes = failures;
                     throw err;
                 }
             }
         };
         try {
-            await withTimeout(BitShares.subscribe('account', bsCallback, accountName), NATIVE_CLIENT.SUBSCRIPTIONS.SUBSCRIBE_TIMEOUT_MS, 'BitShares.subscribe');
+            await withTimeout(BitShares.subscribe('account', bsCallback, accountName), constants_1.NATIVE_CLIENT.SUBSCRIPTIONS.SUBSCRIBE_TIMEOUT_MS, 'BitShares.subscribe');
         }
         catch (subscribeErr) {
             // Roll back any partial native-subscription state set up before the
@@ -385,7 +448,7 @@ async function _ensureAccountSubscriber(accountName, userCallback = null) {
                 }
                 catch (rollbackErr) {
                     chainOrdersLogger.warn(`Failed to roll back partial subscription for ${accountName} after error: ` +
-                        `${rollbackErr?.message || rollbackErr}`);
+                        `${(0, errors_1.getErrorMessage)(rollbackErr)}`);
                 }
             }
             throw subscribeErr;
@@ -412,7 +475,7 @@ async function selectAccount() {
     accountNames.forEach((name, index) => {
         console.log(`${index + 1}. ${name}`);
     });
-    const choiceStr = await readInput('Select account number: ');
+    const choiceStr = await (0, system_1.readInput)('Select account number: ');
     const choice = parseInt(choiceStr, 10) - 1;
     if (choice < 0 || choice >= accountNames.length) {
         throw new Error('Invalid account selection.');
@@ -431,7 +494,7 @@ async function selectAccount() {
         }
     }
     catch (e) {
-        console.error(`Failed to resolve account ID for ${selectedAccount}: ${e.message}`);
+        console.error(`Failed to resolve account ID for ${selectedAccount}: ${(0, errors_1.getErrorMessage)(e)}`);
     }
     if (selectedId) {
         await setPreferredAccount(selectedId, selectedAccount);
@@ -446,7 +509,7 @@ async function selectAccount() {
  * @returns {boolean} True if value is a daemon signing token
  */
 function isDaemonSigningToken(value) {
-    return getKeyStore().isDaemonSigningKey(value);
+    return (0, key_store_1.getKeyStore)().isDaemonSigningKey(value);
 }
 /**
  * Execute blockchain operations via the credential daemon.
@@ -456,7 +519,16 @@ function isDaemonSigningToken(value) {
  * @returns {Promise<import('./types').BroadcastResult>} Broadcast result
  */
 async function executeViaDaemonToken(accountName, signingToken, operations, extraOptions = {}) {
-    return getKeyStore().executeOperations(accountName, operations, signingToken, extraOptions);
+    const nodeManager = getNodeManager();
+    const healthyNodes = nodeManager?.getHealthyNodes() ?? [];
+    const fallbackNodes = healthyNodes.length > 1 ? healthyNodes.slice(1) : undefined;
+    const opts = extraOptions;
+    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');
+    }
+    return (0, key_store_1.getKeyStore)().executeOperations(accountName, operations, signingToken, opts);
 }
 /**
  * Fetch a single limit order by id from the blockchain.
@@ -483,7 +555,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 = TIMING.CONNECTION_TIMEOUT_MS) {
+async function readSingleOrder(orderId, timeoutMs = constants_1.TIMING.CONNECTION_TIMEOUT_MS) {
     if (!orderId || typeof orderId !== 'string')
         return null;
     await waitForConnected(timeoutMs);
@@ -512,10 +584,10 @@ async function readSingleOrder(orderId, timeoutMs = TIMING.CONNECTION_TIMEOUT_MS
  * @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 = TIMING.CONNECTION_TIMEOUT_MS) {
+async function batchReadOrders(orderIds, timeoutMs = constants_1.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'))];
+    const uniqueIds = [...new Set(orderIds.filter((id) => id && typeof id === 'string'))];
     if (uniqueIds.length === 0)
         return new Map();
     await waitForConnected(timeoutMs);
@@ -546,7 +618,7 @@ async function batchReadOrders(orderIds, timeoutMs = TIMING.CONNECTION_TIMEOUT_M
  * @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 = TIMING.CONNECTION_TIMEOUT_MS, suppress_log = true) {
+async function readOpenOrders(accountId = null, timeoutMs = constants_1.TIMING.CONNECTION_TIMEOUT_MS, suppress_log = true) {
     await waitForConnected(timeoutMs);
     try {
         let accId = accountId;
@@ -570,7 +642,7 @@ async function readOpenOrders(accountId = null, timeoutMs = TIMING.CONNECTION_TI
         return orders;
     }
     catch (error) {
-        chainOrdersLogger.error(`Error reading open orders: ${error.message}`);
+        chainOrdersLogger.error(`Error reading open orders: ${(0, errors_1.getErrorMessage)(error)}`);
         throw error;
     }
 }
@@ -615,7 +687,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: ${error.message}`));
+        readOpenOrders(accountId, 30000, true).catch((error) => chainOrdersLogger.error(`Error loading account for listening: ${(0, errors_1.getErrorMessage)(error)}`));
     }
     else {
         chainOrdersLogger.warn('Unable to derive account id before listening for fills; skipping open-order prefetch.');
@@ -644,14 +716,14 @@ async function listenForFills(accountRef, callback) {
                         }
                     }
                     catch (e) {
-                        chainOrdersLogger.warn(`Unsubscribe failed: ${e.message}`);
+                        chainOrdersLogger.warn(`Unsubscribe failed: ${(0, errors_1.getErrorMessage)(e)}`);
                     }
                     accountSubscriptions.delete(accountName);
                 }
             });
         }
         catch (e) {
-            chainOrdersLogger.error(`Error unsubscribing listenForFills ${e.message}`);
+            chainOrdersLogger.error(`Error unsubscribing listenForFills ${(0, errors_1.getErrorMessage)(e)}`);
         }
     };
 }
@@ -677,7 +749,7 @@ async function buildUpdateOrderOp(accountName, orderId, newParams, cachedOrder =
     let order = cachedOrder;
     if (!order) {
         const orders = await readOpenOrders(accId);
-        order = orders.find(o => o.id === orderId);
+        order = orders.find((o) => o.id === orderId);
     }
     if (!order)
         throw new Error(`Order ${orderId} not found`);
@@ -686,11 +758,10 @@ 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 = blockchainToFloat(currentSellInt, sellPrecision);
+    const currentSellFloat = (0, math_1.blockchainToFloat)(currentSellInt, sellPrecision);
     const priceRatioBase = order.sell_price.base.amount;
     const priceRatioQuote = order.sell_price.quote.amount;
     const currentReceiveInt = Math.round((currentSellInt * priceRatioQuote) / priceRatioBase);
-    const currentReceiveFloat = blockchainToFloat(currentReceiveInt, receivePrecision);
     // Determine target sell amount first.
     // IMPORTANT: When amountToSell is undefined, use currentSellInt directly to avoid
     // floating-point precision loss (blockchainToFloat -> floatToBlockchainInt roundtrip).
@@ -698,12 +769,12 @@ async function buildUpdateOrderOp(accountName, orderId, newParams, cachedOrder =
     let newSellFloat;
     if (newParams.amountToSell !== undefined && newParams.amountToSell !== null) {
         newSellFloat = newParams.amountToSell;
-        newSellInt = floatToBlockchainInt(newSellFloat, sellPrecision);
+        newSellInt = (0, math_1.floatToBlockchainInt)(newSellFloat, sellPrecision);
     }
     else {
         // Keep current amount exactly as-is on-chain, bypassing float conversion
         newSellInt = currentSellInt;
-        newSellFloat = blockchainToFloat(currentSellInt, sellPrecision);
+        newSellFloat = (0, math_1.blockchainToFloat)(currentSellInt, sellPrecision);
     }
     // Determine an initial receive amount for price-change detection.
     // Policy:
@@ -712,7 +783,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 = floatToBlockchainInt(newParams.minToReceive, receivePrecision);
+        candidateReceiveInt = (0, math_1.floatToBlockchainInt)(newParams.minToReceive, receivePrecision);
     }
     else if (newParams.newPrice !== undefined && newParams.newPrice !== null) {
         const price = toFiniteNumber(newParams.newPrice);
@@ -720,14 +791,14 @@ async function buildUpdateOrderOp(accountName, orderId, newParams, cachedOrder =
         const receiveFloat = (newParams.orderType === 'sell')
             ? (sellFloat * price)
             : (sellFloat / price);
-        candidateReceiveInt = floatToBlockchainInt(receiveFloat, receivePrecision);
+        candidateReceiveInt = (0, math_1.floatToBlockchainInt)(receiveFloat, receivePrecision);
     }
     else {
         candidateReceiveInt = Math.round((newSellInt * priceRatioQuote) / priceRatioBase);
     }
     // Validate amounts before converting to blockchain integers / computing deltas
-    const candidateReceiveFloat = blockchainToFloat(candidateReceiveInt, receivePrecision);
-    if (!validateOrderAmountsWithinLimits(newSellFloat, candidateReceiveFloat, sellPrecision, receivePrecision)) {
+    const candidateReceiveFloat = (0, math_1.blockchainToFloat)(candidateReceiveInt, receivePrecision);
+    if (!(0, math_1.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. ` +
@@ -742,8 +813,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 = normalizeInt(newSellInt, sellPrecision);
-        const roundedCurrentSellInt = normalizeInt(currentSellInt, sellPrecision);
+        const roundedNewSellInt = (0, math_1.normalizeInt)(newSellInt, sellPrecision);
+        const roundedCurrentSellInt = (0, math_1.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;
@@ -753,14 +824,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 = floatToBlockchainInt(newParams.minToReceive, receivePrecision);
+        newReceiveInt = (0, math_1.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 = floatToBlockchainInt(receiveFloat, receivePrecision);
+        newReceiveInt = (0, math_1.floatToBlockchainInt)(receiveFloat, receivePrecision);
     }
     else {
         // Keep existing on-chain price ratio.
@@ -796,23 +867,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 = floatToBlockchainInt(newParams.minToReceive, receivePrecision);
+        newReceiveInt = (0, math_1.floatToBlockchainInt)(newParams.minToReceive, receivePrecision);
     }
     else if (newParams.newPrice !== undefined && newParams.newPrice !== null) {
         const price = toFiniteNumber(newParams.newPrice);
-        const adjustedSellFloat = blockchainToFloat(adjustedSellInt, sellPrecision);
+        const adjustedSellFloat = (0, math_1.blockchainToFloat)(adjustedSellInt, sellPrecision);
         const receiveFloat = (newParams.orderType === 'sell')
             ? (adjustedSellFloat * price)
             : (adjustedSellFloat / price);
-        newReceiveInt = floatToBlockchainInt(receiveFloat, receivePrecision);
+        newReceiveInt = (0, math_1.floatToBlockchainInt)(receiveFloat, receivePrecision);
     }
     else {
         // Keep existing on-chain price ratio.
         newReceiveInt = Math.round((adjustedSellInt * priceRatioQuote) / priceRatioBase);
     }
-    const adjustedSellFloat = blockchainToFloat(adjustedSellInt, sellPrecision);
-    const finalReceiveFloat = blockchainToFloat(newReceiveInt, receivePrecision);
-    if (!validateOrderAmountsWithinLimits(adjustedSellFloat, finalReceiveFloat, sellPrecision, receivePrecision)) {
+    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)) {
         throw new Error(`Cannot update order: calculated amounts exceed blockchain limits. ` +
             `Sell: ${adjustedSellFloat}, Receive: ${finalReceiveFloat}. ` +
             `Consider adjusting minPrice/maxPrice configuration.`);
@@ -821,7 +892,7 @@ async function buildUpdateOrderOp(accountName, orderId, newParams, cachedOrder =
         op: {
             op_name: 'limit_order_update',
             op_data: {
-                fee: { amount: 0, asset_id: NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
+                fee: { amount: 0, asset_id: constants_1.NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
                 seller: accId,
                 order: orderId,
                 new_price: {
@@ -850,7 +921,7 @@ async function buildUpdateOrderOp(accountName, orderId, newParams, cachedOrder =
  * @returns {Promise<Object|null>} Success object or null if skipped.
  * @throws {Error} If update fails.
  */
-async function updateOrder(accountName, privateKey, orderId, newParams) {
+async function updateOrder(accountName, privateKey, orderId, newParams, extraOptions = {}) {
     try {
         const buildResult = await buildUpdateOrderOp(accountName, orderId, newParams);
         if (!buildResult) {
@@ -859,7 +930,7 @@ async function updateOrder(accountName, privateKey, orderId, newParams) {
         }
         const { op } = buildResult;
         if (isDaemonSigningToken(privateKey)) {
-            const result = await executeViaDaemonToken(accountName, privateKey, [op]);
+            const result = await executeViaDaemonToken(accountName, privateKey, [op], extraOptions);
             chainOrdersLogger.info(`Order ${orderId} updated successfully`);
             return { success: true, orderId, raw: result.raw, operation_results: result.operation_results };
         }
@@ -878,7 +949,7 @@ async function updateOrder(accountName, privateKey, orderId, newParams) {
         return { success: true, orderId };
     }
     catch (error) {
-        chainOrdersLogger.error(`Error updating order: ${error.message}`);
+        chainOrdersLogger.error(`Error updating order: ${(0, errors_1.getErrorMessage)(error)}`);
         throw error;
     }
 }
@@ -904,13 +975,13 @@ async function buildCreateOrderOp(accountName, amountToSell, sellAssetId, minToR
     }
     const sellPrecision = await _getAssetPrecision(sellAssetId);
     const receivePrecision = await _getAssetPrecision(receiveAssetId);
-    const amountToSellInt = floatToBlockchainInt(amountToSell, sellPrecision);
-    const minToReceiveInt = floatToBlockchainInt(minToReceive, receivePrecision);
+    const amountToSellInt = (0, math_1.floatToBlockchainInt)(amountToSell, sellPrecision);
+    const minToReceiveInt = (0, math_1.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 (!validateOrderAmountsWithinLimits(amountToSell, minToReceive, sellPrecision, receivePrecision)) {
+    if (!(0, math_1.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` +
@@ -920,7 +991,7 @@ async function buildCreateOrderOp(accountName, amountToSell, sellAssetId, minToR
     const op = {
         op_name: 'limit_order_create',
         op_data: {
-            fee: { amount: 0, asset_id: NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
+            fee: { amount: 0, asset_id: constants_1.NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
             seller: accId,
             amount_to_sell: { amount: amountToSellInt, asset_id: sellAssetId },
             min_to_receive: { amount: minToReceiveInt, asset_id: receiveAssetId },
@@ -947,7 +1018,7 @@ async function buildCreateOrderOp(accountName, amountToSell, sellAssetId, minToR
  * @returns {Promise<Object>} The transaction result or dry run info.
  * @throws {Error} If account not found or creation fails.
  */
-async function createOrder(accountName, privateKey, amountToSell, sellAssetId, minToReceive, receiveAssetId, expiration, dryRun = false) {
+async function createOrder(accountName, privateKey, amountToSell, sellAssetId, minToReceive, receiveAssetId, expiration, dryRun = false, extraOptions = {}) {
     try {
         const buildResult = await buildCreateOrderOp(accountName, amountToSell, sellAssetId, minToReceive, receiveAssetId, expiration);
         if (!buildResult)
@@ -958,7 +1029,7 @@ async function createOrder(accountName, privateKey, amountToSell, sellAssetId, m
             return { dryRun: true, params: op.op_data };
         }
         if (isDaemonSigningToken(privateKey)) {
-            const result = await executeViaDaemonToken(accountName, privateKey, [op]);
+            const result = await executeViaDaemonToken(accountName, privateKey, [op], extraOptions);
             chainOrdersLogger.info(`Limit order created successfully for account ${accountName}`);
             return result;
         }
@@ -972,7 +1043,7 @@ async function createOrder(accountName, privateKey, amountToSell, sellAssetId, m
         return result;
     }
     catch (error) {
-        chainOrdersLogger.error(`Error creating limit order: ${error.message}`);
+        chainOrdersLogger.error(`Error creating limit order: ${(0, errors_1.getErrorMessage)(error)}`);
         throw error;
     }
 }
@@ -990,7 +1061,7 @@ async function buildCancelOrderOp(accountName, orderId) {
     return {
         op_name: 'limit_order_cancel',
         op_data: {
-            fee: { amount: 0, asset_id: NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
+            fee: { amount: 0, asset_id: constants_1.NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
             fee_paying_account: accId,
             order: orderId
         }
@@ -1032,8 +1103,8 @@ async function cancelOrder(accountName, privateKey, orderId, extraOptions = {})
     catch (error) {
         if (accountId) {
             try {
-                const openOrders = await readOpenOrders(accountId, TIMING.CONNECTION_TIMEOUT_MS, true);
-                const stillPresent = Array.isArray(openOrders) && openOrders.some(order => String(order?.id ?? '') === String(orderId));
+                const openOrders = await readOpenOrders(accountId, constants_1.TIMING.CONNECTION_TIMEOUT_MS, true);
+                const stillPresent = Array.isArray(openOrders) && openOrders.some((order) => String(order?.id ?? '') === String(orderId));
                 if (!stillPresent) {
                     chainOrdersLogger.info(`Order ${orderId} cancellation confirmed after broadcast failure`);
                     return { success: true, orderId, verified: true, verifiedAfterFailure: true };
@@ -1043,7 +1114,7 @@ async function cancelOrder(accountName, privateKey, orderId, extraOptions = {})
                 // Fall through to the original error.
             }
         }
-        chainOrdersLogger.error(`Error cancelling order: ${error.message}`);
+        chainOrdersLogger.error(`Error cancelling order: ${(0, errors_1.getErrorMessage)(error)}`);
         throw error;
     }
 }
@@ -1052,14 +1123,15 @@ async function cancelOrder(accountName, privateKey, orderId, extraOptions = {})
  * @param {string} accountName - Account paying fees (usually the bot account)
  * @param {string|Object} privateKey - Private key for signing (or daemon signing token)
  * @param {Array} operations - Array of operation objects { op_name, op_data } returned by build helpers
+ * @param {Object} [extraOptions] - Optional parameters (fallbackNodes, etc.)
  * @returns {Promise<Object>} Transaction result
  */
-async function executeBatch(accountName, privateKey, operations) {
+async function executeBatch(accountName, privateKey, operations, extraOptions = {}) {
     if (!operations || operations.length === 0)
         return { success: true, operations: 0 };
     try {
         if (isDaemonSigningToken(privateKey)) {
-            const result = await executeViaDaemonToken(accountName, privateKey, operations);
+            const result = await executeViaDaemonToken(accountName, privateKey, operations, extraOptions);
             recordOwnCancelOps(operations);
             return result;
         }
@@ -1094,7 +1166,7 @@ async function executeBatch(accountName, privateKey, operations) {
         };
     }
     catch (error) {
-        chainOrdersLogger.error(`Error executing batch transaction: ${error.message}`);
+        chainOrdersLogger.error(`Error executing batch transaction: ${(0, errors_1.getErrorMessage)(error)}`);
         throw error;
     }
 }
@@ -1168,7 +1240,7 @@ async function getOnChainAssetBalances(accountRef, assets, options = {}) {
                 }
             }
             catch (dealErr) {
-                chainOrdersLogger.warn(`getOnChainAssetBalances: failed to fetch credit deals for ${accountRef}: ${dealErr?.message}`);
+                chainOrdersLogger.warn(`getOnChainAssetBalances: failed to fetch credit deals for ${accountRef}: ${(0, errors_1.getErrorMessage)(dealErr)}`);
             }
         }
         // If assets omitted, build list from balances and limit_orders
@@ -1198,7 +1270,7 @@ async function getOnChainAssetBalances(accountRef, assets, options = {}) {
                 }
             }
             catch (e) {
-                chainOrdersLogger.warn(`lookup_asset_symbols failed for ${a}: ${e.message}`);
+                chainOrdersLogger.warn(`lookup_asset_symbols failed for ${a}: ${(0, errors_1.getErrorMessage)(e)}`);
             }
             // try to get precision and symbol
             let precision = null;
@@ -1211,7 +1283,7 @@ async function getOnChainAssetBalances(accountRef, assets, options = {}) {
                 }
             }
             catch (e) {
-                chainOrdersLogger.warn(`Failed to fetch asset data for ${aid}: ${e.message}`);
+                chainOrdersLogger.warn(`Failed to fetch asset data for ${aid}: ${(0, errors_1.getErrorMessage)(e)}`);
             }
             if (precision === null) {
                 chainOrdersLogger.error(`CRITICAL: Could not determine precision for asset ${aid}. Skipping balance entry to prevent massive scaling errors.`);
@@ -1219,14 +1291,14 @@ async function getOnChainAssetBalances(accountRef, assets, options = {}) {
             }
             const freeRaw = freeInt.get(String(aid)) || 0;
             const lockedRaw = lockedInt.get(String(aid)) || 0;
-            const free = blockchainToFloat(freeRaw, precision);
-            const locked = blockchainToFloat(lockedRaw, precision);
+            const free = (0, math_1.blockchainToFloat)(freeRaw, precision);
+            const locked = (0, math_1.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: ${err.message}`);
+        chainOrdersLogger.error(`getOnChainAssetBalances failed: ${(0, errors_1.getErrorMessage)(err)}`);
         return {};
     }
 }
@@ -1244,7 +1316,7 @@ function buildLiquidityPoolExchangeOp(accountId, poolId, sellAmountInt, sellAsse
     return {
         op_name: 'liquidity_pool_exchange',
         op_data: {
-            fee: { amount: 0, asset_id: NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
+            fee: { amount: 0, asset_id: constants_1.NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
             account: accountId,
             pool: poolId,
             amount_to_sell: { amount: sellAmountInt, asset_id: sellAssetId },
@@ -1260,29 +1332,5 @@ function buildLiquidityPoolExchangeOp(accountId, poolId, sellAmountInt, sellAsse
 function getFillProcessingMode() {
     return FILL_PROCESSING_MODE;
 }
-module.exports = {
-    selectAccount,
-    setPreferredAccount,
-    resolveAccountId,
-    resolveAccountName,
-    readOpenOrders,
-    readSingleOrder,
-    batchReadOrders,
-    listenForFills,
-    updateOrder,
-    createOrder,
-    cancelOrder,
-    getOnChainAssetBalances,
-    getFillProcessingMode,
-    FILL_PROCESSING_MODE,
-    buildUpdateOrderOp,
-    buildCreateOrderOp,
-    buildCancelOrderOp,
-    buildLiquidityPoolExchangeOp,
-    executeBatch,
-    wasRecentlyOwnCancelled,
-    recordOwnCancel,
-    BroadcastUncertainError,
-    // Note: authentication and key retrieval moved to modules/chain_keys.ts
-};
+module.exports = { selectAccount, setPreferredAccount, resolveAccountId, resolveAccountName, readOpenOrders, readSingleOrder, batchReadOrders, listenForFills, updateOrder, createOrder, cancelOrder, getOnChainAssetBalances, getFillProcessingMode, FILL_PROCESSING_MODE, buildUpdateOrderOp, buildCreateOrderOp, buildCancelOrderOp, buildLiquidityPoolExchangeOp, executeBatch, wasRecentlyOwnCancelled, recordOwnCancel, BroadcastUncertainError: dexbot_credential_client_1.BroadcastUncertainError };
 //# sourceMappingURL=chain_orders.js.map