@clonegod/ttd-core 3.1.25 → 3.1.27

package/dist/alert/codes.js

@@ -68,6 +68,7 @@ exports.ALERT_CODES = {
     },
     INFRA_PROCESS_CRASH_LOOP: { code: 'INFRA_PROCESS_CRASH_LOOP', severity: S.CRITICAL, category: 'infra', desc: '进程 5 分钟内反复重启', suggested_action: '停用该进程' },
     INFRA_ENV_MISSING: { code: 'INFRA_ENV_MISSING', severity: S.ERROR, category: 'infra', desc: '关键 env 未配置' },
+    CONFIG_TOKEN_DUPLICATE: { code: 'CONFIG_TOKEN_DUPLICATE', severity: S.WARN, category: 'infra', desc: '同一 address 对应多个 symbol 或 pool 引用缺失 token（配置垃圾数据）', suggested_action: '人工清理 token-list.json / pool-list.json / fixed_symbol_address.json' },
     ANALYZE_UPSTREAM_MISSING: { code: 'ANALYZE_UPSTREAM_MISSING', severity: S.WARN, category: 'analyze', desc: '上游消息缺环节（PreTrade/OnTrade/PostTrade）' },
     ANALYZE_SQLITE_FULL: { code: 'ANALYZE_SQLITE_FULL', severity: S.WARN, category: 'analyze', desc: 'SQLite 接近容量上限' },
     ANALYZE_SQLITE_WRITE_FAIL: { code: 'ANALYZE_SQLITE_WRITE_FAIL', severity: S.ERROR, category: 'analyze', desc: 'SQLite 写失败' },

package/dist/alert/log_rules.js

@@ -46,6 +46,7 @@ registerLogRules([
     { pattern: /pricefeed.*(parse failed|not an array|empty)|empty response at page/i,
         level: 'warn', code: 'THIRDPARTY_DATA_INVALID' },
     { pattern: /price cache miss/i, level: 'warn', code: 'QUOTE_PRICE_CACHE_MISS' },
+    { pattern: /\[token-duplicate\]|\[pool-skip\]/, level: 'warn', code: 'CONFIG_TOKEN_DUPLICATE' },
     { pattern: /sqlite.*(disk|full|i\/o error|cleanup error|write.*fail)/i,
         level: 'error', code: 'ANALYZE_SQLITE_WRITE_FAIL' },
     { pattern: /db size.*\d+mb.*limit/i, level: 'warn', code: 'ANALYZE_SQLITE_FULL' },

package/dist/cache/arb_cache.d.ts

@@ -33,7 +33,34 @@ export declare class ArbCache {
     get_one_token_info_by_symbol(symbol: string): Promise<StandardTokenInfoType>;
     publish_token_change_event(): Promise<void>;
     cache_pool_list(): Promise<void>;
-    set_pool_token_info(pool: StandardPoolInfoType, token_info_list: StandardTokenInfoType[]): void;
+    private scan_duplicate_address;
+    resolve_duplicate_address(authoritative_mappings: Array<{
+        address: string;
+        symbol: string;
+    }>): Promise<{
+        cleaned_tokens: Array<{
+            address: string;
+            dropped_symbols: string[];
+            kept_symbol: string;
+        }>;
+        cleaned_pools: Array<{
+            pool_address: string;
+            pool_name: string;
+            dex_id: string;
+        }>;
+        skipped_trading_pools: Array<{
+            pool_address: string;
+            pool_name: string;
+            dex_id: string;
+            reason: string;
+        }>;
+        not_found: Array<{
+            address: string;
+            symbol: string;
+            reason: string;
+        }>;
+    }>;
+    set_pool_token_info(pool: StandardPoolInfoType, token_info_list: StandardTokenInfoType[]): boolean;
     set_pool_extra(pool: StandardPoolInfoType): void;
     update_pool_list(input_dex_pool_list: StandardDexPoolConfigType[]): Promise<void>;
     get_pool_list_by_pair(pair: string): Promise<StandardPoolInfoType[]>;

package/dist/cache/arb_cache.js

@@ -17,6 +17,7 @@ const core_env_1 = require("../app_config/core_env");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const index_1 = require("../index");
+const fixed_symbol_address_1 = require("../token/fixed_symbol_address");
 class ArbCache {
     constructor(env_args) {
         this.chain_id = env_args.chain_id;
@@ -81,33 +82,23 @@ class ArbCache {
         return path_1.default.join('config', chain_id, file_name);
     }
     refresh_local_cache_token_list(token_list) {
-        const new_by_addr = new Map();
+        const prev_by_symbol = new Map(this.token_symbol_map);
+        this.token_symbol_map.clear();
+        this.token_address_map.clear();
         const merged = [];
         for (const fresh of token_list) {
-            new_by_addr.set(fresh.address, fresh);
-        }
-        const to_delete_addr = [];
-        for (const [addr, existing] of this.token_address_map) {
-            const fresh = new_by_addr.get(addr);
-            if (fresh) {
+            const existing = prev_by_symbol.get(fresh.symbol);
+            let token_ref;
+            if (existing) {
                 Object.assign(existing, fresh);
-                merged.push(existing);
-                new_by_addr.delete(addr);
+                token_ref = existing;
             }
             else {
-                to_delete_addr.push(addr);
+                token_ref = fresh;
             }
-        }
-        for (const addr of to_delete_addr) {
-            this.token_address_map.delete(addr);
-        }
-        for (const fresh of new_by_addr.values()) {
-            this.token_address_map.set(fresh.address, fresh);
-            merged.push(fresh);
-        }
-        this.token_symbol_map.clear();
-        for (const token of merged) {
-            this.token_symbol_map.set(token.symbol, token);
+            this.token_symbol_map.set(token_ref.symbol, token_ref);
+            this.token_address_map.set(token_ref.address, token_ref);
+            merged.push(token_ref);
         }
         this.token_list = merged;
         this.token_list_cache_last_update_time = (0, index_1.getCurDateTime)();
@@ -156,6 +147,7 @@ class ArbCache {
             }
             let config = (0, index_1.readFile)(filepath);
             let token_list = config.token_list.filter(e => e.enable);
+            this.scan_duplicate_address(token_list);
             for (let token of token_list) {
                 let field = token.symbol;
                 let value = JSON.stringify(token);
@@ -254,12 +246,22 @@ class ArbCache {
             let all_dex_pool = [];
             let config = (0, index_1.readFile)(filepath);
             let token_list = yield this.get_token_list();
+            const skipped = [];
             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 });
+                const valid_pools = [];
                 for (let pool of pool_list) {
                     pool.dex_id = dex_id;
-                    this.set_pool_token_info(pool, token_list);
+                    if (!this.set_pool_token_info(pool, token_list)) {
+                        const [t0, t1] = pool.pool_name.split('/');
+                        const missing = [
+                            !pool.tokenA ? t0 : null,
+                            !pool.tokenB ? t1 : null,
+                        ].filter(Boolean).join(',');
+                        skipped.push({ pool_address: pool.pool_address, pool_name: pool.pool_name, dex_id, missing });
+                        continue;
+                    }
                     this.set_pool_extra(pool);
                     let field = pool.pool_address;
                     let value = JSON.stringify(pool);
@@ -267,14 +269,131 @@ class ArbCache {
                     if (index_1.LOG.debug) {
                         (0, index_1.log_trace)(`cache_pool_list, pool_address=${pool.pool_address}, result: ` + JSON.stringify(result));
                     }
+                    valid_pools.push(pool);
                 }
-                all_dex_pool.push(...pool_list);
+                all_dex_pool.push(...valid_pools);
+            }
+            if (skipped.length > 0) {
+                const lines = skipped.map((s, i) => `  ${i + 1}. [${s.dex_id}] ${s.pool_name} (pool=${s.pool_address}) — missing symbol(s): ${s.missing}`);
+                (0, index_1.log_warn)(`[pool-skip] 跳过 ${skipped.length} 个池子：token 在 token-list 中找不到（多 symbol 冲突 / symbol 已删等），请人工清理 pool-list.json 或相关 token 映射:\n${lines.join('\n')}`);
             }
             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);
         });
     }
+    scan_duplicate_address(token_list) {
+        var _a;
+        const by_addr = new Map();
+        for (const t of token_list) {
+            const addr = (t.address || '').toLowerCase();
+            if (!addr)
+                continue;
+            if (!by_addr.has(addr))
+                by_addr.set(addr, []);
+            by_addr.get(addr).push(t);
+        }
+        const fixed_by_addr = new Map();
+        for (const f of (0, fixed_symbol_address_1.get_fixed_symbol_address)()) {
+            fixed_by_addr.set((f.address || '').toLowerCase(), f.symbol);
+        }
+        const conflicts = [];
+        for (const [addr, tokens] of by_addr) {
+            if (tokens.length <= 1)
+                continue;
+            conflicts.push({
+                address: addr,
+                symbols: tokens.map(t => t.symbol),
+                fixed_symbol: (_a = fixed_by_addr.get(addr)) !== null && _a !== void 0 ? _a : null,
+            });
+        }
+        if (conflicts.length === 0)
+            return;
+        const lines = conflicts.map((c, i) => {
+            const auth = c.fixed_symbol ? ` 权威 symbol=${c.fixed_symbol}` : ' 未在 fixed_symbol_address.json 登记（需先登记权威 symbol）';
+            return `  ${i + 1}. address=${c.address}  symbols=[${c.symbols.join(', ')}]${auth}`;
+        });
+        (0, index_1.log_warn)(`[token-duplicate] 发现 ${conflicts.length} 个 address 被多 symbol 引用（垃圾数据，需人工清理 token-list.json + pool-list.json + Redis）:\n${lines.join('\n')}`);
+    }
+    resolve_duplicate_address(authoritative_mappings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token_list = yield this.get_token_list();
+            const by_addr = new Map();
+            for (const t of token_list) {
+                const addr = (t.address || '').toLowerCase();
+                if (!addr)
+                    continue;
+                if (!by_addr.has(addr))
+                    by_addr.set(addr, []);
+                by_addr.get(addr).push(t);
+            }
+            const tokens_to_disable = [];
+            const cleaned_tokens = [];
+            const not_found = [];
+            for (const { address, symbol } of authoritative_mappings) {
+                const addr = (address || '').toLowerCase();
+                const tokens = by_addr.get(addr) || [];
+                if (tokens.length === 0) {
+                    not_found.push({ address: addr, symbol, reason: `address 在 token-list 中未找到` });
+                    continue;
+                }
+                const canonical = tokens.find(t => t.symbol === symbol);
+                if (!canonical) {
+                    not_found.push({ address: addr, symbol, reason: `symbol=${symbol} 在 address ${addr} 的条目中未找到（token-list 里 symbols=[${tokens.map(t => t.symbol).join(',')}]）` });
+                    continue;
+                }
+                const dropped = tokens.filter(t => t.symbol !== symbol);
+                if (dropped.length === 0)
+                    continue;
+                for (const t of dropped) {
+                    tokens_to_disable.push(Object.assign(Object.assign({}, t), { enable: false }));
+                }
+                cleaned_tokens.push({
+                    address: addr,
+                    dropped_symbols: dropped.map(t => t.symbol),
+                    kept_symbol: symbol,
+                });
+            }
+            const dropped_symbols = new Set(tokens_to_disable.map(t => t.symbol));
+            const cleaned_pools = [];
+            const skipped_trading_pools = [];
+            if (dropped_symbols.size > 0) {
+                const pool_list = yield this.get_pool_list();
+                const trade_pool_set = new Set((yield this.get_all_trade_pools()).map(p => p.pool_address));
+                const pools_to_disable_by_dex = new Map();
+                for (const p of pool_list) {
+                    const [t0, t1] = (p.pool_name || '').split('/');
+                    if (!dropped_symbols.has(t0) && !dropped_symbols.has(t1))
+                        continue;
+                    if (trade_pool_set.has(p.pool_address)) {
+                        skipped_trading_pools.push({
+                            pool_address: p.pool_address,
+                            pool_name: p.pool_name,
+                            dex_id: p.dex_id,
+                            reason: 'pool in trading config (protected)',
+                        });
+                        continue;
+                    }
+                    if (!pools_to_disable_by_dex.has(p.dex_id))
+                        pools_to_disable_by_dex.set(p.dex_id, []);
+                    pools_to_disable_by_dex.get(p.dex_id).push(Object.assign(Object.assign({}, p), { enable: false }));
+                    cleaned_pools.push({ pool_address: p.pool_address, pool_name: p.pool_name, dex_id: p.dex_id });
+                }
+                if (pools_to_disable_by_dex.size > 0) {
+                    const dex_pool_list = [];
+                    for (const [dex_id, pools] of pools_to_disable_by_dex) {
+                        dex_pool_list.push({ dex_id: dex_id, pool_list: pools });
+                    }
+                    yield this.update_pool_list(dex_pool_list);
+                }
+            }
+            if (tokens_to_disable.length > 0) {
+                yield this.update_token_list(tokens_to_disable);
+            }
+            (0, index_1.log_warn)(`[resolve-duplicate] 完成: disabled ${tokens_to_disable.length} 个 symbol, 删 ${cleaned_pools.length} 个 pool, 跳过交易中 pool ${skipped_trading_pools.length} 个, 映射 not_found ${not_found.length} 个`);
+            return { cleaned_tokens, cleaned_pools, skipped_trading_pools, not_found };
+        });
+    }
     set_pool_token_info(pool, token_info_list) {
         if (index_1.LOG.debug) {
             (0, index_1.log_trace)(`set_pool_token_info`);
@@ -282,13 +401,7 @@ class ArbCache {
         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!`);
-        }
+        return !!(pool.tokenA && pool.tokenB);
     }
     set_pool_extra(pool) {
         if (index_1.LOG.debug) {

package/package.json

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

package/types/index.d.ts

@@ -599,7 +599,13 @@ export declare class ArbCache {
     get_one_token_info_by_symbol(symbol: string): Promise<StandardTokenInfoType>;
     publish_token_change_event(): Promise<void>;
     cache_pool_list(): Promise<void>;
-    set_pool_token_info(pool: StandardPoolInfoType, token_info_list: StandardTokenInfoType[]): void;
+    set_pool_token_info(pool: StandardPoolInfoType, token_info_list: StandardTokenInfoType[]): boolean;
+    resolve_duplicate_address(authoritative_mappings: Array<{ address: string; symbol: string }>): Promise<{
+        cleaned_tokens: Array<{ address: string; dropped_symbols: string[]; kept_symbol: string }>;
+        cleaned_pools: Array<{ pool_address: string; pool_name: string; dex_id: string }>;
+        skipped_trading_pools: Array<{ pool_address: string; pool_name: string; dex_id: string; reason: string }>;
+        not_found: Array<{ address: string; symbol: string; reason: string }>;
+    }>;
     set_pool_extra(pool: StandardPoolInfoType): void;
     update_pool_list(input_dex_pool_list: StandardDexPoolConfigType[]): Promise<void>;
     get_pool_list_by_pair(pair: string): Promise<StandardPoolInfoType[]>;