dexbot 1.1.10

package/dist/modules/chain_orders.js

@@ -0,0 +1,1201 @@
+"use strict";
+/**
+ * modules/chain_orders.ts - Blockchain Interaction Layer
+ *
+ * BitShares blockchain operations and order management interface.
+ * Provides all blockchain I/O operations for the bot.
+ *
+ * Responsibilities:
+ * - Account selection and management
+ * - Reading open orders from blockchain
+ * - Creating, updating, and canceling limit orders
+ * - Listening for fill events via subscriptions
+ * - Fetching on-chain asset balances and metadata
+ * - Batch operation execution
+ * - Fill deduplication and processing mode selection
+ *
+ * All order amounts are human-readable floats externally,
+ * converted to blockchain integers internally using asset precision.
+ *
+ * ===============================================================================
+ * EXPORTS (18 functions + 2 constants)
+ * ===============================================================================
+ *
+ * ACCOUNT MANAGEMENT (3 functions - async)
+ *   1. selectAccount(nameOrId) - Select/authenticate account by name or ID
+ *      Prompts for password if needed, caches selection
+ *      Returns { accountId, accountName, authority }
+ *
+ *   2. setPreferredAccount(accountId, accountName) - Set preferred account
+ *      Used by selectAccount() if no account specified
+ *
+ *   3. resolveAccountId(nameOrId) - Resolve account name to ID (async, cached)
+ *   4. resolveAccountName(id) - Resolve account ID to name (async, cached)
+ *
+ * ORDER OPERATIONS (5 functions - async)
+ *   5. readOpenOrders(accountId) - Read all open orders for account
+ *      Returns array of { id, seller, sells, receives, ...blockchain fields }
+ *
+ *   6. createOrder(accountId, orderParams, broadcastFn) - Create limit order
+ *      orderParams: { sellSymbol, sellAmount, buySymbol, buyAmount, fillOrKill, ... }
+ *      Returns { tx_id, operation_results } or throws
+ *
+ *   7. updateOrder(accountId, orderId, newAmount, broadcastFn) - Update existing order
+ *      Changes order amount, preserves price
+ *      Returns transaction result
+ *
+ *   8. cancelOrder(accountId, orderId, broadcastFn) - Cancel order
+ *      Removes order from blockchain
+ *      Returns transaction result
+ *
+ *   9. executeBatch(operations, broadcastFn) - Execute batch of operations
+ *      Executes multiple operations (create/update/cancel) in one transaction
+ *      Returns transaction result
+ *
+ * FILL EVENT HANDLING (1 function - async)
+ *   10. listenForFills(accountId, fillCallback) - Subscribe to fill events
+ *      Invokes fillCallback({ id, orderId, side, amount, price, proceeds, ... })
+ *      Returns unsubscribe function
+ *
+ * ACCOUNT STATE (1 function - async)
+ *   11. getOnChainAssetBalances(accountId) - Fetch account asset balances
+ *      Returns { BTS: amount, USD: amount, ... } (human-readable floats)
+ *
+ * OPERATION BUILDERS (3 functions)
+ *   12. buildCreateOrderOp(accountId, orderParams) - Build create order operation
+ *   13. buildUpdateOrderOp(accountId, orderId, newAmount) - Build update order operation
+ *   14. buildCancelOrderOp(accountId, orderId) - Build cancel order operation
+ *
+ * CONFIGURATION (2 functions/constants)
+ *   15. getFillProcessingMode() - Get current fill processing mode
+ *       Returns 'history' (use fill event data) or 'open' (fetch open orders)
+ *
+ *   14. FILL_PROCESSING_MODE - Constant: current fill processing mode
+ *
+ * ===============================================================================
+ *
+ * ACCOUNT RESOLUTION:
+ * - Caches account name ↔ ID mappings to avoid repeated blockchain queries
+ * - Shared with modules/chain_keys.ts for authentication
+ *
+ * FILL MODES:
+ * - 'history' mode: Use fill event data directly (faster, preferred)
+ * - 'open' mode: Fetch open orders from blockchain (backup method, more API calls)
+ *
+ * RACE CONDITION PREVENTION:
+ * - _subscriptionLock: Serializes subscription map access
+ * - _preferredAccountLock: Serializes preferred account access
+ * - _resolutionLock: Serializes account resolution calls
+ *
+ * AUTHENTICATION:
+ * Moved to modules/chain_keys.ts for centralized key management.
+ * Use chain_keys.authenticate() and getPrivateKey() for auth operations.
+ *
+ * ===============================================================================
+ */
+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');
+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;
+// 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
+// expire after RECENT_OWN_CANCEL_TTL_MS so the buffer self-cleans.
+const RECENT_OWN_CANCEL_TTL_MS = ORDER_EVENTS.RECENT_OWN_CANCEL_TTL_MS;
+const RECENT_OWN_CANCEL_MAX_ENTRIES = ORDER_EVENTS.RECENT_OWN_CANCEL_MAX_ENTRIES;
+const _recentOwnCancels = new Map();
+function recordOwnCancel(orderId) {
+    if (!orderId)
+        return;
+    const now = Date.now();
+    _recentOwnCancels.set(String(orderId), now);
+    // Lazy GC: drop expired entries when the buffer grows.
+    if (_recentOwnCancels.size > RECENT_OWN_CANCEL_MAX_ENTRIES) {
+        for (const [id, ts] of _recentOwnCancels) {
+            if (now - ts > RECENT_OWN_CANCEL_TTL_MS)
+                _recentOwnCancels.delete(id);
+        }
+    }
+}
+function recordOwnCancelOps(operations) {
+    for (const op of operations || []) {
+        if (op?.op_name === 'limit_order_cancel' && op.op_data?.order) {
+            recordOwnCancel(op.op_data.order);
+        }
+    }
+}
+function wasRecentlyOwnCancelled(orderId) {
+    if (!orderId)
+        return false;
+    const ts = _recentOwnCancels.get(String(orderId));
+    if (ts == null)
+        return false;
+    if (Date.now() - ts > RECENT_OWN_CANCEL_TTL_MS) {
+        _recentOwnCancels.delete(String(orderId));
+        return false;
+    }
+    return true;
+}
+// Key/auth helpers provided by modules/chain_keys.ts
+// (authenticate(), getPrivateKey(), MasterPasswordError)
+/**
+ * Fill processing mode from FILL_PROCESSING.MODE constant:
+ * - '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;
+// 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();
+// Cache for account resolutions (name -> id and id -> name)
+const _accountResolutionCache = new Map();
+/**
+ * Resolve asset precision from ID or symbol via BitShares DB.
+ * @param {string} assetRef - Asset ID or symbol.
+ * @returns {Promise<number>} The asset's precision (number of decimals).
+ * @throws {Error} If precision cannot be resolved.
+ * @private
+ */
+async function _getAssetPrecision(assetRef) {
+    if (!assetRef)
+        throw new Error("Asset reference required for _getAssetPrecision");
+    try {
+        if (typeof assetRef === 'string' && assetRef.match(/^1\.3\.\d+$/)) {
+            if (BitShares && BitShares.db && typeof BitShares.db.get_assets === 'function') {
+                const assets = await BitShares.db.get_assets([assetRef]);
+                if (Array.isArray(assets) && assets[0] && typeof assets[0].precision === 'number')
+                    return assets[0].precision;
+            }
+        }
+        else if (typeof assetRef === 'string') {
+            if (BitShares && BitShares.db && typeof BitShares.db.lookup_asset_symbols === 'function') {
+                const res = await BitShares.db.lookup_asset_symbols([assetRef]);
+                if (Array.isArray(res) && res[0] && typeof res[0].precision === 'number')
+                    return res[0].precision;
+            }
+        }
+    }
+    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: asset not found or precision missing.`);
+}
+// Preferred account ID and name for operations (can be changed)
+// Access MUST be protected by _preferredAccountLock to prevent race conditions
+let preferredAccountId = null;
+let preferredAccountName = null;
+const _multiBotWarnings = new Set();
+function _warnOnce(key, message) {
+    if (_multiBotWarnings.has(key))
+        return;
+    _multiBotWarnings.add(key);
+    chainOrdersLogger.warn(message);
+}
+/**
+ * Set the preferred account for subsequent operations.
+ * This allows other functions to operate without requiring account parameters.
+ * Uses AsyncLock to prevent race conditions when multiple functions access this simultaneously.
+ * Warns once when overwriting a different account (multi-bot monolithic mode detection).
+ * @param {string} accountId - BitShares account ID (e.g., '1.2.12345')
+ * @param {string} accountName - Human-readable account name
+ */
+async function setPreferredAccount(accountId, accountName) {
+    await _preferredAccountLock.acquire(async () => {
+        if (preferredAccountName && accountName && preferredAccountName !== accountName) {
+            _warnOnce(`account-overwrite:${preferredAccountName}->${accountName}`, `[MULTI-BOT] Preferred account overwritten: '${preferredAccountName}' -> '${accountName}'. ` +
+                `All functions without explicit account params now target '${accountName}'.`);
+        }
+        preferredAccountId = accountId;
+        if (accountName)
+            preferredAccountName = accountName;
+    });
+}
+/**
+ * Get the current preferred account (thread-safe).
+ * @returns {Promise<{id: string|null, name: string|null}>}
+ */
+async function getPreferredAccount() {
+    return await _preferredAccountLock.acquire(async () => {
+        return { id: preferredAccountId, name: preferredAccountName };
+    });
+}
+/**
+ * Resolve an account ID to its human-readable name via chain lookup.
+ * Results are cached to prevent repeated lookups (fixes Issue #4).
+ * @param {string} accountRef - Account ID (e.g., '1.2.12345') or name
+ * @returns {Promise<string|null>} Account name or null if not found
+ */
+async function resolveAccountName(accountRef) {
+    if (!accountRef)
+        return null;
+    if (typeof accountRef !== 'string')
+        return null;
+    if (!/^1\.2\./.test(accountRef))
+        return accountRef;
+    return await _resolutionLock.acquire(async () => {
+        // Check cache first
+        const cacheKey = `id->${accountRef}`;
+        if (_accountResolutionCache.has(cacheKey)) {
+            return _accountResolutionCache.get(cacheKey);
+        }
+        try {
+            await waitForConnected();
+            const full = await BitShares.db.get_full_accounts([accountRef], false);
+            if (full && full[0] && full[0][1] && full[0][1].account && full[0][1].account.name) {
+                const name = full[0][1].account.name;
+                _accountResolutionCache.set(cacheKey, name);
+                // Also cache reverse mapping
+                _accountResolutionCache.set(`name->${name}`, accountRef);
+                return name;
+            }
+        }
+        catch (err) {
+            // ignore resolution failures
+        }
+        _accountResolutionCache.set(cacheKey, null);
+        return null;
+    });
+}
+/**
+ * Resolve an account name to its ID via chain lookup.
+ * Results are cached to prevent repeated lookups (fixes Issue #4).
+ * @param {string} accountName - Human-readable account name
+ * @returns {Promise<string|null>} Account ID or null if not found
+ */
+async function resolveAccountId(accountName) {
+    if (!accountName)
+        return null;
+    if (typeof accountName !== 'string')
+        return null;
+    // If already in ID format, return as-is
+    if (/^1\.2\.\d+$/.test(accountName))
+        return accountName;
+    return await _resolutionLock.acquire(async () => {
+        // Check cache first
+        const cacheKey = `name->${accountName}`;
+        if (_accountResolutionCache.has(cacheKey)) {
+            return _accountResolutionCache.get(cacheKey);
+        }
+        try {
+            await waitForConnected();
+            const full = await BitShares.db.get_full_accounts([accountName], false);
+            // full[0][0] is the account name (key), full[0][1] contains account data
+            if (full && full[0] && full[0][1] && full[0][1].account && full[0][1].account.id) {
+                const id = full[0][1].account.id;
+                _accountResolutionCache.set(cacheKey, id);
+                // Also cache reverse mapping
+                _accountResolutionCache.set(`id->${id}`, accountName);
+                return id;
+            }
+        }
+        catch (err) {
+            // ignore resolution failures
+        }
+        _accountResolutionCache.set(cacheKey, null);
+        return null;
+    });
+}
+// Track active account subscriptions so we avoid duplicate listeners per account
+// Map accountName -> { userCallbacks: Set<Function>, bsCallback: Function }
+// Access MUST be protected by _subscriptionLock to prevent TOCTOU races (fixes Issue #1)
+const accountSubscriptions = new Map();
+/**
+ * Ensure a per-account BitShares subscription exists so we only subscribe once.
+ * @param {string} accountName - The name of the account to subscribe to.
+ * @param {Function} [userCallback] - Optional user callback to register before the native
+ *   subscription's initial catch-up runs. Prevents initial catch-up fills from being lost.
+ * @returns {Promise<Object>} The subscription entry { userCallbacks, bsCallback }.
+ * @private
+ */
+async function _ensureAccountSubscriber(accountName, userCallback = null) {
+    return await _subscriptionLock.acquire(async () => {
+        // Check again inside lock to prevent duplicate subscriptions
+        if (accountSubscriptions.has(accountName)) {
+            return accountSubscriptions.get(accountName);
+        }
+        const userCallbacks = new Set();
+        if (typeof userCallback === 'function') {
+            userCallbacks.add(userCallback);
+        }
+        // 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 op = update.op;
+                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
+                const failures = [];
+                for (const c of [...userCallbacks]) {
+                    try {
+                        await Promise.resolve(c(fills));
+                    }
+                    catch (e) {
+                        failures.push(e);
+                        chainOrdersLogger.error(`chain_orders listener error ${e.message}`);
+                    }
+                }
+                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('; ')}`);
+                    err.causes = failures;
+                    throw err;
+                }
+            }
+        };
+        try {
+            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
+            // timeout or hard failure. BitShares.subscribe registers the entry
+            // in the native subscriptions map and adds bsCallback to
+            // entry.callbacks before its first await; if we fail before it
+            // returns, that state would otherwise be leaked and the next call
+            // for the same account would observe a half-dead subscription.
+            if (typeof BitShares.unsubscribe === 'function') {
+                try {
+                    await BitShares.unsubscribe('account', bsCallback, accountName);
+                }
+                catch (rollbackErr) {
+                    chainOrdersLogger.warn(`Failed to roll back partial subscription for ${accountName} after error: ` +
+                        `${rollbackErr?.message || rollbackErr}`);
+                }
+            }
+            throw subscribeErr;
+        }
+        const entry = { userCallbacks, bsCallback };
+        accountSubscriptions.set(accountName, entry);
+        return entry;
+    });
+}
+/**
+ * Interactive account selection from stored encrypted keys.
+ * Prompts user to authenticate and select an account.
+ * Uses AsyncLock to prevent race conditions with concurrent listenForFills calls (fixes Issue #2, #5).
+ * @returns {Promise<Object>} { accountName, privateKey, id }
+ */
+async function selectAccount() {
+    const masterPassword = await chainKeys.authenticate();
+    const accountsData = chainKeys.loadAccounts();
+    const accountNames = Object.keys(accountsData.accounts);
+    if (accountNames.length === 0) {
+        throw new Error('No accounts found. Please add accounts using modules/chain_keys.ts');
+    }
+    console.log('Available accounts:');
+    accountNames.forEach((name, index) => {
+        console.log(`${index + 1}. ${name}`);
+    });
+    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.');
+    }
+    const selectedAccount = accountNames[choice];
+    const privateKey = chainKeys.getPrivateKey(selectedAccount, masterPassword);
+    let selectedId = null;
+    try {
+        const full = await BitShares.db.get_full_accounts([selectedAccount], false);
+        if (full && full[0]) {
+            const candidateId = full[0][0];
+            if (candidateId && String(candidateId).startsWith('1.2.'))
+                selectedId = candidateId;
+            else if (full[0][1] && full[0][1].account && full[0][1].account.id)
+                selectedId = full[0][1].account.id;
+        }
+    }
+    catch (e) {
+        console.error(`Failed to resolve account ID for ${selectedAccount}: ${e.message}`);
+    }
+    if (selectedId) {
+        await setPreferredAccount(selectedId, selectedAccount);
+    }
+    const pref = await getPreferredAccount();
+    console.log(`Selected account: ${selectedAccount} (ID: ${pref.id})`);
+    return { accountName: selectedAccount, privateKey: privateKey, id: pref.id };
+}
+/**
+ * Check if a value is a credential daemon signing token.
+ * @param {*} value - Value to check
+ * @returns {boolean} True if value is a daemon signing token
+ */
+function isDaemonSigningToken(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
+ */
+async function executeViaDaemonToken(accountName, signingToken, operations) {
+    return getKeyStore().executeOperations(accountName, operations, signingToken);
+}
+/**
+ * Fetch a single limit order by id from the blockchain.
+ *
+ * Used by the sync engine as a targeted refetch when the cached `rawOnChain.for_sale`
+ * is observed to be smaller than the grid's own size (a "drift signal" — the chain
+ * value can only decrease, never grow on its own). The refetch is the only
+ * operation that re-anchors the cache to chain truth for an order whose in-memory
+ * baseline has fallen out of sync (e.g., a missed fill event).
+ *
+ * Return semantics:
+ *   - returns the raw order object on success
+ *   - returns `null` if the order is genuinely absent from the chain (`get_objects`
+ *     returns null for missing ids) — this is the authoritative "order is gone"
+ *     signal
+ *   - THROWS on any other error (connection timeout, RPC failure, etc.). Callers
+ *     use try/catch to distinguish "tried-and-gone" (null) from "tried-and-failed"
+ *     (caught) and fall back to the cache.
+ *
+ * @param {string} orderId - BitShares limit order id (e.g. "1.7.572840453")
+ * @param {number} [timeoutMs] - Connection timeout in milliseconds. Defaults to
+ *   the full CONNECTION_TIMEOUT_MS (30s); sync-engine callers should pass a
+ *   smaller value so a disconnected node does not stall a fill cycle.
+ * @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) {
+    if (!orderId || typeof orderId !== 'string')
+        return null;
+    await waitForConnected(timeoutMs);
+    if (!BitShares || !BitShares.db || typeof BitShares.db.get_objects !== 'function') {
+        throw new Error('readSingleOrder: BitShares.db.get_objects unavailable');
+    }
+    const results = await BitShares.db.get_objects([orderId]);
+    const order = Array.isArray(results) ? results[0] : null;
+    if (!order)
+        return null;
+    if (order.id !== orderId)
+        return null;
+    return order;
+}
+/**
+ * Fetch all open limit orders for an account from the blockchain.
+ * Uses AsyncLock to safely access preferred accountId (fixes Issue #2).
+ * @param {string|null} accountId - Account ID to query (uses preferred if null)
+ * @param {number} timeoutMs - Connection timeout in milliseconds
+ * @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) {
+    await waitForConnected(timeoutMs);
+    try {
+        let accId = accountId;
+        if (!accId) {
+            const pref = await getPreferredAccount();
+            accId = pref.id;
+            if (!accId) {
+                throw new Error('No account selected. Please call selectAccount() first or pass an account id');
+            }
+            _warnOnce(`readOpenOrders-no-accountId`, `[MULTI-BOT] readOpenOrders called without explicit accountId — using preferred '${pref.name || accId}'. ` +
+                `Pass accountId explicitly in multi-bot mode.`);
+        }
+        if (!accId) {
+            throw new Error('No account selected. Please call selectAccount() first or pass an account id');
+        }
+        const fullAccount = await BitShares.db.get_full_accounts([accId], false);
+        const orders = fullAccount[0][1].limit_orders || [];
+        if (!suppress_log) {
+            chainOrdersLogger.info(`Found ${orders.length} open orders for account ${accId}`);
+        }
+        return orders;
+    }
+    catch (error) {
+        chainOrdersLogger.error(`Error reading open orders: ${error.message}`);
+        throw error;
+    }
+}
+/**
+ * Subscribe to fill events for an account.
+ * Calls the callback when any of the account's orders are filled.
+ * Uses AsyncLock to safely access preferredAccount and subscription state (fixes Issue #2, #5).
+ *
+ * @param {string|Function} accountRef - Account name/id, or callback if using preferred
+ * @param {Function} [callback] - Function called with array of fill operations (when accountRef is a string)
+ * @returns {Function} Unsubscribe function to stop listening
+ */
+async function listenForFills(accountRef, callback) {
+    let userCallback = null;
+    let accountToken = null;
+    if (typeof accountRef === 'function' && arguments.length === 1) {
+        userCallback = accountRef;
+    }
+    else {
+        accountToken = accountRef;
+        userCallback = callback;
+    }
+    if (typeof userCallback !== 'function') {
+        chainOrdersLogger.error('listenForFills requires a callback function');
+        return () => { };
+    }
+    // Safely access preferredAccount using getPreferredAccount (fixes Issue #2, #5)
+    const pref = await getPreferredAccount();
+    let accountName = accountToken || pref.name;
+    if (!accountName && pref.id) {
+        accountName = await resolveAccountName(pref.id);
+    }
+    if (!accountName && accountToken) {
+        accountName = await resolveAccountName(accountToken);
+    }
+    if (!accountName) {
+        chainOrdersLogger.error('listenForFills requires an account name or a preferredAccount to be set');
+        return () => { };
+    }
+    let accountId = /^1\.2\./.test(accountToken || '') ? accountToken : pref.id;
+    if (!accountId) {
+        accountId = await resolveAccountId(accountName);
+    }
+    if (accountId) {
+        readOpenOrders(accountId, 30000, true).catch(error => chainOrdersLogger.error(`Error loading account for listening: ${error.message}`));
+    }
+    else {
+        chainOrdersLogger.warn('Unable to derive account id before listening for fills; skipping open-order prefetch.');
+    }
+    // Pass userCallback to _ensureAccountSubscriber so the native subscription's
+    // initial catch-up fills are dispatched to the caller (not lost).
+    // If the subscription already exists, the callback is added below instead.
+    const entry = await _ensureAccountSubscriber(accountName, userCallback);
+    // Add callback inside lock to prevent race with concurrent listenForFills calls.
+    // If _ensureAccountSubscriber already added it (new subscription), this is a no-op
+    // (Set.add deduplicates by reference).
+    const listenerCount = await _subscriptionLock.acquire(async () => {
+        entry.userCallbacks.add(userCallback);
+        return entry.userCallbacks.size;
+    });
+    chainOrdersLogger.info(`Listening for fills on account: ${accountName} (total listeners: ${listenerCount})`);
+    // Return an unsubscribe function that atomically removes the listener
+    return async function unsubscribe() {
+        try {
+            await _subscriptionLock.acquire(async () => {
+                entry.userCallbacks.delete(userCallback);
+                if (entry.userCallbacks.size === 0) {
+                    try {
+                        if (typeof BitShares.unsubscribe === 'function') {
+                            await BitShares.unsubscribe('account', entry.bsCallback, accountName);
+                        }
+                    }
+                    catch (e) {
+                        chainOrdersLogger.warn(`Unsubscribe failed: ${e.message}`);
+                    }
+                    accountSubscriptions.delete(accountName);
+                }
+            });
+        }
+        catch (e) {
+            chainOrdersLogger.error(`Error unsubscribing listenForFills ${e.message}`);
+        }
+    };
+}
+/**
+ * Build a limit_order_update operation.
+ * @param {string} accountName - The name of the account.
+ * @param {string} orderId - The ID of the order to update.
+ * @param {Object} newParams - The new parameters for the order.
+ * @param {number} [newParams.amountToSell] - New amount to sell.
+ * @param {number} [newParams.minToReceive] - New minimum amount to receive.
+ * @param {number} [newParams.newPrice] - New price.
+ * @param {string} [newParams.orderType] - Type of the order ('buy' or 'sell').
+ * @param {string} [newParams.expiration] - New expiration date.
+ * @param {Object} [cachedOrder=null] - Optional already-fetched raw chain order.
+ * @returns {Promise<Object|null>} Operation object or null if no change.
+ * @throws {Error} If account or order not found, or if amounts exceed limits.
+ */
+async function buildUpdateOrderOp(accountName, orderId, newParams, cachedOrder = null) {
+    const accId = await resolveAccountId(accountName);
+    if (!accId)
+        throw new Error(`Account ${accountName} not found`);
+    // Use cached order if provided, otherwise fetch fresh from blockchain
+    let order = cachedOrder;
+    if (!order) {
+        const orders = await readOpenOrders(accId);
+        order = orders.find(o => o.id === orderId);
+    }
+    if (!order)
+        throw new Error(`Order ${orderId} not found`);
+    const sellAssetId = order.sell_price.base.asset_id;
+    const receiveAssetId = order.sell_price.quote.asset_id;
+    const sellPrecision = await _getAssetPrecision(sellAssetId);
+    const receivePrecision = await _getAssetPrecision(receiveAssetId);
+    const currentSellInt = toFiniteNumber(order.for_sale);
+    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);
+    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).
+    let newSellInt;
+    let newSellFloat;
+    if (newParams.amountToSell !== undefined && newParams.amountToSell !== null) {
+        newSellFloat = newParams.amountToSell;
+        newSellInt = floatToBlockchainInt(newSellFloat, sellPrecision);
+    }
+    else {
+        // Keep current amount exactly as-is on-chain, bypassing float conversion
+        newSellInt = currentSellInt;
+        newSellFloat = blockchainToFloat(currentSellInt, sellPrecision);
+    }
+    // Determine an initial receive amount for price-change detection.
+    // Policy:
+    // - If minToReceive is provided: use it as an absolute override.
+    // - Else if newPrice is provided: compute receive from the (new or current) sell amount.
+    // - 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);
+    }
+    else if (newParams.newPrice !== undefined && newParams.newPrice !== null) {
+        const price = toFiniteNumber(newParams.newPrice);
+        const sellFloat = (newParams.amountToSell !== undefined && newParams.amountToSell !== null) ? newParams.amountToSell : currentSellFloat;
+        const receiveFloat = (newParams.orderType === 'sell')
+            ? (sellFloat * price)
+            : (sellFloat / price);
+        candidateReceiveInt = 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)) {
+        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. ` +
+            `Consider adjusting minPrice/maxPrice configuration.`);
+    }
+    // Calculate delta (new - current)
+    // IMPORTANT: BitShares limit_order_update takes a delta for amount_to_sell
+    // But for the new_price, it takes the NEW total amounts.
+    let deltaSellInt = newSellInt - currentSellInt;
+    // PRECISION FIX: If delta is ±1 and it's due to floating-point precision loss,
+    // use the current amount to avoid unnecessary blockchain changes.
+    // 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);
+        // If they match after rounding to precision, use the current amount (delta = 0)
+        if (roundedNewSellInt === roundedCurrentSellInt || Math.abs(roundedNewSellInt - roundedCurrentSellInt) <= 1) {
+            newSellInt = currentSellInt;
+            deltaSellInt = 0;
+        }
+    }
+    // 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);
+    }
+    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);
+    }
+    else {
+        // Keep existing on-chain price ratio.
+        newReceiveInt = Math.round((newSellInt * priceRatioQuote) / priceRatioBase);
+    }
+    // Check if price or amount is actually changing
+    const priceChanged = newReceiveInt !== currentReceiveInt;
+    const amountChanged = deltaSellInt !== 0;
+    // PRECISION FIX for price-only updates: if price change is too small to detect (rounds to same value),
+    // adjust minToReceive by 1 unit in the appropriate direction to force the operation.
+    // This ensures partial orders are actually moved even when price change is < 1 blockchain unit.
+    if (!priceChanged && !amountChanged && newParams.newPrice !== undefined && newParams.newPrice !== null) {
+        if (newParams.orderType === 'sell') {
+            // SELL moving down = lower price = receive less → decrease by 1
+            newReceiveInt = currentReceiveInt - 1;
+        }
+        else if (newParams.orderType === 'buy') {
+            // BUY moving up = higher price = receive more → increase by 1
+            newReceiveInt = currentReceiveInt + 1;
+        }
+    }
+    // Skip update only if BOTH amount and price are unchanged
+    if (!amountChanged && newReceiveInt === currentReceiveInt) {
+        return null;
+    }
+    // At this point, at least one field (amount or price) changed.
+    // If BOTH are unchanged (which shouldn't happen due to check above),
+    // we need to enforce a minimum delta of +1 to ensure operation validity
+    if (!amountChanged && !priceChanged) {
+        deltaSellInt = 1;
+    }
+    // Adjust newSellInt to strict logic: current + delta
+    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);
+    }
+    else if (newParams.newPrice !== undefined && newParams.newPrice !== null) {
+        const price = toFiniteNumber(newParams.newPrice);
+        const adjustedSellFloat = blockchainToFloat(adjustedSellInt, sellPrecision);
+        const receiveFloat = (newParams.orderType === 'sell')
+            ? (adjustedSellFloat * price)
+            : (adjustedSellFloat / price);
+        newReceiveInt = 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)) {
+        throw new Error(`Cannot update order: calculated amounts exceed blockchain limits. ` +
+            `Sell: ${adjustedSellFloat}, Receive: ${finalReceiveFloat}. ` +
+            `Consider adjusting minPrice/maxPrice configuration.`);
+    }
+    return {
+        op: {
+            op_name: 'limit_order_update',
+            op_data: {
+                fee: { amount: 0, asset_id: NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
+                seller: accId,
+                order: orderId,
+                new_price: {
+                    base: {
+                        amount: adjustedSellInt,
+                        asset_id: sellAssetId
+                    },
+                    quote: {
+                        amount: newReceiveInt,
+                        asset_id: receiveAssetId
+                    }
+                },
+                ...(deltaSellInt !== 0 ? { delta_amount_to_sell: { amount: deltaSellInt, asset_id: sellAssetId } } : {}),
+                ...(newParams.expiration ? { new_expiration: newParams.expiration } : {})
+            }
+        },
+        finalInts: { sell: adjustedSellInt, receive: newReceiveInt, sellAssetId, receiveAssetId }
+    };
+}
+/**
+ * Update an existing limit order on the blockchain.
+ * @param {string} accountName - The name of the account.
+ * @param {string|Object} privateKey - The private key for signing (or daemon signing token).
+ * @param {string} orderId - The ID of the order to update.
+ * @param {Object} newParams - The new parameters for the order.
+ * @returns {Promise<Object|null>} Success object or null if skipped.
+ * @throws {Error} If update fails.
+ */
+async function updateOrder(accountName, privateKey, orderId, newParams) {
+    try {
+        const buildResult = await buildUpdateOrderOp(accountName, orderId, newParams);
+        if (!buildResult) {
+            chainOrdersLogger.info(`Delta is 0; skipping limit_order_update (no change to amount_to_sell)`);
+            return null;
+        }
+        const { op } = buildResult;
+        if (isDaemonSigningToken(privateKey)) {
+            const result = await executeViaDaemonToken(accountName, privateKey, [op]);
+            chainOrdersLogger.info(`Order ${orderId} updated successfully`);
+            return { success: true, orderId, raw: result.raw, operation_results: result.operation_results };
+        }
+        const acc = await createAccountClient(accountName, privateKey);
+        await acc.initPromise;
+        const tx = acc.newTx();
+        // Use explicit method call for robustness
+        if (typeof tx.limit_order_update === 'function') {
+            tx.limit_order_update(op.op_data);
+        }
+        else {
+            throw new Error(`Transaction builder does not support limit_order_update`);
+        }
+        await tx.broadcast();
+        chainOrdersLogger.info(`Order ${orderId} updated successfully`);
+        return { success: true, orderId };
+    }
+    catch (error) {
+        chainOrdersLogger.error(`Error updating order: ${error.message}`);
+        throw error;
+    }
+}
+/**
+ * Build a limit_order_create operation.
+ * @param {string} accountName - The name of the account.
+ * @param {number} amountToSell - The amount of the asset to sell.
+ * @param {string} sellAssetId - The ID of the asset to sell.
+ * @param {number} minToReceive - The minimum amount of the asset to receive.
+ * @param {string} receiveAssetId - The ID of the asset to receive.
+ * @param {string} [expiration] - The expiration date for the order.
+ * @returns {Promise<Object|null>} The operation object, or null if amounts would round to 0.
+ * @throws {Error} If account not found.
+ */
+async function buildCreateOrderOp(accountName, amountToSell, sellAssetId, minToReceive, receiveAssetId, expiration) {
+    const accId = await resolveAccountId(accountName);
+    if (!accId)
+        throw new Error(`Account ${accountName} not found`);
+    if (!expiration) {
+        const now = new Date();
+        now.setFullYear(now.getFullYear() + 1);
+        expiration = now.toISOString().split('T')[0] + 'T23:59:59';
+    }
+    const sellPrecision = await _getAssetPrecision(sellAssetId);
+    const receivePrecision = await _getAssetPrecision(receiveAssetId);
+    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 (!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` +
+            `  Required: both > 0`);
+        return null;
+    }
+    const op = {
+        op_name: 'limit_order_create',
+        op_data: {
+            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 },
+            expiration: expiration,
+            fill_or_kill: false,
+            extensions: []
+        }
+    };
+    return {
+        op,
+        finalInts: { sell: amountToSellInt, receive: minToReceiveInt, sellAssetId, receiveAssetId }
+    };
+}
+/**
+ * Create a new limit order on the blockchain.
+ * @param {string} accountName - The name of the account.
+ * @param {string|Object} privateKey - The private key for signing (or daemon signing token).
+ * @param {number} amountToSell - The amount of the asset to sell.
+ * @param {string} sellAssetId - The ID of the asset to sell.
+ * @param {number} minToReceive - The minimum amount of the asset to receive.
+ * @param {string} receiveAssetId - The ID of the asset to receive.
+ * @param {string} [expiration] - The expiration date for the order.
+ * @param {boolean} [dryRun=false] - Whether to simulate the operation.
+ * @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) {
+    try {
+        const buildResult = await buildCreateOrderOp(accountName, amountToSell, sellAssetId, minToReceive, receiveAssetId, expiration);
+        if (!buildResult)
+            return { skipped: true };
+        const { op } = buildResult;
+        if (dryRun) {
+            chainOrdersLogger.info(`Dry run: Limit order prepared for account ${accountName} (not broadcasted)`);
+            return { dryRun: true, params: op.op_data };
+        }
+        if (isDaemonSigningToken(privateKey)) {
+            const result = await executeViaDaemonToken(accountName, privateKey, [op]);
+            chainOrdersLogger.info(`Limit order created successfully for account ${accountName}`);
+            return result;
+        }
+        const acc = await createAccountClient(accountName, privateKey);
+        await acc.initPromise;
+        const tx = acc.newTx();
+        // Invoke standard method directly
+        tx.limit_order_create(op.op_data);
+        const result = await tx.broadcast();
+        chainOrdersLogger.info(`Limit order created successfully for account ${accountName}`);
+        return result;
+    }
+    catch (error) {
+        chainOrdersLogger.error(`Error creating limit order: ${error.message}`);
+        throw error;
+    }
+}
+/**
+ * Build a limit_order_cancel operation.
+ * @param {string} accountName - The name of the account.
+ * @param {string} orderId - The ID of the order to cancel.
+ * @returns {Promise<Object>} The operation object.
+ * @throws {Error} If account not found.
+ */
+async function buildCancelOrderOp(accountName, orderId) {
+    const accId = await resolveAccountId(accountName);
+    if (!accId)
+        throw new Error(`Account ${accountName} not found`);
+    return {
+        op_name: 'limit_order_cancel',
+        op_data: {
+            fee: { amount: 0, asset_id: NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
+            fee_paying_account: accId,
+            order: orderId
+        }
+    };
+}
+/**
+ * Cancel an existing limit order on the blockchain.
+ * @param {string} accountName - The name of the account.
+ * @param {string|Object} privateKey - The private key for signing (or daemon signing token).
+ * @param {string} orderId - The ID of the order to cancel.
+ * @returns {Promise<Object>} Success object with order ID and verification metadata.
+ * @throws {Error} If cancellation fails.
+ */
+async function cancelOrder(accountName, privateKey, orderId) {
+    let accountId = null;
+    try {
+        const op = await buildCancelOrderOp(accountName, orderId);
+        accountId = op.op_data.fee_paying_account;
+        if (isDaemonSigningToken(privateKey)) {
+            const result = await executeViaDaemonToken(accountName, privateKey, [op]);
+            recordOwnCancel(orderId);
+            chainOrdersLogger.info(`Order ${orderId} cancelled successfully`);
+            return { success: true, orderId, verified: true, raw: result.raw, operation_results: result.operation_results };
+        }
+        const acc = await createAccountClient(accountName, privateKey);
+        await acc.initPromise;
+        const tx = acc.newTx();
+        // Explicit call
+        tx.limit_order_cancel(op.op_data);
+        await tx.broadcast();
+        recordOwnCancel(orderId);
+        chainOrdersLogger.info(`Order ${orderId} cancelled successfully`);
+        return { success: true, orderId, verified: true };
+    }
+    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));
+                if (!stillPresent) {
+                    chainOrdersLogger.info(`Order ${orderId} cancellation confirmed after broadcast failure`);
+                    return { success: true, orderId, verified: true, verifiedAfterFailure: true };
+                }
+            }
+            catch (_) {
+                // Fall through to the original error.
+            }
+        }
+        chainOrdersLogger.error(`Error cancelling order: ${error.message}`);
+        throw error;
+    }
+}
+/**
+ * Execute a batch of operations in a single transaction.
+ * @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
+ * @returns {Promise<Object>} Transaction result
+ */
+async function executeBatch(accountName, privateKey, operations) {
+    if (!operations || operations.length === 0)
+        return { success: true, operations: 0 };
+    try {
+        if (isDaemonSigningToken(privateKey)) {
+            const result = await executeViaDaemonToken(accountName, privateKey, operations);
+            recordOwnCancelOps(operations);
+            return result;
+        }
+        const acc = await createAccountClient(accountName, privateKey);
+        await acc.initPromise;
+        const tx = acc.newTx();
+        for (const op of operations) {
+            if (typeof tx[op.op_name] === 'function') {
+                tx[op.op_name](op.op_data);
+            }
+            else {
+                chainOrdersLogger.warn(`Transaction builder missing method for ${op.op_name}`);
+                throw new Error(`Transaction builder does not support ${op.op_name}`);
+            }
+        }
+        const result = await tx.broadcast();
+        // Record own-cancel correlation for the self-cancel guard in the fill
+        // consumer. Without this, batched cancels (the dominant COW path) would
+        // skip the ring buffer and the guard would not recognize their
+        // propagation artifacts as non-economic. Only fires after a successful
+        // broadcast so failed batches never poison the buffer.
+        recordOwnCancelOps(operations);
+        // Normalize broadcast response shape across node variants.
+        const operationResults = (result && Array.isArray(result.operation_results) && result.operation_results.length > 0 && result.operation_results) ||
+            (result && result.trx && Array.isArray(result.trx.operation_results) && result.trx.operation_results.length > 0 && result.trx.operation_results) ||
+            (Array.isArray(result) && result[0] && result[0].trx && Array.isArray(result[0].trx.operation_results) && result[0].trx.operation_results.length > 0 && result[0].trx.operation_results) ||
+            [];
+        return {
+            success: true,
+            raw: result,
+            operation_results: operationResults
+        };
+    }
+    catch (error) {
+        chainOrdersLogger.error(`Error executing batch transaction: ${error.message}`);
+        throw error;
+    }
+}
+/**
+ * Fetch on-chain balances and locked amounts for the specified account and assets.
+ * This helper only reads on-chain balances and open-order locks and MUST NOT be
+ * mixed with the manager's internal "available for orders" calculations.
+ *
+ * @param {String} accountRef - account name or id
+ * @param {Array<String>} assets - array of asset ids or symbols to query (e.g. ['1.3.0','IOB.XRP'])
+ * @returns {Object} mapping assetRef -> { assetId, symbol, precision, freeRaw, lockedRaw, free, locked, total }
+ */
+async function getOnChainAssetBalances(accountRef, assets) {
+    if (!accountRef)
+        return {};
+    try {
+        await waitForConnected();
+        // Resolve account id if name provided
+        let accountId = accountRef;
+        if (typeof accountRef === 'string' && !/^1\.2\./.test(accountRef)) {
+            const full = await BitShares.db.get_full_accounts([accountRef], false);
+            if (Array.isArray(full) && full[0] && full[0][0])
+                accountId = full[0][0];
+        }
+        // Fetch full account data so we have balances and limit_orders
+        const full = await BitShares.db.get_full_accounts([accountId], false);
+        if (!Array.isArray(full) || !full[0] || !full[0][1])
+            return {};
+        const accountData = full[0][1] || {};
+        const balances = accountData.balances || [];
+        const limitOrders = accountData.limit_orders || [];
+        // Build free balances map by asset id
+        const freeInt = new Map();
+        for (const b of balances) {
+            const aid = String(b.asset_type || b.asset_id || b.asset);
+            const val = toFiniteNumber(b.balance || b.amount);
+            freeInt.set(aid, (freeInt.get(aid) || 0) + val);
+        }
+        // Build locked map (for_sale) grouped by base asset id
+        const lockedInt = new Map();
+        for (const o of limitOrders) {
+            if (!o || !o.sell_price || !o.sell_price.base)
+                continue;
+            const baseId = String(o.sell_price.base.asset_id);
+            const forSale = toFiniteNumber(o.for_sale);
+            lockedInt.set(baseId, (lockedInt.get(baseId) || 0) + forSale);
+        }
+        // If assets omitted, build list from balances and limit_orders
+        let assetList = assets;
+        if (!assetList || !Array.isArray(assetList) || assetList.length === 0) {
+            assetList = [];
+            for (const b of balances)
+                assetList.push(String(b.asset_type || b.asset_id || b.asset));
+            for (const o of limitOrders) {
+                if (!o || !o.sell_price || !o.sell_price.base)
+                    continue;
+                assetList.push(String(o.sell_price.base.asset_id));
+            }
+            // de-duplicate
+            assetList = Array.from(new Set(assetList));
+        }
+        const out = {};
+        for (const a of assetList) {
+            // resolve asset id and precision
+            let aid = a;
+            try {
+                if (!/^1\.3\./.test(String(a))) {
+                    // symbol -> asset
+                    const res = await BitShares.db.lookup_asset_symbols([String(a)]).catch(() => null);
+                    if (res && res[0] && res[0].id)
+                        aid = res[0].id;
+                }
+            }
+            catch (e) {
+                chainOrdersLogger.warn(`lookup_asset_symbols failed for ${a}: ${e.message}`);
+            }
+            // try to get precision and symbol
+            let precision = null;
+            let symbol = String(a);
+            try {
+                const am = await BitShares.db.get_assets([aid]).catch(() => null);
+                if (Array.isArray(am) && am[0]) {
+                    precision = typeof am[0].precision === 'number' ? am[0].precision : null;
+                    symbol = am[0].symbol || symbol;
+                }
+            }
+            catch (e) {
+                chainOrdersLogger.warn(`Failed to fetch asset data for ${aid}: ${e.message}`);
+            }
+            if (precision === null) {
+                chainOrdersLogger.error(`CRITICAL: Could not determine precision for asset ${aid}. Skipping balance entry to prevent massive scaling errors.`);
+                continue;
+            }
+            const freeRaw = freeInt.get(String(aid)) || 0;
+            const lockedRaw = lockedInt.get(String(aid)) || 0;
+            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: ${err.message}`);
+        return {};
+    }
+}
+/**
+ * Build a liquidity_pool_exchange operation for swapping assets via AMM pool.
+ * @param {string} accountId - The blockchain account ID (1.2.x)
+ * @param {string} poolId - The liquidity pool ID (1.19.x)
+ * @param {number} sellAmountInt - Amount to sell (blockchain integer, not float)
+ * @param {string} sellAssetId - Asset ID to sell
+ * @param {number} minReceiveInt - Minimum amount to receive (blockchain integer)
+ * @param {string} receiveAssetId - Asset ID to receive
+ * @returns {Object} The operation object with op_name and op_data
+ */
+function buildLiquidityPoolExchangeOp(accountId, poolId, sellAmountInt, sellAssetId, minReceiveInt, receiveAssetId) {
+    return {
+        op_name: 'liquidity_pool_exchange',
+        op_data: {
+            fee: { amount: 0, asset_id: NATIVE_CLIENT.CHAIN.CORE_ASSET_ID },
+            account: accountId,
+            pool: poolId,
+            amount_to_sell: { amount: sellAmountInt, asset_id: sellAssetId },
+            min_to_receive: { amount: minReceiveInt, asset_id: receiveAssetId },
+            extensions: []
+        }
+    };
+}
+/**
+ * Get the current fill processing mode.
+ * @returns {string} 'history' or 'open'
+ */
+function getFillProcessingMode() {
+    return FILL_PROCESSING_MODE;
+}
+module.exports = {
+    selectAccount,
+    setPreferredAccount,
+    resolveAccountId,
+    resolveAccountName,
+    readOpenOrders,
+    readSingleOrder,
+    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
+};
+//# sourceMappingURL=chain_orders.js.map