dexbot 1.4.11 → 1.4.12

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

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * modules/order/utils/system.ts - System and I/O Utilities
  *
@@ -47,84 +46,26 @@
  *
  * ===============================================================================
  */
-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 timeout_1 = require("./timeout");
-const systemLogger = new logger_1.default('System');
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+import { path } from '../../path_api.js';
+import { getStorage } from '../../storage/index.js';
+const storage = getStorage();
+import { API_LIMITS, ORDER_TYPES, COW_ACTIONS, FEE_PARAMETERS, BTS_PRECISION, PIPELINE_TIMING, NATIVE_CLIENT } from '../../constants.js';
+import { PATHS } from '../../paths.js';
+import { toFiniteNumber, isValidNumber } from '../format.js';
+import * as MathUtils from './math.js';
+import * as OrderUtils from './order.js';
+import Logger from '../../logger.js';
+import { runtime } from '../../runtime.js';
+import { getErrorMessage } from '../../utils/errors.js';
+import { withTimeout } from './timeout.js';
+const { ensureDir, readJSON } = storage;
+const systemLogger = new Logger('System');
 function _debugLogAndNull(method, symA, symB) {
     return (err) => {
         // debug level: underlying derivePoolPrice/deriveMarketPrice already log at warn
-        systemLogger.debug(`derivePrice(${method}) for ${symA}/${symB}: ${(0, errors_1.getErrorMessage)(err)}`);
+        systemLogger.debug(`derivePrice(${method}) for ${symA}/${symB}: ${getErrorMessage(err)}`);
         return null;
     };
 }
@@ -141,7 +82,7 @@ const poolIdCache = new Map();
  * @returns {Promise<Object>} Asset metadata with id, symbol, precision
  * @throws {Error} If asset cannot be found on blockchain
  */
-const lookupAsset = async (BitShares, s) => {
+export const lookupAsset = async (BitShares, s) => {
     if (!BitShares)
         return null;
     let cached = null;
@@ -170,12 +111,11 @@ const lookupAsset = async (BitShares, s) => {
             }
         }
         catch (e) {
-            systemLogger.debug(`lookupAsset: method failed for ${s}: ${(0, errors_1.getErrorMessage)(e)}`);
+            systemLogger.debug(`lookupAsset: method failed for ${s}: ${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).
@@ -186,11 +126,11 @@ exports.lookupAsset = lookupAsset;
  * @param {string} symB - Second asset symbol
  * @returns {Promise<number|null>} Derived market price or null if unavailable
  */
-const deriveMarketPrice = async (BitShares, symA, symB) => {
+export const deriveMarketPrice = async (BitShares, symA, symB) => {
     try {
         const [aMeta, bMeta] = await Promise.all([
-            (0, exports.lookupAsset)(BitShares, symA),
-            (0, exports.lookupAsset)(BitShares, symB)
+            lookupAsset(BitShares, symA),
+            lookupAsset(BitShares, symB)
         ]);
         if (!aMeta?.id || !bMeta?.id)
             return null;
@@ -199,23 +139,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, 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;
+                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;
                 if (bestBid !== null && bestAsk !== null)
                     mid = (bestBid + bestAsk) / 2;
             }
             catch (e) {
-                systemLogger.debug(`deriveMarketPrice: get_order_book failed for ${symA}/${symB}: ${(0, errors_1.getErrorMessage)(e)}`);
+                systemLogger.debug(`deriveMarketPrice: get_order_book failed for ${symA}/${symB}: ${getErrorMessage(e)}`);
             }
         }
         if (mid === null && typeof BitShares.db?.get_ticker === 'function') {
             try {
                 const t = await BitShares.db.get_ticker(baseId, quoteId);
-                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);
+                mid = isValidNumber(t?.latest) ? toFiniteNumber(t.latest) : (isValidNumber(t?.latest_price) ? toFiniteNumber(t.latest_price) : null);
             }
             catch (err) {
-                systemLogger.debug(`deriveMarketPrice: get_ticker failed for ${symA}/${symB}: ${(0, errors_1.getErrorMessage)(err)}`);
+                systemLogger.debug(`deriveMarketPrice: get_ticker failed for ${symA}/${symB}: ${getErrorMessage(err)}`);
             }
         }
         // Return B/A orientation to match market price format
@@ -226,11 +166,10 @@ const deriveMarketPrice = async (BitShares, symA, symB) => {
         return finalPrice;
     }
     catch (err) {
-        systemLogger.warn(`deriveMarketPrice failed for ${symA}/${symB}: ${(0, errors_1.getErrorMessage)(err)}`);
+        systemLogger.warn(`deriveMarketPrice failed for ${symA}/${symB}: ${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).
@@ -241,11 +180,11 @@ exports.deriveMarketPrice = deriveMarketPrice;
  * @param {string} symB - Second asset symbol
  * @returns {Promise<number|null>} Derived pool price or null if unavailable
  */
-const derivePoolPrice = async (BitShares, symA, symB) => {
+export const derivePoolPrice = async (BitShares, symA, symB) => {
     try {
         const [aMeta, bMeta] = await Promise.all([
-            (0, exports.lookupAsset)(BitShares, symA),
-            (0, exports.lookupAsset)(BitShares, symB)
+            lookupAsset(BitShares, symA),
+            lookupAsset(BitShares, symB)
         ]);
         if (!aMeta?.id || !bMeta?.id)
             return null;
@@ -259,7 +198,7 @@ const derivePoolPrice = async (BitShares, symA, symB) => {
                     const valid = pools.filter((p) => p?.id);
                     if (valid.length) {
                         chosen = valid.sort((a, b) => {
-                            const getBal = (p) => (0, format_1.toFiniteNumber)(String(p.asset_a) === String(aMeta.id) ? p.balance_a : p.balance_b);
+                            const getBal = (p) => toFiniteNumber(String(p.asset_a) === String(aMeta.id) ? p.balance_a : p.balance_b);
                             return getBal(b) - getBal(a);
                         })[0];
                         if (chosen)
@@ -268,7 +207,7 @@ const derivePoolPrice = async (BitShares, symA, symB) => {
                 }
             }
             catch (e) {
-                systemLogger.debug(`derivePoolPrice: get_liquidity_pools_by_both_assets failed: ${(0, errors_1.getErrorMessage)(e)}`);
+                systemLogger.debug(`derivePoolPrice: get_liquidity_pools_by_both_assets failed: ${getErrorMessage(e)}`);
             }
         }
         if (!chosen && cachedPoolId && typeof BitShares.db?.get_objects === 'function') {
@@ -286,10 +225,13 @@ const derivePoolPrice = async (BitShares, symA, symB) => {
             if (typeof listFn === 'function') {
                 try {
                     let startId = '1.19.0';
-                    const PAGE_SIZE = 100;
+                    const pageSize = API_LIMITS.POOL_BATCH_SIZE;
                     const allMatches = [];
+                    let scannedBatches = 0;
                     while (true) {
-                        const pools = await listFn(PAGE_SIZE, startId);
+                        if (scannedBatches++ >= API_LIMITS.MAX_POOL_SCAN_BATCHES)
+                            break;
+                        const pools = await listFn(pageSize, startId);
                         if (!pools || pools.length === 0)
                             break;
                         // BitShares list_liquidity_pools is inclusive of startId.
@@ -304,7 +246,7 @@ const derivePoolPrice = async (BitShares, symA, symB) => {
                         if (matches.length) {
                             allMatches.push(...matches);
                         }
-                        if (pools.length < PAGE_SIZE) {
+                        if (pools.length < pageSize) {
                             break;
                         }
                         else {
@@ -314,44 +256,44 @@ 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) => (0, format_1.toFiniteNumber)(String(p.asset_a) === String(aMeta.id) ? p.balance_a : p.balance_b);
+                            const getBal = (p) => 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: ${(0, errors_1.getErrorMessage)(e) || e}`);
+                    systemLogger.warn(`derivePoolPrice: pool pagination failed: ${getErrorMessage(e) || e}`);
                 }
             }
         }
         if (!chosen)
             return null;
-        if (!chosen.reserves && !(0, format_1.isValidNumber)(chosen.balance_a) && typeof BitShares.db?.get_objects === 'function') {
+        if (!chosen.reserves && !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}: ${(0, errors_1.getErrorMessage)(e)}`);
+                systemLogger.debug(`derivePoolPrice: get_objects failed for pool ${chosen.id}: ${getErrorMessage(e)}`);
             }
         }
         let amtA = null, amtB = null;
-        if ((0, format_1.isValidNumber)(chosen.balance_a) && (0, format_1.isValidNumber)(chosen.balance_b)) {
+        if (isValidNumber(chosen.balance_a) && isValidNumber(chosen.balance_b)) {
             // Pools store assets ordered by ID: lower ID is always first (asset_a)
-            const aIdNum = (0, format_1.toFiniteNumber)(String(aMeta.id).split('.')[2]);
-            const bIdNum = (0, format_1.toFiniteNumber)(String(bMeta.id).split('.')[2]);
+            const aIdNum = toFiniteNumber(String(aMeta.id).split('.')[2]);
+            const bIdNum = 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 = (0, format_1.toFiniteNumber)(chosen.balance_a);
-                amtB = (0, format_1.toFiniteNumber)(chosen.balance_b);
+                amtA = toFiniteNumber(chosen.balance_a);
+                amtB = toFiniteNumber(chosen.balance_b);
             }
             else {
-                amtA = (0, format_1.toFiniteNumber)(chosen.balance_b);
-                amtB = (0, format_1.toFiniteNumber)(chosen.balance_a);
+                amtA = toFiniteNumber(chosen.balance_b);
+                amtB = toFiniteNumber(chosen.balance_a);
             }
         }
         else if (Array.isArray(chosen.reserves)) {
@@ -362,7 +304,7 @@ const derivePoolPrice = async (BitShares, symA, symB) => {
                 amtB = resB.amount;
             }
         }
-        if (!(0, format_1.isValidNumber)(amtA) || !(0, format_1.isValidNumber)(amtB) || (0, format_1.toFiniteNumber)(amtB) === 0)
+        if (!isValidNumber(amtA) || !isValidNumber(amtB) || toFiniteNumber(amtB) === 0)
             return null;
         const floatA = MathUtils.blockchainToFloat(amtA, aMeta.precision);
         const floatB = MathUtils.blockchainToFloat(amtB, bMeta.precision);
@@ -374,11 +316,10 @@ const derivePoolPrice = async (BitShares, symA, symB) => {
         return finalPrice;
     }
     catch (err) {
-        systemLogger.warn(`derivePoolPrice failed for ${symA}/${symB}: ${(0, errors_1.getErrorMessage)(err)}`);
+        systemLogger.warn(`derivePoolPrice failed for ${symA}/${symB}: ${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.
@@ -389,7 +330,7 @@ exports.derivePoolPrice = derivePoolPrice;
  * @param {string} [mode='auto'] - Derivation mode: "pool", "book", or "auto" (pool → book).
  * @returns {Promise<number|null>} Derived price or null if all methods fail
  */
-const derivePrice = async (BitShares, symA, symB, mode = 'auto') => {
+export const derivePrice = async (BitShares, symA, symB, mode = 'auto') => {
     mode = String(mode).toLowerCase();
     const validModes = new Set(['pool', 'book', 'auto']);
     if (!validModes.has(mode)) {
@@ -397,23 +338,22 @@ const derivePrice = async (BitShares, symA, symB, mode = 'auto') => {
         return null;
     }
     if (mode === 'pool') {
-        return await (0, exports.derivePoolPrice)(BitShares, symA, symB).catch(_debugLogAndNull('pool', symA, symB));
+        return await derivePoolPrice(BitShares, symA, symB).catch(_debugLogAndNull('pool', symA, symB));
     }
     if (mode === 'book') {
-        return await (0, exports.deriveMarketPrice)(BitShares, symA, symB).catch(_debugLogAndNull('book', symA, symB));
+        return await deriveMarketPrice(BitShares, symA, symB).catch(_debugLogAndNull('book', symA, symB));
     }
     // mode === 'auto': pool preferred, market fallback
     let poolP = null;
-    poolP = await (0, exports.derivePoolPrice)(BitShares, symA, symB).catch(_debugLogAndNull('auto/pool', symA, symB));
+    poolP = await derivePoolPrice(BitShares, symA, symB).catch(_debugLogAndNull('auto/pool', symA, symB));
     if (poolP != null && poolP > 0)
         return poolP;
-    const m = await (0, exports.deriveMarketPrice)(BitShares, symA, symB).catch(_debugLogAndNull('auto/book', symA, symB));
+    const m = await 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.
@@ -422,19 +362,19 @@ exports.derivePrice = derivePrice;
  * @param {string} shareAssetRef - Share asset symbol or reference
  * @returns {Promise<Object|null>} Object with {shareAsset, pool} or null if not found
  */
-async function resolveLiquidityPoolByShareAsset(BitShares, shareAssetRef) {
+export async function resolveLiquidityPoolByShareAsset(BitShares, shareAssetRef) {
     if (!BitShares?.db || typeof BitShares.db.get_liquidity_pools_by_share_asset !== 'function') {
         return null;
     }
-    const shareAsset = await (0, exports.lookupAsset)(BitShares, shareAssetRef).catch((e) => {
-        systemLogger.debug(`resolveLiquidityPoolByShareAsset: lookupAsset failed for ${shareAssetRef}: ${(0, errors_1.getErrorMessage)(e)}`);
+    const shareAsset = await lookupAsset(BitShares, shareAssetRef).catch((e) => {
+        systemLogger.debug(`resolveLiquidityPoolByShareAsset: lookupAsset failed for ${shareAssetRef}: ${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}: ${(0, errors_1.getErrorMessage)(e)}`);
+        systemLogger.debug(`resolveLiquidityPoolByShareAsset: get_liquidity_pools_by_share_asset failed for ${shareAssetRef}: ${getErrorMessage(e)}`);
         return null;
     });
     if (!Array.isArray(response)) {
@@ -452,8 +392,8 @@ async function resolveLiquidityPoolByShareAsset(BitShares, shareAssetRef) {
 async function getAssetCurrentSupply(BitShares, assetRef) {
     const asset = typeof assetRef === 'object' && assetRef !== null
         ? assetRef
-        : await (0, exports.lookupAsset)(BitShares, assetRef).catch((e) => {
-            systemLogger.debug(`getAssetCurrentSupply: lookupAsset failed for ${assetRef}: ${(0, errors_1.getErrorMessage)(e)}`);
+        : await lookupAsset(BitShares, assetRef).catch((e) => {
+            systemLogger.debug(`getAssetCurrentSupply: lookupAsset failed for ${assetRef}: ${getErrorMessage(e)}`);
             return null;
         });
     if (!asset) {
@@ -461,7 +401,7 @@ async function getAssetCurrentSupply(BitShares, assetRef) {
     }
     const hasDirectSupply = asset.current_supply != null;
     const directSupply = hasDirectSupply
-        ? (0, format_1.toFiniteNumber)(asset.current_supply?.amount ?? asset.current_supply, -1)
+        ? toFiniteNumber(asset.current_supply?.amount ?? asset.current_supply, -1)
         : -1;
     if (hasDirectSupply && Number.isFinite(directSupply) && directSupply >= 0) {
         return directSupply;
@@ -471,11 +411,11 @@ 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}: ${(0, errors_1.getErrorMessage)(e)}`);
+        systemLogger.debug(`getAssetCurrentSupply: get_objects failed for ${dynamicId}: ${getErrorMessage(e)}`);
         return null;
     });
     const dynamicData = Array.isArray(objects) ? objects[0] : null;
-    const supply = (0, format_1.toFiniteNumber)(dynamicData?.current_supply?.amount
+    const supply = toFiniteNumber(dynamicData?.current_supply?.amount
         ?? dynamicData?.current_supply?.value
         ?? dynamicData?.current_supply, undefined);
     return Number.isFinite(supply) && supply >= 0 ? supply : null;
@@ -491,11 +431,11 @@ async function getAssetCurrentSupply(BitShares, assetRef) {
  * @param {string} [mode='auto'] - Price derivation mode ("pool", "book", or "auto")
  * @returns {Promise<number|null>} Value per share in denomination asset, or null
  */
-async function deriveLiquidityPoolTokenValue(BitShares, shareAssetRef, denominationAssetRef, mode = 'auto') {
+export async function deriveLiquidityPoolTokenValue(BitShares, shareAssetRef, denominationAssetRef, mode = 'auto') {
     try {
         const [shareAsset, denominationAsset] = await Promise.all([
-            (0, exports.lookupAsset)(BitShares, shareAssetRef),
-            (0, exports.lookupAsset)(BitShares, denominationAssetRef),
+            lookupAsset(BitShares, shareAssetRef),
+            lookupAsset(BitShares, denominationAssetRef),
         ]);
         if (!shareAsset?.id || !denominationAsset?.id) {
             return null;
@@ -505,8 +445,8 @@ async function deriveLiquidityPoolTokenValue(BitShares, shareAssetRef, denominat
             return null;
         }
         const [assetA, assetB, supply] = await Promise.all([
-            (0, exports.lookupAsset)(BitShares, poolInfo.pool.asset_a),
-            (0, exports.lookupAsset)(BitShares, poolInfo.pool.asset_b),
+            lookupAsset(BitShares, poolInfo.pool.asset_a),
+            lookupAsset(BitShares, poolInfo.pool.asset_b),
             getAssetCurrentSupply(BitShares, shareAsset),
         ]);
         if (!assetA?.id || !assetB?.id || !Number.isFinite(supply) || supply <= 0) {
@@ -514,34 +454,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 (!(0, format_1.isValidNumber)(reserveA) || !(0, format_1.isValidNumber)(reserveB)) {
+        if (!isValidNumber(reserveA) || !isValidNumber(reserveB)) {
             return null;
         }
         const priceA = String(assetA.id) === String(denominationAsset.id)
             ? 1
-            : 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)}`);
+            : await derivePrice(BitShares, assetA.id, denominationAsset.id, mode).catch((e) => {
+                systemLogger.debug(`deriveLiquidityPoolTokenValue: derivePrice failed for ${assetA.id}/${denominationAsset.id}: ${getErrorMessage(e)}`);
                 return null;
             });
         const priceB = String(assetB.id) === String(denominationAsset.id)
             ? 1
-            : 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)}`);
+            : await derivePrice(BitShares, assetB.id, denominationAsset.id, mode).catch((e) => {
+                systemLogger.debug(`deriveLiquidityPoolTokenValue: derivePrice failed for ${assetB.id}/${denominationAsset.id}: ${getErrorMessage(e)}`);
                 return null;
             });
-        if (priceA == null || priceB == null || !(0, format_1.isValidNumber)(priceA) || !(0, format_1.isValidNumber)(priceB) || priceA <= 0 || priceB <= 0) {
+        if (priceA == null || priceB == null || !isValidNumber(priceA) || !isValidNumber(priceB) || priceA <= 0 || priceB <= 0) {
             return null;
         }
         const supplyFloat = MathUtils.blockchainToFloat(supply, shareAsset.precision);
-        if (!(0, format_1.isValidNumber)(supplyFloat) || supplyFloat <= 0) {
+        if (!isValidNumber(supplyFloat) || supplyFloat <= 0) {
             return null;
         }
         const totalValue = reserveA * priceA + reserveB * priceB;
         const valuePerShare = totalValue / supplyFloat;
-        return (0, format_1.isValidNumber)(valuePerShare) && valuePerShare > 0 ? valuePerShare : null;
+        return isValidNumber(valuePerShare) && valuePerShare > 0 ? valuePerShare : null;
     }
     catch (err) {
-        systemLogger.debug(`deriveLiquidityPoolTokenValue failed for ${shareAssetRef}/${denominationAssetRef}: ${(0, errors_1.getErrorMessage)(err)}`);
+        systemLogger.debug(`deriveLiquidityPoolTokenValue failed for ${shareAssetRef}/${denominationAssetRef}: ${getErrorMessage(err)}`);
         return null;
     }
 }
@@ -560,10 +500,10 @@ async function deriveLiquidityPoolTokenValue(BitShares, shareAssetRef, denominat
  * @param {string} botKey - Bot key (e.g. "iob-xrp-bts-0")
  * @returns {Object|null} Snapshot with center and optional dynamicWeights fields, or null if invalid
  */
-function loadAmaCenterSnapshot(botKey) {
+export function loadAmaCenterSnapshot(botKey) {
     try {
-        const gridPriceFile = path_api_1.path.join(paths_1.PATHS.ORDERS_DIR, `${botKey}.dynamicgrid.json`);
-        const data = (0, fs_utils_1.readJSON)(gridPriceFile);
+        const gridPriceFile = path.join(PATHS.ORDERS_DIR, `${botKey}.dynamicgrid.json`);
+        const data = readJSON(gridPriceFile);
         const gridCenterPrice = Number(data?.gridCenterPrice ?? data?.centerPrice);
         const amaCenterPrice = Number(data?.amaCenterPrice);
         if (!Number.isFinite(gridCenterPrice) || gridCenterPrice <= 0) {
@@ -603,7 +543,7 @@ function loadAmaCenterSnapshot(botKey) {
  * @param {string} botKey - Bot key (e.g. "iob-xrp-bts-0")
  * @returns {number|null} Grid center price in B/A format, or null if file absent/invalid
  */
-function loadAmaCenterPrice(botKey) {
+export function loadAmaCenterPrice(botKey) {
     const snapshot = loadAmaCenterSnapshot(botKey);
     return snapshot ? snapshot.gridCenterPrice : null;
 }
@@ -614,9 +554,9 @@ function loadAmaCenterPrice(botKey) {
  * Load previously persisted fee cache from disk.
  * @returns {Record<string, any>} Cached fee data or empty object
  */
-function _loadFeeCacheFromDisk() {
+export function _loadFeeCacheFromDisk() {
     try {
-        const filePath = paths_1.PATHS.PROFILES.FEE_CACHE_JSON;
+        const filePath = PATHS.PROFILES.FEE_CACHE_JSON;
         if (storage.exists(filePath)) {
             const diskCache = storage.readJSON(filePath);
             if (diskCache && typeof diskCache === 'object') {
@@ -626,7 +566,7 @@ function _loadFeeCacheFromDisk() {
         }
     }
     catch (e) {
-        systemLogger.debug(`_loadFeeCacheFromDisk: ${(0, errors_1.getErrorMessage)(e)}`);
+        systemLogger.debug(`_loadFeeCacheFromDisk: ${getErrorMessage(e)}`);
     }
     return {};
 }
@@ -634,12 +574,12 @@ function _loadFeeCacheFromDisk() {
  * Persist fee cache to disk for recovery across restarts.
  * @param {Record<string, any>} cache - Fee cache to persist
  */
-function _saveFeeCacheToDisk(cache) {
+export function _saveFeeCacheToDisk(cache) {
     try {
-        storage.writeJSON(paths_1.PATHS.PROFILES.FEE_CACHE_JSON, cache);
+        storage.writeJSON(PATHS.PROFILES.FEE_CACHE_JSON, cache);
     }
     catch (e) {
-        systemLogger.debug(`_saveFeeCacheToDisk: ${(0, errors_1.getErrorMessage)(e)}`);
+        systemLogger.debug(`_saveFeeCacheToDisk: ${getErrorMessage(e)}`);
     }
 }
 /**
@@ -652,7 +592,7 @@ function _saveFeeCacheToDisk(cache) {
  * @param {Object} BitShares - BitShares client instance
  * @returns {Promise<Object>} Fee cache object keyed by asset symbol
  */
-async function initializeFeeCache(botsConfig, BitShares) {
+export async function initializeFeeCache(botsConfig, BitShares) {
     const uniqueAssets = new Set(['BTS']);
     for (const bot of botsConfig) {
         if (bot.assetA)
@@ -662,8 +602,8 @@ async function initializeFeeCache(botsConfig, BitShares) {
     }
     // Seed from disk so previously cached assets survive transient API failures
     const cache = _loadFeeCacheFromDisk();
-    const maxAttempts = constants_1.FEE_PARAMETERS.FEE_CACHE_RETRY_ATTEMPTS;
-    const baseDelay = constants_1.FEE_PARAMETERS.FEE_CACHE_RETRY_DELAY_MS;
+    const maxAttempts = FEE_PARAMETERS.FEE_CACHE_RETRY_ATTEMPTS;
+    const baseDelay = FEE_PARAMETERS.FEE_CACHE_RETRY_DELAY_MS;
     for (const assetSymbol of uniqueAssets) {
         let lastError = null;
         for (let attempt = 1; attempt <= maxAttempts; attempt++) {
@@ -674,23 +614,23 @@ async function initializeFeeCache(botsConfig, BitShares) {
                     const findFee = (opCode) => {
                         const param = currentFees.find((p) => p[0] === opCode);
                         const fee = param?.[1]?.fee;
-                        const feeNum = (0, format_1.toFiniteNumber)(fee);
+                        const feeNum = toFiniteNumber(fee);
                         return {
                             raw: feeNum,
                             satoshis: feeNum,
-                            bts: MathUtils.blockchainToFloat(feeNum, constants_1.BTS_PRECISION)
+                            bts: MathUtils.blockchainToFloat(feeNum, BTS_PRECISION)
                         };
                     };
-                    const makerFeeDiscountRaw = (0, format_1.toFiniteNumber)(globalProps?.parameters?.extensions?.maker_fee_discount_percent, constants_1.FEE_PARAMETERS.MAKER_REFUND_PERCENT * 10000);
+                    const makerFeeDiscountRaw = toFiniteNumber(globalProps?.parameters?.extensions?.maker_fee_discount_percent, FEE_PARAMETERS.MAKER_REFUND_PERCENT * NATIVE_CLIENT.CHAIN.PERCENT_100);
                     cache.BTS = {
-                        limitOrderCreate: findFee(1),
-                        limitOrderCancel: findFee(2),
-                        limitOrderUpdate: findFee(77),
-                        makerFeeDiscountPercent: Math.max(0, makerFeeDiscountRaw) / 10000
+                        limitOrderCreate: findFee(NATIVE_CLIENT.OPERATIONS.LIMIT_ORDER_CREATE),
+                        limitOrderCancel: findFee(NATIVE_CLIENT.OPERATIONS.LIMIT_ORDER_CANCEL),
+                        limitOrderUpdate: findFee(NATIVE_CLIENT.OPERATIONS.LIMIT_ORDER_UPDATE),
+                        makerFeeDiscountPercent: Math.max(0, makerFeeDiscountRaw) / NATIVE_CLIENT.CHAIN.PERCENT_100
                     };
                 }
                 else {
-                    const fullAsset = await (0, exports.lookupAsset)(BitShares, assetSymbol);
+                    const fullAsset = await lookupAsset(BitShares, assetSymbol);
                     const options = fullAsset.options || {};
                     cache[assetSymbol] = {
                         assetId: fullAsset.id,
@@ -712,14 +652,14 @@ async function initializeFeeCache(botsConfig, BitShares) {
                 lastError = error;
                 if (attempt < maxAttempts) {
                     const delay = baseDelay * attempt;
-                    systemLogger.warn(`initializeFeeCache: attempt ${attempt}/${maxAttempts} failed for ${assetSymbol}: ${(0, errors_1.getErrorMessage)(error)}. Retrying in ${delay}ms...`);
+                    systemLogger.warn(`initializeFeeCache: attempt ${attempt}/${maxAttempts} failed for ${assetSymbol}: ${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}: ${(0, errors_1.getErrorMessage)(lastError)}` +
+            systemLogger.warn(`initializeFeeCache: all ${maxAttempts} attempts failed for ${assetSymbol}: ${getErrorMessage(lastError)}` +
                 (hasDiskFallback ? '. Using previously cached value from disk.' : '.'));
         }
     }
@@ -738,7 +678,7 @@ async function initializeFeeCache(botsConfig, BitShares) {
  * @param {Object} accountOrders - AccountOrders data accessor
  * @returns {Promise<boolean>} True if persistence succeeded, false on error
  */
-async function persistGridSnapshot(manager, accountOrders, snapshotOrders, recentFillKeys, fundSnapshot) {
+export async function persistGridSnapshot(manager, accountOrders, snapshotOrders, recentFillKeys, fundSnapshot) {
     if (!manager || !accountOrders)
         return false;
     try {
@@ -782,7 +722,7 @@ async function persistGridSnapshot(manager, accountOrders, snapshotOrders, recen
  * @param {Object} manager - OrderManager instance
  * @returns {Promise<boolean>} True if persisted successfully or no warning, false on error
  */
-async function retryPersistenceIfNeeded(manager) {
+export async function retryPersistenceIfNeeded(manager) {
     if (!manager || !manager._persistenceWarning)
         return true;
     try {
@@ -793,7 +733,7 @@ async function retryPersistenceIfNeeded(manager) {
         return success;
     }
     catch (e) {
-        systemLogger.warn(`retryPersistenceIfNeeded failed: ${(0, errors_1.getErrorMessage)(e)}`);
+        systemLogger.warn(`retryPersistenceIfNeeded failed: ${getErrorMessage(e)}`);
         return false;
     }
 }
@@ -812,7 +752,7 @@ async function retryPersistenceIfNeeded(manager) {
  * @param {Function} updateGridFromBlockchainSnapshotFn - Grid resize function (injected to avoid circular dependency with grid.ts)
  * @returns {Promise<void>}
  */
-async function applyGridDivergenceCorrections(manager, accountOrders, _botKey, updateOrdersOnChainBatchFn, updateGridFromBlockchainSnapshotFn) {
+export async function applyGridDivergenceCorrections(manager, accountOrders, _botKey, updateOrdersOnChainBatchFn, updateGridFromBlockchainSnapshotFn) {
     if (!manager._gridLock)
         return;
     if (typeof updateGridFromBlockchainSnapshotFn !== 'function') {
@@ -830,13 +770,13 @@ async function applyGridDivergenceCorrections(manager, accountOrders, _botKey, u
     let pendingBoundaryIdx = manager.boundaryIdx;
     let hadBoundaryShift = false;
     if (manager._gridSidesUpdated && manager._gridSidesUpdated.size > 0) {
-        const hasBuy = manager._gridSidesUpdated.has(constants_1.ORDER_TYPES.BUY);
-        const hasSell = manager._gridSidesUpdated.has(constants_1.ORDER_TYPES.SELL);
+        const hasBuy = manager._gridSidesUpdated.has(ORDER_TYPES.BUY);
+        const hasSell = manager._gridSidesUpdated.has(ORDER_TYPES.SELL);
         let resizeOrderType = hasBuy && hasSell
             ? 'both'
             : hasBuy
-                ? constants_1.ORDER_TYPES.BUY
-                : constants_1.ORDER_TYPES.SELL;
+                ? ORDER_TYPES.BUY
+                : ORDER_TYPES.SELL;
         // If out-of-spread correction moves boundary, recompute both sides.
         // syncBoundaryToFunds is a pure computation — it does NOT write
         // manager.boundaryIdx.  We store the result in pendingBoundaryIdx
@@ -847,14 +787,14 @@ async function applyGridDivergenceCorrections(manager, accountOrders, _botKey, u
         if (hadBoundaryShift) {
             pendingBoundaryIdx = boundarySync.newIdx;
             resizeOrderType = 'both';
-            manager._gridSidesUpdated.add(constants_1.ORDER_TYPES.BUY);
-            manager._gridSidesUpdated.add(constants_1.ORDER_TYPES.SELL);
+            manager._gridSidesUpdated.add(ORDER_TYPES.BUY);
+            manager._gridSidesUpdated.add(ORDER_TYPES.SELL);
         }
         try {
             resizeCowResult = await updateGridFromBlockchainSnapshotFn(manager, resizeOrderType, true, pendingBoundaryIdx);
         }
         catch (err) {
-            manager.logger?.log?.(`[DIVERGENCE-COW] Grid resize failed: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+            manager.logger?.log?.(`[DIVERGENCE-COW] Grid resize failed: ${getErrorMessage(err)}`, 'error');
             manager._gridSidesUpdated.clear();
             return undefined;
         }
@@ -871,7 +811,7 @@ async function applyGridDivergenceCorrections(manager, accountOrders, _botKey, u
             : new WorkingGrid(manager.orders, { baseVersion: manager._gridVersion });
         const actions = resizeCowResult?.actions ? [...resizeCowResult.actions] : [];
         for (const orderType of manager._gridSidesUpdated) {
-            const sideName = orderType === constants_1.ORDER_TYPES.BUY ? 'buy' : 'sell';
+            const sideName = orderType === ORDER_TYPES.BUY ? 'buy' : 'sell';
             const sidePrecision = MathUtils.getPrecisionByOrderType(manager.assets, orderType);
             // Get current on-chain orders for this side.
             // Filter by WORKING GRID type (not master type) so that slots whose
@@ -907,13 +847,13 @@ async function applyGridDivergenceCorrections(manager, accountOrders, _botKey, u
                 // 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 || !((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 (!isDesired || !slot || !(toFiniteNumber(slot.size) > 0)) {
+                    removeActionsForOrder(actions, COW_ACTIONS.UPDATE, onChainOrder);
+                    const hasQueuedCancel = hasActionForOrder(actions, 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: constants_1.COW_ACTIONS.CANCEL,
+                            type: COW_ACTIONS.CANCEL,
                             id: onChainOrder.id,
                             orderId: onChainOrder.orderId
                         });
@@ -923,20 +863,20 @@ async function applyGridDivergenceCorrections(manager, accountOrders, _botKey, u
                     continue;
                 }
                 // Phase 1 already queued committed size updates. Avoid duplicate UPDATEs.
-                const hasQueuedUpdate = hasActionForOrder(actions, constants_1.COW_ACTIONS.UPDATE, onChainOrder);
-                const hasQueuedCancel = hasActionForOrder(actions, constants_1.COW_ACTIONS.CANCEL, onChainOrder);
+                const hasQueuedUpdate = hasActionForOrder(actions, COW_ACTIONS.UPDATE, onChainOrder);
+                const hasQueuedCancel = hasActionForOrder(actions, COW_ACTIONS.CANCEL, onChainOrder);
                 if (hasQueuedUpdate || hasQueuedCancel) {
                     continue;
                 }
-                const newSize = (0, format_1.toFiniteNumber)(slot.size);
-                const currentSize = (0, format_1.toFiniteNumber)(onChainOrder.size);
+                const newSize = toFiniteNumber(slot.size);
+                const currentSize = 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: constants_1.COW_ACTIONS.UPDATE,
+                        type: COW_ACTIONS.UPDATE,
                         id: onChainOrder.id,
                         orderId: onChainOrder.orderId,
                         newGridId: onChainOrder.id,
@@ -953,11 +893,11 @@ async function applyGridDivergenceCorrections(manager, accountOrders, _botKey, u
             }
             // Process holes: CREATE new orders for empty desired slots
             for (const slot of desiredSlots) {
-                const hasCreate = hasActionForOrder(actions, constants_1.COW_ACTIONS.CREATE, slot);
+                const hasCreate = hasActionForOrder(actions, 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: constants_1.COW_ACTIONS.CREATE,
+                        type: COW_ACTIONS.CREATE,
                         id: slot.id,
                         order: {
                             id: slot.id,
@@ -1036,7 +976,7 @@ async function applyGridDivergenceCorrections(manager, accountOrders, _botKey, u
             }
         }
         catch (err) {
-            manager.logger.log(`[DIVERGENCE-COW] Error executing divergence corrections: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+            manager.logger.log(`[DIVERGENCE-COW] Error executing divergence corrections: ${getErrorMessage(err)}`, 'error');
             manager._gridSidesUpdated.clear();
             return { committed: false, boundaryChanged: hadBoundaryShift };
         }
@@ -1071,7 +1011,7 @@ async function applyGridDivergenceCorrections(manager, accountOrders, _botKey, u
  * @param {Object} manager - OrderManager instance
  * @returns {{ changed: boolean, newIdx?: number }}
  */
-function syncBoundaryToFunds(manager) {
+export function syncBoundaryToFunds(manager) {
     const availA = (manager.funds?.available?.sell || 0);
     const availB = (manager.funds?.available?.buy || 0);
     const allSlots = Array.from(manager.orders.values()).sort((a, b) => a.price - b.price);
@@ -1084,9 +1024,9 @@ function syncBoundaryToFunds(manager) {
     let minSellIdx = allSlots.length;
     for (let i = 0; i < allSlots.length; i++) {
         const slot = allSlots[i];
-        if (slot.type === constants_1.ORDER_TYPES.BUY && i > maxBuyIdx)
+        if (slot.type === ORDER_TYPES.BUY && i > maxBuyIdx)
             maxBuyIdx = i;
-        if (slot.type === constants_1.ORDER_TYPES.SELL && i < minSellIdx)
+        if (slot.type === ORDER_TYPES.SELL && i < minSellIdx)
             minSellIdx = i;
     }
     // Build clamp bounds from whichever sides have typed slots.
@@ -1115,9 +1055,9 @@ function syncBoundaryToFunds(manager) {
  * @param {string} profilesDir - Path to profiles directory
  * @returns {boolean} True if directory was created, false if it already existed
  */
-function ensureProfilesDirectory(profilesDir) {
+export function ensureProfilesDirectory(profilesDir) {
     if (!storage.exists(profilesDir)) {
-        (0, fs_utils_1.ensureDir)(profilesDir);
+        ensureDir(profilesDir);
         return true;
     }
     return false;
@@ -1127,7 +1067,7 @@ function ensureProfilesDirectory(profilesDir) {
  * @param {number} ms - Milliseconds to sleep
  * @returns {Promise<void>}
  */
-function sleep(ms) {
+export function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 /**
@@ -1141,10 +1081,10 @@ function sleep(ms) {
  * @param {string} [options.mask=''] - Character to display instead of input
  * @returns {Promise<string>} Trimmed user input
  */
-function readInput(prompt, options = {}) {
+export function readInput(prompt, options = {}) {
     return new Promise((resolve) => {
-        const stdin = runtime_1.runtime.stdin;
-        const stdout = runtime_1.runtime.stdout;
+        const stdin = runtime.stdin;
+        const stdout = runtime.stdout;
         const ESC_SEQUENCE_TIMEOUT_MS = 150;
         let input = '';
         let cursorPos = 0;
@@ -1235,7 +1175,7 @@ function readInput(prompt, options = {}) {
             if (ch === '\u0003') {
                 cleanup();
                 stdout.write('\r\x1b[K\n');
-                runtime_1.runtime.exit(0);
+                runtime.exit(0);
             }
             // Backspace
             if (ch === '\u007f' || ch === '\u0008') {
@@ -1289,7 +1229,7 @@ function readInput(prompt, options = {}) {
  * @param {string} prompt - Prompt text to display
  * @returns {Promise<string>} User-entered password
  */
-async function readPassword(prompt) { return readInput(prompt, { mask: '*', hideEchoBack: false }); }
+export async function readPassword(prompt) { return readInput(prompt, { mask: '*', hideEchoBack: false }); }
 /**
  * Execute async function with exponential backoff retry logic.
  * Retries on failure with increasing delays up to maxDelayMs.
@@ -1304,8 +1244,8 @@ async function readPassword(prompt) { return readInput(prompt, { mask: '*', hide
  * @returns {Promise<*>} Result of function execution
  * @throws {Error} If all attempts fail, throws the final error
  */
-async function withRetry(fn, 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;
+export 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;
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
         try {
             return await fn();
@@ -1339,9 +1279,9 @@ async function withRetry(fn, options = {}) {
  * @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) {
+export async function withBlockchainRetry(fn, label, options) {
     const timeoutMs = options?.timeoutMs ?? 30000;
-    const maxRetries = options?.maxRetries ?? constants_1.PIPELINE_TIMING.RETRY_MAX_ATTEMPTS;
+    const maxRetries = options?.maxRetries ?? PIPELINE_TIMING.RETRY_MAX_ATTEMPTS;
     const retryDelayMs = options?.retryDelayMs ?? 2000;
     const logger = options?.logger;
     let lastError;
@@ -1349,7 +1289,7 @@ async function withBlockchainRetry(fn, label, options) {
     function raceWithTimeout(attemptLabel) {
         const p = fn();
         Promise.resolve(p).catch(() => { });
-        return (0, timeout_1.withTimeout)(p, timeoutMs, { label: `${label} ${attemptLabel}` });
+        return withTimeout(p, timeoutMs, { label: `${label} ${attemptLabel}` });
     }
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
         try {
@@ -1363,12 +1303,12 @@ async function withBlockchainRetry(fn, label, options) {
                 const nodeManager = getNodeManager?.();
                 const nodeUrl = nodeManager?.getBestNode?.();
                 if (nodeUrl && typeof nodeManager.reportNodeFailure === 'function') {
-                    nodeManager.reportNodeFailure(nodeUrl, (0, errors_1.getErrorMessage)(err), 'blockchain-op');
+                    nodeManager.reportNodeFailure(nodeUrl, 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');
+                logger?.log?.(`${label} attempt ${attempt}/${maxRetries} failed: ${getErrorMessage(err)}. Retrying in ${retryDelayMs}ms...`, 'warn');
                 await sleep(retryDelayMs);
             }
         }
@@ -1389,7 +1329,7 @@ async function withBlockchainRetry(fn, label, options) {
         }
     }
     catch (_) { /* failover recovery errors are non-fatal — throw original error */ }
-    throw new Error(`${label} failed after ${maxRetries} attempts: ${(0, errors_1.getErrorMessage)(lastError)}`);
+    throw new Error(`${label} failed after ${maxRetries} attempts: ${getErrorMessage(lastError)}`);
 }
 // ================================================================================
 // SECTION 6: GENERAL UTILITIES
@@ -1402,7 +1342,7 @@ async function withBlockchainRetry(fn, label, options) {
  * @param {string} account - Account name (optional)
  * @returns {string|null} Resolved account reference or null
  */
-function resolveAccountRef(manager, account) {
+export function resolveAccountRef(manager, account) {
     if (manager && typeof manager.accountId === 'string' && manager.accountId) {
         return manager.accountId;
     }
@@ -1419,7 +1359,7 @@ function resolveAccountRef(manager, account) {
  * @param {Object} obj
  * @returns {Object}
  */
-function deepFreeze(obj) {
+export function deepFreeze(obj) {
     if (obj === null || typeof obj !== 'object')
         return obj;
     Object.freeze(obj);
@@ -1438,7 +1378,7 @@ function deepFreeze(obj) {
  * @param {Map} map
  * @returns {Map}
  */
-function cloneMap(map) {
+export function cloneMap(map) {
     return new Map(map);
 }
 /**
@@ -1447,8 +1387,9 @@ function cloneMap(map) {
  * @param {string} raw - The raw string content with possible comments.
  * @returns {Object} The parsed JSON object.
  */
-function parseJsonWithComments(raw) {
+export function parseJsonWithComments(raw) {
     const stripped = raw.replace(/\/\*(?:.|[\r\n])*?\*\//g, '').replace(/(^|\s*)\/\/.*$/gm, '');
     return JSON.parse(stripped);
 }
+export { ensureDir };
 //# sourceMappingURL=system.js.map