@clonegod/ttd-core 2.0.15 → 2.0.16

package/dist/app_config/AbstractTradeAppConfig.d.ts

@@ -0,0 +1,15 @@
+import { TradeResponseType } from "../../types";
+import { AbastrcatTrade } from "../trade/abstract_trade";
+import { AbstractTransactionResultCheck } from "../trade/abstract_tx_check";
+import { AppConfig } from "./AppConfig";
+export declare abstract class AbstractTradeAppConfig extends AppConfig {
+    is_already_subscribe_wallet_raw_txn: boolean;
+    trade_instance: AbastrcatTrade;
+    tx_result_checker: AbstractTransactionResultCheck;
+    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;
+    cache_trade_result(trade_response: TradeResponseType): Promise<void>;
+}

package/dist/app_config/AbstractTradeAppConfig.js

@@ -0,0 +1,66 @@
+"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.AbstractTradeAppConfig = void 0;
+const __1 = require("..");
+const handle_order_message_1 = require("../trade/handle_order_message");
+const AppConfig_1 = require("./AppConfig");
+class AbstractTradeAppConfig extends AppConfig_1.AppConfig {
+    constructor() {
+        super();
+        this.is_already_subscribe_wallet_raw_txn = false;
+    }
+    init() {
+        const _super = Object.create(null, {
+            init: { get: () => super.init }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.init.call(this);
+            this.arb_cache.listen_trade_result(this);
+        });
+    }
+    init_trade_runtime() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let { chain_id, dex_id, trade_group_id, trade_pair } = this.env_args;
+                this.trade_runtime = yield this.arb_cache.create_trade_runtime(chain_id, trade_group_id, dex_id, trade_pair);
+                this.trade_runtime.wallet_token_accounts = new Map();
+            }
+            catch (err) {
+                (0, __1.log_error)(`create_trade_runtime error!`, err);
+                yield (0, __1.sleep)(1000);
+                process.exit(0);
+            }
+        });
+    }
+    subscribe_order_event(trade_instance, tx_result_checker) {
+        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 group_id = this.trade_runtime.group.id;
+            let pair_name = this.trade_runtime.pair_name;
+            let dex_id = this.trade_runtime.dex_id;
+            yield this.arb_event_subscriber.subscribe_order_event(group_id, pair_name, dex_id, handler);
+            (0, __1.log_info)(`subscribe_order_event, success`, { dex_id, group_id, pair_name });
+        });
+    }
+    cache_trade_result(trade_response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                (0, __1.log_info)(`cache_trade_result`, trade_response);
+                yield this.arb_cache.cache_trade_result(trade_response);
+            }
+            catch (err) {
+                (0, __1.log_error)(`cache_trade_result error!`, err);
+            }
+        });
+    }
+}
+exports.AbstractTradeAppConfig = AbstractTradeAppConfig;

package/dist/app_config/AppConfig.d.ts

@@ -0,0 +1,16 @@
+import EventEmitter from "events";
+import { StandardTokenInfoType, TradeRuntimeType } from "../../types";
+import { ArbCache, ArbEventSubscriber } from "../cache";
+import { EnvArgs } from "./EnvArgs";
+export declare class AppConfig extends EventEmitter {
+    env_args: EnvArgs;
+    app_full_name: string;
+    arb_cache: ArbCache;
+    arb_event_subscriber: ArbEventSubscriber;
+    trade_runtime: TradeRuntimeType;
+    constructor();
+    init(): Promise<void>;
+    subscribe_config_change(): Promise<void>;
+    cache_token_market_price(token_info_with_price: StandardTokenInfoType, ttl?: number): Promise<void>;
+    get_token_market_price(symbol: string): Promise<StandardTokenInfoType>;
+}

package/dist/app_config/AppConfig.js

@@ -0,0 +1,66 @@
+"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.AppConfig = void 0;
+const events_1 = __importDefault(require("events"));
+const __1 = require("..");
+const EnvArgs_1 = require("./EnvArgs");
+class AppConfig extends events_1.default {
+    constructor() {
+        super();
+        this.env_args = new EnvArgs_1.EnvArgs();
+        let { chain_id, app_name, dex_id } = this.env_args;
+        this.app_full_name = `${chain_id}_${dex_id}_${app_name}`;
+        global.app_config = this;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.arb_cache = (0, __1.getArbCache)(this.env_args);
+            yield this.arb_cache.init();
+            let common_service_config = yield this.arb_cache.get_common_service();
+            if ((0, __1.isEmpty)(common_service_config)) {
+                throw new Error(`get_common_service from cache failed! read from cache=${(0, __1.to_json_str)(common_service_config)}`);
+            }
+        });
+    }
+    subscribe_config_change() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.arb_event_subscriber = (0, __1.getArbEventSubscriber)(this.arb_cache);
+            yield this.arb_event_subscriber.pre_load_config_cache();
+            const refresh_trade_runtime = (is_sussess, event) => __awaiter(this, void 0, void 0, function* () {
+                (0, __1.log_info)(`subscribe_config_change_event, callback`, { is_sussess, event });
+                if (event.event_type === __1.REDIS_EVENT_TYPE_CONFIG_CHANGE.GROUP_CONFIG_CHANGE) {
+                    if (!this.trade_runtime) {
+                        (0, __1.log_warn)(`refresh_trade_runtime, skip...`);
+                        return;
+                    }
+                    this.trade_runtime = yield this.arb_cache.create_trade_runtime(this.trade_runtime.chain_id, this.trade_runtime.group.id, this.trade_runtime.dex_id, this.trade_runtime.pair_name);
+                }
+            });
+            yield this.arb_event_subscriber.subscribe_config_change_event(refresh_trade_runtime);
+        });
+    }
+    cache_token_market_price(token_info_with_price_1) {
+        return __awaiter(this, arguments, void 0, function* (token_info_with_price, ttl = -1) {
+            token_info_with_price.update_time = (0, __1.getCurDateTime)();
+            yield this.arb_cache.cache_token_market_price(token_info_with_price, ttl);
+        });
+    }
+    get_token_market_price(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.arb_cache.get_token_market_price(symbol);
+        });
+    }
+}
+exports.AppConfig = AppConfig;

package/dist/app_config/EnvArgs.d.ts

@@ -0,0 +1,27 @@
+import { CHAIN_ID, DEX_ID } from "..";
+export declare class EnvArgs {
+    app_name: string;
+    app_base_dir: string;
+    chain_id: CHAIN_ID;
+    dex_id: DEX_ID;
+    redis_host: string;
+    redis_port: string;
+    config_center_host: string;
+    trade_analyze_url: string;
+    rpc_endpoint: string;
+    ws_endpoint: string;
+    grpc_endpoint: string;
+    grpc_token: string;
+    auto_quote_enable: boolean;
+    auto_quote_interval_mills: number;
+    quote_pair: string;
+    quote_amount_usd: number;
+    quote_pool_address: string;
+    quote_pool_name: string;
+    quote_pool_fee_rate: number;
+    trade_group_id: string;
+    trade_pair: string;
+    token_price_cache_seconds: number;
+    constructor(chain_id?: CHAIN_ID, dex_id?: DEX_ID);
+    print(): void;
+}

package/dist/app_config/EnvArgs.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvArgs = void 0;
+const __1 = require("..");
+class EnvArgs {
+    constructor(chain_id, dex_id) {
+        var _a, _b;
+        this.app_name = process.env.APP_NAME || '';
+        this.app_base_dir = process.env.APP_BASE_DIR || '';
+        this.chain_id = chain_id || ((_a = process.env.CHAIN_ID) === null || _a === void 0 ? void 0 : _a.toUpperCase());
+        if ((0, __1.isEmpty)(this.chain_id)) {
+            throw new Error(`environment: CHAIN_ID is empty!!!`);
+        }
+        this.dex_id = dex_id || ((_b = process.env.DEX_ID) === null || _b === void 0 ? void 0 : _b.toUpperCase());
+        if ((0, __1.isEmpty)(this.dex_id)) {
+        }
+        this.redis_host = process.env.REDIS_HOST || '127.0.0.1';
+        this.redis_port = process.env.REDIS_PORT || '6379';
+        this.config_center_host = process.env.CONFIG_CENTER_HOST || '';
+        this.trade_analyze_url = process.env.TRADE_ANALYZE_URL || '';
+        this.rpc_endpoint = process.env.RPC_ENDPOINT || '';
+        this.ws_endpoint = process.env.WS_ENDPOINT || '';
+        this.grpc_endpoint = process.env.GRPC_ENDPOINT || '';
+        this.grpc_token = process.env.GRPC_TOKEN || '';
+        this.auto_quote_enable = process.env.AUTO_QUOTE_ENABLE === 'true';
+        this.auto_quote_interval_mills = parseInt(process.env.AUTO_QUOTE_INTERVAL_MILLS || '60000');
+        this.quote_pair = process.env.QUOTE_PAIR || '';
+        this.quote_amount_usd = parseInt(process.env.QUOTE_AMOUNT_USD || '100');
+        this.quote_pool_address = process.env.QUOTE_POOL_ADDRESS || '';
+        this.quote_pool_name = process.env.QUOTE_POOL_NAME || '';
+        this.quote_pool_fee_rate = parseInt(process.env.QUOTE_POOL_FEE_RATE || '0');
+        this.trade_group_id = process.env.TRADE_GROUP_ID || '';
+        this.trade_pair = process.env.TRADE_PAIR || '';
+        this.token_price_cache_seconds = parseInt(process.env.TOKEN_PRICE_CACHE_SECONDS || '600');
+    }
+    print() {
+        console.log('>>> EnvArgs', this);
+    }
+}
+exports.EnvArgs = EnvArgs;

package/dist/app_config/index.d.ts

@@ -1,5 +1,5 @@
-import { AppConfig } from './app_config';
-export * from './env_args';
-export * from './app_config';
-export * from './app_trade_config';
+import { AppConfig } from './AppConfig';
+export * from './EnvArgs';
+export * from './AppConfig';
+export * from './AbstractTradeAppConfig';
 export declare const getGlobalAppConfig: () => AppConfig;

package/dist/app_config/index.js

@@ -15,9 +15,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGlobalAppConfig = void 0;
-__exportStar(require("./env_args"), exports);
-__exportStar(require("./app_config"), exports);
-__exportStar(require("./app_trade_config"), exports);
+__exportStar(require("./EnvArgs"), exports);
+__exportStar(require("./AppConfig"), exports);
+__exportStar(require("./AbstractTradeAppConfig"), exports);
 const getGlobalAppConfig = () => {
     let app_config = global.app_config;
     if (!app_config) {

package/dist/trade/handle_order_message.d.ts

@@ -1,6 +1,5 @@
-import { AppConfig } from "../app_config";
-import { TradeAppConfig } from "../app_config/app_trade_config";
+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: TradeAppConfig, 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: AbstractTransactionResultCheck, recv_order_msg: string) => Promise<void>;

package/package.json

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