@clonegod/ttd-core 2.0.1

package/dist/cache/redis_client.js

@@ -0,0 +1,73 @@
+"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.getCache = getCache;
+const moment_1 = __importDefault(require("moment"));
+const redis_1 = require("redis");
+let redisClient;
+let isReady;
+let ip = process.env.REDIS_HOST || '127.0.0.1';
+let port = process.env.REDIS_PORT || '6379';
+let url = `redis://${ip}:${port}`;
+const cacheOptions = {
+    url
+};
+let current_time = () => (0, moment_1.default)().format('YYYY-MM-DD HH:mm:ss SSS');
+console.log('\n\n');
+console.log(current_time(), `-------> Init redis start`);
+console.log(current_time(), `Connect to redis, url=${url}`);
+var first_call = true;
+let wait_redis_ready = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (module_name = '') {
+    for (let i = 1; i <= 10; i++) {
+        try {
+            if (!redisClient) {
+                console.log(current_time(), module_name, `[${i}] redis not ready`);
+                yield new Promise((r) => setTimeout(r, 1000));
+                continue;
+            }
+            console.log(current_time(), module_name, `[${i}] ping...`);
+            let res = yield redisClient.ping();
+            console.log(current_time(), module_name, `[${i}] ping, got: ${res}`);
+            break;
+        }
+        catch (err) {
+            console.error(current_time(), module_name, `[${i}] ping, got error!`, err);
+        }
+    }
+});
+function getCache() {
+    return __awaiter(this, arguments, void 0, function* (module_name = '') {
+        if (!first_call) {
+            yield wait_redis_ready(module_name);
+        }
+        first_call = false;
+        if (!isReady) {
+            redisClient = (0, redis_1.createClient)(Object.assign({}, cacheOptions));
+            redisClient.on('error', err => console.error(`Redis Error: ${err}`));
+            redisClient.on('connect', () => console.info('Redis connected'));
+            redisClient.on('reconnecting', () => console.info('Redis reconnecting'));
+            redisClient.on('ready', () => {
+                isReady = true;
+                console.info('Redis ready!');
+            });
+            yield redisClient.connect();
+        }
+        return redisClient;
+    });
+}
+getCache().then(connection => {
+    redisClient = connection;
+}).catch(err => {
+    console.error({ err }, 'Failed to connect to Redis');
+});

package/dist/cache/redis_cmd.d.ts

@@ -0,0 +1,14 @@
+import { RedisClientType } from "redis";
+export declare class RedisCommand {
+    redis_client: RedisClientType;
+    constructor();
+    init(): Promise<void>;
+    exists(key: string): Promise<number>;
+    ttl(key: string): Promise<number>;
+    expire(key: string, ttl: number): Promise<boolean>;
+    del(key: string): Promise<number>;
+    set_nx(key: string, value: string): Promise<boolean>;
+    hinc(key: string, field: string, ttl?: number): Promise<number[]>;
+    subscribe(channel: string, listener: any): Promise<void>;
+    publish(channel: string, message: string): Promise<void>;
+}

package/dist/cache/redis_cmd.js

@@ -0,0 +1,83 @@
+"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.RedisCommand = void 0;
+const index_1 = require("../index");
+const redis_client_1 = require("./redis_client");
+class RedisCommand {
+    constructor() {
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, index_1.log_info)('init redis client start');
+            yield (0, index_1.sleep)(1000);
+            this.redis_client = yield (0, redis_client_1.getCache)('RedisCommand');
+            (0, index_1.log_info)('init redis client done');
+        });
+    }
+    exists(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.redis_client.exists(key);
+        });
+    }
+    ttl(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.redis_client.ttl(key);
+        });
+    }
+    expire(key, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.redis_client.expire(key, ttl);
+        });
+    }
+    del(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.redis_client.del(key);
+        });
+    }
+    set_nx(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.redis_client.setNX(key, value);
+        });
+    }
+    hinc(key_1, field_1) {
+        return __awaiter(this, arguments, void 0, function* (key, field, ttl = 3600) {
+            let res = [];
+            let res1 = yield this.redis_client.hIncrBy(key, field, 1);
+            res.push(res1);
+            if (ttl > 0) {
+                let res2 = yield this.redis_client.hExpire(key, field, ttl);
+                res.push(res2);
+            }
+            return res;
+        });
+    }
+    subscribe(channel, listener) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let subscriber = this.redis_client.duplicate();
+            subscriber.on('error', (err) => __awaiter(this, void 0, void 0, function* () {
+                let mills = 3000;
+                (0, index_1.log_error)(`subscribe channel error! channel: ${channel}`, err);
+                (0, index_1.log_info)(`wait ${mills} ms, re-subscribe channel: ${channel}`);
+                yield (0, index_1.sleep)(mills);
+                this.subscribe(channel, listener);
+            }));
+            yield subscriber.connect();
+            subscriber.subscribe(channel, listener);
+        });
+    }
+    publish(channel, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.redis_client.publish(channel, message);
+        });
+    }
+}
+exports.RedisCommand = RedisCommand;

package/dist/index.d.ts

@@ -0,0 +1,216 @@
+import BN from 'bn.js';
+import Decimal from 'decimal.js';
+import fs from "fs";
+import { ArbCache, StandardPoolInfoType, StandardTokenInfoType, TokenPriceWithAmountType, TradeCommandLineArgs, TradeResponseType, UniqueOrderbookIdType } from '../types';
+import * as cache from './cache';
+export * from './analyze';
+export * from './app_config';
+export * from './pool';
+export * from './quote';
+export * from './token';
+export declare const FAILED = "FAILED";
+export declare const SUCCESS = "SUCCESS";
+export declare const NOT_FOUND = "NOT_FOUND";
+export declare const PROCESSING = "PROCESSING";
+export declare const REGEX_HEX_PREFIX: RegExp;
+export declare const QUOTE_AMOUNT_USD_MIN = 50;
+export declare const QUOTE_AMOUNT_USD_MAX = 500;
+export declare const TRANSACTION_STATE_PROCESSING = "TRANSACTION_STATE_PROCESSING";
+export declare const TRANSACTION_STATE_SUCCESS = "TRANSACTION_STATE_SUCCESS";
+export declare const TRANSACTION_STATE_FAILED = "TRANSACTION_STATE_FAILED";
+export declare const STREAMING_TRANSACTION_CONFIRMED = "STREAMING_TRANSACTION_CONFIRMED";
+export declare enum CHAIN_ID {
+    TRON = "TRON",
+    SOLANA = "SOLANA",
+    BSC = "BSC"
+}
+export declare enum DEX_ID {
+    SUNSWAP_V2 = "SUNSWAP-V2",
+    SUNSWAP_V3 = "SUNSWAP-V3",
+    RAYDIUM_AMM = "RAYDIUM-AMM",
+    RAYDIUM_CLMM = "RAYDIUM-CLMM",
+    RAYDIUM_CPMM = "RAYDIUM-CPMM",
+    ORCA_CLMM = "ORCA-CLMM",
+    METEORA_DLMM = "METEORA-DLMM",
+    PUMPFUN_AMM = "PUMPFUN-AMM",
+    PANCAKE_AMM = "PANCAKE-AMM",
+    PANCAKE_CLMM = "PANCAKE-CLMM"
+}
+export declare enum GROUP_ID {
+    TRON_DEV1 = "TRON-DEV1",
+    TRON_TEST1 = "TRON-TEST1",
+    TRON_TEST2 = "TRON-TEST2",
+    TRON_TTD1 = "TRON-TTD1"
+}
+export declare enum TRADE_TYPE {
+    SWAP = "swap",
+    ORDERBOOK = "orderbook"
+}
+export declare enum SystemErrorCodeType {
+    INVALID_GROUP_ID = "INVALID_GROUP_ID",
+    SYSTEM_ERROR = "SYSTEM_ERROR",
+    UNKOWN_ERROR = "UNKOWN_ERROR"
+}
+export declare enum TradeErrorCodeType {
+    AmountOutBelowMinimum = "AmountOutBelowMinimum",
+    InsufficientFunds = "InsufficientFunds",
+    ExceededCUsLimit = "ExceededCUsLimit",
+    BlockhashNotFound = "BlockhashNotFound",
+    AccountNotInitialized = "AccountNotInitialized",
+    InvalidTickArraySequence = "InvalidTickArraySequence",
+    TokenNotApproved = "TokenNotApproved",
+    UNKOWN = "UNKOWN"
+}
+export declare enum OnChainDataSubscribeType {
+    WS = "ws",
+    GRPC = "grpc"
+}
+export declare enum CACHE_KEY_TYPE {
+    MARKET_TOKEN_PRICE = "m:price",
+    CONFIG_TOKEN_LIST = "c:token",
+    CONFIG_POOL_LIST = "c:pool",
+    CONFIG_PAIR_LIST = "c:pair",
+    CONFIG_COMMON_SERVICE = "c:common",
+    CONFIG_TRADE_SERVICE = "c:trade",
+    QUOTE_PRICE = "q:price",
+    ORDER_MESSAGE = "o:msg",
+    ORDER_RESULT = "o:result"
+}
+export declare const format_symbol_name: (symbol: string) => string;
+export declare const format_unique_orderbook_id: (chain_id: CHAIN_ID, dex_id: DEX_ID, pool_id: string, fee_rate: number) => string;
+export declare const parse_unique_orderbook_id: (unique_orderbook_id: string) => UniqueOrderbookIdType;
+export declare const format_unique_order_msg_id: (group_id: string, price_id: string, order_trace_id: string) => string;
+export declare const format_order_lock_key: (chain_id: string, group_id: string, price_id: string, order_trace_id: string) => string;
+export declare const getRedisCache: () => Promise<import("redis").RedisClientType>;
+export declare const getLoadingCache: () => cache.LoadingCache;
+export declare const getRedisCommamd: () => cache.RedisCommand;
+export declare const getArbCache: (env_args: any) => cache.ArbCache;
+export declare const getArbEventPublisher: (arb_cache: any) => cache.ArbEventPublisher;
+export declare const getArbEventSubscriber: (arb_cache: any) => cache.ArbEventSubscriber;
+export declare const get_cache_key: (chain_id: CHAIN_ID, cache_type: string, id: string) => string;
+export declare const get_config_channel_name: (chain_id: CHAIN_ID) => string;
+export declare const get_quote_channel_name: (chain_id: string) => string;
+export declare const get_order_channel_name: (group_id: string, pair: string, dex_id: DEX_ID) => string;
+export declare const get_wallet_raw_tx_channel_name: (group_id: string, wallet: string) => string;
+export declare const get_tx_result_channel_name: (group_id: string, pair: string) => string;
+export declare enum REDIS_EVENT_CHANNEL {
+    CONFIG_CHANGE = "CONFIG_CHANGE",
+    QUOTE = "QUOTE",
+    ORDER = "ORDER",
+    ORDER_RESULT = "ORDER_RESULT",
+    TX_RAW_DATA = "TX_RAW_DATA",
+    TX_RESULT = "TX_RESULT",
+    TRADE_INSTANCE_STATUS = "TRADE_INSTANCE_STATUS"
+}
+export declare enum REDIS_EVENT_TYPE_CONFIG_CHANGE {
+    TOKEN_CONFIG_CHANGE = "TOKEN_CONFIG_CHANGE",
+    POOL_CONFIG_CHANGE = "POOL_CONFIG_CHANGE",
+    GROUP_CONFIG_CHANGE = "GROUP_CONFIG_CHANGE"
+}
+export declare enum REDIS_EVENT_TYPE_QUOTE {
+    NEW_QUOTE_PRICE = "NEW_QUOTE_PRICE"
+}
+export declare enum REDIS_EVENT_TYPE_ORDER {
+    NEW_ORDER = "NEW_ORDER",
+    ORDER_PROCESSING = "ORDER_PROCESSING",
+    ORDER_SUCCESS = "ORDER_SUCCESS",
+    ORDER_FAILED = "ORDER_FAILED",
+    ORDER_NOT_FOUND = "ORDER_NOT_FOUND"
+}
+export declare enum REDIS_EVENT_TYPE_TRADE_INSTANCE_CHANGE {
+    TRADE_INSTANCE_STARTUP = "TRADE_INSTANCE_STARTUP",
+    TRADE_INSTANCE_EXIT = "TRADE_INSTANCE_EXIT"
+}
+export declare function _caller(): {
+    method: string;
+    module: string;
+};
+export declare enum LOG_LEVEL {
+    TRACE = 1,
+    DEBUG = 2,
+    INFO = 3,
+    WARN = 4,
+    ERROR = 5
+}
+export declare const _active_log_level: number;
+export declare abstract class LOG {
+    static trace: boolean;
+    static debug: boolean;
+    static info: boolean;
+    static warn: boolean;
+}
+export declare function log_trace(msg: string, data?: {}, traceId?: string): void;
+export declare function log_debug(msg: string, data?: {}, traceId?: string): void;
+export declare function log_warn(msg: string, data?: {}, traceId?: string): void;
+export declare function log_info(msg: string, data?: {}, traceId?: string, caller?: {
+    module: string;
+}, level?: LOG_LEVEL): void;
+export declare function log_error(msg: string, err: Error, traceId?: string, caller?: {
+    module: string;
+}): void;
+export declare function new_line(lines?: number): void;
+export declare const generateRandomNumber: (min: number, max: number) => number;
+export declare class DecimalUtil {
+    static adjustDecimals(input: Decimal, shift?: number): Decimal;
+    static fromBN(input: BN, shift?: number): Decimal;
+    static fromNumber(input: number, shift?: number): Decimal;
+    static toBN(input: Decimal, shift?: number): BN;
+    static number_div(number1: number, number2: number, decimals?: number): number;
+}
+export declare const to_json_str: (value: object, space?: number) => string;
+export declare const DATE_TIME_FORMAT_DEFAULT = "YYYY-MM-DD HH:mm:ss SSS";
+export declare const DATE_TIME_FORMAT_NO_WHITESPACE = "YYYY_MM_DD_HH_mm_ss";
+export declare function getCurDateTime(format?: string): string;
+export declare function getCurTimeShort(): string;
+export declare function parseToDateTime(milliseconds: number, format?: string): string;
+export declare function getCurTimeInMills(): number;
+export declare function curr_milliseconds(): number;
+export declare function sleep(mills: any): Promise<void>;
+export declare function parseDateTimeStrToMills(date_time_str: string, format?: string): number;
+export declare const uuid: () => any;
+export declare const deep_clone: (obj: object) => any;
+export declare function isEmpty(v: any): boolean;
+export declare const isTrue: (value: string | undefined) => boolean;
+export declare const isArray: (arg: any) => arg is any[];
+export declare const deep_merge_object: (default_obj: object, new_obj: object) => any;
+export declare const postJSON: (url: any, data: any) => Promise<unknown>;
+export declare const home_dir: () => string;
+export declare function file_exists(filepath: string): boolean;
+export declare function readFile(filename: string, to_json_object?: boolean, print_content?: boolean): any;
+export declare function writeFile(filename: string, data: string): void;
+export declare function mkdirSync(path: fs.PathLike, recursive?: boolean): void;
+export declare function getServerInfo(): {
+    region: string;
+    ip: string;
+    name: string;
+};
+export declare function getIPAddress(): string;
+export declare function load_wallet(group_id: string, only_pubkey?: boolean): {
+    public_key: string;
+    private_key: string;
+};
+export declare const success: (data: any) => {
+    code: number;
+    msg: string;
+    data: any;
+};
+export declare const failed: (err: Error, error_code?: string, code?: number) => {
+    code: number;
+    msg: string;
+    error_code: string;
+};
+export declare const estimate_amount_in_token: (arb_cache: ArbCache, token: StandardTokenInfoType, amount_in_usd: number, query_token_market_price_url?: string) => Promise<string>;
+export declare const calc_amount_in_token: (amount_in_usd: number, market_price: string, token_info: StandardTokenInfoType) => TokenPriceWithAmountType;
+export declare const get_input_out_token: (poolInfo: StandardPoolInfoType, aToB: boolean) => {
+    inputToken: StandardTokenInfoType;
+    outputToken: StandardTokenInfoType;
+};
+export declare const get_input_out_token_fix: (poolInfo: StandardPoolInfoType, aToB: boolean) => {
+    inputToken: StandardTokenInfoType;
+    outputToken: StandardTokenInfoType;
+};
+export declare const parse_trade_cmdline_args: () => TradeCommandLineArgs;
+export declare const save_trade_execution_logs: (trade_response: TradeResponseType) => Promise<void>;
+export declare const inspect_arb_local_cache: (express: any, appConfig: any) => void;
+export declare const execute_bash: (command: string, parse_json?: boolean) => Promise<any>;
+export declare function chunkArray<T>(arr: T[], chunkSize: number): T[][];