@clonegod/ttd-core 2.0.1

package/dist/cache/arb_cache.js

@@ -0,0 +1,1010 @@
+"use strict";
+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.ArbCache = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const index_1 = require("../index");
+class ArbCache {
+    constructor(env_args) {
+        this.chain_id = env_args.chain_id;
+        this.loading_cache = (0, index_1.getLoadingCache)();
+        this.redis_cmd = (0, index_1.getRedisCommamd)();
+        this.token_list = [];
+        this.token_symbol_map = new Map();
+        this.token_address_map = new Map();
+        this.pool_list = [];
+        this.pool_address_map = new Map();
+        this.trade_config_list = [];
+        this.trade_config_map = new Map();
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                yield Promise.all([
+                    this.loading_cache.init(),
+                    this.redis_cmd.init()
+                ]);
+                this.redis_event_publisher = (0, index_1.getArbEventPublisher)(this);
+                (0, index_1.mkdirSync)(path_1.default.join('config', this.chain_id, 'bak').toLowerCase(), true);
+                if (((_a = process.env.APP_NAME) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'config-center') {
+                    yield this.init_configs();
+                }
+            }
+            catch (err) {
+                (0, index_1.log_error)('arb_cache init error!', err);
+                throw err;
+            }
+        });
+    }
+    init_configs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let app_name = process.env.APP_NAME;
+            if (((_a = process.env.APP_NAME) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== 'config-center') {
+                (0, index_1.log_warn)(`Only config-center can initial config! process.env.APP_NAME=${app_name}, return`);
+                return;
+            }
+            let enable_init_cache = process.env.ENABLE_INIT_CACHE;
+            if (!(0, index_1.isTrue)(enable_init_cache)) {
+                (0, index_1.log_warn)(`Skip initial config data! process.env.ENABLE_INIT_CACHE=${enable_init_cache}`);
+                return;
+            }
+            (0, index_1.log_trace)(`init cache start`);
+            yield this.cache_common_service();
+            yield this.cache_token_list();
+            yield this.cache_pool_list();
+            yield this.cache_trade_group();
+            (0, index_1.log_trace)(`init cache finish`);
+        });
+    }
+    get_config_filepath(suffix) {
+        let chain_id = this.chain_id.toLowerCase();
+        let file_name = `config-${chain_id}-${suffix}`;
+        return path_1.default.join('config', chain_id, file_name);
+    }
+    get_bak_config_filepath(suffix) {
+        let chain_id = this.chain_id.toLowerCase();
+        let file_name = `config-${chain_id}-${suffix}`;
+        let bak_dir = 'bak';
+        (0, index_1.mkdirSync)(path_1.default.join('config', chain_id, bak_dir));
+        return path_1.default.join('config', chain_id, 'bak', file_name);
+    }
+    refresh_local_cache_token_list(token_list) {
+        this.token_list = token_list;
+        this.token_symbol_map.clear();
+        this.token_address_map.clear();
+        for (let token of token_list) {
+            this.token_symbol_map.set(token.symbol, token);
+            this.token_address_map.set(token.address, token);
+        }
+        this.token_list_cache_last_update_time = (0, index_1.getCurDateTime)();
+        (0, index_1.log_trace)('refresh_local_cache_token_list, success', {
+            token_list_len: this.token_list.length,
+            token_symbol_map_size: this.token_symbol_map.size,
+            token_address_map_szie: this.token_address_map.size
+        });
+    }
+    refresh_local_cache_pool_list(pool_list) {
+        this.pool_list = pool_list;
+        this.pool_address_map.clear();
+        for (let pool of pool_list) {
+            this.pool_address_map.set(pool.pool_address, pool);
+        }
+        this.pool_list_cahce_last_update_time = (0, index_1.getCurDateTime)();
+        (0, index_1.log_trace)('refresh_local_cache_pool_list, success', {
+            pool_list_len: this.pool_list.length,
+            pool_address_map_size: this.pool_address_map.size
+        });
+    }
+    refresh_local_cache_group_map(trade_config) {
+        let group_id = trade_config.group.id;
+        let group_id_set_in_env = process.env.GROUP_ID;
+        if (group_id_set_in_env && group_id !== group_id_set_in_env) {
+            (0, index_1.log_warn)(`skip set trade group in local cache! group_id not match to current trader process:`, {
+                group_id_set_in_env,
+                group_id
+            });
+            return;
+        }
+        let others = this.trade_config_list.filter(e => e.group.id !== group_id);
+        others.push(trade_config);
+        this.trade_config_list = others;
+        this.trade_config_map.set(group_id, trade_config);
+        this.trade_config_cache_last_update_time = (0, index_1.getCurDateTime)();
+        (0, index_1.log_trace)('refresh_local_cache_group_map, success', { group_id });
+    }
+    cache_token_list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, index_1.log_trace)(`cache_token_list, start`);
+            let filepath = this.get_config_filepath('token-list.json');
+            if (!(0, index_1.file_exists)(filepath)) {
+                throw new Error(`cache_token_list failed, config file not exist! filepath=${filepath}`);
+            }
+            let config = (0, index_1.readFile)(filepath);
+            let token_list = config.token_list.filter(e => e.enable);
+            for (let token of token_list) {
+                let field = token.symbol;
+                let value = JSON.stringify(token);
+                let result = yield this.loading_cache.hset(this.chain_id, index_1.CACHE_KEY_TYPE.CONFIG_TOKEN_LIST, field, value);
+                if (index_1.LOG.debug) {
+                    (0, index_1.log_trace)(`cache_token_list, symbol=${field}, result: ` + JSON.stringify(result));
+                }
+                if (token.market_price) {
+                    this.cache_token_market_price(token, -1);
+                }
+            }
+            this.refresh_local_cache_token_list(token_list);
+            let result = yield this.loading_cache.hlen(this.chain_id, index_1.CACHE_KEY_TYPE.CONFIG_TOKEN_LIST);
+            (0, index_1.log_trace)(`cache_token_list, end`, result);
+        });
+    }
+    update_token_list(input_token_list) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, index_1.log_trace)(`update_token_list, start`);
+            if ((0, index_1.isEmpty)(input_token_list)) {
+                (0, index_1.log_warn)(`update_token_list, skip! invalid input: token list is empty!`);
+                return;
+            }
+            let filepath = this.get_config_filepath('token-list.json');
+            if (!(0, index_1.file_exists)(filepath)) {
+                throw new Error(`update_token_list failed, config file not exist! filepath=${filepath}`);
+            }
+            let config = (0, index_1.readFile)(filepath);
+            for (let token of input_token_list) {
+                let others = config.token_list.filter(e => e.symbol.toUpperCase() !== token.symbol.toUpperCase());
+                if (token.enable) {
+                    others.push(token);
+                }
+                else {
+                    (0, index_1.log_warn)(`update_token_list, token not enable, delete`, token);
+                    let field = token.symbol;
+                    yield this.loading_cache.hdel(this.chain_id, index_1.CACHE_KEY_TYPE.CONFIG_TOKEN_LIST, field);
+                }
+                others = others.sort((a, b) => a.symbol.localeCompare(b.symbol));
+                config.token_list = others;
+            }
+            (0, index_1.writeFile)(filepath, (0, index_1.to_json_str)(config));
+            yield this.cache_token_list();
+            (0, index_1.log_trace)(`update_token_list, end. token_list.len=${config.token_list.length}`);
+        });
+    }
+    get_token_list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(0, index_1.isEmpty)(this.token_list)) {
+                return this.token_list;
+            }
+            return yield this.get_token_list_no_cache();
+        });
+    }
+    get_token_list_no_cache() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let token_list = [];
+            let res = yield this.loading_cache.hget_all(this.chain_id, index_1.CACHE_KEY_TYPE.CONFIG_TOKEN_LIST);
+            let { key, value } = res;
+            for (let name of Object.keys(value)) {
+                token_list.push(JSON.parse(value[name]));
+            }
+            (0, index_1.log_warn)(`get_token_list_no_cache, key=${key}, token_list.len=${token_list.length}`);
+            this.refresh_local_cache_token_list(token_list);
+            return token_list;
+        });
+    }
+    get_one_token_info_by_symbol(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let token_info = null;
+            if (this.token_symbol_map.has(symbol)) {
+                token_info = this.token_symbol_map.get(symbol);
+            }
+            if (!token_info) {
+                let token_list = yield this.get_token_list();
+                token_info = token_list.find(e => e.symbol === symbol);
+            }
+            if (!token_info) {
+                throw new Error(`get_one_token_info_by_symbol failed, token not exist! symbol: ${symbol}`);
+            }
+            return token_info;
+        });
+    }
+    publish_token_change_event() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.redis_event_publisher.publish_config_change_event({
+                event_type: index_1.REDIS_EVENT_TYPE_CONFIG_CHANGE.TOKEN_CONFIG_CHANGE,
+                event_time: new Date().getTime()
+            });
+        });
+    }
+    cache_pool_list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, index_1.log_trace)(`cache_pool_list, start`);
+            let filepath = this.get_config_filepath('pool-list.json');
+            if (!(0, index_1.file_exists)(filepath)) {
+                throw new Error(`cache_pool_list failed, config file not exist! filepath=${filepath}`);
+            }
+            let all_dex_pool = [];
+            let config = (0, index_1.readFile)(filepath);
+            let token_list = yield this.get_token_list();
+            for (let { dex_id, pool_list } of config.dex_list) {
+                pool_list = pool_list.filter(e => e.enable);
+                (0, index_1.log_trace)(`cache_pool_list`, { dex_id, pool_list_len: pool_list.length });
+                for (let pool of pool_list) {
+                    pool.dex_id = dex_id;
+                    this.set_pool_token_info(pool, token_list);
+                    this.set_pool_extra(pool);
+                    let field = pool.pool_address;
+                    let value = JSON.stringify(pool);
+                    let result = yield this.loading_cache.hset(this.chain_id, index_1.CACHE_KEY_TYPE.CONFIG_POOL_LIST, field, value);
+                    if (index_1.LOG.debug) {
+                        (0, index_1.log_trace)(`cache_pool_list, pool_address=${pool.pool_address}, result: ` + JSON.stringify(result));
+                    }
+                }
+                all_dex_pool.push(...pool_list);
+            }
+            this.refresh_local_cache_pool_list(all_dex_pool);
+            let result = yield this.loading_cache.hlen(this.chain_id, index_1.CACHE_KEY_TYPE.CONFIG_POOL_LIST);
+            (0, index_1.log_trace)(`cache_pool_list, end`, result);
+        });
+    }
+    set_pool_token_info(pool, token_info_list) {
+        if (index_1.LOG.debug) {
+            (0, index_1.log_trace)(`set_pool_token_info`);
+        }
+        let [token0, token1] = pool.pool_name.split('/');
+        pool.tokenA = token_info_list.find(e => e.symbol === token0);
+        pool.tokenB = token_info_list.find(e => e.symbol === token1);
+        if (!pool.tokenA || !pool.tokenB) {
+            (0, index_1.log_warn)('set_pool_token_info failed! tokenA or tokenB not exists!', {
+                pool_info: pool,
+                token_symbol_list: token_info_list.map(e => e.symbol)
+            });
+            throw new Error(`set_pool_token_info failed! tokenA or tokenB not exists!`);
+        }
+    }
+    set_pool_extra(pool) {
+        if (index_1.LOG.debug) {
+            (0, index_1.log_trace)(`update_pool_extra`);
+        }
+        let { pool_name, quote_token, pair: pair } = pool;
+        let is_reverse_token = pool_name.startsWith(quote_token);
+        pool.is_reverse_token = is_reverse_token;
+        if (!pair) {
+            throw new Error(`!!! invalid config: pair is empty! pool_name=${pool_name}`);
+        }
+        if (is_reverse_token && pool_name === pair) {
+            (0, index_1.log_trace)(`Warn: bad pair set in the pool config file, check it!`, {
+                pool_name,
+                quote_token,
+                pair,
+                is_reverse_token,
+            });
+            let [token0, token1] = pool.pool_name.split('/');
+            pool.pair = token1 + '/' + token0;
+        }
+    }
+    update_pool_list(input_dex_pool_list) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, index_1.log_trace)(`update_pool_list, start`);
+            if ((0, index_1.isEmpty)(input_dex_pool_list)) {
+                (0, index_1.log_warn)(`update_pool_list, skip! invalid input: pool list is empty!`);
+                return;
+            }
+            let dex_id_list = input_dex_pool_list.map(e => e.dex_id);
+            let dex_id_set = new Set(dex_id_list);
+            if (dex_id_set.size != input_dex_pool_list.length) {
+                throw new Error(`duplicate dex_id in request data! ${dex_id_list}`);
+            }
+            let filepath = this.get_config_filepath('pool-list.json');
+            if (!(0, index_1.file_exists)(filepath)) {
+                throw new Error(`update_pool_list failed, config file not exist! filepath=${filepath}`);
+            }
+            let config = (0, index_1.readFile)(filepath);
+            for (let { dex_id, pool_list } of input_dex_pool_list) {
+                let dex_pool_config = config.dex_list.find(e => e.dex_id === dex_id);
+                if ((0, index_1.isEmpty)(dex_pool_config)) {
+                    dex_pool_config = { dex_id, pool_list: [] };
+                    config.dex_list.push(dex_pool_config);
+                }
+                for (let pool of pool_list) {
+                    let others = dex_pool_config.pool_list.filter(e => e.pool_address !== pool.pool_address);
+                    if (pool.enable) {
+                        others.push(pool);
+                    }
+                    else {
+                        (0, index_1.log_warn)(`update_pool_list, pool not enable, delete`, pool);
+                        let field = pool.pool_address;
+                        yield this.loading_cache.hdel(this.chain_id, index_1.CACHE_KEY_TYPE.CONFIG_POOL_LIST, field);
+                    }
+                    others = others.sort((a, b) => a.pool_name.localeCompare(b.pool_name));
+                    dex_pool_config.pool_list = others;
+                }
+            }
+            (0, index_1.writeFile)(filepath, (0, index_1.to_json_str)(config));
+            yield this.cache_pool_list();
+            (0, index_1.log_trace)(`update_pool_list, end, dex_list.len=${config.dex_list.length}`);
+        });
+    }
+    get_pool_list_by_pair(pair) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let pool_list = yield this.get_pool_list();
+            return pool_list.filter(e => (0, index_1.isEmpty)(pair) || e.pair === pair);
+        });
+    }
+    get_pool_list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(0, index_1.isEmpty)(this.pool_list)) {
+                return this.pool_list;
+            }
+            (0, index_1.log_warn)(`get_pool_list, local cache is empty, try get_pool_list_no_cache...`);
+            return yield this.get_pool_list_no_cache();
+        });
+    }
+    get_pool_list_no_cache() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let res = yield this.loading_cache.hget_all(this.chain_id, index_1.CACHE_KEY_TYPE.CONFIG_POOL_LIST);
+                let { key, value } = res;
+                let pool_list = [];
+                for (let name of Object.keys(value)) {
+                    pool_list.push(JSON.parse(value[name]));
+                }
+                (0, index_1.log_warn)(`get_pool_list_no_cache, key=${key}, pool_list.len=${pool_list.length}`);
+                this.refresh_local_cache_pool_list(pool_list);
+                return pool_list;
+            }
+            catch (err) {
+                (0, index_1.log_error)('get_pool_list_no_cache error!!!', err);
+                throw new Error(`get_pool_list_no_cache error! err=${err.message}`);
+            }
+        });
+    }
+    get_one_pool_info(pool_address_1) {
+        return __awaiter(this, arguments, void 0, function* (pool_address, refresh_cache_if_not_found = true) {
+            let pool_info = null;
+            if (this.pool_address_map.has(pool_address)) {
+                pool_info = this.pool_address_map.get(pool_address);
+            }
+            if (!pool_info && refresh_cache_if_not_found) {
+                (0, index_1.log_warn)(`get_one_pool_info, from local pool_address_map got: ${pool_info}, try get_pool_list_no_cache...`);
+                let pool_list = yield this.get_pool_list_no_cache();
+                pool_info = pool_list.find(e => e.pool_address === pool_address);
+            }
+            if (!pool_info) {
+                throw new Error(`get_one_pool_info failed, not exist! pool_address=${pool_address}`);
+            }
+            return pool_info;
+        });
+    }
+    publish_pool_change_event() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.redis_event_publisher.publish_config_change_event({
+                event_type: index_1.REDIS_EVENT_TYPE_CONFIG_CHANGE.POOL_CONFIG_CHANGE,
+                event_time: new Date().getTime()
+            });
+        });
+    }
+    get_one_pair(input_pair) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let pair_list = yield this.get_pair_list(input_pair);
+            return pair_list.find(e => e.pair === input_pair);
+        });
+    }
+    get_pair_list() {
+        return __awaiter(this, arguments, void 0, function* (input_pair = '') {
+            if (index_1.LOG.debug) {
+                (0, index_1.log_trace)(`get_pair_list, start`, { input_pair });
+            }
+            let pair_list = [];
+            let pair_set = new Set();
+            let pair_price_decimals = new Map();
+            let pool_list = yield this.get_pool_list_by_pair(input_pair);
+            for (let { pair, quote_price_decimals } of pool_list) {
+                pair_set.add(pair);
+                if (quote_price_decimals || quote_price_decimals > 0) {
+                    pair_price_decimals.set(pair, quote_price_decimals);
+                }
+            }
+            for (let pair of pair_set) {
+                let [base_symbol, quote_symbol] = pair.split('/');
+                let tokenA = yield this.get_one_token_info_by_symbol(base_symbol);
+                let tokenB = yield this.get_one_token_info_by_symbol(quote_symbol);
+                let price_decimals = pair_price_decimals.get(pair);
+                if (!price_decimals || price_decimals <= 0) {
+                    price_decimals = 12;
+                }
+                let pool_list = (yield this.get_pool_list_by_pair(pair)).filter(e => e.enable).map(e => e.pool_address);
+                pair_list.push({
+                    pair,
+                    tokenA,
+                    tokenB,
+                    price_decimals,
+                    pool_list
+                });
+            }
+            pair_list = pair_list.sort((a, b) => a.pair.localeCompare(b.pair));
+            if (index_1.LOG.debug) {
+                (0, index_1.log_trace)(`get_pair_list, end`, pair_list);
+            }
+            return pair_list;
+        });
+    }
+    cache_common_service() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, index_1.log_trace)(`cache_common_service, start`);
+            let filepath = this.get_config_filepath('common-service.json');
+            if (!(0, index_1.file_exists)(filepath)) {
+                throw new Error(`cache_common_service failed, config file not exist! filepath=${filepath}`);
+            }
+            let config = (0, index_1.readFile)(filepath);
+            let service_list = [
+                {
+                    name: 'config_center',
+                    service: config.config_center
+                },
+                {
+                    name: 'quote',
+                    service: config.quote || []
+                },
+                {
+                    name: 'orderbook',
+                    service: config.orderbook
+                },
+                {
+                    name: 'trade_proxy',
+                    service: config.trade_proxy
+                },
+            ];
+            for (let { name, service } of service_list) {
+                let field = name;
+                let value = JSON.stringify(service);
+                let result = yield this.loading_cache.hset(this.chain_id, index_1.CACHE_KEY_TYPE.CONFIG_COMMON_SERVICE, field, value);
+                (0, index_1.log_trace)(`cache_common_service, field=${field}, result: ` + JSON.stringify(result));
+            }
+            (0, index_1.log_trace)(`cache_common_service, end`);
+        });
+    }
+    get_common_service() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let res = yield this.loading_cache.hget_all(this.chain_id, index_1.CACHE_KEY_TYPE.CONFIG_COMMON_SERVICE);
+                let { key, value } = res;
+                if (index_1.LOG.debug) {
+                    (0, index_1.log_trace)('get_common_service, res=', res);
+                }
+                let config = JSON.parse('{}');
+                for (let name of Object.keys(value)) {
+                    config[name] = JSON.parse(value[name]);
+                }
+                return config;
+            }
+            catch (err) {
+                (0, index_1.log_error)('get_common_service error!!!', err);
+                throw new Error(`get_common_service error! err=${err.message}`);
+            }
+        });
+    }
+    cache_trade_group() {
+        return __awaiter(this, arguments, void 0, function* (update_group_id = '') {
+            (0, index_1.log_trace)(`cache_trade_service, start`);
+            let config_dir = path_1.default.join('config', this.chain_id.toLowerCase());
+            let all_files = fs_1.default.readdirSync(config_dir);
+            let files = all_files.filter(fname => {
+                let fname_lower = fname.toLowerCase();
+                let fname_prefix = `config-${this.chain_id}-trade`.toLowerCase();
+                if (!(0, index_1.isEmpty)(update_group_id)) {
+                    fname_prefix = `config-${this.chain_id}-trade-${update_group_id}`.toLowerCase();
+                }
+                return fname_lower.startsWith(fname_prefix) && fname_lower.indexOf('template') === -1;
+            }) || [];
+            if ((0, index_1.isEmpty)(files)) {
+                (0, index_1.log_trace)(`Files in the directory: ${config_dir} \n []`);
+            }
+            else {
+                (0, index_1.log_trace)(`Files in the directory: ${config_dir}:`, files);
+            }
+            for (let group_file_name of files) {
+                let filepath;
+                try {
+                    filepath = path_1.default.join(config_dir, group_file_name);
+                    if (!(0, index_1.file_exists)(filepath)) {
+                        throw new Error(`cache_trade_group failed, config file not exist! filepath=${filepath}`);
+                    }
+                    let group_config = (0, index_1.readFile)(filepath);
+                    let { group } = group_config;
+                    let { id: group_id } = group;
+                    (0, index_1.log_trace)(`cache_trade_service, group_id=${group_id}`);
+                    let value = JSON.stringify(group_config);
+                    let result = yield this.loading_cache.hset(this.chain_id, index_1.CACHE_KEY_TYPE.CONFIG_TRADE_SERVICE, group_id, value);
+                    this.refresh_local_cache_group_map(group_config);
+                    yield this.redis_event_publisher.publish_config_change_event({
+                        event_type: index_1.REDIS_EVENT_TYPE_CONFIG_CHANGE.GROUP_CONFIG_CHANGE,
+                        event_time: new Date().getTime(),
+                        group_id
+                    });
+                    (0, index_1.log_trace)(`cache_trade_service, group_id=${group_id}, result: `, result);
+                }
+                catch (err) {
+                    (0, index_1.log_error)('cache_trade_service error! file_path=' + filepath, err);
+                    continue;
+                }
+            }
+            (0, index_1.log_trace)(`cache_trade_service, end`);
+        });
+    }
+    update_trade_group(input_trade_config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, index_1.log_trace)(`update_trade_service, start`);
+            let group_id = input_trade_config === null || input_trade_config === void 0 ? void 0 : input_trade_config.group.id;
+            if (!group_id) {
+                throw new Error(`update_trade_group failed, invalid input: group id is empty or null!`);
+            }
+            let filepath = this.get_config_filepath(`trade-${group_id}.json`);
+            if (!(0, index_1.file_exists)(filepath)) {
+                throw new Error(`update_trade_group failed, config file not exist! filepath=${filepath}`);
+            }
+            let trade_config = (0, index_1.readFile)(filepath);
+            let merge_pairs_map = new Map();
+            for (let pair of trade_config.pair_list || []) {
+                merge_pairs_map.set(pair.name, pair);
+            }
+            for (let pair of input_trade_config.pair_list) {
+                if (pair.enable) {
+                    merge_pairs_map.set(pair.name, pair);
+                }
+                else {
+                    merge_pairs_map.delete(pair.name);
+                    (0, index_1.log_warn)(`update_trade_group, pair not enable, delete`, pair);
+                }
+            }
+            let merge_pairs_list = Array.from(merge_pairs_map.values()).sort((a, b) => a.name.localeCompare(b.name));
+            input_trade_config.pair_list = merge_pairs_list;
+            if (!input_trade_config.group.enable) {
+                input_trade_config.pair_list = [];
+            }
+            (0, index_1.writeFile)(filepath, (0, index_1.to_json_str)(input_trade_config));
+            yield this.cache_trade_group(group_id);
+            (0, index_1.log_trace)(`update_trade_service, end`);
+        });
+    }
+    get_trade_group_id_list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let res = yield this.loading_cache.hkeys(this.chain_id, index_1.CACHE_KEY_TYPE.CONFIG_TRADE_SERVICE);
+            if (index_1.LOG.debug) {
+                (0, index_1.log_trace)('get_trade_group_id_list, res=', res);
+            }
+            let { key, value } = res;
+            return value;
+        });
+    }
+    get_trade_service_by_group_id(group_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let trade_group_config;
+            if (this.trade_config_map.has(group_id)) {
+                trade_group_config = this.trade_config_map.get(group_id);
+            }
+            else {
+                trade_group_config = yield this.get_trade_service_by_group_id_no_cache(group_id);
+            }
+            return (0, index_1.deep_clone)(trade_group_config);
+        });
+    }
+    get_trade_service_by_group_id_no_cache(group_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((0, index_1.isEmpty)(group_id)) {
+                throw new Error(`get_trade_service_by_group_id_no_cache, invalid group_id=${group_id}, return`);
+            }
+            (0, index_1.log_info)(`get_trade_service_by_group_id_no_cache, group_id=${group_id}, start`);
+            let res = yield this.loading_cache.hget(this.chain_id, index_1.CACHE_KEY_TYPE.CONFIG_TRADE_SERVICE, group_id);
+            let { key, field, value } = res;
+            let trade_group;
+            if (value) {
+                trade_group = JSON.parse(value);
+                this.refresh_local_cache_group_map(trade_group);
+            }
+            else {
+                throw new Error(`get_trade_service_by_group_id_no_cache, failed! group_id=${group_id}, not exist!`);
+            }
+            (0, index_1.log_info)(`get_trade_service_by_group_id_no_cache, end`);
+            return trade_group;
+        });
+    }
+    create_trade_runtime(chain_id, group_id, dex_id, pair_name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let args = { group_id, dex_id, pair_name };
+            if ((0, index_1.isEmpty)(chain_id)) {
+                throw new Error(`Check chain_id: failed! chain_id is empty or null!!! check .env file`);
+            }
+            if ((0, index_1.isEmpty)(group_id)) {
+                throw new Error(`check failed! invalid input: group_id is empty or null! \n${(0, index_1.to_json_str)(args)}`);
+            }
+            if ((0, index_1.isEmpty)(pair_name)) {
+                throw new Error(`Check pair: failed! pair is empty or null! \n${(0, index_1.to_json_str)(args)}`);
+            }
+            if (pair_name !== pair_name.toUpperCase()) {
+                throw new Error(`Check pair: failed! pair need uppercase!! \n${(0, index_1.to_json_str)(args)}`);
+            }
+            if ((0, index_1.isEmpty)(dex_id)) {
+                throw new Error(`check failed! dex_id is empty or null! \n${(0, index_1.to_json_str)(args)}`);
+            }
+            let dex_id_list = ((_a = process.env.DEX_ID_LIST) === null || _a === void 0 ? void 0 : _a.split(',')) || [];
+            if (!dex_id_list.includes(dex_id)) {
+                throw new Error(`check failed! dex_id not support! \n ${(0, index_1.to_json_str)({ dex_id, dex_id_list })}`);
+            }
+            (0, index_1.log_trace)(`create_trade_runtime, start`, args);
+            let wallet = (0, index_1.load_wallet)(group_id, false);
+            if ((0, index_1.isEmpty)(wallet.public_key) || (0, index_1.isEmpty)(wallet.private_key)) {
+                throw new Error(`wallet public_key or private_key is empty!!! group_id=${group_id}`);
+            }
+            let trade_config = yield this.get_trade_service_by_group_id(group_id);
+            if ((0, index_1.isEmpty)(trade_config)) {
+                throw new Error(`no trade config for the group! group_id=${group_id}, trade config=${(0, index_1.to_json_str)(trade_config)}`);
+            }
+            if ((0, index_1.isEmpty)(trade_config.pair_list)) {
+                throw new Error(`no trade pair for the group: pair_list is empty!!! please config atleast one pair, then startup! group_id=${group_id}, trade config=${(0, index_1.to_json_str)(trade_config)}`);
+            }
+            let pair_config = this.find_pair_in_trade_config(pair_name, trade_config);
+            if ((0, index_1.isEmpty)(pair_config)) {
+                throw new Error(`Not support pair for the group! pair=${pair_name}, group_id=${group_id}, all support pair: ${JSON.stringify(trade_config.pair_list.map(e => e.name))}`);
+            }
+            let pair_dex = this.find_pair_dex_in_trade_config(dex_id, pair_config);
+            if ((0, index_1.isEmpty)(pair_dex)) {
+                throw new Error(`pair not config in this dex! pair=${pair_name}, dex_id=${dex_id}! all support dex_id: ${JSON.stringify(pair_config.dex_list.map(e => e.dex_id))}`);
+            }
+            let update_settings = (0, index_1.deep_merge_object)(trade_config.settings, pair_config.settings);
+            let pool_info_list = [];
+            for (let pool_address of pair_dex.pool_list) {
+                let pool_info = yield this.get_one_pool_info(pool_address);
+                pool_info_list.push(pool_info);
+            }
+            pair_dex.pool_info_list = pool_info_list;
+            let trade_runtime = {
+                chain_id,
+                dex_id,
+                group: trade_config.group,
+                wallet,
+                pair_name: pair_config.name,
+                auto_approve: pair_config.auto_approve,
+                pair_dex: pair_dex,
+                settings: update_settings
+            };
+            let _trade_runtime = JSON.parse(JSON.stringify(trade_runtime));
+            _trade_runtime.wallet = {
+                public_key: trade_runtime.wallet.public_key,
+                private_key: '******'
+            };
+            (0, index_1.new_line)(5);
+            setTimeout(() => {
+                console.log(`=================================================================================`);
+                console.log(`|                              TRADE GROUP RUNTIME                              |`);
+                console.log(`=================================================================================`);
+                console.dir(_trade_runtime, { depth: 4 });
+            }, 0);
+            (0, index_1.log_trace)(`create_trade_runtime, end`);
+            return trade_runtime;
+        });
+    }
+    find_pair_in_trade_config(pair_name, trade_config) {
+        return trade_config.pair_list.find(e => e.name === pair_name);
+    }
+    find_pair_dex_in_trade_config(dex_id, pair_config) {
+        let pair_dex_config = pair_config.dex_list.find(e => e.dex_id === dex_id);
+        return pair_dex_config;
+    }
+    cache_token_market_price(token_with_price_1) {
+        return __awaiter(this, arguments, void 0, function* (token_with_price, ttl = -1) {
+            (0, index_1.log_trace)(`cache_market_price, start`);
+            if ((0, index_1.isEmpty)(token_with_price.market_price)) {
+                throw new Error(`token market price is null or empty!`);
+            }
+            let { symbol } = token_with_price;
+            let field = (0, index_1.format_symbol_name)(symbol);
+            let value = JSON.stringify(token_with_price);
+            let result = yield this.loading_cache.hset_ex(this.chain_id, index_1.CACHE_KEY_TYPE.MARKET_TOKEN_PRICE, field, value, ttl);
+            (0, index_1.log_trace)('cache_market_price, end', result);
+        });
+    }
+    get_token_market_price(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let id = (0, index_1.format_symbol_name)(symbol);
+                let res = yield this.loading_cache.hget(this.chain_id, index_1.CACHE_KEY_TYPE.MARKET_TOKEN_PRICE, id);
+                if (index_1.LOG.debug) {
+                    (0, index_1.log_trace)(`get_token_market_price, symbol=${symbol}, res=`, res);
+                }
+                let { key, field, value } = res;
+                let token_with_price = JSON.parse(value);
+                return token_with_price;
+            }
+            catch (err) {
+                (0, index_1.log_error)('get_token_market_price error!!! key expired ???', err);
+                throw new Error(`get_token_market_price error! err=${err.message}`);
+            }
+        });
+    }
+    cache_price_message(price_msg_1) {
+        return __awaiter(this, arguments, void 0, function* (price_msg, ttl = 3600) {
+            if (index_1.LOG.debug) {
+                (0, index_1.log_trace)(`cache_price_message, ttl=${ttl}, start`);
+            }
+            let { price_id } = price_msg;
+            if (!price_id) {
+                throw new Error(`cache_price_message failed! invalid price_id=${price_id}`);
+            }
+            let field = price_id;
+            let value = JSON.stringify(price_msg);
+            let result = yield this.loading_cache.hset_ex(this.chain_id, index_1.CACHE_KEY_TYPE.QUOTE_PRICE, field, value, ttl);
+            if (index_1.LOG.debug) {
+                (0, index_1.log_trace)('cache_price_message, end', result);
+            }
+        });
+    }
+    get_price_message(price_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!price_id) {
+                throw new Error(`get_price_message failed! invalid price_id=${price_id}`);
+            }
+            let res = yield this.loading_cache.hget(this.chain_id, index_1.CACHE_KEY_TYPE.QUOTE_PRICE, price_id);
+            if (index_1.LOG.debug) {
+                (0, index_1.log_trace)(`get_price_message, res=`, res);
+            }
+            let { key, field, value } = res;
+            let price_message = JSON.parse(value);
+            return price_message;
+        });
+    }
+    cache_order_message(order_msg_1) {
+        return __awaiter(this, arguments, void 0, function* (order_msg, ttl = 3600) {
+            if (index_1.LOG.debug) {
+                (0, index_1.log_trace)(`cache_order_message, ttl=${ttl}, start`);
+            }
+            let unique_order_msg_id = order_msg.unique_order_msg_id;
+            if ((0, index_1.isEmpty)(unique_order_msg_id)) {
+                let { group_id, price_id, order_trace_id } = order_msg;
+                throw new Error(`cache_order_message failed! unique_order_msg_id cann't null! 
+                group_id=${group_id}, price_id=${price_id}, order_trace_id=${order_trace_id}`);
+            }
+            let field = order_msg.unique_order_msg_id;
+            let value = JSON.stringify(order_msg);
+            let result = yield this.loading_cache.hset_ex(this.chain_id, index_1.CACHE_KEY_TYPE.ORDER_MESSAGE, field, value, ttl);
+            if (index_1.LOG.debug) {
+                (0, index_1.log_trace)('cache_order_message, end', result);
+            }
+            return result;
+        });
+    }
+    get_order_message(group_id, price_id, order_trace_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!group_id || !price_id || !order_trace_id) {
+                throw new Error(`get_order_message failed! invalid params: 
+                group_id=${group_id}, price_id=${price_id}, trace_id=${order_trace_id}`);
+            }
+            let _field = (0, index_1.format_unique_order_msg_id)(group_id, price_id, order_trace_id);
+            let res = yield this.loading_cache.hget(this.chain_id, index_1.CACHE_KEY_TYPE.ORDER_MESSAGE, _field);
+            if (index_1.LOG.debug) {
+                (0, index_1.log_trace)(`get_order_message, res=`, res);
+            }
+            let { key, field, value } = res;
+            let order_message = JSON.parse(value);
+            return order_message;
+        });
+    }
+    cache_trade_result(trade_result_1) {
+        return __awaiter(this, arguments, void 0, function* (trade_result, ttl = 3600) {
+            if (index_1.LOG.debug) {
+                (0, index_1.log_trace)(`cache_trade_result, ttl=${ttl}, start`);
+            }
+            let { group_id, txid } = trade_result === null || trade_result === void 0 ? void 0 : trade_result.data;
+            if (!group_id && !txid) {
+                throw new Error(`cache_trade_result failed! invalid field value: group_id=${group_id}, txid=${txid}`);
+            }
+            let field = `${group_id}_${txid}`;
+            let value = JSON.stringify(trade_result);
+            let result = yield this.loading_cache.hset_ex(this.chain_id, index_1.CACHE_KEY_TYPE.ORDER_RESULT, field, value, ttl);
+            if (index_1.LOG.debug) {
+                (0, index_1.log_trace)('cache_trade_result, end', result);
+            }
+            return result;
+        });
+    }
+    get_trade_result(group_id, txid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!group_id || !txid) {
+                throw new Error(`get_trade_result failed! invalid params: group_id=${group_id}, txid=${txid}`);
+            }
+            let _field = `${group_id}_${txid}`;
+            let res = yield this.loading_cache.hget(this.chain_id, index_1.CACHE_KEY_TYPE.ORDER_RESULT, _field);
+            if (index_1.LOG.debug) {
+                (0, index_1.log_trace)(`get_trade_result, res=`, res);
+            }
+            let { key, field, value } = res;
+            let trade_result = JSON.parse(value);
+            return trade_result;
+        });
+    }
+    listen_trade_result(event_emitter) {
+        this.event_emitter = event_emitter;
+        let trade_response;
+        this.event_emitter.on(index_1.TRANSACTION_STATE_PROCESSING, (no_trade_result) => __awaiter(this, void 0, void 0, function* () {
+            trade_response = {
+                code: 100,
+                msg: index_1.PROCESSING,
+                data: no_trade_result
+            };
+            yield this.cache_trade_result(trade_response);
+            (0, index_1.log_trace)(`listen_trade_result, cache tx status: ${index_1.TRANSACTION_STATE_PROCESSING}`, {
+                txid: no_trade_result === null || no_trade_result === void 0 ? void 0 : no_trade_result.txid,
+                event: index_1.TRANSACTION_STATE_PROCESSING
+            });
+        }));
+        this.event_emitter.on(index_1.TRANSACTION_STATE_SUCCESS, (success_result) => __awaiter(this, void 0, void 0, function* () {
+            let { txid } = success_result;
+            trade_response = {
+                code: 200,
+                msg: index_1.SUCCESS,
+                data: success_result
+            };
+            let { group_id, pair } = success_result;
+            this.redis_event_publisher.publish_tx_result_event(group_id, pair, trade_response);
+            yield this.cache_trade_result(trade_response);
+            (0, index_1.log_trace)(`listen_trade_result, cache tx status: ${index_1.TRANSACTION_STATE_SUCCESS}`, {
+                txid: txid,
+                event: index_1.TRANSACTION_STATE_SUCCESS
+            });
+        }));
+        this.event_emitter.on(index_1.TRANSACTION_STATE_FAILED, (err_result) => __awaiter(this, void 0, void 0, function* () {
+            let { txid, error_code } = err_result;
+            trade_response = {
+                code: 500,
+                msg: index_1.FAILED,
+                data: err_result,
+                error_code,
+            };
+            let { group_id, pair } = err_result;
+            this.redis_event_publisher.publish_tx_result_event(group_id, pair, trade_response);
+            yield this.cache_trade_result(trade_response);
+            (0, index_1.log_trace)(`listen_trade_result, cache failed tx status: ${index_1.TRANSACTION_STATE_FAILED}`, {
+                txid,
+                event: index_1.TRANSACTION_STATE_FAILED
+            });
+        }));
+    }
+    get_pair_dex_pool_list(quote_pair_list, dex_id_list) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let pool_list = [];
+            for (let pair of quote_pair_list) {
+                let pair_info = yield this.get_one_pair(pair);
+                if (!pair_info) {
+                    continue;
+                }
+                for (let pool_address of pair_info.pool_list) {
+                    let pool = yield this.get_one_pool_info(pool_address);
+                    if (dex_id_list.includes(pool.dex_id)) {
+                        pool_list.push(pool);
+                    }
+                }
+            }
+            return pool_list;
+        });
+    }
+    get_trade_dex_pool_list(dex_id_list, trade_runtime) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let pool_list = [];
+            let pair = trade_runtime.pair_name;
+            let pair_info = yield this.get_one_pair(pair);
+            if (!pair_info) {
+                throw new Error(`Invalid pair: ${pair}`);
+            }
+            for (let pool_address of pair_info.pool_list) {
+                let pool = yield this.get_one_pool_info(pool_address);
+                if (dex_id_list.includes(pool.dex_id)) {
+                    pool_list.push(pool);
+                }
+            }
+            return pool_list;
+        });
+    }
+    get_group_trade_pair_info(chain_id, group_id, pair) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!chain_id || !group_id) {
+                throw new Error(`get_group_trade_pair_info fail! invalid params: chain_id=${chain_id}, group_id=${group_id}, pair=${pair}`);
+            }
+            const pair_map = new Map();
+            let trade_group_conifg = yield this.get_trade_service_by_group_id(group_id);
+            let { pair_list } = trade_group_conifg;
+            let pair_names = pair_list.filter(e => (0, index_1.isEmpty)(pair) || e.name === pair).map(e => e.name);
+            let trade_group_pool_id_list = [];
+            for (let trade_pair of pair_list) {
+                for (let dex of trade_pair.dex_list) {
+                    trade_group_pool_id_list.push(...dex.pool_list);
+                }
+            }
+            for (let pair_name of pair_names) {
+                let pair_info = yield this.get_one_pair(pair_name);
+                if (!pair_info) {
+                    (0, index_1.log_warn)(`not found pair info!!!`, { chain_id, group_id, pair });
+                }
+                else {
+                    let unique_orderbook_id_list = [];
+                    for (let _pool_address of pair_info.pool_list.filter(e => trade_group_pool_id_list.includes(e))) {
+                        let { dex_id, pool_address, fee_rate } = yield this.get_one_pool_info(_pool_address);
+                        unique_orderbook_id_list.push((0, index_1.format_unique_orderbook_id)(chain_id, dex_id, pool_address, fee_rate));
+                    }
+                    pair_info.pool_list = unique_orderbook_id_list;
+                    pair_map.set(pair_name, pair_info);
+                }
+            }
+            return pair_map;
+        });
+    }
+    get_all_trade_tokens() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let token_address_set = new Set();
+            let group_id_list = yield this.get_trade_group_id_list();
+            for (let group_id of group_id_list) {
+                let trade_group_conifg = yield this.get_trade_service_by_group_id(group_id);
+                let { pair_list } = trade_group_conifg;
+                let trade_group_pool_id_list = [];
+                for (let trade_pair of pair_list) {
+                    for (let dex of trade_pair.dex_list) {
+                        trade_group_pool_id_list.push(...dex.pool_list);
+                    }
+                }
+                for (let pool_id of trade_group_pool_id_list) {
+                    try {
+                        let { tokenA, tokenB } = yield this.get_one_pool_info(pool_id);
+                        token_address_set.add(tokenA.address);
+                        token_address_set.add(tokenB.address);
+                    }
+                    catch (err) {
+                        (0, index_1.log_warn)(`get_all_trade_tokens error: ${err.message}`);
+                    }
+                }
+            }
+            let token_list = [];
+            for (let token_address of token_address_set) {
+                token_list.push(this.token_address_map.get(token_address));
+            }
+            return token_list;
+        });
+    }
+    get_all_trade_pools() {
+        return __awaiter(this, arguments, void 0, function* (group_id = '') {
+            let pools = [];
+            let group_id_list = yield this.get_trade_group_id_list();
+            group_id_list = group_id_list.filter(gid => (0, index_1.isEmpty)(group_id) || gid === group_id);
+            for (let group_id of group_id_list) {
+                let trade_group_conifg = yield this.get_trade_service_by_group_id(group_id);
+                let { pair_list } = trade_group_conifg;
+                let trade_group_pool_id_list = [];
+                for (let trade_pair of pair_list) {
+                    for (let dex of trade_pair.dex_list) {
+                        trade_group_pool_id_list.push(...dex.pool_list);
+                    }
+                }
+                for (let pool_id of trade_group_pool_id_list) {
+                    try {
+                        let pool = yield this.get_one_pool_info(pool_id);
+                        pools.push(pool);
+                    }
+                    catch (err) {
+                        (0, index_1.log_warn)(`get_all_trade_pools error: ${err.message}`);
+                    }
+                }
+            }
+            return pools;
+        });
+    }
+}
+exports.ArbCache = ArbCache;