dexbot 1.3.3 → 1.4.1

package/dist/modules/order/utils/system.js

@@ -29,12 +29,13 @@
  * SECTION 4: GRID UTILITIES (1 function)
  *   - syncBoundaryToFunds(manager) - Sync boundary position to available funds
  *
- * SECTION 5: UI & INTERACTIVE UTILITIES (5 functions)
+ * SECTION 5: UI & INTERACTIVE UTILITIES (6 functions)
  *   - ensureProfilesDirectory(profilesDir) - Ensure profiles directory exists
  *   - sleep(ms) - Pause execution for specified duration
  *   - readInput(prompt, options) - Read user input from stdin
  *   - readPassword(prompt) - Read password with masked echo
  *   - withRetry(fn, options) - Execute async function with exponential backoff
+ *   - withBlockchainRetry(fn, label, options) - Blockchain op with timeout + retry + node failover
  *
  * SECTION 6: GENERAL UTILITIES (5 functions)
  *   - resolveAccountRef(manager, account) - Resolve best account reference
@@ -45,23 +46,83 @@
  *
  * ===============================================================================
  */
-const { path } = require('../../path_api');
-const { getStorage } = require('../../storage');
-const storage = getStorage();
-const { API_LIMITS, ORDER_TYPES, COW_ACTIONS, FEE_PARAMETERS, BTS_PRECISION, PIPELINE_TIMING } = require('../../constants');
-const { PATHS } = require('../../paths');
-const Format = require('../format');
-const { toFiniteNumber, isValidNumber } = Format;
-const MathUtils = require('./math');
-const OrderUtils = require('./order');
-const Logger = require('../../logger');
-const { runtime } = require('../../runtime');
-const { ensureDir, readJSON } = require('../../utils/fs_utils');
-const systemLogger = new Logger('System');
+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.ensureDir = exports.derivePrice = exports.derivePoolPrice = exports.deriveMarketPrice = exports.lookupAsset = void 0;
+exports.resolveLiquidityPoolByShareAsset = resolveLiquidityPoolByShareAsset;
+exports.deriveLiquidityPoolTokenValue = deriveLiquidityPoolTokenValue;
+exports.loadAmaCenterSnapshot = loadAmaCenterSnapshot;
+exports.loadAmaCenterPrice = loadAmaCenterPrice;
+exports._loadFeeCacheFromDisk = _loadFeeCacheFromDisk;
+exports._saveFeeCacheToDisk = _saveFeeCacheToDisk;
+exports.initializeFeeCache = initializeFeeCache;
+exports.persistGridSnapshot = persistGridSnapshot;
+exports.retryPersistenceIfNeeded = retryPersistenceIfNeeded;
+exports.applyGridDivergenceCorrections = applyGridDivergenceCorrections;
+exports.syncBoundaryToFunds = syncBoundaryToFunds;
+exports.ensureProfilesDirectory = ensureProfilesDirectory;
+exports.sleep = sleep;
+exports.readInput = readInput;
+exports.readPassword = readPassword;
+exports.withRetry = withRetry;
+exports.withBlockchainRetry = withBlockchainRetry;
+exports.resolveAccountRef = resolveAccountRef;
+exports.deepFreeze = deepFreeze;
+exports.cloneMap = cloneMap;
+exports.parseJsonWithComments = parseJsonWithComments;
+const path_api_1 = require("../../path_api");
+const storage_1 = require("../../storage");
+const storage = (0, storage_1.getStorage)();
+const constants_1 = require("../../constants");
+const paths_1 = require("../../paths");
+const format_1 = require("../format");
+const MathUtils = __importStar(require("./math"));
+const OrderUtils = __importStar(require("./order"));
+const logger_1 = __importDefault(require("../../logger"));
+const runtime_1 = require("../../runtime");
+const fs_utils_1 = require("../../utils/fs_utils");
+Object.defineProperty(exports, "ensureDir", { enumerable: true, get: function () { return fs_utils_1.ensureDir; } });
+const errors_1 = require("../../utils/errors");
+const systemLogger = new logger_1.default('System');
 function _debugLogAndNull(method, symA, symB) {
     return (err) => {
         // debug level: underlying derivePoolPrice/deriveMarketPrice already log at warn
-        systemLogger.debug(`derivePrice(${method}) for ${symA}/${symB}: ${err.message}`);
+        systemLogger.debug(`derivePrice(${method}) for ${symA}/${symB}: ${(0, errors_1.getErrorMessage)(err)}`);
         return null;
     };
 }
@@ -107,11 +168,12 @@ const lookupAsset = async (BitShares, s) => {
             }
         }
         catch (e) {
-            systemLogger.debug(`lookupAsset: method failed for ${s}: ${e.message}`);
+            systemLogger.debug(`lookupAsset: method failed for ${s}: ${(0, errors_1.getErrorMessage)(e)}`);
         }
     }
     throw new Error(`CRITICAL: Cannot fetch asset precision for '${s}'`);
 };
+exports.lookupAsset = lookupAsset;
 /**
  * Derive price from BitShares DEX order book.
  * Returns price in B/A format (units of asset B per 1 unit of asset A).
@@ -125,8 +187,8 @@ const lookupAsset = async (BitShares, s) => {
 const deriveMarketPrice = async (BitShares, symA, symB) => {
     try {
         const [aMeta, bMeta] = await Promise.all([
-            lookupAsset(BitShares, symA),
-            lookupAsset(BitShares, symB)
+            (0, exports.lookupAsset)(BitShares, symA),
+            (0, exports.lookupAsset)(BitShares, symB)
         ]);
         if (!aMeta?.id || !bMeta?.id)
             return null;
@@ -135,23 +197,23 @@ const deriveMarketPrice = async (BitShares, symA, symB) => {
         let mid = null;
         if (typeof BitShares.db?.get_order_book === 'function') {
             try {
-                const ob = await BitShares.db.get_order_book(baseId, quoteId, API_LIMITS.ORDERBOOK_DEPTH);
-                const bestBid = isValidNumber(ob.bids?.[0]?.price) ? toFiniteNumber(ob.bids[0].price) : null;
-                const bestAsk = isValidNumber(ob.asks?.[0]?.price) ? toFiniteNumber(ob.asks[0].price) : null;
+                const ob = await BitShares.db.get_order_book(baseId, quoteId, constants_1.API_LIMITS.ORDERBOOK_DEPTH);
+                const bestBid = (0, format_1.isValidNumber)(ob.bids?.[0]?.price) ? (0, format_1.toFiniteNumber)(ob.bids[0].price) : null;
+                const bestAsk = (0, format_1.isValidNumber)(ob.asks?.[0]?.price) ? (0, format_1.toFiniteNumber)(ob.asks[0].price) : null;
                 if (bestBid !== null && bestAsk !== null)
                     mid = (bestBid + bestAsk) / 2;
             }
             catch (e) {
-                systemLogger.debug(`deriveMarketPrice: get_order_book failed for ${symA}/${symB}: ${e.message}`);
+                systemLogger.debug(`deriveMarketPrice: get_order_book failed for ${symA}/${symB}: ${(0, errors_1.getErrorMessage)(e)}`);
             }
         }
         if (mid === null && typeof BitShares.db?.get_ticker === 'function') {
             try {
                 const t = await BitShares.db.get_ticker(baseId, quoteId);
-                mid = isValidNumber(t?.latest) ? toFiniteNumber(t.latest) : (isValidNumber(t?.latest_price) ? toFiniteNumber(t.latest_price) : null);
+                mid = (0, format_1.isValidNumber)(t?.latest) ? (0, format_1.toFiniteNumber)(t.latest) : ((0, format_1.isValidNumber)(t?.latest_price) ? (0, format_1.toFiniteNumber)(t.latest_price) : null);
             }
             catch (err) {
-                systemLogger.debug(`deriveMarketPrice: get_ticker failed for ${symA}/${symB}: ${err.message}`);
+                systemLogger.debug(`deriveMarketPrice: get_ticker failed for ${symA}/${symB}: ${(0, errors_1.getErrorMessage)(err)}`);
             }
         }
         // Return B/A orientation to match market price format
@@ -162,10 +224,11 @@ const deriveMarketPrice = async (BitShares, symA, symB) => {
         return finalPrice;
     }
     catch (err) {
-        systemLogger.warn(`deriveMarketPrice failed for ${symA}/${symB}: ${err.message}`);
+        systemLogger.warn(`deriveMarketPrice failed for ${symA}/${symB}: ${(0, errors_1.getErrorMessage)(err)}`);
         return null;
     }
 };
+exports.deriveMarketPrice = deriveMarketPrice;
 /**
  * Derive price from BitShares Liquidity Pool (AMM).
  * Returns price in B/A format (units of asset B per 1 unit of asset A).
@@ -179,8 +242,8 @@ const deriveMarketPrice = async (BitShares, symA, symB) => {
 const derivePoolPrice = async (BitShares, symA, symB) => {
     try {
         const [aMeta, bMeta] = await Promise.all([
-            lookupAsset(BitShares, symA),
-            lookupAsset(BitShares, symB)
+            (0, exports.lookupAsset)(BitShares, symA),
+            (0, exports.lookupAsset)(BitShares, symB)
         ]);
         if (!aMeta?.id || !bMeta?.id)
             return null;
@@ -191,10 +254,10 @@ const derivePoolPrice = async (BitShares, symA, symB) => {
             try {
                 const pools = await BitShares.db.get_liquidity_pools_by_both_assets(aMeta.id, bMeta.id);
                 if (Array.isArray(pools) && pools.length > 0) {
-                    const valid = pools.filter(p => p?.id);
+                    const valid = pools.filter((p) => p?.id);
                     if (valid.length) {
                         chosen = valid.sort((a, b) => {
-                            const getBal = p => toFiniteNumber(String(p.asset_a) === String(aMeta.id) ? p.balance_a : p.balance_b);
+                            const getBal = (p) => (0, format_1.toFiniteNumber)(String(p.asset_a) === String(aMeta.id) ? p.balance_a : p.balance_b);
                             return getBal(b) - getBal(a);
                         })[0];
                         if (chosen)
@@ -203,7 +266,7 @@ const derivePoolPrice = async (BitShares, symA, symB) => {
                 }
             }
             catch (e) {
-                systemLogger.debug(`derivePoolPrice: get_liquidity_pools_by_both_assets failed: ${e.message}`);
+                systemLogger.debug(`derivePoolPrice: get_liquidity_pools_by_both_assets failed: ${(0, errors_1.getErrorMessage)(e)}`);
             }
         }
         if (!chosen && cachedPoolId && typeof BitShares.db?.get_objects === 'function') {
@@ -232,7 +295,7 @@ const derivePoolPrice = async (BitShares, symA, symB) => {
                         const effectivePools = (startId === '1.19.0') ? pools : pools.slice(1);
                         if (effectivePools.length === 0)
                             break;
-                        const matches = effectivePools.filter(p => {
+                        const matches = effectivePools.filter((p) => {
                             const ids = (p.asset_ids || [p.asset_a, p.asset_b]).map(String);
                             return ids.includes(String(aMeta.id)) && ids.includes(String(bMeta.id));
                         });
@@ -249,55 +312,55 @@ const derivePoolPrice = async (BitShares, symA, symB) => {
                     if (allMatches.length) {
                         // Select pool with highest balance for our assetA
                         chosen = allMatches.sort((a, b) => {
-                            const getBal = p => toFiniteNumber(String(p.asset_a) === String(aMeta.id) ? p.balance_a : p.balance_b);
+                            const getBal = (p) => (0, format_1.toFiniteNumber)(String(p.asset_a) === String(aMeta.id) ? p.balance_a : p.balance_b);
                             return getBal(b) - getBal(a);
                         })[0];
                         poolIdCache.set(cacheKey, chosen.id);
                     }
                 }
                 catch (e) {
-                    systemLogger.warn(`derivePoolPrice: pool pagination failed: ${e.message || e}`);
+                    systemLogger.warn(`derivePoolPrice: pool pagination failed: ${(0, errors_1.getErrorMessage)(e) || e}`);
                 }
             }
         }
         if (!chosen)
             return null;
-        if (!chosen.reserves && !isValidNumber(chosen.balance_a) && typeof BitShares.db?.get_objects === 'function') {
+        if (!chosen.reserves && !(0, format_1.isValidNumber)(chosen.balance_a) && typeof BitShares.db?.get_objects === 'function') {
             try {
                 const [full] = await BitShares.db.get_objects([chosen.id]);
                 if (full)
                     chosen = full;
             }
             catch (e) {
-                systemLogger.debug(`derivePoolPrice: get_objects failed for pool ${chosen.id}: ${e.message}`);
+                systemLogger.debug(`derivePoolPrice: get_objects failed for pool ${chosen.id}: ${(0, errors_1.getErrorMessage)(e)}`);
             }
         }
         let amtA = null, amtB = null;
-        if (isValidNumber(chosen.balance_a) && isValidNumber(chosen.balance_b)) {
+        if ((0, format_1.isValidNumber)(chosen.balance_a) && (0, format_1.isValidNumber)(chosen.balance_b)) {
             // Pools store assets ordered by ID: lower ID is always first (asset_a)
-            const aIdNum = toFiniteNumber(String(aMeta.id).split('.')[2]);
-            const bIdNum = toFiniteNumber(String(bMeta.id).split('.')[2]);
+            const aIdNum = (0, format_1.toFiniteNumber)(String(aMeta.id).split('.')[2]);
+            const bIdNum = (0, format_1.toFiniteNumber)(String(bMeta.id).split('.')[2]);
             const aIsFirst = aIdNum < bIdNum;
             // If config's assetA has lower ID, it's the pool's first asset (asset_a)
             // Otherwise, our assetA corresponds to pool's second asset (asset_b)
             if (aIsFirst) {
-                amtA = toFiniteNumber(chosen.balance_a);
-                amtB = toFiniteNumber(chosen.balance_b);
+                amtA = (0, format_1.toFiniteNumber)(chosen.balance_a);
+                amtB = (0, format_1.toFiniteNumber)(chosen.balance_b);
             }
             else {
-                amtA = toFiniteNumber(chosen.balance_b);
-                amtB = toFiniteNumber(chosen.balance_a);
+                amtA = (0, format_1.toFiniteNumber)(chosen.balance_b);
+                amtB = (0, format_1.toFiniteNumber)(chosen.balance_a);
             }
         }
         else if (Array.isArray(chosen.reserves)) {
-            const resA = chosen.reserves.find(r => String(r.asset_id) === String(aMeta.id));
-            const resB = chosen.reserves.find(r => String(r.asset_id) === String(bMeta.id));
+            const resA = chosen.reserves.find((r) => String(r.asset_id) === String(aMeta.id));
+            const resB = chosen.reserves.find((r) => String(r.asset_id) === String(bMeta.id));
             if (resA && resB) {
                 amtA = resA.amount;
                 amtB = resB.amount;
             }
         }
-        if (!isValidNumber(amtA) || !isValidNumber(amtB) || toFiniteNumber(amtB) === 0)
+        if (!(0, format_1.isValidNumber)(amtA) || !(0, format_1.isValidNumber)(amtB) || (0, format_1.toFiniteNumber)(amtB) === 0)
             return null;
         const floatA = MathUtils.blockchainToFloat(amtA, aMeta.precision);
         const floatB = MathUtils.blockchainToFloat(amtB, bMeta.precision);
@@ -309,10 +372,11 @@ const derivePoolPrice = async (BitShares, symA, symB) => {
         return finalPrice;
     }
     catch (err) {
-        systemLogger.warn(`derivePoolPrice failed for ${symA}/${symB}: ${err.message}`);
+        systemLogger.warn(`derivePoolPrice failed for ${symA}/${symB}: ${(0, errors_1.getErrorMessage)(err)}`);
         return null;
     }
 };
+exports.derivePoolPrice = derivePoolPrice;
 /**
  * Derive price from blockchain using specified mode.
  * Attempts pool or market derivation based on mode, with fallback chain.
@@ -331,22 +395,23 @@ const derivePrice = async (BitShares, symA, symB, mode = 'auto') => {
         return null;
     }
     if (mode === 'pool') {
-        return await derivePoolPrice(BitShares, symA, symB).catch(_debugLogAndNull('pool', symA, symB));
+        return await (0, exports.derivePoolPrice)(BitShares, symA, symB).catch(_debugLogAndNull('pool', symA, symB));
     }
     if (mode === 'book') {
-        return await deriveMarketPrice(BitShares, symA, symB).catch(_debugLogAndNull('book', symA, symB));
+        return await (0, exports.deriveMarketPrice)(BitShares, symA, symB).catch(_debugLogAndNull('book', symA, symB));
     }
     // mode === 'auto': pool preferred, market fallback
     let poolP = null;
-    poolP = await derivePoolPrice(BitShares, symA, symB).catch(_debugLogAndNull('auto/pool', symA, symB));
-    if (poolP > 0)
+    poolP = await (0, exports.derivePoolPrice)(BitShares, symA, symB).catch(_debugLogAndNull('auto/pool', symA, symB));
+    if (poolP != null && poolP > 0)
         return poolP;
-    const m = await deriveMarketPrice(BitShares, symA, symB).catch(_debugLogAndNull('auto/book', symA, symB));
-    if (m > 0)
+    const m = await (0, exports.deriveMarketPrice)(BitShares, symA, symB).catch(_debugLogAndNull('auto/book', symA, symB));
+    if (m != null && m > 0)
         return m;
     systemLogger.debug(`derivePrice: all methods failed for ${symA}/${symB}`);
     return null;
 };
+exports.derivePrice = derivePrice;
 /**
  * Resolve a liquidity pool from a share asset reference.
  * Looks up the share asset, then queries the blockchain for associated pools.
@@ -359,15 +424,15 @@ async function resolveLiquidityPoolByShareAsset(BitShares, shareAssetRef) {
     if (!BitShares?.db || typeof BitShares.db.get_liquidity_pools_by_share_asset !== 'function') {
         return null;
     }
-    const shareAsset = await lookupAsset(BitShares, shareAssetRef).catch((e) => {
-        systemLogger.debug(`resolveLiquidityPoolByShareAsset: lookupAsset failed for ${shareAssetRef}: ${e.message}`);
+    const shareAsset = await (0, exports.lookupAsset)(BitShares, shareAssetRef).catch((e) => {
+        systemLogger.debug(`resolveLiquidityPoolByShareAsset: lookupAsset failed for ${shareAssetRef}: ${(0, errors_1.getErrorMessage)(e)}`);
         return null;
     });
     if (!shareAsset?.id) {
         return null;
     }
     const response = await BitShares.db.get_liquidity_pools_by_share_asset([shareAsset.id], false, false).catch((e) => {
-        systemLogger.debug(`resolveLiquidityPoolByShareAsset: get_liquidity_pools_by_share_asset failed for ${shareAssetRef}: ${e.message}`);
+        systemLogger.debug(`resolveLiquidityPoolByShareAsset: get_liquidity_pools_by_share_asset failed for ${shareAssetRef}: ${(0, errors_1.getErrorMessage)(e)}`);
         return null;
     });
     if (!Array.isArray(response)) {
@@ -385,14 +450,14 @@ async function resolveLiquidityPoolByShareAsset(BitShares, shareAssetRef) {
 async function getAssetCurrentSupply(BitShares, assetRef) {
     const asset = typeof assetRef === 'object' && assetRef !== null
         ? assetRef
-        : await lookupAsset(BitShares, assetRef).catch((e) => {
-            systemLogger.debug(`getAssetCurrentSupply: lookupAsset failed for ${assetRef}: ${e.message}`);
+        : await (0, exports.lookupAsset)(BitShares, assetRef).catch((e) => {
+            systemLogger.debug(`getAssetCurrentSupply: lookupAsset failed for ${assetRef}: ${(0, errors_1.getErrorMessage)(e)}`);
             return null;
         });
     if (!asset) {
         return null;
     }
-    const directSupply = toFiniteNumber(asset.current_supply?.amount ?? asset.current_supply, null);
+    const directSupply = (0, format_1.toFiniteNumber)(asset.current_supply?.amount ?? asset.current_supply, undefined);
     if (Number.isFinite(directSupply) && directSupply >= 0) {
         return directSupply;
     }
@@ -401,13 +466,13 @@ async function getAssetCurrentSupply(BitShares, assetRef) {
         return null;
     }
     const objects = await BitShares.db.get_objects([dynamicId]).catch((e) => {
-        systemLogger.debug(`getAssetCurrentSupply: get_objects failed for ${dynamicId}: ${e.message}`);
+        systemLogger.debug(`getAssetCurrentSupply: get_objects failed for ${dynamicId}: ${(0, errors_1.getErrorMessage)(e)}`);
         return null;
     });
     const dynamicData = Array.isArray(objects) ? objects[0] : null;
-    const supply = toFiniteNumber(dynamicData?.current_supply?.amount
+    const supply = (0, format_1.toFiniteNumber)(dynamicData?.current_supply?.amount
         ?? dynamicData?.current_supply?.value
-        ?? dynamicData?.current_supply, null);
+        ?? dynamicData?.current_supply, undefined);
     return Number.isFinite(supply) && supply >= 0 ? supply : null;
 }
 /**
@@ -424,8 +489,8 @@ async function getAssetCurrentSupply(BitShares, assetRef) {
 async function deriveLiquidityPoolTokenValue(BitShares, shareAssetRef, denominationAssetRef, mode = 'auto') {
     try {
         const [shareAsset, denominationAsset] = await Promise.all([
-            lookupAsset(BitShares, shareAssetRef),
-            lookupAsset(BitShares, denominationAssetRef),
+            (0, exports.lookupAsset)(BitShares, shareAssetRef),
+            (0, exports.lookupAsset)(BitShares, denominationAssetRef),
         ]);
         if (!shareAsset?.id || !denominationAsset?.id) {
             return null;
@@ -435,8 +500,8 @@ async function deriveLiquidityPoolTokenValue(BitShares, shareAssetRef, denominat
             return null;
         }
         const [assetA, assetB, supply] = await Promise.all([
-            lookupAsset(BitShares, poolInfo.pool.asset_a),
-            lookupAsset(BitShares, poolInfo.pool.asset_b),
+            (0, exports.lookupAsset)(BitShares, poolInfo.pool.asset_a),
+            (0, exports.lookupAsset)(BitShares, poolInfo.pool.asset_b),
             getAssetCurrentSupply(BitShares, shareAsset),
         ]);
         if (!assetA?.id || !assetB?.id || !Number.isFinite(supply) || supply <= 0) {
@@ -444,34 +509,34 @@ async function deriveLiquidityPoolTokenValue(BitShares, shareAssetRef, denominat
         }
         const reserveA = MathUtils.blockchainToFloat(poolInfo.pool.balance_a, assetA.precision);
         const reserveB = MathUtils.blockchainToFloat(poolInfo.pool.balance_b, assetB.precision);
-        if (!isValidNumber(reserveA) || !isValidNumber(reserveB)) {
+        if (!(0, format_1.isValidNumber)(reserveA) || !(0, format_1.isValidNumber)(reserveB)) {
             return null;
         }
         const priceA = String(assetA.id) === String(denominationAsset.id)
             ? 1
-            : await derivePrice(BitShares, assetA.id, denominationAsset.id, mode).catch((e) => {
-                systemLogger.debug(`deriveLiquidityPoolTokenValue: derivePrice failed for ${assetA.id}/${denominationAsset.id}: ${e.message}`);
+            : await (0, exports.derivePrice)(BitShares, assetA.id, denominationAsset.id, mode).catch((e) => {
+                systemLogger.debug(`deriveLiquidityPoolTokenValue: derivePrice failed for ${assetA.id}/${denominationAsset.id}: ${(0, errors_1.getErrorMessage)(e)}`);
                 return null;
             });
         const priceB = String(assetB.id) === String(denominationAsset.id)
             ? 1
-            : await derivePrice(BitShares, assetB.id, denominationAsset.id, mode).catch((e) => {
-                systemLogger.debug(`deriveLiquidityPoolTokenValue: derivePrice failed for ${assetB.id}/${denominationAsset.id}: ${e.message}`);
+            : await (0, exports.derivePrice)(BitShares, assetB.id, denominationAsset.id, mode).catch((e) => {
+                systemLogger.debug(`deriveLiquidityPoolTokenValue: derivePrice failed for ${assetB.id}/${denominationAsset.id}: ${(0, errors_1.getErrorMessage)(e)}`);
                 return null;
             });
-        if (!isValidNumber(priceA) || !isValidNumber(priceB) || priceA <= 0 || priceB <= 0) {
+        if (priceA == null || priceB == null || !(0, format_1.isValidNumber)(priceA) || !(0, format_1.isValidNumber)(priceB) || priceA <= 0 || priceB <= 0) {
             return null;
         }
         const supplyFloat = MathUtils.blockchainToFloat(supply, shareAsset.precision);
-        if (!isValidNumber(supplyFloat) || supplyFloat <= 0) {
+        if (!(0, format_1.isValidNumber)(supplyFloat) || supplyFloat <= 0) {
             return null;
         }
         const totalValue = reserveA * priceA + reserveB * priceB;
         const valuePerShare = totalValue / supplyFloat;
-        return isValidNumber(valuePerShare) && valuePerShare > 0 ? valuePerShare : null;
+        return (0, format_1.isValidNumber)(valuePerShare) && valuePerShare > 0 ? valuePerShare : null;
     }
     catch (err) {
-        systemLogger.debug(`deriveLiquidityPoolTokenValue failed for ${shareAssetRef}/${denominationAssetRef}: ${err.message}`);
+        systemLogger.debug(`deriveLiquidityPoolTokenValue failed for ${shareAssetRef}/${denominationAssetRef}: ${(0, errors_1.getErrorMessage)(err)}`);
         return null;
     }
 }
@@ -492,8 +557,8 @@ async function deriveLiquidityPoolTokenValue(BitShares, shareAssetRef, denominat
  */
 function loadAmaCenterSnapshot(botKey) {
     try {
-        const gridPriceFile = path.join(PATHS.ORDERS_DIR, `${botKey}.dynamicgrid.json`);
-        const data = readJSON(gridPriceFile);
+        const gridPriceFile = path_api_1.path.join(paths_1.PATHS.ORDERS_DIR, `${botKey}.dynamicgrid.json`);
+        const data = (0, fs_utils_1.readJSON)(gridPriceFile);
         const gridCenterPrice = Number(data?.gridCenterPrice ?? data?.centerPrice);
         const amaCenterPrice = Number(data?.amaCenterPrice);
         if (!Number.isFinite(gridCenterPrice) || gridCenterPrice <= 0) {
@@ -546,7 +611,7 @@ function loadAmaCenterPrice(botKey) {
  */
 function _loadFeeCacheFromDisk() {
     try {
-        const filePath = PATHS.PROFILES.FEE_CACHE_JSON;
+        const filePath = paths_1.PATHS.PROFILES.FEE_CACHE_JSON;
         if (storage.exists(filePath)) {
             const diskCache = storage.readJSON(filePath);
             if (diskCache && typeof diskCache === 'object') {
@@ -556,7 +621,7 @@ function _loadFeeCacheFromDisk() {
         }
     }
     catch (e) {
-        systemLogger.debug(`_loadFeeCacheFromDisk: ${e.message}`);
+        systemLogger.debug(`_loadFeeCacheFromDisk: ${(0, errors_1.getErrorMessage)(e)}`);
     }
     return {};
 }
@@ -566,10 +631,10 @@ function _loadFeeCacheFromDisk() {
  */
 function _saveFeeCacheToDisk(cache) {
     try {
-        storage.writeJSON(PATHS.PROFILES.FEE_CACHE_JSON, cache);
+        storage.writeJSON(paths_1.PATHS.PROFILES.FEE_CACHE_JSON, cache);
     }
     catch (e) {
-        systemLogger.debug(`_saveFeeCacheToDisk: ${e.message}`);
+        systemLogger.debug(`_saveFeeCacheToDisk: ${(0, errors_1.getErrorMessage)(e)}`);
     }
 }
 /**
@@ -592,8 +657,8 @@ async function initializeFeeCache(botsConfig, BitShares) {
     }
     // Seed from disk so previously cached assets survive transient API failures
     const cache = _loadFeeCacheFromDisk();
-    const maxAttempts = FEE_PARAMETERS.FEE_CACHE_RETRY_ATTEMPTS;
-    const baseDelay = FEE_PARAMETERS.FEE_CACHE_RETRY_DELAY_MS;
+    const maxAttempts = constants_1.FEE_PARAMETERS.FEE_CACHE_RETRY_ATTEMPTS;
+    const baseDelay = constants_1.FEE_PARAMETERS.FEE_CACHE_RETRY_DELAY_MS;
     for (const assetSymbol of uniqueAssets) {
         let lastError = null;
         for (let attempt = 1; attempt <= maxAttempts; attempt++) {
@@ -602,16 +667,16 @@ async function initializeFeeCache(botsConfig, BitShares) {
                     const globalProps = await BitShares.db.getGlobalProperties();
                     const currentFees = globalProps.parameters.current_fees.parameters;
                     const findFee = (opCode) => {
-                        const param = currentFees.find(p => p[0] === opCode);
+                        const param = currentFees.find((p) => p[0] === opCode);
                         const fee = param?.[1]?.fee;
-                        const feeNum = toFiniteNumber(fee);
+                        const feeNum = (0, format_1.toFiniteNumber)(fee);
                         return {
                             raw: feeNum,
                             satoshis: feeNum,
-                            bts: MathUtils.blockchainToFloat(feeNum, BTS_PRECISION)
+                            bts: MathUtils.blockchainToFloat(feeNum, constants_1.BTS_PRECISION)
                         };
                     };
-                    const makerFeeDiscountRaw = toFiniteNumber(globalProps?.parameters?.extensions?.maker_fee_discount_percent, FEE_PARAMETERS.MAKER_REFUND_PERCENT * 10000);
+                    const makerFeeDiscountRaw = (0, format_1.toFiniteNumber)(globalProps?.parameters?.extensions?.maker_fee_discount_percent, constants_1.FEE_PARAMETERS.MAKER_REFUND_PERCENT * 10000);
                     cache.BTS = {
                         limitOrderCreate: findFee(1),
                         limitOrderCancel: findFee(2),
@@ -620,7 +685,7 @@ async function initializeFeeCache(botsConfig, BitShares) {
                     };
                 }
                 else {
-                    const fullAsset = await lookupAsset(BitShares, assetSymbol);
+                    const fullAsset = await (0, exports.lookupAsset)(BitShares, assetSymbol);
                     const options = fullAsset.options || {};
                     cache[assetSymbol] = {
                         assetId: fullAsset.id,
@@ -642,14 +707,14 @@ async function initializeFeeCache(botsConfig, BitShares) {
                 lastError = error;
                 if (attempt < maxAttempts) {
                     const delay = baseDelay * attempt;
-                    systemLogger.warn(`initializeFeeCache: attempt ${attempt}/${maxAttempts} failed for ${assetSymbol}: ${error.message}. Retrying in ${delay}ms...`);
+                    systemLogger.warn(`initializeFeeCache: attempt ${attempt}/${maxAttempts} failed for ${assetSymbol}: ${(0, errors_1.getErrorMessage)(error)}. Retrying in ${delay}ms...`);
                     await sleep(delay);
                 }
             }
         }
         if (lastError) {
             const hasDiskFallback = cache[assetSymbol] !== undefined;
-            systemLogger.warn(`initializeFeeCache: all ${maxAttempts} attempts failed for ${assetSymbol}: ${lastError.message}` +
+            systemLogger.warn(`initializeFeeCache: all ${maxAttempts} attempts failed for ${assetSymbol}: ${(0, errors_1.getErrorMessage)(lastError)}` +
                 (hasDiskFallback ? '. Using previously cached value from disk.' : '.'));
         }
     }
@@ -721,7 +786,7 @@ async function retryPersistenceIfNeeded(manager) {
         return success;
     }
     catch (e) {
-        systemLogger.warn(`retryPersistenceIfNeeded failed: ${e.message}`);
+        systemLogger.warn(`retryPersistenceIfNeeded failed: ${(0, errors_1.getErrorMessage)(e)}`);
         return false;
     }
 }
@@ -739,10 +804,10 @@ async function retryPersistenceIfNeeded(manager) {
  * @param {Function} updateOrdersOnChainBatchFn - Batch update function for blockchain operations
  * @returns {Promise<void>}
  */
-async function applyGridDivergenceCorrections(manager, accountOrders, botKey, updateOrdersOnChainBatchFn) {
+async function applyGridDivergenceCorrections(manager, accountOrders, _botKey, updateOrdersOnChainBatchFn) {
     if (!manager._gridLock)
         return;
-    const { calculateGapSlots, updateGridFromBlockchainSnapshot } = require('../grid');
+    const { updateGridFromBlockchainSnapshot } = require('../grid');
     const { WorkingGrid } = require('../working_grid');
     const { hasActionForOrder, removeActionsForOrder } = require('./validate');
     // Phase 1: Pre-lock grid resizing using COW
@@ -753,13 +818,13 @@ async function applyGridDivergenceCorrections(manager, accountOrders, botKey, up
     let resizeCowResult = null;
     let pendingBoundaryIdx = manager.boundaryIdx;
     if (manager._gridSidesUpdated && manager._gridSidesUpdated.size > 0) {
-        const hasBuy = manager._gridSidesUpdated.has(ORDER_TYPES.BUY);
-        const hasSell = manager._gridSidesUpdated.has(ORDER_TYPES.SELL);
+        const hasBuy = manager._gridSidesUpdated.has(constants_1.ORDER_TYPES.BUY);
+        const hasSell = manager._gridSidesUpdated.has(constants_1.ORDER_TYPES.SELL);
         let resizeOrderType = hasBuy && hasSell
             ? 'both'
             : hasBuy
-                ? ORDER_TYPES.BUY
-                : ORDER_TYPES.SELL;
+                ? constants_1.ORDER_TYPES.BUY
+                : constants_1.ORDER_TYPES.SELL;
         // If out-of-spread correction moves boundary, recompute both sides.
         // Store the new index in pendingBoundaryIdx — do NOT touch manager.boundaryIdx
         // here; updateGridFromBlockchainSnapshot will re-assign slot types in the
@@ -768,14 +833,14 @@ async function applyGridDivergenceCorrections(manager, accountOrders, botKey, up
         if (manager.outOfSpread > 0 && boundarySync.changed) {
             pendingBoundaryIdx = boundarySync.newIdx;
             resizeOrderType = 'both';
-            manager._gridSidesUpdated.add(ORDER_TYPES.BUY);
-            manager._gridSidesUpdated.add(ORDER_TYPES.SELL);
+            manager._gridSidesUpdated.add(constants_1.ORDER_TYPES.BUY);
+            manager._gridSidesUpdated.add(constants_1.ORDER_TYPES.SELL);
         }
         try {
             resizeCowResult = await updateGridFromBlockchainSnapshot(manager, resizeOrderType, true, pendingBoundaryIdx);
         }
         catch (err) {
-            manager.logger?.log?.(`[DIVERGENCE-COW] Grid resize failed: ${err.message}`, 'error');
+            manager.logger?.log?.(`[DIVERGENCE-COW] Grid resize failed: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
             manager._gridSidesUpdated.clear();
             return;
         }
@@ -792,14 +857,14 @@ async function applyGridDivergenceCorrections(manager, accountOrders, botKey, up
             : new WorkingGrid(manager.orders, { baseVersion: manager._gridVersion });
         const actions = resizeCowResult?.actions ? [...resizeCowResult.actions] : [];
         for (const orderType of manager._gridSidesUpdated) {
-            const sideName = orderType === ORDER_TYPES.BUY ? 'buy' : 'sell';
+            const sideName = orderType === constants_1.ORDER_TYPES.BUY ? 'buy' : 'sell';
             const sidePrecision = MathUtils.getPrecisionByOrderType(manager.assets, orderType);
             // Get current on-chain orders for this side (from master, not working)
             const currentOnChainOrders = Array.from(manager.orders.values())
-                .filter(o => o.type === orderType && OrderUtils.isOrderPlaced(o));
+                .filter((o) => o.type === orderType && OrderUtils.isOrderPlaced(o));
             // Get all slots for this side from working grid
             const allSideSlots = Array.from(workingGrid.values())
-                .filter(o => o.type === orderType)
+                .filter((o) => o.type === orderType)
                 .sort((a, b) => sideName === 'buy' ? b.price - a.price : a.price - b.price);
             // Calculate target count
             const baseTargetCount = (manager.config.activeOrders && Number.isFinite(manager.config.activeOrders[sideName]))
@@ -808,8 +873,8 @@ async function applyGridDivergenceCorrections(manager, accountOrders, botKey, up
             const targetCount = baseTargetCount;
             // Determine desired slots (closest to market)
             const desiredSlots = allSideSlots.slice(0, targetCount);
-            const desiredSlotIds = new Set(desiredSlots.map(s => s.id));
-            const onChainBySlotId = new Map(currentOnChainOrders.map(o => [o.id, o]));
+            const desiredSlotIds = new Set(desiredSlots.map((s) => s.id));
+            const onChainBySlotId = new Map(currentOnChainOrders.map((o) => [o.id, o]));
             // Process on-chain orders:
             // - In desired window: keep/update committed size (if not already queued by Phase 1)
             // - Outside desired window: cancel surplus order
@@ -817,13 +882,13 @@ async function applyGridDivergenceCorrections(manager, accountOrders, botKey, up
                 // Get current slot from working grid (may have been updated in Phase 1)
                 const slot = workingGrid.get(onChainOrder.id);
                 const isDesired = desiredSlotIds.has(onChainOrder.id);
-                if (!isDesired || !slot || !(toFiniteNumber(slot.size) > 0)) {
-                    removeActionsForOrder(actions, COW_ACTIONS.UPDATE, onChainOrder);
-                    const hasQueuedCancel = hasActionForOrder(actions, COW_ACTIONS.CANCEL, onChainOrder);
+                if (!isDesired || !slot || !((0, format_1.toFiniteNumber)(slot.size) > 0)) {
+                    removeActionsForOrder(actions, constants_1.COW_ACTIONS.UPDATE, onChainOrder);
+                    const hasQueuedCancel = hasActionForOrder(actions, constants_1.COW_ACTIONS.CANCEL, onChainOrder);
                     if (!hasQueuedCancel) {
                         manager.logger.log(`[DIVERGENCE-COW] Queueing cancel for surplus ${onChainOrder.id} (chain id ${onChainOrder.orderId})`, 'info');
                         actions.push({
-                            type: COW_ACTIONS.CANCEL,
+                            type: constants_1.COW_ACTIONS.CANCEL,
                             id: onChainOrder.id,
                             orderId: onChainOrder.orderId
                         });
@@ -833,20 +898,20 @@ async function applyGridDivergenceCorrections(manager, accountOrders, botKey, up
                     continue;
                 }
                 // Phase 1 already queued committed size updates. Avoid duplicate UPDATEs.
-                const hasQueuedUpdate = hasActionForOrder(actions, COW_ACTIONS.UPDATE, onChainOrder);
-                const hasQueuedCancel = hasActionForOrder(actions, COW_ACTIONS.CANCEL, onChainOrder);
+                const hasQueuedUpdate = hasActionForOrder(actions, constants_1.COW_ACTIONS.UPDATE, onChainOrder);
+                const hasQueuedCancel = hasActionForOrder(actions, constants_1.COW_ACTIONS.CANCEL, onChainOrder);
                 if (hasQueuedUpdate || hasQueuedCancel) {
                     continue;
                 }
-                const newSize = toFiniteNumber(slot.size);
-                const currentSize = toFiniteNumber(onChainOrder.size);
+                const newSize = (0, format_1.toFiniteNumber)(slot.size);
+                const currentSize = (0, format_1.toFiniteNumber)(onChainOrder.size);
                 const sizeChanged = Number.isFinite(sidePrecision)
                     ? MathUtils.floatToBlockchainInt(newSize, sidePrecision) !== MathUtils.floatToBlockchainInt(currentSize, sidePrecision)
                     : newSize !== currentSize;
                 if (sizeChanged) {
                     manager.logger.log(`[DIVERGENCE-COW] Queueing size update for ${onChainOrder.id}: ${currentSize} -> ${newSize}`, 'info');
                     actions.push({
-                        type: COW_ACTIONS.UPDATE,
+                        type: constants_1.COW_ACTIONS.UPDATE,
                         id: onChainOrder.id,
                         orderId: onChainOrder.orderId,
                         newGridId: onChainOrder.id,
@@ -863,11 +928,11 @@ async function applyGridDivergenceCorrections(manager, accountOrders, botKey, up
             }
             // Process holes: CREATE new orders for empty desired slots
             for (const slot of desiredSlots) {
-                const hasCreate = hasActionForOrder(actions, COW_ACTIONS.CREATE, slot);
+                const hasCreate = hasActionForOrder(actions, constants_1.COW_ACTIONS.CREATE, slot);
                 if (!onChainBySlotId.has(slot.id) && slot.size > 0 && !hasCreate) {
                     manager.logger.log(`[DIVERGENCE-COW] Queueing new placement for slot ${slot.id}`, 'info');
                     actions.push({
-                        type: COW_ACTIONS.CREATE,
+                        type: constants_1.COW_ACTIONS.CREATE,
                         id: slot.id,
                         order: {
                             id: slot.id,
@@ -938,7 +1003,7 @@ async function applyGridDivergenceCorrections(manager, accountOrders, botKey, up
             }
         }
         catch (err) {
-            manager.logger.log(`[DIVERGENCE-COW] Error executing divergence corrections: ${err.message}`, 'error');
+            manager.logger.log(`[DIVERGENCE-COW] Error executing divergence corrections: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
             manager._gridSidesUpdated.clear();
         }
     }
@@ -983,9 +1048,9 @@ function syncBoundaryToFunds(manager) {
     let minSellIdx = allSlots.length;
     for (let i = 0; i < allSlots.length; i++) {
         const slot = allSlots[i];
-        if (slot.type === ORDER_TYPES.BUY && i > maxBuyIdx)
+        if (slot.type === constants_1.ORDER_TYPES.BUY && i > maxBuyIdx)
             maxBuyIdx = i;
-        if (slot.type === ORDER_TYPES.SELL && i < minSellIdx)
+        if (slot.type === constants_1.ORDER_TYPES.SELL && i < minSellIdx)
             minSellIdx = i;
     }
     // Build clamp bounds from whichever sides have typed slots.
@@ -1016,7 +1081,7 @@ function syncBoundaryToFunds(manager) {
  */
 function ensureProfilesDirectory(profilesDir) {
     if (!storage.exists(profilesDir)) {
-        ensureDir(profilesDir);
+        (0, fs_utils_1.ensureDir)(profilesDir);
         return true;
     }
     return false;
@@ -1027,7 +1092,7 @@ function ensureProfilesDirectory(profilesDir) {
  * @returns {Promise<void>}
  */
 function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }
 /**
  * Read user input from stdin with optional masking.
@@ -1042,8 +1107,8 @@ function sleep(ms) {
  */
 function readInput(prompt, options = {}) {
     return new Promise((resolve) => {
-        const stdin = runtime.stdin;
-        const stdout = runtime.stdout;
+        const stdin = runtime_1.runtime.stdin;
+        const stdout = runtime_1.runtime.stdout;
         const ESC_SEQUENCE_TIMEOUT_MS = 150;
         let input = '';
         let cursorPos = 0;
@@ -1134,7 +1199,7 @@ function readInput(prompt, options = {}) {
             if (ch === '\u0003') {
                 cleanup();
                 stdout.write('\r\x1b[K\n');
-                runtime.exit(0);
+                runtime_1.runtime.exit(0);
             }
             // Backspace
             if (ch === '\u007f' || ch === '\u0008') {
@@ -1204,7 +1269,7 @@ async function readPassword(prompt) { return readInput(prompt, { mask: '*', hide
  * @throws {Error} If all attempts fail, throws the final error
  */
 async function withRetry(fn, options = {}) {
-    const { maxAttempts = PIPELINE_TIMING.RETRY_MAX_ATTEMPTS, baseDelayMs = PIPELINE_TIMING.RETRY_BASE_DELAY_MS, maxDelayMs = PIPELINE_TIMING.RETRY_MAX_DELAY_MS, logger = null, operationName = 'operation' } = options;
+    const { maxAttempts = constants_1.PIPELINE_TIMING.RETRY_MAX_ATTEMPTS, baseDelayMs = constants_1.PIPELINE_TIMING.RETRY_BASE_DELAY_MS, maxDelayMs = constants_1.PIPELINE_TIMING.RETRY_MAX_DELAY_MS, logger = null, operationName = 'operation' } = options;
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
         try {
             return await fn();
@@ -1217,6 +1282,87 @@ async function withRetry(fn, options = {}) {
             await sleep(delay);
         }
     }
+    throw new Error(`${operationName} failed after ${maxAttempts} attempts`);
+}
+/**
+ * Execute a blockchain operation with timeout, retry, and node failover reporting.
+ * Reports each failure to NodeManager so the node gets blacklisted after
+ * consecutive failures, triggering automatic failover to a healthy node.
+ *
+ * After exhausting the retry budget, force-blacklists the current node and
+ * reconnects to a different healthy node, then makes one final attempt.
+ * This prevents the bot from hanging indefinitely on a stuck node.
+ *
+ * Defaults: 30s timeout, 3 retries (PIPELINE_TIMING.RETRY_MAX_ATTEMPTS), 2s retry delay.
+ * All configurable via options.
+ *
+ * @param fn - Async function wrapping the blockchain operation
+ * @param label - Short human-readable label for error messages
+ * @param options.logger - Optional logger for retry warnings
+ * @param options.timeoutMs - Override timeout per attempt (default 30000)
+ * @param options.maxRetries - Override max retry count (default PIPELINE_TIMING.RETRY_MAX_ATTEMPTS)
+ * @param options.retryDelayMs - Override delay between retries (default 2000)
+ */
+async function withBlockchainRetry(fn, label, options) {
+    const timeoutMs = options?.timeoutMs ?? 30000;
+    const maxRetries = options?.maxRetries ?? constants_1.PIPELINE_TIMING.RETRY_MAX_ATTEMPTS;
+    const retryDelayMs = options?.retryDelayMs ?? 2000;
+    const logger = options?.logger;
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            const resultPromise = fn();
+            // Swallow late unhandled rejections from the race loser
+            Promise.resolve(resultPromise).catch(() => { });
+            return await Promise.race([
+                resultPromise,
+                new Promise((_, reject) => {
+                    setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms (attempt ${attempt}/${maxRetries})`)), timeoutMs);
+                })
+            ]);
+        }
+        catch (err) {
+            lastError = err;
+            // Report node failure so NodeManager can blacklist and trigger failover
+            try {
+                const { getNodeManager } = require('../../bitshares_client');
+                const nodeManager = getNodeManager();
+                const nodeUrl = nodeManager?.getBestNode?.();
+                if (nodeUrl && typeof nodeManager.reportNodeFailure === 'function') {
+                    nodeManager.reportNodeFailure(nodeUrl, (0, errors_1.getErrorMessage)(err), 'blockchain-op');
+                }
+            }
+            catch (_) { /* reporting errors are non-fatal */ }
+            if (attempt < maxRetries) {
+                logger?.log?.(`${label} attempt ${attempt}/${maxRetries} failed: ${(0, errors_1.getErrorMessage)(err)}. Retrying in ${retryDelayMs}ms...`, 'warn');
+                await sleep(retryDelayMs);
+            }
+        }
+    }
+    // All retries exhausted — force-switch to a different node and retry once more
+    try {
+        const { getNodeManager, reconnectForCycle } = require('../../bitshares_client');
+        const nodeManager = getNodeManager?.();
+        const failedNode = nodeManager?.getBestNode?.();
+        if (failedNode && typeof nodeManager.blacklistNode === 'function') {
+            nodeManager.blacklistNode(failedNode);
+            logger?.log?.(`${label}: blacklisted node ${failedNode.substring(0, 40)}... after ${maxRetries} failed attempts. Switching nodes...`, 'warn');
+        }
+        const reconnected = await reconnectForCycle(label + ' failover');
+        if (reconnected) {
+            logger?.log?.(`${label}: reconnected to different node. Retrying operation...`, 'warn');
+            const resultPromise = fn();
+            Promise.resolve(resultPromise).catch(() => { });
+            return await Promise.race([
+                resultPromise,
+                new Promise((_, reject) => {
+                    setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms (failover attempt)`)), timeoutMs);
+                })
+            ]);
+        }
+    }
+    catch (_) { /* failover recovery errors are non-fatal — throw original error */ }
+    throw new Error(`${label} failed after ${maxRetries} attempts: ${(0, errors_1.getErrorMessage)(lastError)}`);
 }
 // ================================================================================
 // SECTION 6: GENERAL UTILITIES
@@ -1250,7 +1396,7 @@ function deepFreeze(obj) {
     if (obj === null || typeof obj !== 'object')
         return obj;
     Object.freeze(obj);
-    Object.getOwnPropertyNames(obj).forEach(prop => {
+    Object.getOwnPropertyNames(obj).forEach((prop) => {
         if (Object.prototype.hasOwnProperty.call(obj, prop) &&
             obj[prop] !== null &&
             (typeof obj[prop] === 'object' || typeof obj[prop] === 'function') &&
@@ -1278,29 +1424,4 @@ function parseJsonWithComments(raw) {
     const stripped = raw.replace(/\/\*(?:.|[\r\n])*?\*\//g, '').replace(/(^|\s*)\/\/.*$/gm, '');
     return JSON.parse(stripped);
 }
-module.exports = {
-    lookupAsset,
-    deriveMarketPrice,
-    derivePoolPrice,
-    derivePrice,
-    resolveLiquidityPoolByShareAsset,
-    deriveLiquidityPoolTokenValue,
-    loadAmaCenterPrice,
-    loadAmaCenterSnapshot,
-    initializeFeeCache,
-    persistGridSnapshot,
-    retryPersistenceIfNeeded,
-    applyGridDivergenceCorrections,
-    syncBoundaryToFunds,
-    ensureProfilesDirectory,
-    sleep,
-    readInput,
-    readPassword,
-    withRetry,
-    resolveAccountRef,
-    deepFreeze,
-    cloneMap,
-    ensureDir,
-    parseJsonWithComments
-};
 //# sourceMappingURL=system.js.map