@clonegod/ttd-core 2.0.1

package/dist/test/test_log_level.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xx = xx;
+exports.yy = yy;
+exports.zz = zz;
+const index_1 = require("../index");
+function xx() {
+    (0, index_1.log_debug)('xx run');
+    yy();
+}
+function yy() {
+    (0, index_1.log_info)('yy run');
+    zz();
+}
+function zz() {
+    (0, index_1.log_error)('zz error', new Error(''));
+}
+const main = () => {
+    (0, index_1.new_line)(3);
+    console.log('process.env.LOG_LEVEL=', process.env.LOG_LEVEL);
+    console.log('LOG_LEVEL[process.env.LOG_LEVEL]=', index_1.LOG_LEVEL[process.env.LOG_LEVEL]);
+    console.log('LOG_LEVEL.DEBUG=', index_1.LOG_LEVEL.DEBUG);
+    console.log('_active_log_level', index_1._active_log_level);
+    console.log('log_trace', index_1.LOG.trace);
+    console.log('log_debug', index_1.LOG.debug);
+    console.log('log_info', index_1.LOG.info);
+    console.log('log_warn', index_1.LOG.warn);
+};
+main();

package/dist/test/test_merge_property.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/test_merge_property.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+const main = () => {
+    let default_settings = {
+        slippage: 10,
+        strategy: {
+            fee_exact: 0.0001,
+            fee_max: 0.0005,
+        }
+    };
+    let pair_settings = {
+        slippage: 30,
+        strategy: {
+            fee_exact: 0.0002
+        }
+    };
+    const deepMergedObjSpread = (0, index_1.deep_merge_object)(default_settings, pair_settings);
+    console.log(deepMergedObjSpread);
+};
+main();

package/dist/token/cache_token_config.d.ts

@@ -0,0 +1,2 @@
+import { CHAIN_ID, FormattedTokenInfo } from "../index";
+export declare const cache_token_config: (chain_id: CHAIN_ID, valid_tokens_map: Map<string, FormattedTokenInfo[]>) => Promise<void>;

package/dist/token/cache_token_config.js

@@ -0,0 +1,68 @@
+"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.cache_token_config = void 0;
+const axios_1 = __importDefault(require("axios"));
+const index_1 = require("../index");
+const is_not_arb_token_1 = require("./is_not_arb_token");
+const cache_token_config = (chain_id, valid_tokens_map) => __awaiter(void 0, void 0, void 0, function* () {
+    (0, index_1.log_info)(`cache_token_config start`);
+    let config_token_url = `http://${process.env.CONFIG_CENTER_HOST}/${chain_id}/config/tokens`;
+    let count = 0;
+    let batch_symbols = (0, index_1.chunkArray)(Array.from(valid_tokens_map.keys()), 20);
+    for (let one_batch of batch_symbols) {
+        let valid_tokens = [];
+        for (let key of one_batch) {
+            let value = valid_tokens_map.get(key);
+            if (!value || value.length !== 1) {
+                continue;
+            }
+            let token = value[0];
+            let std_token = {
+                symbol: token.symbol,
+                address: token.address,
+                address_hex: '',
+                decimals: token.decimals,
+                name: token.name,
+                is_token2022: false,
+                market_price: token.price,
+                update_time: (0, index_1.getCurDateTime)(),
+                alias: (0, index_1.get_token_symbol_alias)(token.address),
+                enable: true
+            };
+            if ((0, is_not_arb_token_1.is_not_arb_token)(std_token.symbol)) {
+                continue;
+            }
+            valid_tokens.push(std_token);
+            count += 1;
+        }
+        if (valid_tokens.length === 0) {
+            continue;
+        }
+        const body = valid_tokens;
+        const res = (yield axios_1.default.post(config_token_url, body, {
+            headers: { 'Content-Type': 'application/json' }
+        })).data;
+        (0, index_1.log_trace)('cache_token_config, res', res);
+        yield (0, index_1.sleep)(200);
+    }
+    (0, index_1.log_info)(`cache_token_config finish! sync token count: ${count}`);
+    let notify_config_change_url = `http://${process.env.CONFIG_CENTER_HOST}/${chain_id}/config/change?type=token`;
+    let res = (yield axios_1.default.get(notify_config_change_url)).data;
+    (0, index_1.log_info)('fetch tokens end, notify config change', {
+        notify_config_change_url,
+        res
+    });
+});
+exports.cache_token_config = cache_token_config;

package/dist/token/fixed_symbol_address.d.ts

@@ -0,0 +1,2 @@
+import { TokenFixedSymbolAddress } from './types';
+export declare const fixed_symbol_address: TokenFixedSymbolAddress[];

package/dist/token/fixed_symbol_address.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixed_symbol_address = void 0;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const index_1 = require("../index");
+const get_fixed_symbol_address = () => {
+    let chain_id = process.env.CHAIN_ID;
+    if (!chain_id) {
+        throw new Error(`process.env.CHAIN_ID is null or empty`);
+    }
+    let filepath = process.env.BSC_FIXED_SYMBOL_ADDRESS_FILE || path_1.default.join(os_1.default.homedir(), 'data', 'onchain_data', chain_id.toLowerCase(), 'fixed_symbol_address.json');
+    console.log(`get_fixed_symbol_address: ${filepath}`);
+    let fixed_symbol_address_list = [];
+    try {
+        fixed_symbol_address_list = (0, index_1.readFile)(filepath, true, true);
+    }
+    catch (error) {
+        console.error('get_fixed_symbol_address erro!', error);
+    }
+    return fixed_symbol_address_list;
+};
+exports.fixed_symbol_address = get_fixed_symbol_address();

package/dist/token/index.d.ts

@@ -0,0 +1,6 @@
+export * from './cache_token_config';
+export * from './fixed_symbol_address';
+export * from './is_not_arb_token';
+export * from './price';
+export * from './token_util';
+export * from './types';

package/dist/token/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cache_token_config"), exports);
+__exportStar(require("./fixed_symbol_address"), exports);
+__exportStar(require("./is_not_arb_token"), exports);
+__exportStar(require("./price"), exports);
+__exportStar(require("./token_util"), exports);
+__exportStar(require("./types"), exports);

package/dist/token/is_not_arb_token.d.ts

@@ -0,0 +1 @@
+export declare const is_not_arb_token: (token_or_pool_name: string) => boolean;

package/dist/token/is_not_arb_token.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.is_not_arb_token = void 0;
+const is_not_arb_token = (token_or_pool_name) => {
+    let symbols = token_or_pool_name.toUpperCase().split('/').filter(Boolean);
+    return (symbols.includes('USDC') && symbols.includes('USDT'))
+        || symbols.includes('BUSD')
+        || symbols.includes('TUSD')
+        || symbols.includes('FDUSD')
+        || symbols.includes('LUSD')
+        || symbols.includes('RZUSD')
+        || symbols.includes('USDE')
+        || symbols.includes('AXLUSDC')
+        || symbols.includes('USDS')
+        || symbols.includes('USDG')
+        || symbols.includes('USDY')
+        || symbols.includes('EURC')
+        || symbols.includes('BSOL')
+        || symbols.includes('JITOSOL')
+        || symbols.includes('JUPSOL')
+        || symbols.includes('MSOL')
+        || symbols.includes('SSOL');
+};
+exports.is_not_arb_token = is_not_arb_token;

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

@@ -0,0 +1,2 @@
+import { FormattedTokenPrice } from "../../index";
+export declare function fetchPriceFromGeckoTerminal(network: string, addresses: string[]): Promise<Map<string, FormattedTokenPrice>>;

package/dist/token/price/gecko_terminal.js

@@ -0,0 +1,69 @@
+"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.fetchPriceFromGeckoTerminal = fetchPriceFromGeckoTerminal;
+const axios_1 = __importDefault(require("axios"));
+const index_1 = require("../../index");
+function fetchPriceFromGeckoTerminal(network, addresses) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = new Map();
+        const currentTime = (0, index_1.getCurDateTime)();
+        const timeout = 10000;
+        const maxRetries = 3;
+        const retrysleepMs = 1000;
+        const addressString = addresses.join(',');
+        const url = `https://api.geckoterminal.com/api/v2/simple/networks/${network.toLowerCase()}/token_price/${addressString}`;
+        (0, index_1.log_debug)(`[fetchPriceFromGeckoTerminal] Requesting prices for ${addresses.length} tokens`);
+        let retryCount = 0;
+        while (retryCount <= maxRetries) {
+            try {
+                const response = yield axios_1.default.get(url, { timeout });
+                if (response.data && response.data.data && response.data.data.attributes && response.data.data.attributes.token_prices) {
+                    const tokenPrices = response.data.data.attributes.token_prices;
+                    const foundTokens = Object.keys(tokenPrices);
+                    if (foundTokens.length > 0) {
+                        (0, index_1.log_debug)(`[fetchPriceFromGeckoTerminal] Retrieved prices for ${foundTokens.length}/${addresses.length} tokens`);
+                    }
+                    else {
+                        (0, index_1.log_debug)(`[fetchPriceFromGeckoTerminal] No prices found for any tokens`);
+                    }
+                    for (const address of addresses) {
+                        if (tokenPrices[address]) {
+                            result.set(address, {
+                                symbol: '',
+                                address: address,
+                                price: tokenPrices[address],
+                                update_time: currentTime
+                            });
+                        }
+                    }
+                }
+                else {
+                    (0, index_1.log_debug)(`[fetchPriceFromGeckoTerminal] Invalid response format from GeckoTerminal API`);
+                }
+                break;
+            }
+            catch (error) {
+                retryCount++;
+                (0, index_1.log_warn)(`[fetchPriceFromGeckoTerminal] Request failed (attempt ${retryCount}/${maxRetries}): ${error instanceof Error ? error.message : String(error)}`);
+                if (retryCount <= maxRetries) {
+                    const currentRetrysleep = retrysleepMs * retryCount;
+                    (0, index_1.log_debug)(`[fetchPriceFromGeckoTerminal] Retrying in ${currentRetrysleep}ms...`);
+                    yield (0, index_1.sleep)(currentRetrysleep);
+                }
+            }
+        }
+        return result;
+    });
+}

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

@@ -0,0 +1,2 @@
+import { FormattedTokenPrice } from "../types";
+export declare function get_bsc_token_price_info(addresses: string[]): Promise<Map<string, FormattedTokenPrice>>;

package/dist/token/price/get_bsc_token_price.js

@@ -0,0 +1,131 @@
+"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.get_bsc_token_price_info = get_bsc_token_price_info;
+const axios_1 = __importDefault(require("axios"));
+const index_1 = require("../../index");
+const gecko_terminal_1 = require("./gecko_terminal");
+function get_bsc_token_price_info(addresses) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = new Map();
+        const PRICE_CHANNELS = [
+            {
+                name: 'PancakeSwap',
+                fetchFn: fetchPriceFromPancakeSwap,
+                batchSize: 10,
+                batchDelay: 1000,
+            },
+            {
+                name: 'GeckoTerminal',
+                fetchFn: (address_list) => (0, gecko_terminal_1.fetchPriceFromGeckoTerminal)(index_1.CHAIN_ID.BSC, address_list),
+                batchSize: 10,
+                batchDelay: 2000,
+            },
+        ];
+        try {
+            for (const channel of PRICE_CHANNELS) {
+                if (addresses.length === 0)
+                    break;
+                (0, index_1.log_debug)(`[get_token_price_info] Processing ${addresses.length} tokens using ${channel.name}`);
+                const batches = (0, index_1.chunkArray)(addresses, channel.batchSize);
+                (0, index_1.log_debug)(`[get_token_price_info] Split into ${batches.length} batches of size ${channel.batchSize}`);
+                let remainingAddresses = [...addresses];
+                for (let i = 0; i < batches.length; i++) {
+                    const batch = batches[i];
+                    if (batch.length === 0)
+                        continue;
+                    (0, index_1.log_debug)(`[get_token_price_info] Processing batch ${i + 1}/${batches.length} (${batch.length} tokens) with ${channel.name}`);
+                    try {
+                        const channelResult = yield channel.fetchFn(batch);
+                        for (const [address, priceInfo] of channelResult.entries()) {
+                            result.set(address, priceInfo);
+                            remainingAddresses = remainingAddresses.filter(addr => addr !== address);
+                        }
+                        (0, index_1.log_debug)(`[get_token_price_info] ${channel.name} found prices for ${channelResult.size}/${batch.length} tokens in batch ${i + 1}`);
+                    }
+                    catch (error) {
+                        (0, index_1.log_warn)(`[get_token_price_info] Error processing batch ${i + 1} with ${channel.name}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                    if (i < batches.length - 1) {
+                        yield (0, index_1.sleep)(channel.batchDelay);
+                    }
+                }
+                addresses = [...remainingAddresses];
+                if (addresses.length === 0) {
+                    (0, index_1.log_debug)(`[get_token_price_info] All token prices retrieved using ${channel.name}`);
+                    break;
+                }
+            }
+            if (result.size === 0) {
+                throw new Error(`Unable to get price information for any token: ${addresses.join(', ')}`);
+            }
+            if (addresses.length > 0) {
+                (0, index_1.log_warn)(`[get_token_price_info] Failed to get prices for ${addresses.length} tokens after trying all channels: ${addresses.join(', ')}`);
+            }
+            (0, index_1.log_debug)(`[get_token_price_info] Completed price fetching for ${result.size} tokens`);
+            return result;
+        }
+        catch (error) {
+            throw new Error(`Failed to get token price information: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+}
+function fetchPriceFromPancakeSwap(addresses) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = new Map();
+        const currentTime = (0, index_1.getCurDateTime)();
+        const timeout = 10000;
+        const maxRetries = 2;
+        const retrysleepMs = 500;
+        const addressString = addresses.map(addr => `56:${addr}`).join('%2C');
+        const url = `https://wallet-api.pancakeswap.com/v1/prices/list/${addressString}`;
+        (0, index_1.log_debug)(`[fetchPriceFromPancakeSwap] Requesting PancakeSwap API for ${addresses.length} tokens`);
+        let retryCount = 0;
+        while (retryCount <= maxRetries) {
+            try {
+                const response = yield axios_1.default.get(url, { timeout });
+                if (response.data) {
+                    for (const address of addresses) {
+                        const key = `56:${address}`;
+                        if (response.data[key] !== undefined) {
+                            result.set(address, {
+                                symbol: '',
+                                address: address,
+                                price: response.data[key].toString(),
+                                update_time: currentTime
+                            });
+                        }
+                    }
+                    (0, index_1.log_debug)(`[fetchPriceFromPancakeSwap] Retrieved prices for ${result.size}/${addresses.length} tokens`);
+                }
+                else {
+                    (0, index_1.log_debug)(`[fetchPriceFromPancakeSwap] Invalid response from PancakeSwap for ${addresses.length} tokens`);
+                }
+                break;
+            }
+            catch (error) {
+                retryCount++;
+                (0, index_1.log_warn)(`[fetchPriceFromPancakeSwap] Request failed (attempt ${retryCount}/${maxRetries}): ${error instanceof Error ? error.message : String(error)}`);
+                if (retryCount <= maxRetries) {
+                    const currentRetrysleep = retrysleepMs * retryCount;
+                    (0, index_1.log_debug)(`[fetchPriceFromPancakeSwap] Retrying in ${currentRetrysleep}ms...`);
+                    yield (0, index_1.sleep)(currentRetrysleep);
+                }
+            }
+        }
+        return result;
+    });
+}
+(() => __awaiter(void 0, void 0, void 0, function* () {
+}))();

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

@@ -0,0 +1,2 @@
+import { FormattedTokenPrice } from "../types";
+export declare function get_solana_token_price_info(addresses: string[]): Promise<Map<string, FormattedTokenPrice>>;

package/dist/token/price/get_solana_token_price.js

@@ -0,0 +1,17 @@
+"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.get_solana_token_price_info = get_solana_token_price_info;
+function get_solana_token_price_info(addresses) {
+    return __awaiter(this, void 0, void 0, function* () {
+        throw new Error(`not implement yet!`);
+    });
+}

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

@@ -0,0 +1,2 @@
+import { FormattedTokenPrice } from "../types";
+export declare function get_tron_token_price_info(addresses: string[]): Promise<Map<string, FormattedTokenPrice>>;

package/dist/token/price/get_tron_token_price.js

@@ -0,0 +1,17 @@
+"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.get_tron_token_price_info = get_tron_token_price_info;
+function get_tron_token_price_info(addresses) {
+    return __awaiter(this, void 0, void 0, function* () {
+        throw new Error(`not implement yet!`);
+    });
+}

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

@@ -0,0 +1,3 @@
+export * from './get_bsc_token_price';
+export * from './get_solana_token_price';
+export * from './get_tron_token_price';

package/dist/token/price/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./get_bsc_token_price"), exports);
+__exportStar(require("./get_solana_token_price"), exports);
+__exportStar(require("./get_tron_token_price"), exports);

package/dist/token/token_util.d.ts

@@ -0,0 +1,3 @@
+export declare const formate_token_symbol: (symbol: string) => string;
+export declare const is_valid_symbol: (symbol: string) => boolean;
+export declare function get_token_symbol_alias(token_address: string): string;

package/dist/token/token_util.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.is_valid_symbol = exports.formate_token_symbol = void 0;
+exports.get_token_symbol_alias = get_token_symbol_alias;
+const __1 = require("..");
+const formate_token_symbol = (symbol) => {
+    return symbol.toUpperCase()
+        .replace('$', '')
+        .replace('WSOL', 'SOL')
+        .replace('WBTC', 'BTC')
+        .replace('WETH', 'ETH').replace('WHETH', 'ETH')
+        .replace('WBNB', 'BNB')
+        .trim();
+};
+exports.formate_token_symbol = formate_token_symbol;
+const is_valid_symbol = (symbol) => {
+    return !(0, __1.isEmpty)(symbol) && /^[a-zA-Z0-9_.+-]+$/.test(symbol);
+};
+exports.is_valid_symbol = is_valid_symbol;
+function get_token_symbol_alias(token_address) {
+    let token = __1.fixed_symbol_address.find(e => e.address === token_address);
+    return (token === null || token === void 0 ? void 0 : token.alias) || '';
+}

package/dist/token/types.d.ts

@@ -0,0 +1,29 @@
+export interface PriceChannelConfig {
+    name: string;
+    fetchFn: (addresses: string[]) => Promise<Map<string, FormattedTokenPrice>>;
+    batchSize: number;
+    batchDelay: number;
+}
+export interface TokenFixedSymbolAddress {
+    symbol: string;
+    ref: string;
+    alias: string;
+    address: string;
+}
+export interface FormattedTokenInfo {
+    chainId: number;
+    address: string;
+    programId: string;
+    logoURI: string;
+    symbol: string;
+    name: string;
+    decimals: number;
+    is_token_2022: boolean;
+    price?: string;
+}
+export interface FormattedTokenPrice {
+    symbol: string;
+    address: string;
+    price: string;
+    update_time: string;
+}

package/dist/token/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,47 @@
+{
+    "name": "@clonegod/ttd-core",
+    "version": "2.0.1",
+    "description": "Common types and utilities for trading systems",
+    "main": "dist/index.js",
+    "types": "types/index.d.ts",
+    "keywords": [],
+    "author": "",
+    "license": "ISC",
+    "scripts": {
+        "clean": "rm -rf dist node_modules",
+        "build": "npx tsc --outDir ./dist",
+        "push": "npm run build && npm publish"
+    },
+    "dependencies": {
+        "dotenv": "^16.4.7",
+        "redis": "^4.7.0",
+        "express": "^4.19.2",
+        "express-ws": "^5.0.2",
+        "body-parser": "^1.20.3",
+        "axios": "^1.8.4",
+        "bn.js": "^5.2.1",
+        "bs58": "^6.0.0",
+        "decimal.js": "^10.5.0",
+        "moment": "^2.30.1",
+        "uuid": "^11.1.0",
+        "short-uuid": "^5.2.0",
+        "keccak": "^3.0.4",
+        "@noble/secp256k1": "1.7.1",
+        "typescript": "^5.3.3",
+        "ts-node": "^10.9.2"
+    },
+    "devDependencies": {
+        "@types/bn.js": "~5.1.5",
+        "chai": "^5.0.0",
+        "mocha": "^10.2.0",
+        "rimraf": "^5.0.5",
+        "ts-mocha": "^10.0.0",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.3.3",
+        "@types/node": "^22.7.9"
+    },
+    "overrides": {},
+    "publishConfig": {
+        "access": "public"
+    }
+}