@clonegod/ttd-core 2.0.1

package/dist/index.js

@@ -0,0 +1,883 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuid = exports.DATE_TIME_FORMAT_NO_WHITESPACE = exports.DATE_TIME_FORMAT_DEFAULT = exports.to_json_str = exports.DecimalUtil = exports.generateRandomNumber = exports.LOG = exports._active_log_level = exports.LOG_LEVEL = exports.REDIS_EVENT_TYPE_TRADE_INSTANCE_CHANGE = exports.REDIS_EVENT_TYPE_ORDER = exports.REDIS_EVENT_TYPE_QUOTE = exports.REDIS_EVENT_TYPE_CONFIG_CHANGE = exports.REDIS_EVENT_CHANNEL = exports.get_tx_result_channel_name = exports.get_wallet_raw_tx_channel_name = exports.get_order_channel_name = exports.get_quote_channel_name = exports.get_config_channel_name = exports.get_cache_key = exports.getArbEventSubscriber = exports.getArbEventPublisher = exports.getArbCache = exports.getRedisCommamd = exports.getLoadingCache = exports.getRedisCache = exports.format_order_lock_key = exports.format_unique_order_msg_id = exports.parse_unique_orderbook_id = exports.format_unique_orderbook_id = exports.format_symbol_name = exports.CACHE_KEY_TYPE = exports.OnChainDataSubscribeType = exports.TradeErrorCodeType = exports.SystemErrorCodeType = exports.TRADE_TYPE = exports.GROUP_ID = exports.DEX_ID = exports.CHAIN_ID = exports.STREAMING_TRANSACTION_CONFIRMED = exports.TRANSACTION_STATE_FAILED = exports.TRANSACTION_STATE_SUCCESS = exports.TRANSACTION_STATE_PROCESSING = exports.QUOTE_AMOUNT_USD_MAX = exports.QUOTE_AMOUNT_USD_MIN = exports.REGEX_HEX_PREFIX = exports.PROCESSING = exports.NOT_FOUND = exports.SUCCESS = exports.FAILED = void 0;
+exports.execute_bash = exports.inspect_arb_local_cache = exports.save_trade_execution_logs = exports.parse_trade_cmdline_args = exports.get_input_out_token_fix = exports.get_input_out_token = exports.calc_amount_in_token = exports.estimate_amount_in_token = exports.failed = exports.success = exports.home_dir = exports.postJSON = exports.deep_merge_object = exports.isArray = exports.isTrue = exports.deep_clone = void 0;
+exports._caller = _caller;
+exports.log_trace = log_trace;
+exports.log_debug = log_debug;
+exports.log_warn = log_warn;
+exports.log_info = log_info;
+exports.log_error = log_error;
+exports.new_line = new_line;
+exports.getCurDateTime = getCurDateTime;
+exports.getCurTimeShort = getCurTimeShort;
+exports.parseToDateTime = parseToDateTime;
+exports.getCurTimeInMills = getCurTimeInMills;
+exports.curr_milliseconds = curr_milliseconds;
+exports.sleep = sleep;
+exports.parseDateTimeStrToMills = parseDateTimeStrToMills;
+exports.isEmpty = isEmpty;
+exports.file_exists = file_exists;
+exports.readFile = readFile;
+exports.writeFile = writeFile;
+exports.mkdirSync = mkdirSync;
+exports.getServerInfo = getServerInfo;
+exports.getIPAddress = getIPAddress;
+exports.load_wallet = load_wallet;
+exports.chunkArray = chunkArray;
+require('dotenv').config();
+const bn_js_1 = __importDefault(require("bn.js"));
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const fs_1 = __importDefault(require("fs"));
+const moment_1 = __importDefault(require("moment"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const cache = __importStar(require("./cache"));
+const market_price_1 = require("./market_price");
+__exportStar(require("./analyze"), exports);
+__exportStar(require("./app_config"), exports);
+__exportStar(require("./pool"), exports);
+__exportStar(require("./quote"), exports);
+__exportStar(require("./token"), exports);
+const short = require('short-uuid');
+const exec = require('util').promisify(require('child_process').exec);
+exports.FAILED = 'FAILED';
+exports.SUCCESS = 'SUCCESS';
+exports.NOT_FOUND = 'NOT_FOUND';
+exports.PROCESSING = 'PROCESSING';
+exports.REGEX_HEX_PREFIX = /^(0x)/;
+exports.QUOTE_AMOUNT_USD_MIN = 50;
+exports.QUOTE_AMOUNT_USD_MAX = 500;
+exports.TRANSACTION_STATE_PROCESSING = 'TRANSACTION_STATE_PROCESSING';
+exports.TRANSACTION_STATE_SUCCESS = 'TRANSACTION_STATE_SUCCESS';
+exports.TRANSACTION_STATE_FAILED = 'TRANSACTION_STATE_FAILED';
+exports.STREAMING_TRANSACTION_CONFIRMED = 'STREAMING_TRANSACTION_CONFIRMED';
+var CHAIN_ID;
+(function (CHAIN_ID) {
+    CHAIN_ID["TRON"] = "TRON";
+    CHAIN_ID["SOLANA"] = "SOLANA";
+    CHAIN_ID["BSC"] = "BSC";
+})(CHAIN_ID || (exports.CHAIN_ID = CHAIN_ID = {}));
+var DEX_ID;
+(function (DEX_ID) {
+    DEX_ID["SUNSWAP_V2"] = "SUNSWAP-V2";
+    DEX_ID["SUNSWAP_V3"] = "SUNSWAP-V3";
+    DEX_ID["RAYDIUM_AMM"] = "RAYDIUM-AMM";
+    DEX_ID["RAYDIUM_CLMM"] = "RAYDIUM-CLMM";
+    DEX_ID["RAYDIUM_CPMM"] = "RAYDIUM-CPMM";
+    DEX_ID["ORCA_CLMM"] = "ORCA-CLMM";
+    DEX_ID["METEORA_DLMM"] = "METEORA-DLMM";
+    DEX_ID["PUMPFUN_AMM"] = "PUMPFUN-AMM";
+    DEX_ID["PANCAKE_AMM"] = "PANCAKE-AMM";
+    DEX_ID["PANCAKE_CLMM"] = "PANCAKE-CLMM";
+})(DEX_ID || (exports.DEX_ID = DEX_ID = {}));
+var GROUP_ID;
+(function (GROUP_ID) {
+    GROUP_ID["TRON_DEV1"] = "TRON-DEV1";
+    GROUP_ID["TRON_TEST1"] = "TRON-TEST1";
+    GROUP_ID["TRON_TEST2"] = "TRON-TEST2";
+    GROUP_ID["TRON_TTD1"] = "TRON-TTD1";
+})(GROUP_ID || (exports.GROUP_ID = GROUP_ID = {}));
+var TRADE_TYPE;
+(function (TRADE_TYPE) {
+    TRADE_TYPE["SWAP"] = "swap";
+    TRADE_TYPE["ORDERBOOK"] = "orderbook";
+})(TRADE_TYPE || (exports.TRADE_TYPE = TRADE_TYPE = {}));
+var SystemErrorCodeType;
+(function (SystemErrorCodeType) {
+    SystemErrorCodeType["INVALID_GROUP_ID"] = "INVALID_GROUP_ID";
+    SystemErrorCodeType["SYSTEM_ERROR"] = "SYSTEM_ERROR";
+    SystemErrorCodeType["UNKOWN_ERROR"] = "UNKOWN_ERROR";
+})(SystemErrorCodeType || (exports.SystemErrorCodeType = SystemErrorCodeType = {}));
+var TradeErrorCodeType;
+(function (TradeErrorCodeType) {
+    TradeErrorCodeType["AmountOutBelowMinimum"] = "AmountOutBelowMinimum";
+    TradeErrorCodeType["InsufficientFunds"] = "InsufficientFunds";
+    TradeErrorCodeType["ExceededCUsLimit"] = "ExceededCUsLimit";
+    TradeErrorCodeType["BlockhashNotFound"] = "BlockhashNotFound";
+    TradeErrorCodeType["AccountNotInitialized"] = "AccountNotInitialized";
+    TradeErrorCodeType["InvalidTickArraySequence"] = "InvalidTickArraySequence";
+    TradeErrorCodeType["TokenNotApproved"] = "TokenNotApproved";
+    TradeErrorCodeType["UNKOWN"] = "UNKOWN";
+})(TradeErrorCodeType || (exports.TradeErrorCodeType = TradeErrorCodeType = {}));
+var OnChainDataSubscribeType;
+(function (OnChainDataSubscribeType) {
+    OnChainDataSubscribeType["WS"] = "ws";
+    OnChainDataSubscribeType["GRPC"] = "grpc";
+})(OnChainDataSubscribeType || (exports.OnChainDataSubscribeType = OnChainDataSubscribeType = {}));
+var CACHE_KEY_TYPE;
+(function (CACHE_KEY_TYPE) {
+    CACHE_KEY_TYPE["MARKET_TOKEN_PRICE"] = "m:price";
+    CACHE_KEY_TYPE["CONFIG_TOKEN_LIST"] = "c:token";
+    CACHE_KEY_TYPE["CONFIG_POOL_LIST"] = "c:pool";
+    CACHE_KEY_TYPE["CONFIG_PAIR_LIST"] = "c:pair";
+    CACHE_KEY_TYPE["CONFIG_COMMON_SERVICE"] = "c:common";
+    CACHE_KEY_TYPE["CONFIG_TRADE_SERVICE"] = "c:trade";
+    CACHE_KEY_TYPE["QUOTE_PRICE"] = "q:price";
+    CACHE_KEY_TYPE["ORDER_MESSAGE"] = "o:msg";
+    CACHE_KEY_TYPE["ORDER_RESULT"] = "o:result";
+})(CACHE_KEY_TYPE || (exports.CACHE_KEY_TYPE = CACHE_KEY_TYPE = {}));
+const format_symbol_name = (symbol) => {
+    return symbol.replace('USDC', 'USDT')
+        .replace('WTRX', 'TRX')
+        .replace('$', '')
+        .replace('WSOL', 'SOL')
+        .replace('WBTC', 'BTC')
+        .replace('WETH', 'ETH')
+        .replace('WBNB', 'BNB')
+        .toUpperCase();
+};
+exports.format_symbol_name = format_symbol_name;
+const format_unique_orderbook_id = (chain_id, dex_id, pool_id, fee_rate) => {
+    return `${chain_id}_${dex_id}_${pool_id}_${fee_rate}`;
+};
+exports.format_unique_orderbook_id = format_unique_orderbook_id;
+const parse_unique_orderbook_id = (unique_orderbook_id) => {
+    let [chain_id, dex_id, pool_id, fee_rate] = unique_orderbook_id.split('_');
+    return {
+        chain_id,
+        dex_id,
+        pool_id,
+        fee_rate
+    };
+};
+exports.parse_unique_orderbook_id = parse_unique_orderbook_id;
+const format_unique_order_msg_id = (group_id, price_id, order_trace_id) => {
+    return `${group_id}_${price_id}_${order_trace_id}`;
+};
+exports.format_unique_order_msg_id = format_unique_order_msg_id;
+const format_order_lock_key = (chain_id, group_id, price_id, order_trace_id) => {
+    return `${chain_id}:lock:${group_id}:${price_id}:${order_trace_id}`;
+};
+exports.format_order_lock_key = format_order_lock_key;
+const getRedisCache = () => __awaiter(void 0, void 0, void 0, function* () {
+    yield sleep(1000);
+    return cache.getCache();
+});
+exports.getRedisCache = getRedisCache;
+const getLoadingCache = () => {
+    return new cache.LoadingCache();
+};
+exports.getLoadingCache = getLoadingCache;
+const getRedisCommamd = () => {
+    return new cache.RedisCommand();
+};
+exports.getRedisCommamd = getRedisCommamd;
+const getArbCache = (env_args) => {
+    return new cache.ArbCache(env_args);
+};
+exports.getArbCache = getArbCache;
+const getArbEventPublisher = (arb_cache) => {
+    return new cache.ArbEventPublisher(arb_cache);
+};
+exports.getArbEventPublisher = getArbEventPublisher;
+const getArbEventSubscriber = (arb_cache) => {
+    return new cache.ArbEventSubscriber(arb_cache);
+};
+exports.getArbEventSubscriber = getArbEventSubscriber;
+const get_cache_key = (chain_id, cache_type, id) => {
+    let chain_id_lower = chain_id.toLowerCase();
+    let key = '';
+    if (!id) {
+        key = `${chain_id_lower}:${cache_type}`;
+    }
+    else {
+        key = `${chain_id_lower}:${cache_type}:${id}`;
+    }
+    return key;
+};
+exports.get_cache_key = get_cache_key;
+const get_config_channel_name = (chain_id) => {
+    return `${chain_id}_${REDIS_EVENT_CHANNEL.CONFIG_CHANGE}`.toUpperCase();
+};
+exports.get_config_channel_name = get_config_channel_name;
+const get_quote_channel_name = (chain_id) => {
+    return `${REDIS_EVENT_CHANNEL.QUOTE}_${chain_id}`.toUpperCase();
+};
+exports.get_quote_channel_name = get_quote_channel_name;
+const get_order_channel_name = (group_id, pair, dex_id) => {
+    return `${REDIS_EVENT_CHANNEL.ORDER}_${pair}_${dex_id}_${group_id}`.toUpperCase();
+};
+exports.get_order_channel_name = get_order_channel_name;
+const get_wallet_raw_tx_channel_name = (group_id, wallet) => {
+    return `${REDIS_EVENT_CHANNEL.TX_RAW_DATA}_${group_id}_${wallet}`.toUpperCase();
+};
+exports.get_wallet_raw_tx_channel_name = get_wallet_raw_tx_channel_name;
+const get_tx_result_channel_name = (group_id, pair) => {
+    return `${REDIS_EVENT_CHANNEL.TX_RESULT}_${group_id}_${pair}`.toUpperCase();
+};
+exports.get_tx_result_channel_name = get_tx_result_channel_name;
+var REDIS_EVENT_CHANNEL;
+(function (REDIS_EVENT_CHANNEL) {
+    REDIS_EVENT_CHANNEL["CONFIG_CHANGE"] = "CONFIG_CHANGE";
+    REDIS_EVENT_CHANNEL["QUOTE"] = "QUOTE";
+    REDIS_EVENT_CHANNEL["ORDER"] = "ORDER";
+    REDIS_EVENT_CHANNEL["ORDER_RESULT"] = "ORDER_RESULT";
+    REDIS_EVENT_CHANNEL["TX_RAW_DATA"] = "TX_RAW_DATA";
+    REDIS_EVENT_CHANNEL["TX_RESULT"] = "TX_RESULT";
+    REDIS_EVENT_CHANNEL["TRADE_INSTANCE_STATUS"] = "TRADE_INSTANCE_STATUS";
+})(REDIS_EVENT_CHANNEL || (exports.REDIS_EVENT_CHANNEL = REDIS_EVENT_CHANNEL = {}));
+var REDIS_EVENT_TYPE_CONFIG_CHANGE;
+(function (REDIS_EVENT_TYPE_CONFIG_CHANGE) {
+    REDIS_EVENT_TYPE_CONFIG_CHANGE["TOKEN_CONFIG_CHANGE"] = "TOKEN_CONFIG_CHANGE";
+    REDIS_EVENT_TYPE_CONFIG_CHANGE["POOL_CONFIG_CHANGE"] = "POOL_CONFIG_CHANGE";
+    REDIS_EVENT_TYPE_CONFIG_CHANGE["GROUP_CONFIG_CHANGE"] = "GROUP_CONFIG_CHANGE";
+})(REDIS_EVENT_TYPE_CONFIG_CHANGE || (exports.REDIS_EVENT_TYPE_CONFIG_CHANGE = REDIS_EVENT_TYPE_CONFIG_CHANGE = {}));
+var REDIS_EVENT_TYPE_QUOTE;
+(function (REDIS_EVENT_TYPE_QUOTE) {
+    REDIS_EVENT_TYPE_QUOTE["NEW_QUOTE_PRICE"] = "NEW_QUOTE_PRICE";
+})(REDIS_EVENT_TYPE_QUOTE || (exports.REDIS_EVENT_TYPE_QUOTE = REDIS_EVENT_TYPE_QUOTE = {}));
+var REDIS_EVENT_TYPE_ORDER;
+(function (REDIS_EVENT_TYPE_ORDER) {
+    REDIS_EVENT_TYPE_ORDER["NEW_ORDER"] = "NEW_ORDER";
+    REDIS_EVENT_TYPE_ORDER["ORDER_PROCESSING"] = "ORDER_PROCESSING";
+    REDIS_EVENT_TYPE_ORDER["ORDER_SUCCESS"] = "ORDER_SUCCESS";
+    REDIS_EVENT_TYPE_ORDER["ORDER_FAILED"] = "ORDER_FAILED";
+    REDIS_EVENT_TYPE_ORDER["ORDER_NOT_FOUND"] = "ORDER_NOT_FOUND";
+})(REDIS_EVENT_TYPE_ORDER || (exports.REDIS_EVENT_TYPE_ORDER = REDIS_EVENT_TYPE_ORDER = {}));
+var REDIS_EVENT_TYPE_TRADE_INSTANCE_CHANGE;
+(function (REDIS_EVENT_TYPE_TRADE_INSTANCE_CHANGE) {
+    REDIS_EVENT_TYPE_TRADE_INSTANCE_CHANGE["TRADE_INSTANCE_STARTUP"] = "TRADE_INSTANCE_STARTUP";
+    REDIS_EVENT_TYPE_TRADE_INSTANCE_CHANGE["TRADE_INSTANCE_EXIT"] = "TRADE_INSTANCE_EXIT";
+})(REDIS_EVENT_TYPE_TRADE_INSTANCE_CHANGE || (exports.REDIS_EVENT_TYPE_TRADE_INSTANCE_CHANGE = REDIS_EVENT_TYPE_TRADE_INSTANCE_CHANGE = {}));
+function _caller() {
+    try {
+        throw new Error('');
+    }
+    catch (err) {
+        let line = err.stack.split('\n')[3];
+        let module = (line.substring(line.lastIndexOf(path_1.default.sep) + 1, line.indexOf(':')).replace('.js', ''));
+        return {
+            method: '',
+            module
+        };
+    }
+}
+var LOG_LEVEL;
+(function (LOG_LEVEL) {
+    LOG_LEVEL[LOG_LEVEL["TRACE"] = 1] = "TRACE";
+    LOG_LEVEL[LOG_LEVEL["DEBUG"] = 2] = "DEBUG";
+    LOG_LEVEL[LOG_LEVEL["INFO"] = 3] = "INFO";
+    LOG_LEVEL[LOG_LEVEL["WARN"] = 4] = "WARN";
+    LOG_LEVEL[LOG_LEVEL["ERROR"] = 5] = "ERROR";
+})(LOG_LEVEL || (exports.LOG_LEVEL = LOG_LEVEL = {}));
+let _log_level = LOG_LEVEL[process.env.LOG_LEVEL];
+if (_log_level) {
+    console.log(`Log level`, {
+        'process.env.LOG_LEVEL': process.env.LOG_LEVEL,
+        _log_level
+    });
+}
+else {
+    _log_level = LOG_LEVEL.INFO;
+    console.log(`Log level is invalid! set default level: INFO`, {
+        'process.env.LOG_LEVEL': process.env.LOG_LEVEL,
+        _log_level
+    });
+}
+exports._active_log_level = _log_level;
+class LOG {
+}
+exports.LOG = LOG;
+LOG.trace = exports._active_log_level <= LOG_LEVEL.TRACE;
+LOG.debug = exports._active_log_level <= LOG_LEVEL.DEBUG;
+LOG.info = exports._active_log_level <= LOG_LEVEL.INFO;
+LOG.warn = exports._active_log_level <= LOG_LEVEL.WARN;
+function log_trace(msg, data = {}, traceId = '') {
+    log_info(msg, data, traceId, _caller(), LOG_LEVEL.TRACE);
+}
+function log_debug(msg, data = {}, traceId = '') {
+    log_info(msg, data, traceId, _caller(), LOG_LEVEL.DEBUG);
+}
+function log_warn(msg, data = {}, traceId = '') {
+    log_info(`!!! ${msg}`, data, traceId, _caller(), LOG_LEVEL.WARN);
+}
+function log_info(msg, data = {}, traceId = '', caller = undefined, level = LOG_LEVEL.INFO) {
+    if (level < _log_level) {
+        return;
+    }
+    if (!caller) {
+        caller = _caller();
+    }
+    if (traceId) {
+        console.log(`${getCurDateTime()} - [${level}] - [${caller.module}] - ${traceId} - ${msg}`);
+    }
+    else {
+        console.log(`${getCurDateTime()} - [${level}] - [${caller.module}] - ${msg}`);
+    }
+    if (!isEmpty(data)) {
+        console.dir(data, { depth: parseInt(process.env.LOG_DEPTH || '4') });
+    }
+}
+function log_error(msg, err, traceId = '', caller = undefined) {
+    if (!caller) {
+        caller = _caller();
+    }
+    if (traceId) {
+        console.error(`${getCurDateTime()} - [5] - [${caller.module}] - ${msg}`, err);
+    }
+    else {
+        console.error(`${getCurDateTime()} - [5] - [${caller.module}] - ${traceId} - ${msg}`, err);
+    }
+}
+function new_line(lines = 2) {
+    for (let i = 0; i < lines; i++) {
+        console.log('>');
+    }
+}
+const generateRandomNumber = (min, max) => {
+    if (min > max) {
+        [min, max] = [max, min];
+    }
+    const randomNumber = Math.floor(Math.random() * (max - min + 1)) + min;
+    return randomNumber;
+};
+exports.generateRandomNumber = generateRandomNumber;
+class DecimalUtil {
+    static adjustDecimals(input, shift = 0) {
+        return input.div(decimal_js_1.default.pow(10, shift));
+    }
+    static fromBN(input, shift = 0) {
+        return new decimal_js_1.default(input.toString()).div(new decimal_js_1.default(10).pow(shift));
+    }
+    static fromNumber(input, shift = 0) {
+        return new decimal_js_1.default(input).div(new decimal_js_1.default(10).pow(shift));
+    }
+    static toBN(input, shift = 0) {
+        if (input.isNeg()) {
+            throw new Error('Negative decimal value ${input} cannot be converted to BN.');
+        }
+        const shiftedValue = input.mul(new decimal_js_1.default(10).pow(shift));
+        const zeroDecimalValue = shiftedValue.trunc();
+        return new bn_js_1.default(zeroDecimalValue.toString());
+    }
+    static number_div(number1, number2, decimals = 6) {
+        if (number2 == 0) {
+            return 0;
+        }
+        return Math.abs(Number(this.fromNumber(number1).div(this.fromNumber(number2)).toFixed(decimals)));
+    }
+}
+exports.DecimalUtil = DecimalUtil;
+const to_json_str = (value, space = 4) => {
+    return JSON.stringify(value, null, space);
+};
+exports.to_json_str = to_json_str;
+exports.DATE_TIME_FORMAT_DEFAULT = 'YYYY-MM-DD HH:mm:ss SSS';
+exports.DATE_TIME_FORMAT_NO_WHITESPACE = 'YYYY_MM_DD_HH_mm_ss';
+function getCurDateTime(format = '') {
+    if (format) {
+        return (0, moment_1.default)().format(format);
+    }
+    return (0, moment_1.default)().format(exports.DATE_TIME_FORMAT_DEFAULT);
+}
+function getCurTimeShort() {
+    return (0, moment_1.default)().format('HH:mm:ss SSS');
+}
+function parseToDateTime(milliseconds, format = exports.DATE_TIME_FORMAT_DEFAULT) {
+    return moment_1.default.utc(milliseconds).format(format);
+}
+function getCurTimeInMills() {
+    return (0, moment_1.default)().valueOf();
+}
+function curr_milliseconds() {
+    return (0, moment_1.default)().valueOf();
+}
+function sleep(mills) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield new Promise((r) => setTimeout(r, mills));
+    });
+}
+function parseDateTimeStrToMills(date_time_str, format = exports.DATE_TIME_FORMAT_DEFAULT) {
+    return (0, moment_1.default)(date_time_str, format, true).valueOf();
+}
+const uuid = () => {
+    return short.generate();
+};
+exports.uuid = uuid;
+const deep_clone = (obj) => {
+    return JSON.parse(JSON.stringify(obj));
+};
+exports.deep_clone = deep_clone;
+function isEmpty(v) {
+    let type = typeof v;
+    if (type === 'undefined') {
+        return true;
+    }
+    if (type === 'boolean') {
+        return !v;
+    }
+    if (v === null) {
+        return true;
+    }
+    if (v === undefined) {
+        return true;
+    }
+    if (v instanceof Array) {
+        if (v.length < 1) {
+            return true;
+        }
+    }
+    else if (type === 'string') {
+        if (v.trim().length < 1) {
+            return true;
+        }
+        if (v === '0' || v === 'false') {
+            return true;
+        }
+    }
+    else if (type === 'object') {
+        if (Object.keys(v).length < 1) {
+            return true;
+        }
+    }
+    else if (type === 'number') {
+        if (v === 0 || isNaN(v)) {
+            return true;
+        }
+    }
+    return false;
+}
+const isTrue = (value) => {
+    if (!value)
+        return false;
+    return value.toString().toLowerCase() === 'true';
+};
+exports.isTrue = isTrue;
+const isArray = (arg) => Array.isArray(arg);
+exports.isArray = isArray;
+const deep_merge_object = (default_obj, new_obj) => {
+    const result = Object.assign({}, default_obj);
+    for (let key in new_obj) {
+        if (new_obj.hasOwnProperty(key)) {
+            if (new_obj[key] instanceof Object && default_obj[key] instanceof Object) {
+                result[key] = (0, exports.deep_merge_object)(default_obj[key], new_obj[key]);
+            }
+            else {
+                result[key] = new_obj[key];
+            }
+        }
+    }
+    return result;
+};
+exports.deep_merge_object = deep_merge_object;
+const postJSON = (url, data) => __awaiter(void 0, void 0, void 0, function* () {
+    const rawResponse = yield fetch(url, {
+        method: 'POST',
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(data),
+    });
+    try {
+        return rawResponse.json();
+    }
+    catch (err) {
+        console.error(`postJSON error!`, err);
+        const text = yield rawResponse.text();
+        console.log(`postJSON res text=`, text);
+        throw err;
+    }
+});
+exports.postJSON = postJSON;
+const home_dir = () => {
+    return os_1.default.homedir();
+};
+exports.home_dir = home_dir;
+function file_exists(filepath) {
+    return fs_1.default.existsSync(filepath);
+}
+function readFile(filename, to_json_object = true, print_content = false) {
+    const filepath = path_1.default.resolve('.', filename);
+    const content = fs_1.default.readFileSync(filepath, 'utf-8');
+    if (print_content) {
+        console.log(`Read file: ${filepath}`, content);
+    }
+    if (to_json_object) {
+        return JSON.parse(content);
+    }
+    return content;
+}
+function writeFile(filename, data) {
+    const filepath = path_1.default.resolve('.', filename);
+    if (LOG.trace) {
+        log_trace(`Write file: ${filepath}`);
+    }
+    fs_1.default.writeFileSync(filepath, data, 'utf-8');
+}
+function mkdirSync(path, recursive = false) {
+    if (fs_1.default.existsSync(path)) {
+        return;
+    }
+    fs_1.default.mkdirSync(path, { recursive });
+}
+function getServerInfo() {
+    let region = '';
+    let ip = '';
+    let name = '';
+    try {
+        ip = getIPAddress();
+        name = process.env.SERVER_ID;
+        region = (process.env.SERVER_ID || '').replace('lmm-', '').split('-')[0];
+    }
+    catch (err) {
+        log_error('getServerInfo error!', err);
+    }
+    return {
+        region,
+        ip,
+        name,
+    };
+}
+function getIPAddress() {
+    const ips = [];
+    var interfaces = os_1.default.networkInterfaces();
+    for (var devName in interfaces) {
+        var iface = interfaces[devName] || [];
+        for (var i = 0; i < iface.length; i++) {
+            var alias = iface[i];
+            if (alias.family === 'IPv4' && alias.address !== '127.0.0.1' && !alias.internal) {
+                ips.push(alias.address);
+            }
+        }
+    }
+    if (ips.length > 1) {
+        return ips.find((e) => String(e).indexOf('192.168') === -1);
+    }
+    return ips[0];
+}
+function load_wallet(group_id, only_pubkey = true) {
+    if (!group_id) {
+        throw new Error('Invalid param: group_id is empty or null !');
+    }
+    let wallet_dir = process.env.WALLET_DIR;
+    if (!wallet_dir) {
+        wallet_dir = path_1.default.join((0, exports.home_dir)(), 'data', 'keypairs');
+    }
+    let file_path = path_1.default.join(wallet_dir, `${group_id}.json`);
+    log_info(`Load wallet, group_id=${group_id}, file_path=${file_path}`);
+    let wallet = readFile(file_path, true, false);
+    if (only_pubkey) {
+        return {
+            public_key: wallet.public_key,
+            private_key: ''
+        };
+    }
+    return wallet;
+}
+const success = (data) => {
+    return {
+        code: 200,
+        msg: exports.SUCCESS,
+        data,
+    };
+};
+exports.success = success;
+const failed = (err, error_code = 'SYSTEM_ERROR', code = 500) => {
+    return {
+        code,
+        msg: (err === null || err === void 0 ? void 0 : err.message) || exports.FAILED,
+        error_code
+    };
+};
+exports.failed = failed;
+const estimate_amount_in_token = (arb_cache_1, token_1, amount_in_usd_1, ...args_1) => __awaiter(void 0, [arb_cache_1, token_1, amount_in_usd_1, ...args_1], void 0, function* (arb_cache, token, amount_in_usd, query_token_market_price_url = '') {
+    return yield market_price_1.EstimateAmountInToken.estimate_amount_in_token(arb_cache, token, amount_in_usd, query_token_market_price_url);
+});
+exports.estimate_amount_in_token = estimate_amount_in_token;
+const calc_amount_in_token = (amount_in_usd, market_price, token_info) => {
+    if (isEmpty(market_price) || Number(market_price) === 0) {
+        throw new Error(`calc_token_amount_out error! invalid argument! market_price=${market_price}`);
+    }
+    let { decimals } = token_info;
+    const amount_in_token = Number(new decimal_js_1.default(amount_in_usd).div(new decimal_js_1.default(market_price)).toFixed(decimals));
+    return {
+        token_info,
+        market_price,
+        amount_in_usd,
+        amount_in_token
+    };
+};
+exports.calc_amount_in_token = calc_amount_in_token;
+const get_input_out_token = (poolInfo, aToB) => {
+    let { is_reverse_token } = poolInfo;
+    let inputToken;
+    let outputToken;
+    if (!is_reverse_token) {
+        if (aToB) {
+            inputToken = poolInfo.tokenA;
+            outputToken = poolInfo.tokenB;
+        }
+        else {
+            inputToken = poolInfo.tokenB;
+            outputToken = poolInfo.tokenA;
+        }
+    }
+    else {
+        if (aToB) {
+            inputToken = poolInfo.tokenB;
+            outputToken = poolInfo.tokenA;
+        }
+        else {
+            inputToken = poolInfo.tokenA;
+            outputToken = poolInfo.tokenB;
+        }
+    }
+    return {
+        inputToken,
+        outputToken
+    };
+};
+exports.get_input_out_token = get_input_out_token;
+const get_input_out_token_fix = (poolInfo, aToB) => {
+    let inputToken;
+    let outputToken;
+    if (aToB) {
+        inputToken = poolInfo.tokenA;
+        outputToken = poolInfo.tokenB;
+    }
+    else {
+        inputToken = poolInfo.tokenB;
+        outputToken = poolInfo.tokenA;
+    }
+    return {
+        inputToken,
+        outputToken
+    };
+};
+exports.get_input_out_token_fix = get_input_out_token_fix;
+const parse_trade_cmdline_args = () => {
+    var _a;
+    let chain_id = process.env.CHAIN_ID || '';
+    let input_group_id = process.env.INPUT_GROUP_ID || '';
+    let input_pair = process.env.INPUT_PAIR || '';
+    let input_dex_id = ((_a = process.env.INPUT_DEX_ID) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || '';
+    let cmd_args = {
+        chain_id,
+        input_dex_id,
+        input_pair,
+        input_group_id
+    };
+    return cmd_args;
+};
+exports.parse_trade_cmdline_args = parse_trade_cmdline_args;
+const empty_broadcast = [
+    {
+        rpc: {
+            read: '', write: ''
+        },
+        type: '',
+        fee: {
+            base_fee: 0,
+            priority_fee: 0,
+            total_fee: 0
+        }
+    }
+];
+const log_url = process.env.TRADE_LOG_SEND_URL || '';
+const log_type = process.env.TRADE_LOG_DATA_TYPE || '';
+const save_trade_execution_logs = (trade_response) => __awaiter(void 0, void 0, void 0, function* () {
+    if (LOG.debug) {
+        log_debug(`save_trade_execution_logs, start`, {
+            log_url,
+            log_type,
+            trade_response: JSON.stringify(trade_response)
+        });
+    }
+    try {
+        let { code, msg, data, error_code } = trade_response;
+        let { success, start_time, end_time, total_time, dex_id, pair, chain_id, group_id, txid, balance, execution } = data;
+        let { time, broadcast, server_info } = execution;
+        if (!broadcast) {
+            broadcast = empty_broadcast;
+        }
+        let _broadcast = broadcast[0];
+        let trade_logs = {
+            success, msg, error_code,
+            group_id, chain_id, pair, dex_id,
+            start_time, end_time, total_time,
+            txid,
+            t_block_time: time.block_time,
+            t_stream_time: time.stream_time,
+            t_quote_start_time: time.quote_start_time,
+            t_quote_end_time: time.quote_end_time,
+            t_price_time: time.price_time,
+            t_total_quote_time: time.total_quote_time,
+            t_order_send_time: time.order_send_time,
+            t_order_recv_time: time.order_recv_time,
+            t_order_submit_time: time.order_submit_time,
+            t_order_end_time: time.order_end_time,
+            t_order_block_time: time.order_block_time,
+            t_total_order_time: time.total_order_time,
+            broadcast_type: _broadcast.type,
+            rpc_read: `${_broadcast.rpc.read}`,
+            rpc_write: `${_broadcast.rpc.write}`,
+            gas_base_fee: _broadcast.fee.base_fee,
+            gas_priority_fee: _broadcast.fee.priority_fee,
+            gas_total_fee: _broadcast.fee.total_fee,
+            server_ip: server_info.ip,
+            server_name: server_info.name,
+            server_region: server_info.region,
+        };
+        const payload = {
+            type: log_type,
+            msgJson: JSON.stringify(trade_logs),
+        };
+        if (isEmpty(log_url) || isEmpty(log_type)) {
+            log_warn(`save_trade_execution_logs, skip!!! TRADE_LOG_SEND_URL or TRADE_LOG_DATA_TYPE is empty`);
+            return;
+        }
+        if (LOG.debug) {
+            log_debug('save_trade_execution_logs, data=', {
+                txid,
+                log_url,
+                log_type,
+                payload
+            });
+        }
+        (0, exports.postJSON)(log_url, payload)
+            .then((res) => console.log(`${getCurDateTime()} save_trade_execution_logs, success. txid=${txid}`, res))
+            .catch((err) => {
+            console.error(`${getCurDateTime()} save_trade_execution_logs, error! txid=${txid}`);
+            console.log(err);
+        });
+    }
+    catch (err) {
+        log_error(`save_trade_execution_logs error!`, err);
+    }
+});
+exports.save_trade_execution_logs = save_trade_execution_logs;
+const inspect_arb_local_cache = (express, appConfig) => {
+    let { chain_id } = appConfig.arb_cache;
+    express.get(`/${chain_id}/cache/summary`, (req, res) => {
+        let { token_list, token_list_cache_last_update_time, pool_list, pool_list_cahce_last_update_time, trade_config_list, trade_config_cache_last_update_time } = appConfig.arb_cache;
+        let group_config = trade_config_list.map(e => {
+            return {
+                group_id: e.group.id,
+                pairs: e.pair_list.map(e => e.name)
+            };
+        });
+        let summary = {
+            token_config: {
+                last_update_time: token_list_cache_last_update_time,
+                token_count: token_list.length
+            },
+            pool_config: {
+                last_update_time: pool_list_cahce_last_update_time,
+                pool_count: pool_list.length
+            },
+            trade_config: {
+                last_update_time: trade_config_cache_last_update_time,
+                group_config
+            }
+        };
+        res.json((0, exports.success)({ summary }));
+    });
+    express.get(`/${chain_id}/cache/:type`, (req, res) => {
+        let { token_list, token_symbol_map, token_address_map, token_list_cache_last_update_time, pool_list, pool_address_map, pool_list_cahce_last_update_time, trade_config_list, trade_config_map, trade_config_cache_last_update_time } = appConfig.arb_cache;
+        let type = req.params.type;
+        if (type === 'tokens') {
+            res.json({
+                token_list_cache_last_update_time,
+                token_list,
+                _token_symbol_map: Object.fromEntries(token_symbol_map),
+                _token_address_map: Object.fromEntries(token_address_map),
+            });
+        }
+        else if (type === 'pools') {
+            res.json({
+                pool_list_cahce_last_update_time,
+                pool_list,
+                _pool_address_map: Object.fromEntries(pool_address_map),
+            });
+        }
+        else if (type === 'group') {
+            res.json({
+                trade_config_cache_last_update_time,
+                trade_config_list,
+                _trade_config_map: Object.fromEntries(trade_config_map),
+            });
+        }
+        else {
+            res.json((0, exports.success)({}));
+        }
+    });
+};
+exports.inspect_arb_local_cache = inspect_arb_local_cache;
+const execute_bash = (command_1, ...args_1) => __awaiter(void 0, [command_1, ...args_1], void 0, function* (command, parse_json = true) {
+    try {
+        let out = yield exec(command);
+        log_debug(`execute_bash: `, {
+            command,
+            out
+        });
+        let stdout = out.stdout;
+        if (parse_json) {
+            return JSON.parse(stdout);
+        }
+        return stdout;
+    }
+    catch (err) {
+        throw err;
+    }
+});
+exports.execute_bash = execute_bash;
+function chunkArray(arr, chunkSize) {
+    if (chunkSize <= 0 || !Number.isInteger(chunkSize)) {
+        throw new Error("chunkSize 必须为大于 0 的整数");
+    }
+    const result = [];
+    for (let i = 0; i < arr.length; i += chunkSize) {
+        result.push(arr.slice(i, i + chunkSize));
+    }
+    return result;
+}