@clonegod/ttd-core 2.0.16 → 2.0.18

package/dist/app_config/AbstractTradeAppConfig.d.ts

@@ -9,7 +9,7 @@ export declare abstract class AbstractTradeAppConfig extends AppConfig {
     constructor();
     init(): Promise<void>;
     init_trade_runtime(): Promise<void>;
-    subscribe_order_event(trade_instance: AbastrcatTrade, tx_result_checker: AbstractTransactionResultCheck): Promise<void>;
-    abstract subscribe_wallet_raw_txn_event(): void;
+    subscribe_order_event(trade_instance: AbastrcatTrade, new_tx_result_checker_factory: () => AbstractTransactionResultCheck): Promise<void>;
     cache_trade_result(trade_response: TradeResponseType): Promise<void>;
+    abstract subscribe_wallet_raw_txn_event(): void;
 }

package/dist/app_config/AbstractTradeAppConfig.js

@@ -41,9 +41,9 @@ class AbstractTradeAppConfig extends AppConfig_1.AppConfig {
             }
         });
     }
-    subscribe_order_event(trade_instance, tx_result_checker) {
+    subscribe_order_event(trade_instance, new_tx_result_checker_factory) {
         return __awaiter(this, void 0, void 0, function* () {
-            let handler = (message) => (0, handle_order_message_1.handle_order_message)(this, trade_instance, tx_result_checker, message);
+            let handler = (message) => (0, handle_order_message_1.handle_order_message)(this, trade_instance, new_tx_result_checker_factory, message);
             let group_id = this.trade_runtime.group.id;
             let pair_name = this.trade_runtime.pair_name;
             let dex_id = this.trade_runtime.dex_id;

package/dist/token/price/get_bsc_token_price.js

@@ -17,7 +17,7 @@ require('dotenv').config();
 const axios_1 = __importDefault(require("axios"));
 const index_1 = require("../../index");
 const gecko_terminal_1 = require("./gecko_terminal");
-const cached_price_1 = require("./cached_price");
+const price_cache_1 = require("./price_cache");
 function get_bsc_token_price_info(addresses) {
     return __awaiter(this, void 0, void 0, function* () {
         addresses = addresses.map(addr => addr.toLowerCase());
@@ -25,7 +25,7 @@ function get_bsc_token_price_info(addresses) {
         const PRICE_CHANNELS = [
             {
                 name: 'CachedPrice',
-                fetchFn: cached_price_1.fetchPriceFromCache,
+                fetchFn: price_cache_1.fetchPriceFromCache,
                 batchSize: 100,
                 batchDelay: 1000,
             },
@@ -61,7 +61,7 @@ function get_bsc_token_price_info(addresses) {
                             result.set(address, priceInfo);
                             remainingAddresses = remainingAddresses.filter(addr => addr !== address);
                             if (channel.name !== 'CachedPrice') {
-                                (0, cached_price_1.cache_new_market_price)(address, priceInfo.price, channel.name);
+                                (0, price_cache_1.cache_new_market_price)(address, priceInfo.price, channel.name);
                             }
                         }
                     }

package/dist/token/price/get_solana_token_price.js

@@ -17,14 +17,14 @@ require('dotenv').config();
 const axios_1 = __importDefault(require("axios"));
 const index_1 = require("../../index");
 const gecko_terminal_1 = require("./gecko_terminal");
-const cached_price_1 = require("./cached_price");
+const price_cache_1 = require("./price_cache");
 function get_solana_token_price_info(addresses) {
     return __awaiter(this, void 0, void 0, function* () {
         const result = new Map();
         const PRICE_CHANNELS = [
             {
                 name: 'CachedPrice',
-                fetchFn: cached_price_1.fetchPriceFromCache,
+                fetchFn: price_cache_1.fetchPriceFromCache,
                 batchSize: 100,
                 batchDelay: 1000,
             },
@@ -60,7 +60,7 @@ function get_solana_token_price_info(addresses) {
                             result.set(address, priceInfo);
                             remainingAddresses = remainingAddresses.filter(addr => addr !== address);
                             if (channel.name !== 'CachedPrice') {
-                                (0, cached_price_1.cache_new_market_price)(address, priceInfo.price, channel.name);
+                                (0, price_cache_1.cache_new_market_price)(address, priceInfo.price, channel.name);
                             }
                         }
                         (0, index_1.log_debug)(`[get_token_price_info] ${channel.name} found prices for ${channelResult.size}/${batch.length} tokens in batch ${i + 1}`);

package/dist/token/price/get_tron_token_price.js

@@ -17,14 +17,14 @@ require('dotenv').config();
 const axios_1 = __importDefault(require("axios"));
 const index_1 = require("../../index");
 const gecko_terminal_1 = require("./gecko_terminal");
-const cached_price_1 = require("./cached_price");
+const price_cache_1 = require("./price_cache");
 function get_tron_token_price_info(addresses) {
     return __awaiter(this, void 0, void 0, function* () {
         const result = new Map();
         const PRICE_CHANNELS = [
             {
                 name: 'CachedPrice',
-                fetchFn: cached_price_1.fetchPriceFromCache,
+                fetchFn: price_cache_1.fetchPriceFromCache,
                 batchSize: 100,
                 batchDelay: 1000,
             },
@@ -66,7 +66,7 @@ function get_tron_token_price_info(addresses) {
                             result.set(address, priceInfo);
                             remainingAddresses = remainingAddresses.filter(addr => addr !== address);
                             if (channel.name !== 'CachedPrice') {
-                                (0, cached_price_1.cache_new_market_price)(address, priceInfo.price, channel.name);
+                                (0, price_cache_1.cache_new_market_price)(address, priceInfo.price, channel.name);
                             }
                         }
                         (0, index_1.log_debug)(`[get_token_price_info] ${channel.name} found prices for ${channelResult.size}/${batch.length} tokens in batch ${i + 1}`);

package/dist/token/price/price_cache.d.ts

@@ -0,0 +1,3 @@
+import { FormattedTokenPrice } from "../..";
+export declare const fetchPriceFromCache: (token_address_list: string[]) => Promise<Map<string, FormattedTokenPrice>>;
+export declare function cache_new_market_price(token_address: string, market_price: string, market_source: string): Promise<void>;

package/dist/token/price/price_cache.js

@@ -0,0 +1,115 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchPriceFromCache = void 0;
+exports.cache_new_market_price = cache_new_market_price;
+const __1 = require("../..");
+const check_token_price_timeout = (token_info, token_price_timeout_seconds) => {
+    if ((0, __1.isEmpty)(token_info.market_price) || (0, __1.isEmpty)(token_info.update_time)) {
+        return true;
+    }
+    let last_update_time = token_info.update_time;
+    let diff_seconds = Math.floor((Date.now() - (0, __1.parseDateTimeStrToMills)(last_update_time)) / 1000);
+    return diff_seconds > token_price_timeout_seconds;
+};
+const get_diff_seconds = (last_update_time, now) => {
+    return Math.floor((now - (0, __1.parseDateTimeStrToMills)(last_update_time)) / 1000);
+};
+const fetchPriceFromCache = (token_address_list) => __awaiter(void 0, void 0, void 0, function* () {
+    let result = new Map();
+    let global_app_config;
+    try {
+        global_app_config = (0, __1.getGlobalAppConfig)();
+    }
+    catch (err) {
+        (0, __1.log_warn)('global_app_config is not set, skip get token price from cache');
+        return result;
+    }
+    let token_price_timeout_seconds = 600;
+    let all_token_list = yield global_app_config.arb_cache.get_token_list();
+    let token_list = all_token_list.filter(e => token_address_list.includes(e.address) && !(0, __1.isEmpty)(e.market_price) && !(0, __1.isEmpty)(e.update_time));
+    let not_found_token_list = [];
+    for (let token_info of token_list) {
+        try {
+            if (check_token_price_timeout(token_info, token_price_timeout_seconds)) {
+                not_found_token_list.push(token_info);
+            }
+            else {
+                let diff_seconds = get_diff_seconds(token_info.update_time, Date.now());
+                result.set(token_info.address, {
+                    address: token_info.address,
+                    price: token_info.market_price,
+                    update_time: token_info.update_time,
+                });
+                (0, __1.log_debug)(`get token price from cache(token_info) success: ${token_info.symbol} ${token_info.address}, price=${token_info.market_price} (${diff_seconds}s ago)`);
+            }
+        }
+        catch (err) {
+            (0, __1.log_error)(`get token price from cache failed`, err);
+        }
+    }
+    for (let token_info of not_found_token_list) {
+        let price_info = yield global_app_config.get_token_market_price(token_info.symbol);
+        if (!price_info || check_token_price_timeout(price_info, token_price_timeout_seconds)) {
+            continue;
+        }
+        result.set(token_info.address, {
+            address: token_info.address,
+            price: price_info.market_price,
+            update_time: price_info.update_time,
+        });
+        let diff_seconds = get_diff_seconds(price_info.update_time, Date.now());
+        (0, __1.log_debug)(`get token price from cache(market_price) success: ${token_info.symbol} ${token_info.address}, price=${price_info.market_price} (${diff_seconds}s ago)`);
+    }
+    return result;
+});
+exports.fetchPriceFromCache = fetchPriceFromCache;
+function cache_new_market_price(token_address, market_price, market_source) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let global_app_config;
+        try {
+            global_app_config = (0, __1.getGlobalAppConfig)();
+        }
+        catch (err) {
+            (0, __1.log_warn)('global_app_config is not set, skip get token price from cache');
+            return;
+        }
+        let ttl = global_app_config.env_args.token_price_cache_seconds;
+        let tokenInfo = global_app_config.arb_cache.token_address_map.get(token_address);
+        if (!tokenInfo) {
+            tokenInfo = (yield global_app_config.arb_cache.get_token_list_no_cache()).find(e => e.address === token_address);
+        }
+        if (!tokenInfo) {
+            (0, __1.log_warn)(`tokenInfo is not found in cache: token_address=${token_address}`);
+            return;
+        }
+        let { symbol, address } = tokenInfo;
+        if (market_price && Number(market_price) > 0) {
+            let clone_token_info = (0, __1.deep_clone)(tokenInfo);
+            clone_token_info.market_price = market_price;
+            global_app_config.cache_token_market_price(clone_token_info, ttl)
+                .then(() => {
+                (0, __1.log_info)(`cache new market price success: ${symbol} ${address}, price=${market_price} (${ttl}s), source=${market_source}`);
+            })
+                .catch(err => {
+                (0, __1.log_error)(`cache new market price failed: ${symbol} ${address}, price=${market_price} (${ttl}s)`, err);
+            });
+        }
+        else {
+            (0, __1.log_warn)(`skip cache invalid market_price from ${market_source}`, {
+                symbol,
+                address,
+                market_price,
+                market_source,
+            });
+        }
+    });
+}

package/dist/trade/handle_order_message.d.ts

@@ -2,4 +2,4 @@ import { AbstractTradeAppConfig, AppConfig } from "../app_config";
 import { AbastrcatTrade } from "./abstract_trade";
 import { AbstractTransactionResultCheck } from "./abstract_tx_check";
 export declare const try_lock_order_msg: (appConfig: AppConfig, order_msg: any) => Promise<boolean>;
-export declare const handle_order_message: (trade_appconfig: AbstractTradeAppConfig, trade_instance: AbastrcatTrade, tx_result_checker: AbstractTransactionResultCheck, recv_order_msg: string) => Promise<void>;
+export declare const handle_order_message: (trade_appconfig: AbstractTradeAppConfig, trade_instance: AbastrcatTrade, tx_result_checker_factory: () => AbstractTransactionResultCheck, recv_order_msg: string) => Promise<void>;

package/dist/trade/handle_order_message.js

@@ -56,7 +56,7 @@ const try_lock_order_msg = (appConfig, order_msg) => __awaiter(void 0, void 0, v
     return is_lock_success;
 });
 exports.try_lock_order_msg = try_lock_order_msg;
-const handle_order_message = (trade_appconfig, trade_instance, tx_result_checker, recv_order_msg) => __awaiter(void 0, void 0, void 0, function* () {
+const handle_order_message = (trade_appconfig, trade_instance, tx_result_checker_factory, recv_order_msg) => __awaiter(void 0, void 0, void 0, function* () {
     (0, __1.new_line)(3);
     console.log(`=================================================================================`);
     console.log(`|                              NEW ORDER MESSAGE                                |`);
@@ -94,7 +94,7 @@ const handle_order_message = (trade_appconfig, trade_instance, tx_result_checker
             txid
         };
         global.event_emitter = trade_appconfig;
-        tx_result_checker.set_context(context).set_txid(txid).init_tx_status().check();
+        tx_result_checker_factory().set_context(context).set_txid(txid).init_tx_status().check();
         trade_appconfig.subscribe_wallet_raw_txn_event();
     }
     catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clonegod/ttd-core",
-    "version": "2.0.16",
+    "version": "2.0.18",
     "description": "Common types and utilities for trading systems - use `npm run push` to publish",
     "main": "dist/index.js",
     "types": "types/index.d.ts",