@clonegod/ttd-bsc-common 1.0.0

package/dist/quote/event/pool_event_listener.js

@@ -0,0 +1,231 @@
+"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.PoolEventListener = void 0;
+const ethers_1 = require("ethers");
+const dist_1 = require("@clonegod/ttd-core/dist");
+const constants_1 = require("../../common/constants");
+class PoolEventListener {
+    constructor(appConfig, wsProvider) {
+        this.poolList = [];
+        this.isConnected = false;
+        this.isStarted = false;
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 10;
+        this.baseReconnectDelay = 1000;
+        this.maxReconnectDelay = 30000;
+        this.heartbeatInterval = null;
+        this.connectionTimeout = null;
+        this.connectionTimeoutMs = 15000;
+        this.lastProcessedBlockNumber = 0;
+        this.isBlockListenerActive = false;
+        this.appConfig = appConfig;
+        this.wsProvider = wsProvider;
+    }
+    init(poolList) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.poolList = poolList.filter(pool => ethers_1.ethers.utils.isAddress(pool.pool_address));
+            if (this.poolList.length !== poolList.length) {
+                (0, dist_1.log_warn)(`发现 ${poolList.length - this.poolList.length} 个无效池地址，已过滤`, '');
+            }
+            yield this.initProvider();
+        });
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, dist_1.log_info)(`开始启动区块监听...`);
+            if (!this.isConnected) {
+                (0, dist_1.log_warn)('WebSocket 尚未连接，无法启动监听', '');
+                return;
+            }
+            this.startBlockListener();
+            this.isStarted = true;
+            (0, dist_1.log_info)('区块监听已成功启动');
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, dist_1.log_info)(`停止区块监听...`);
+            this.stopBlockListener();
+            this.cleanupProvider();
+            this.isStarted = false;
+            (0, dist_1.log_info)(`区块监听已停止`);
+        });
+    }
+    initProvider() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                (0, dist_1.log_info)(`正在连接WebSocket: ${this.appConfig.env_args.ws_endpoint}`);
+                yield this.wsProvider.ready;
+                this.setConnectionTimeout();
+                this.clearConnectionTimeout();
+                this.isConnected = true;
+                this.reconnectAttempts = 0;
+                (0, dist_1.log_info)(`WebSocket Provider 已连接`);
+                this.wsProvider.on('error', (err) => {
+                    (0, dist_1.log_error)(`WebSocket Provider 错误:`, err, '');
+                    this.handleConnectionIssue();
+                });
+                this.wsProvider._websocket.on('close', (code) => __awaiter(this, void 0, void 0, function* () {
+                    (0, dist_1.log_warn)(`WebSocket 连接关闭, 代码: ${code}. 尝试重新连接...`, '');
+                    this.handleConnectionIssue();
+                }));
+                this.startHeartbeat();
+            }
+            catch (error) {
+                (0, dist_1.log_error)('初始化 WebSocket 提供者失败:', error, '');
+                this.clearConnectionTimeout();
+                this.handleConnectionIssue();
+            }
+        });
+    }
+    setConnectionTimeout() {
+        this.clearConnectionTimeout();
+        this.connectionTimeout = setTimeout(() => {
+            (0, dist_1.log_error)(`WebSocket 连接超时`, new Error('Connection timeout'), '');
+            this.handleConnectionIssue();
+        }, this.connectionTimeoutMs);
+    }
+    clearConnectionTimeout() {
+        if (this.connectionTimeout) {
+            clearTimeout(this.connectionTimeout);
+            this.connectionTimeout = null;
+        }
+    }
+    handleConnectionIssue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnected)
+                return;
+            this.isConnected = false;
+            this.stopHeartbeat();
+            const delay = Math.min(this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts), this.maxReconnectDelay);
+            this.reconnectAttempts++;
+            (0, dist_1.log_warn)(`WebSocket 断开连接. 重连尝试 ${this.reconnectAttempts}/${this.maxReconnectAttempts}, 延迟 ${delay}ms`, '');
+            if (this.reconnectAttempts > this.maxReconnectAttempts) {
+                (0, dist_1.log_error)(`超过最大重连尝试次数 (${this.maxReconnectAttempts})，停止重连`, new Error('Max reconnect attempts exceeded'), '');
+                return;
+            }
+            yield (0, dist_1.sleep)(delay);
+            try {
+                yield this.initProvider();
+                if (this.isStarted) {
+                    (0, dist_1.log_info)('重连成功，正在重新启动区块监听...');
+                    yield this.start();
+                }
+            }
+            catch (err) {
+                (0, dist_1.log_error)('重新连接失败:', err, '');
+            }
+        });
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.wsProvider)
+                    return;
+                const blockNumber = yield this.wsProvider.getBlockNumber();
+                (0, dist_1.log_debug)(`心跳检测成功，当前区块: ${blockNumber}`);
+            }
+            catch (error) {
+                (0, dist_1.log_warn)(`心跳检测失败，正在重连...`);
+                this.handleConnectionIssue();
+            }
+        }), 15000);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+    cleanupProvider() {
+        this.stopHeartbeat();
+        this.clearConnectionTimeout();
+        this.stopBlockListener();
+        if (this.wsProvider) {
+            try {
+                this.wsProvider.removeAllListeners();
+                if (this.wsProvider._websocket) {
+                    this.wsProvider._websocket.removeAllListeners();
+                    if (this.wsProvider._websocket.readyState === 1) {
+                        this.wsProvider._websocket.close(1000, "Normal closure");
+                    }
+                }
+            }
+            catch (error) {
+                (0, dist_1.log_error)(`清理 Provider 资源时出错:`, error, '');
+            }
+            this.wsProvider = undefined;
+        }
+    }
+    startBlockListener() {
+        (0, dist_1.log_info)(`开始启动区块监听...`);
+        this.stopBlockListener();
+        if (!this.isConnected || !this.wsProvider) {
+            (0, dist_1.log_warn)(`无法启动区块监听: WebSocket未连接`);
+            return;
+        }
+        this.wsProvider.getBlockNumber()
+            .then(blockNumber => {
+            this.lastProcessedBlockNumber = blockNumber;
+            (0, dist_1.log_info)(`初始化区块监听，当前区块: ${blockNumber}`);
+        })
+            .catch(error => {
+            (0, dist_1.log_error)(`获取当前区块失败:`, error, '');
+        });
+        this.wsProvider.on('block', (blockNumber) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.isConnected || !this.isBlockListenerActive)
+                    return;
+                (0, dist_1.log_info)(`------- Block: ${blockNumber} -------`);
+                const previousBlockNumber = this.lastProcessedBlockNumber;
+                this.lastProcessedBlockNumber = blockNumber;
+                const blockUpdateEvent = {
+                    blockNumber: blockNumber,
+                    previousBlockNumber: previousBlockNumber,
+                    timestamp: Date.now()
+                };
+                this.appConfig.emit(constants_1.EVENT_NAMES.BLOCK_UPDATE, blockUpdateEvent);
+            }
+            catch (error) {
+                (0, dist_1.log_error)(`处理区块事件出错:`, error, '');
+            }
+        }));
+        this.isBlockListenerActive = true;
+        (0, dist_1.log_info)(`区块监听已启动，使用WebSocket事件订阅方式`);
+    }
+    stopBlockListener() {
+        if (this.isBlockListenerActive && this.wsProvider) {
+            this.wsProvider.removeListener('block', () => { });
+            this.isBlockListenerActive = false;
+            (0, dist_1.log_info)(`区块监听已停止`);
+        }
+    }
+    isWSConnected() {
+        return this.isConnected;
+    }
+    getConnectionDiagnostics() {
+        return {
+            isConnected: this.isConnected,
+            isStarted: this.isStarted,
+            reconnectAttempts: this.reconnectAttempts,
+            hasActiveHeartbeat: this.heartbeatInterval !== null,
+            wsEndpoint: this.appConfig.env_args.ws_endpoint,
+            wsReadyState: this.wsProvider && this.wsProvider._websocket
+                ? this.wsProvider._websocket.readyState
+                : null,
+            trackingPools: this.poolList.length,
+            lastProcessedBlock: this.lastProcessedBlockNumber
+        };
+    }
+}
+exports.PoolEventListener = PoolEventListener;

package/dist/quote/event/verify_clmm_swap_event.d.ts

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

package/dist/quote/event/verify_clmm_swap_event.js

@@ -0,0 +1,178 @@
+"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 });
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+const ethers_1 = require("ethers");
+const constants_1 = require("../../common/constants");
+const log = (level, msg, data) => {
+    const timestamp = new Date().toISOString();
+    console.log(`${timestamp} [${level}] ${msg}`);
+    if (data)
+        console.log(data);
+};
+function verifySwapEventParsing() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const wsEndpoint = process.env.WS_ENDPOINT || '';
+        const poolAddress = '0xc1a780989734a0e5df875cebe410748562e1c5e6';
+        const poolName = 'B2/BNB';
+        log('INFO', `正在连接到WebSocket: ${wsEndpoint}`);
+        const wsProvider = new ethers_1.ethers.providers.WebSocketProvider(wsEndpoint);
+        yield wsProvider.ready;
+        log('INFO', '连接成功，准备测试事件解析');
+        const updatedSwapHash = ethers_1.ethers.utils.id(constants_1.EVENT_SIGNATURES.SWAP_RAW);
+        log('INFO', `更新后的Swap事件哈希: ${updatedSwapHash}`);
+        const capturedSwapHash = '0x19b47279256b2a23a1665c810c8d55a1758940ee09377d4f8d26497a3577dc83';
+        log('INFO', `之前捕获的Swap事件哈希: ${capturedSwapHash}`);
+        if (updatedSwapHash === capturedSwapHash) {
+            log('INFO', '✅ 事件哈希匹配，签名修改正确');
+        }
+        else {
+            log('WARN', '⚠️ 事件哈希不匹配，可能需要调整签名格式');
+        }
+        const methods = [
+            {
+                name: "方法1：直接使用更新后的SWAP_RAW签名",
+                createInterface: () => new ethers_1.ethers.utils.Interface([constants_1.EVENT_SIGNATURES.SWAP_RAW])
+            },
+            {
+                name: "方法2：添加event前缀（推荐方式）",
+                createInterface: () => new ethers_1.ethers.utils.Interface([`event ${constants_1.EVENT_SIGNATURES.SWAP_RAW}`])
+            },
+            {
+                name: "方法3：带错误处理的解析方式（新增）",
+                parse: (log) => {
+                    try {
+                        const completeSwapDefinition = "event " + constants_1.EVENT_SIGNATURES.SWAP_RAW;
+                        const iface = new ethers_1.ethers.utils.Interface([completeSwapDefinition]);
+                        try {
+                            return iface.parseLog(log);
+                        }
+                        catch (parseError) {
+                            if (parseError.code === 'BUFFER_OVERRUN') {
+                                console.log('\x1b[33m%s\x1b[0m', `检测到BUFFER_OVERRUN错误，触发备用解析流程`);
+                                return {
+                                    args: {
+                                        sender: "备用解析流程",
+                                        recipient: "备用解析流程",
+                                        amount0: ethers_1.ethers.BigNumber.from(0),
+                                        amount1: ethers_1.ethers.BigNumber.from(0),
+                                        sqrtPriceX96: ethers_1.ethers.BigNumber.from(0),
+                                        tick: 0,
+                                    }
+                                };
+                            }
+                            throw parseError;
+                        }
+                    }
+                    catch (error) {
+                        throw error;
+                    }
+                }
+            }
+        ];
+        log('INFO', `设置原始事件监听器，只按地址过滤`);
+        const filter = { address: poolAddress };
+        wsProvider.on(filter, (log) => {
+            var _a, _b, _c, _d;
+            try {
+                const isSwapEvent = (log.topics[0] === capturedSwapHash || log.topics[0] === updatedSwapHash);
+                if (isSwapEvent) {
+                    console.log('\x1b[32m%s\x1b[0m', `收到Swap事件: 交易哈希=${log.transactionHash}, 区块=${log.blockNumber}`);
+                    for (const method of methods) {
+                        try {
+                            let parsedEvent;
+                            if (method.parse) {
+                                parsedEvent = method.parse(log);
+                            }
+                            else if (method.createInterface) {
+                                const iface = method.createInterface();
+                                parsedEvent = iface.parseLog(log);
+                            }
+                            else {
+                                throw new Error("方法未正确定义");
+                            }
+                            console.log('\x1b[32m%s\x1b[0m', `${method.name} - 解析成功!`);
+                            console.log({
+                                sender: parsedEvent.args.sender,
+                                recipient: parsedEvent.args.recipient,
+                                amount0: (_a = parsedEvent.args.amount0) === null || _a === void 0 ? void 0 : _a.toString(),
+                                amount1: (_b = parsedEvent.args.amount1) === null || _b === void 0 ? void 0 : _b.toString(),
+                                sqrtPriceX96: (_c = parsedEvent.args.sqrtPriceX96) === null || _c === void 0 ? void 0 : _c.toString(),
+                                tick: (_d = parsedEvent.args.tick) === null || _d === void 0 ? void 0 : _d.toString()
+                            });
+                        }
+                        catch (error) {
+                            console.log('\x1b[31m%s\x1b[0m', `${method.name} - 解析失败: ${error.message}`);
+                            console.log(error.code ? `错误代码: ${error.code}` : '无错误代码');
+                        }
+                    }
+                    console.log('----------------------------');
+                }
+            }
+            catch (error) {
+                log('ERROR', `处理事件出错:`, error);
+            }
+        });
+        log('INFO', '测试脚本启动成功，等待Swap事件...');
+        const interval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const blockNumber = yield wsProvider.getBlockNumber();
+                log('DEBUG', `心跳检测成功，当前区块: ${blockNumber}`);
+            }
+            catch (error) {
+                log('ERROR', '心跳检测失败，可能断开连接');
+            }
+        }), 15000);
+        process.on('SIGINT', () => {
+            log('INFO', '收到退出信号，正在清理...');
+            clearInterval(interval);
+            wsProvider.removeAllListeners();
+            if (wsProvider._websocket)
+                wsProvider._websocket.close();
+            log('INFO', '已清理，退出程序');
+            process.exit(0);
+        });
+    });
+}
+function updateCurrentPoolState(wsProvider, poolAddress, poolName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        log('INFO', `[${poolName}] 模拟备用方法：通过直接查询获取池状态`);
+        try {
+            const poolAbi = [
+                "function slot0() external view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked)",
+                "function liquidity() external view returns (uint128)"
+            ];
+            const poolContract = new ethers_1.ethers.Contract(poolAddress, poolAbi, wsProvider);
+            const [slot0Data, liquidityData] = yield Promise.all([
+                poolContract.slot0(),
+                poolContract.liquidity()
+            ]);
+            const [sqrtPriceX96, tick] = slot0Data;
+            const liquidity = liquidityData;
+            log('INFO', `[${poolName}] 备用方法成功: tick=${tick}, liquidity=${liquidity.toString()}`);
+            return { sqrtPriceX96, tick, liquidity };
+        }
+        catch (error) {
+            log('ERROR', `[${poolName}] 备用方法失败:`, error);
+            return null;
+        }
+    });
+}
+verifySwapEventParsing()
+    .then(() => log('INFO', '验证脚本启动成功'))
+    .catch(error => {
+    log('ERROR', '验证脚本启动失败:', error);
+    process.exit(1);
+});

package/dist/quote/index.d.ts

@@ -0,0 +1,2 @@
+export * from './event';
+export * from './pricing';

package/dist/quote/index.js

@@ -0,0 +1,18 @@
+"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("./event"), exports);
+__exportStar(require("./pricing"), exports);

package/dist/quote/pricing/index.d.ts

@@ -0,0 +1,2 @@
+export * from './token_price_cache';
+export * from './pool';

package/dist/quote/pricing/index.js

@@ -0,0 +1,18 @@
+"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("./token_price_cache"), exports);
+__exportStar(require("./pool"), exports);

package/dist/quote/pricing/pool.d.ts

@@ -0,0 +1,13 @@
+import { ethers } from 'ethers';
+export declare class Pool {
+    readonly address: string;
+    readonly token0: string;
+    readonly token1: string;
+    readonly fee: number;
+    sqrtPriceX96: ethers.BigNumber;
+    liquidity: ethers.BigNumber;
+    tickCurrent: number;
+    readonly tickSpacing: number;
+    constructor(address: string, token0: string, token1: string, fee: number, sqrtPriceX96: ethers.BigNumber, tickCurrent: number, liquidity: ethers.BigNumber, tickSpacing: number);
+    updateState(sqrtPriceX96: ethers.BigNumber, tickCurrent: number, liquidity: ethers.BigNumber): void;
+}

package/dist/quote/pricing/pool.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pool = void 0;
+class Pool {
+    constructor(address, token0, token1, fee, sqrtPriceX96, tickCurrent, liquidity, tickSpacing) {
+        this.address = address;
+        this.token0 = token0;
+        this.token1 = token1;
+        this.fee = fee;
+        this.sqrtPriceX96 = sqrtPriceX96;
+        this.liquidity = liquidity;
+        this.tickCurrent = tickCurrent;
+        this.tickSpacing = tickSpacing;
+    }
+    updateState(sqrtPriceX96, tickCurrent, liquidity) {
+        this.sqrtPriceX96 = sqrtPriceX96;
+        this.tickCurrent = tickCurrent;
+        this.liquidity = liquidity;
+    }
+}
+exports.Pool = Pool;

package/dist/quote/pricing/token_price_cache.d.ts

@@ -0,0 +1,9 @@
+export declare class TokenPriceCache {
+    private tokenPriceCache;
+    private readonly PRICE_CACHE_TIMEOUT_MILLS;
+    constructor();
+    getTokenPrice(tokenAddress: string): Promise<{
+        price: string;
+        timestamp: number;
+    }>;
+}

package/dist/quote/pricing/token_price_cache.js

@@ -0,0 +1,40 @@
+"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.TokenPriceCache = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+class TokenPriceCache {
+    constructor() {
+        this.tokenPriceCache = new Map();
+        this.PRICE_CACHE_TIMEOUT_MILLS = parseInt(process.env.PRICE_CACHE_TIMEOUT_MILLS || Number(1000 * 60 * 60 * 1).toString());
+        (0, dist_1.log_info)(`代币价格缓存超时时间: ${this.PRICE_CACHE_TIMEOUT_MILLS} ms`);
+    }
+    getTokenPrice(tokenAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            tokenAddress = tokenAddress.toLowerCase();
+            const now = Date.now();
+            const cachedData = this.tokenPriceCache.get(tokenAddress);
+            if (cachedData && (now - cachedData.timestamp) < this.PRICE_CACHE_TIMEOUT_MILLS) {
+                (0, dist_1.log_debug)(`use cached token price: ${tokenAddress}, price: ${cachedData.price}`, '');
+                return cachedData;
+            }
+            const priceMap = yield (0, dist_1.get_bsc_token_price_info)([tokenAddress]);
+            const tokenPrice = priceMap.get(tokenAddress);
+            if (!tokenPrice || !tokenPrice.price || Number(tokenPrice.price) <= 0) {
+                throw new Error(`无法获取代币 ${tokenAddress} 的有效USD价格`);
+            }
+            const newPrice = { price: tokenPrice.price, timestamp: now };
+            this.tokenPriceCache.set(tokenAddress, newPrice);
+            return newPrice;
+        });
+    }
+}
+exports.TokenPriceCache = TokenPriceCache;

package/dist/trade/abstract_dex_trade.d.ts

@@ -0,0 +1,27 @@
+import { AbastrcatTrade, AppConfig, TradeContext } from "@clonegod/ttd-core/dist";
+import { ethers } from "ethers";
+import { DexConfig, EvmChainConfig } from "../types";
+export declare abstract class AbstractEvmDexTrade extends AbastrcatTrade {
+    protected appConfig: AppConfig;
+    protected wallet: ethers.Wallet;
+    protected provider: ethers.providers.JsonRpcProvider;
+    protected approvedTokens: Map<string, boolean>;
+    protected pairContracts: Map<string, ethers.Contract>;
+    protected tokenContracts: Map<string, ethers.Contract>;
+    protected routerContract: ethers.Contract;
+    protected chainConfig: EvmChainConfig;
+    protected dexConfig: DexConfig;
+    constructor(appConfig: AppConfig);
+    protected abstract initConfigs(): void;
+    init(): Promise<void>;
+    protected getTokenContract(tokenAddress: string): ethers.Contract;
+    protected getGasPriceGwei(context: TradeContext): string;
+    protected getBuilderTipAmoutGwei(context: TradeContext): string;
+    protected checkTradeTokenApprove(context: TradeContext, routerAddress?: string): Promise<void>;
+    protected checkTokenApprove(tokenAddress: string, tokenSymbol: string, tokenContract: ethers.Contract, spenderAddress: string): Promise<boolean>;
+    protected isNonceRelatedError(error: any): boolean;
+    protected isNativeCurrency(symbol: string): boolean;
+    protected getWrappedNativeAddress(): string;
+    abstract execute(context: TradeContext, retryCount?: number): Promise<string>;
+    protected buildTipTransferTx(to: string, transfer_amount_gwei: string, gas_price_gwei: string, transfer_nonce: number): Promise<string>;
+}