@clonegod/ttd-core 3.1.26 → 3.1.28

package/dist/app_config/env_registry.js

@@ -45,7 +45,7 @@ registerEnvVars({
     encryption_key: { env: 'ENCRYPTION_KEY', type: 'string', default: '', sensitive: true, desc: '对称加密密钥（用于钱包文件等）' },
     trade_analyze_url: { env: 'TRADE_ANALYZE_URL', type: 'string', default: '', desc: 'analyze HTTP 基址（旧 EnvArgs；未配则 analyze 上报走默认拼接）' },
     providers_file_path: { env: 'PROVIDERS_FILE_PATH', type: 'string', default: '', desc: 'stream-quote providers.json 绝对路径；留空则仅写 Redis' },
-    token_price_refresh_interval_seconds: { env: 'TOKEN_PRICE_REFRESH_INTERVAL_SECONDS', type: 'number', default: 600, desc: 'TokenPriceSyncer 刷价周期(s)：market-data 拉价并推送给 config-center 写 token_list 的频率' },
+    token_price_refresh_interval_seconds: { env: 'TOKEN_PRICE_REFRESH_INTERVAL_SECONDS', type: 'number', default: 600, desc: 'TokenPriceSyncer 刷价周期(s)：market-data 通过 force_fetch 拉外部价（DefiLlama→Gecko→...）并直接批量写入 Redis + 发 TOKEN_CONFIG_CHANGE 事件的频率' },
     token_market_price_url: { env: 'TOKEN_MARKET_PRICE_URL', type: 'string', default: '', desc: '【使用方: ttd-core estimate_token_amount】config-center 市价估算 HTTP 基址；为空则跳过远程回退' },
     fixed_symbol_address_file: { env: 'FIXED_SYMBOL_ADDRESS_FILE', type: 'string', default: '', desc: '固定 symbol/address 映射文件路径（覆盖默认按 CHAIN_ID 推断的路径）' },
     zh_pinyin_map_file: { env: 'ZH_PINYIN_MAP_FILE', type: 'string', default: '', desc: '中文拼音映射文件路径（覆盖默认路径）' },

package/dist/cache/arb_cache.d.ts

@@ -24,6 +24,7 @@ export declare class ArbCache {
     init_configs(): Promise<void>;
     get_config_filepath(suffix: string): string;
     refresh_local_cache_token_list(token_list: StandardTokenInfoType[]): void;
+    getTokenByAddress(address: string): StandardTokenInfoType | undefined;
     refresh_local_cache_pool_list(pool_list: StandardPoolInfoType[]): void;
     refresh_local_cache_group_map(trade_config: TradeServiceConfigType): void;
     cache_token_list(): Promise<void>;
@@ -34,6 +35,32 @@ export declare class ArbCache {
     publish_token_change_event(): Promise<void>;
     cache_pool_list(): Promise<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>;

package/dist/cache/arb_cache.js

@@ -72,6 +72,15 @@ class ArbCache {
             (0, index_1.log_trace)(`init cache start`);
             yield this.cache_token_list();
             yield this.cache_pool_list();
+            const fixed_list = (0, fixed_symbol_address_1.get_fixed_symbol_address)();
+            if (fixed_list.length > 0) {
+                try {
+                    yield this.resolve_duplicate_address(fixed_list.map(f => ({ address: f.address, symbol: f.symbol })));
+                }
+                catch (err) {
+                    (0, index_1.log_warn)(`[init] auto resolve_duplicate_address failed (non-fatal)`, err);
+                }
+            }
             yield this.cache_trade_group();
             (0, index_1.log_trace)(`init cache finish`);
         });
@@ -108,6 +117,20 @@ class ArbCache {
             token_address_map_szie: this.token_address_map.size,
         });
     }
+    getTokenByAddress(address) {
+        var _a;
+        if (!address)
+            return undefined;
+        const exact = this.token_address_map.get(address);
+        if (exact)
+            return exact;
+        const lc = address.toLowerCase();
+        for (const m of this.token_address_map.values()) {
+            if (((_a = m.address) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === lc)
+                return m;
+        }
+        return undefined;
+    }
     refresh_local_cache_pool_list(pool_list) {
         this.pool_list = pool_list;
         this.pool_address_map.clear();
@@ -315,6 +338,85 @@ class ArbCache {
         });
         (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`);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clonegod/ttd-core",
-    "version": "3.1.26",
+    "version": "3.1.28",
     "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

@@ -600,6 +600,12 @@ export declare class ArbCache {
     publish_token_change_event(): Promise<void>;
     cache_pool_list(): Promise<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[]>;