@clonegod/ttd-bsc-common 2.0.1 → 3.0.2

package/dist/config/BscQuoteAppConfig.d.ts

@@ -1,5 +1,5 @@
 import { BscEnvArgs } from "./bsc_env_args";
-import { AppConfig } from "@clonegod/ttd-core/dist";
+import { AppConfig } from '@clonegod/ttd-core';
 export declare class BscQuoteAppConfig extends AppConfig {
     private eventEmitter;
     env_args: BscEnvArgs;

package/dist/config/BscQuoteAppConfig.js

@@ -11,9 +11,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BscQuoteAppConfig = void 0;
 const bsc_env_args_1 = require("./bsc_env_args");
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 const events_1 = require("events");
-class BscQuoteAppConfig extends dist_1.AppConfig {
+class BscQuoteAppConfig extends ttd_core_1.AppConfig {
     constructor() {
         super();
         this.eventEmitter = new events_1.EventEmitter();
@@ -34,9 +34,9 @@ class BscQuoteAppConfig extends dist_1.AppConfig {
             yield _super.init.call(this);
             yield this.arb_cache.init();
             if (!this.arb_event_subscriber) {
-                this.arb_event_subscriber = (0, dist_1.getArbEventSubscriber)(this.arb_cache);
+                this.arb_event_subscriber = (0, ttd_core_1.getArbEventSubscriber)(this.arb_cache);
             }
-            (0, dist_1.log_info)('BscQuoteAppConfig initialized', {
+            (0, ttd_core_1.log_info)('BscQuoteAppConfig initialized', {
                 chain_id: this.env_args.chain_id,
                 dex_id: this.env_args.dex_id,
                 quote_pair: this.env_args.quote_pair,
@@ -48,7 +48,7 @@ class BscQuoteAppConfig extends dist_1.AppConfig {
     subscribe_config_change() {
         return __awaiter(this, void 0, void 0, function* () {
             this.on('config_change', (config) => __awaiter(this, void 0, void 0, function* () {
-                (0, dist_1.log_info)('Config change received', config);
+                (0, ttd_core_1.log_info)('Config change received', config);
                 if (config.env_args) {
                     this.env_args = new bsc_env_args_1.BscEnvArgs();
                 }

package/dist/config/bsc_env_args.d.ts

@@ -1,4 +1,4 @@
-import { EnvArgs } from "@clonegod/ttd-core/dist";
+import { EnvArgs } from '@clonegod/ttd-core';
 export declare class BscEnvArgs extends EnvArgs {
     large_trade_threshold_usd: number;
     gas_price_gwei: number;

package/dist/config/bsc_env_args.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BscEnvArgs = void 0;
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 const decimal_js_1 = require("decimal.js");
-class BscEnvArgs extends dist_1.EnvArgs {
+class BscEnvArgs extends ttd_core_1.EnvArgs {
     constructor() {
         super();
         this.large_trade_threshold_usd = parseInt(process.env.LARGE_TRADE_THRESHOLD_USD || '500');

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

@@ -1,5 +1,5 @@
 import { StandardPoolInfoType } from '@clonegod/ttd-core';
-import { AppConfig } from '@clonegod/ttd-core/dist';
+import { AppConfig } from '@clonegod/ttd-core';
 export interface BlockUpdateEvent {
     blockNumber: number;
     previousBlockNumber: number;

package/dist/quote/event/pool_event_listener.js

@@ -11,7 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PoolEventListener = void 0;
 const ethers_1 = require("ethers");
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 const common_1 = require("../../common");
 const CONFIG = {
     MAX_RETRIES: 3,
@@ -48,37 +48,37 @@ class PoolEventListener {
         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)(`Found ${poolList.length - this.poolList.length} invalid pool addresses, filtered out`, '');
+                (0, ttd_core_1.log_warn)(`Found ${poolList.length - this.poolList.length} invalid pool addresses, filtered out`, '');
             }
             yield this.connect();
         });
     }
     start() {
         return __awaiter(this, void 0, void 0, function* () {
-            (0, dist_1.log_info)(`Starting block listener...`);
+            (0, ttd_core_1.log_info)(`Starting block listener...`);
             if (!this.isConnected || !this.wsProvider) {
-                (0, dist_1.log_warn)('WebSocket not connected, cannot start listener', '');
+                (0, ttd_core_1.log_warn)('WebSocket not connected, cannot start listener', '');
                 return;
             }
             yield this.startBlockListener();
             this.isStarted = true;
-            (0, dist_1.log_info)('Block listener started successfully');
+            (0, ttd_core_1.log_info)('Block listener started successfully');
         });
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
-            (0, dist_1.log_info)(`Stopping block listener...`);
+            (0, ttd_core_1.log_info)(`Stopping block listener...`);
             this.stopBlockListener();
             this.cleanup();
             this.isStarted = false;
-            (0, dist_1.log_info)(`Block listener stopped`);
+            (0, ttd_core_1.log_info)(`Block listener stopped`);
         });
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
             for (let i = 0; i < CONFIG.MAX_RETRIES; i++) {
                 try {
-                    (0, dist_1.log_info)(`Connecting to WebSocket: ${this.ws_endpoint} (Attempt ${i + 1}/${CONFIG.MAX_RETRIES})`);
+                    (0, ttd_core_1.log_info)(`Connecting to WebSocket: ${this.ws_endpoint} (Attempt ${i + 1}/${CONFIG.MAX_RETRIES})`);
                     this.wsProvider = new ethers_1.ethers.providers.WebSocketProvider(this.ws_endpoint);
                     const wsPromise = this.wsProvider.ready;
                     const timeoutPromise = new Promise((_, reject) => {
@@ -87,7 +87,7 @@ class PoolEventListener {
                     yield Promise.race([wsPromise, timeoutPromise]);
                     this.isConnected = true;
                     this.reconnectAttempts = 0;
-                    (0, dist_1.log_info)(`WebSocket connected: ${this.ws_endpoint}`);
+                    (0, ttd_core_1.log_info)(`WebSocket connected: ${this.ws_endpoint}`);
                     this.setupWebSocketListeners();
                     if (this.isStarted) {
                         yield this.startBlockListener();
@@ -95,12 +95,12 @@ class PoolEventListener {
                     return;
                 }
                 catch (error) {
-                    (0, dist_1.log_error)(`WebSocket connection failed (Attempt ${i + 1}/${CONFIG.MAX_RETRIES}):`, error);
+                    (0, ttd_core_1.log_error)(`WebSocket connection failed (Attempt ${i + 1}/${CONFIG.MAX_RETRIES}):`, error);
                     if (i === CONFIG.MAX_RETRIES - 1) {
                         throw error;
                     }
                     const delay = CONFIG.RETRY_DELAY_MULTIPLIER * (i + 1);
-                    (0, dist_1.log_info)(`Waiting ${delay / 1000} seconds before retry...`);
+                    (0, ttd_core_1.log_info)(`Waiting ${delay / 1000} seconds before retry...`);
                     yield new Promise(resolve => setTimeout(resolve, delay));
                 }
             }
@@ -110,15 +110,15 @@ class PoolEventListener {
         if (!this.wsProvider)
             return;
         this.wsProvider.on('error', (err) => {
-            (0, dist_1.log_error)(`WebSocket error:`, err, '');
+            (0, ttd_core_1.log_error)(`WebSocket error:`, err, '');
             this.handleConnectionIssue();
         });
         this.wsProvider._websocket.on('close', (code, reason) => {
-            (0, dist_1.log_warn)(`WebSocket connection closed, code: ${code}, reason: ${reason || 'unknown'}`);
+            (0, ttd_core_1.log_warn)(`WebSocket connection closed, code: ${code}, reason: ${reason || 'unknown'}`);
             this.handleConnectionIssue();
         });
         this.wsProvider._websocket.on('open', () => {
-            (0, dist_1.log_info)('WebSocket connection opened');
+            (0, ttd_core_1.log_info)('WebSocket connection opened');
             this.isConnected = true;
             this.reconnectAttempts = 0;
         });
@@ -138,12 +138,12 @@ class PoolEventListener {
                 this.lastHeartbeatResponse = Date.now();
                 const timeSinceLastHeartbeat = Date.now() - this.lastHeartbeatResponse;
                 if (timeSinceLastHeartbeat > CONFIG.HEARTBEAT_TIMEOUT) {
-                    (0, dist_1.log_warn)(`No heartbeat response for ${timeSinceLastHeartbeat / 1000} seconds`);
+                    (0, ttd_core_1.log_warn)(`No heartbeat response for ${timeSinceLastHeartbeat / 1000} seconds`);
                     this.handleConnectionIssue();
                 }
             }
             catch (error) {
-                (0, dist_1.log_error)('Heartbeat check failed:', error);
+                (0, ttd_core_1.log_error)('Heartbeat check failed:', error);
                 this.handleConnectionIssue();
             }
         }), CONFIG.HEARTBEAT_INTERVAL);
@@ -151,7 +151,7 @@ class PoolEventListener {
     handleConnectionIssue() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isReconnecting) {
-                (0, dist_1.log_info)('Already attempting to reconnect, skipping...');
+                (0, ttd_core_1.log_info)('Already attempting to reconnect, skipping...');
                 return;
             }
             this.isReconnecting = true;
@@ -161,20 +161,20 @@ class PoolEventListener {
                 this.cleanup();
                 this.reconnectAttempts++;
                 const delay = Math.min(CONFIG.BASE_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts), CONFIG.MAX_RECONNECT_DELAY);
-                (0, dist_1.log_info)(`Attempting to reconnect ${this.reconnectAttempts}/${CONFIG.MAX_RECONNECT_ATTEMPTS}, delay ${delay}ms, node: ${this.ws_endpoint}`);
+                (0, ttd_core_1.log_info)(`Attempting to reconnect ${this.reconnectAttempts}/${CONFIG.MAX_RECONNECT_ATTEMPTS}, delay ${delay}ms, node: ${this.ws_endpoint}`);
                 if (this.reconnectAttempts > CONFIG.MAX_RECONNECT_ATTEMPTS) {
-                    (0, dist_1.log_error)(`Reconnection failed, reached maximum attempts (${CONFIG.MAX_RECONNECT_ATTEMPTS}), exiting`, new Error('Max reconnect attempts failed'), '');
+                    (0, ttd_core_1.log_error)(`Reconnection failed, reached maximum attempts (${CONFIG.MAX_RECONNECT_ATTEMPTS}), exiting`, new Error('Max reconnect attempts failed'), '');
                     this.appConfig.emit(common_1.EVENT_NAMES.WS_CONNECTION_FAILED, {
                         endpoint: this.ws_endpoint,
                         attempts: CONFIG.MAX_RECONNECT_ATTEMPTS,
                     });
                     process.exit(1);
                 }
-                yield (0, dist_1.sleep)(delay);
+                yield (0, ttd_core_1.sleep)(delay);
                 yield this.connect();
             }
             catch (error) {
-                (0, dist_1.log_error)('Reconnection attempt failed:', error);
+                (0, ttd_core_1.log_error)('Reconnection attempt failed:', error);
                 setTimeout(() => this.handleConnectionIssue(), CONFIG.BASE_RECONNECT_DELAY);
             }
             finally {
@@ -185,19 +185,19 @@ class PoolEventListener {
     startBlockListener() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.wsProvider || !this.isConnected) {
-                (0, dist_1.log_warn)(`Cannot start block listener: WebSocket not connected`);
+                (0, ttd_core_1.log_warn)(`Cannot start block listener: WebSocket not connected`);
                 return;
             }
             try {
                 const blockNumber = yield this.wsProvider.getBlockNumber();
                 this.lastProcessedBlockNumber = blockNumber;
-                (0, dist_1.log_info)(`Initializing block listener, current block: ${blockNumber}`);
+                (0, ttd_core_1.log_info)(`Initializing block listener, current block: ${blockNumber}`);
                 this.wsProvider.on('block', (blockNumber) => __awaiter(this, void 0, void 0, function* () {
                     try {
                         if (!this.isConnected || !this.isBlockListenerActive)
                             return;
                         this.lastMessageTime = Date.now();
-                        (0, dist_1.log_info)(`------- Block: ${blockNumber} -------`);
+                        (0, ttd_core_1.log_info)(`------- Block: ${blockNumber} -------`);
                         const previousBlockNumber = this.lastProcessedBlockNumber;
                         this.lastProcessedBlockNumber = blockNumber;
                         const blockUpdateEvent = {
@@ -208,16 +208,16 @@ class PoolEventListener {
                         this.appConfig.emit(common_1.EVENT_NAMES.BLOCK_UPDATE, blockUpdateEvent);
                     }
                     catch (error) {
-                        (0, dist_1.log_error)(`Error processing block event:`, error, '');
+                        (0, ttd_core_1.log_error)(`Error processing block event:`, error, '');
                     }
                 }));
                 this.startMessageMonitor();
                 this.startDiagnosticMonitor();
                 this.isBlockListenerActive = true;
-                (0, dist_1.log_info)(`Block listener started using WebSocket event subscription`);
+                (0, ttd_core_1.log_info)(`Block listener started using WebSocket event subscription`);
             }
             catch (error) {
-                (0, dist_1.log_error)(`Failed to start block listener:`, error, '');
+                (0, ttd_core_1.log_error)(`Failed to start block listener:`, error, '');
                 this.isBlockListenerActive = false;
             }
         });
@@ -229,7 +229,7 @@ class PoolEventListener {
         this.messageMonitorInterval = setInterval(() => {
             const timeSinceLastMessage = Date.now() - this.lastMessageTime;
             if (timeSinceLastMessage > CONFIG.MESSAGE_TIMEOUT) {
-                (0, dist_1.log_warn)(`No messages received for ${CONFIG.MESSAGE_TIMEOUT / 1000} seconds, preparing to resubscribe`);
+                (0, ttd_core_1.log_warn)(`No messages received for ${CONFIG.MESSAGE_TIMEOUT / 1000} seconds, preparing to resubscribe`);
                 this.handleConnectionIssue();
             }
         }, CONFIG.MESSAGE_CHECK_INTERVAL);
@@ -244,7 +244,7 @@ class PoolEventListener {
         }, CONFIG.DIAGNOSTIC_INTERVAL);
     }
     logDiagnostics(diagnostics) {
-        (0, dist_1.log_info)(`WebSocket Connection Diagnostics:
+        (0, ttd_core_1.log_info)(`WebSocket Connection Diagnostics:
             Connection Status: ${diagnostics.isConnected ? 'Connected' : 'Disconnected'}
             Reconnection Status: ${diagnostics.isReconnecting ? 'Reconnecting' : 'Not Reconnecting'}
             Listener Status: ${diagnostics.isStarted ? 'Started' : 'Not Started'}
@@ -279,7 +279,7 @@ class PoolEventListener {
                 clearInterval(this.diagnosticInterval);
                 this.diagnosticInterval = null;
             }
-            (0, dist_1.log_info)(`Block listener stopped`);
+            (0, ttd_core_1.log_info)(`Block listener stopped`);
         }
     }
     cleanup() {
@@ -291,7 +291,7 @@ class PoolEventListener {
                 }
             }
             catch (error) {
-                (0, dist_1.log_error)(`Failed to cleanup WebSocket resources:`, error, '');
+                (0, ttd_core_1.log_error)(`Failed to cleanup WebSocket resources:`, error, '');
             }
             this.wsProvider = null;
         }

package/dist/quote/event/swap_debouncer.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwapDebouncer = void 0;
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 class SwapDebouncer {
     constructor(config) {
         this.windows = new Map();
@@ -28,7 +28,7 @@ class SwapDebouncer {
             if (blockNumber > 0) {
                 const lastBlock = this.latestBlock.get(poolAddress) || 0;
                 if (blockNumber < lastBlock) {
-                    (0, dist_1.log_warn)(`SwapDebouncer: stale block dropped, pool=${poolAddress}, event block=${blockNumber}, latest=${lastBlock}`);
+                    (0, ttd_core_1.log_warn)(`SwapDebouncer: stale block dropped, pool=${poolAddress}, event block=${blockNumber}, latest=${lastBlock}`);
                     return;
                 }
                 this.latestBlock.set(poolAddress, blockNumber);

package/dist/quote/pricing/pool_state_initializer.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PoolStateInitializer = void 0;
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 const V2_PAIR_ABI = [
     'function token0() view returns (address)',
     'function token1() view returns (address)',
@@ -49,13 +49,13 @@ class PoolStateInitializer {
                     reserve0: reserves[0].toString(),
                     reserve1: reserves[1].toString(),
                 };
-                (0, dist_1.log_info)(`[PoolStateInitializer] AMM pool initialized: ${poolAddress}`, {
+                (0, ttd_core_1.log_info)(`[PoolStateInitializer] AMM pool initialized: ${poolAddress}`, {
                     token0: state.token0, token1: state.token1, fee: state.fee,
                 });
                 return state;
             }
             catch (error) {
-                (0, dist_1.log_error)(`[PoolStateInitializer] Failed to init AMM pool ${poolAddress}:`, error);
+                (0, ttd_core_1.log_error)(`[PoolStateInitializer] Failed to init AMM pool ${poolAddress}:`, error);
                 throw error;
             }
         });
@@ -84,14 +84,14 @@ class PoolStateInitializer {
                     sqrtPriceX96: sqrtPriceX96.toString(),
                     liquidity: liquidity.toString(),
                 };
-                (0, dist_1.log_info)(`[PoolStateInitializer] CLMM pool initialized: ${poolAddress}`, {
+                (0, ttd_core_1.log_info)(`[PoolStateInitializer] CLMM pool initialized: ${poolAddress}`, {
                     token0: state.token0, token1: state.token1,
                     fee: state.fee, tickSpacing: state.tickSpacing, tick: state.tick,
                 });
                 return state;
             }
             catch (error) {
-                (0, dist_1.log_error)(`[PoolStateInitializer] Failed to init CLMM pool ${poolAddress}:`, error);
+                (0, ttd_core_1.log_error)(`[PoolStateInitializer] Failed to init CLMM pool ${poolAddress}:`, error);
                 throw error;
             }
         });
@@ -125,7 +125,7 @@ class PoolStateInitializer {
                     lpFee: Number(lpFee),
                     protocolFee: Number(protocolFee),
                 };
-                (0, dist_1.log_info)(`[PoolStateInitializer] Infinity pool initialized: ${poolKey}`, {
+                (0, ttd_core_1.log_info)(`[PoolStateInitializer] Infinity pool initialized: ${poolKey}`, {
                     currency0: state.currency0, currency1: state.currency1,
                     fee: state.fee, tickSpacing: state.tickSpacing, tick: state.tick,
                     lpFee: state.lpFee, protocolFee: state.protocolFee,
@@ -133,7 +133,7 @@ class PoolStateInitializer {
                 return state;
             }
             catch (error) {
-                (0, dist_1.log_error)(`[PoolStateInitializer] Failed to init Infinity pool ${poolKey}:`, error);
+                (0, ttd_core_1.log_error)(`[PoolStateInitializer] Failed to init Infinity pool ${poolKey}:`, error);
                 throw error;
             }
         });

package/dist/quote/pricing/sdk_token_factory.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildSdkTokenMap = buildSdkTokenMap;
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 function buildSdkTokenMap(chainId, poolInfoMap, TokenClass) {
     const sdkTokens = new Map();
     for (const poolInfo of poolInfoMap.values()) {
@@ -14,7 +14,7 @@ function buildSdkTokenMap(chainId, poolInfoMap, TokenClass) {
             let name = tokenInfo.name || `Token ${address.substring(0, 8)}`;
             const token = new TokenClass(chainId, address, tokenInfo.decimals, symbol, name);
             sdkTokens.set(address, token);
-            (0, dist_1.log_debug)(`Created SDK Token: ${address}, symbol: ${symbol}, decimals: ${tokenInfo.decimals}`, '');
+            (0, ttd_core_1.log_debug)(`Created SDK Token: ${address}, symbol: ${symbol}, decimals: ${tokenInfo.decimals}`, '');
         }
     }
     return sdkTokens;

package/dist/quote/pricing/token_price_cache.js

@@ -10,12 +10,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenPriceCache = void 0;
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 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`);
+        (0, ttd_core_1.log_info)(`代币价格缓存超时时间: ${this.PRICE_CACHE_TIMEOUT_MILLS} ms`);
     }
     getTokenPrice(tokenAddress) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -23,10 +23,10 @@ class TokenPriceCache {
             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}`, '');
+                (0, ttd_core_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 priceMap = yield (0, ttd_core_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价格`);

package/dist/quote/tick/clmm_tick_cache.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClmmTickCache = void 0;
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 class ClmmTickCache {
     constructor(loader, config = {}) {
         var _a, _b, _c;
@@ -27,7 +27,7 @@ class ClmmTickCache {
     initPool(poolAddress, currentTick, tickSpacing) {
         return __awaiter(this, void 0, void 0, function* () {
             const bitmapIndexes = this.calcBitmapIndexes(currentTick, tickSpacing);
-            (0, dist_1.log_info)(`[TickCache] Init pool ${poolAddress}: tick=${currentTick}, tickSpacing=${tickSpacing}, loading ${bitmapIndexes.length} bitmap words`);
+            (0, ttd_core_1.log_info)(`[TickCache] Init pool ${poolAddress}: tick=${currentTick}, tickSpacing=${tickSpacing}, loading ${bitmapIndexes.length} bitmap words`);
             const ticks = yield this.loader.loadBitmapWords(poolAddress, bitmapIndexes);
             this.pools.set(poolAddress, {
                 ticks,
@@ -39,7 +39,7 @@ class ClmmTickCache {
                 loading: false,
             });
             this.startPeriodicRefresh(poolAddress);
-            (0, dist_1.log_info)(`[TickCache] Pool ${poolAddress} initialized: ${ticks.size} ticks loaded`);
+            (0, ttd_core_1.log_info)(`[TickCache] Pool ${poolAddress} initialized: ${ticks.size} ticks loaded`);
         });
     }
     onSwap(poolAddress, newTick) {
@@ -49,7 +49,7 @@ class ClmmTickCache {
         state.currentTick = newTick;
         const currentBitmapIndex = this.getBitmapIndex(newTick, state.tickSpacing);
         if (!state.bitmapIndexes.includes(currentBitmapIndex)) {
-            (0, dist_1.log_info)(`[TickCache] Pool ${poolAddress}: tick ${newTick} out of cached range, scheduling refresh`);
+            (0, ttd_core_1.log_info)(`[TickCache] Pool ${poolAddress}: tick ${newTick} out of cached range, scheduling refresh`);
             this.scheduleFullRefresh(poolAddress);
         }
     }
@@ -65,7 +65,7 @@ class ClmmTickCache {
     applyLiquidityDelta(poolAddress, tickLower, tickUpper, delta) {
         const state = this.pools.get(poolAddress);
         if (!state) {
-            (0, dist_1.log_warn)(`[TickCache] Pool ${poolAddress} not initialized, ignoring liquidity event`);
+            (0, ttd_core_1.log_warn)(`[TickCache] Pool ${poolAddress} not initialized, ignoring liquidity event`);
             return;
         }
         const absDelta = delta < BigInt(0) ? -delta : delta;
@@ -75,7 +75,7 @@ class ClmmTickCache {
         if (needAsyncRefresh) {
             this.scheduleFullRefresh(poolAddress);
         }
-        (0, dist_1.log_debug)(`[TickCache] Pool ${poolAddress}: liquidity delta applied, tickLower=${tickLower}, tickUpper=${tickUpper}, delta=${delta}`);
+        (0, ttd_core_1.log_debug)(`[TickCache] Pool ${poolAddress}: liquidity delta applied, tickLower=${tickLower}, tickUpper=${tickUpper}, delta=${delta}`);
     }
     updateTickLiquidity(state, tickIndex, netDelta, grossDelta, isLower) {
         const existing = state.ticks.get(tickIndex);
@@ -84,7 +84,7 @@ class ClmmTickCache {
             existing.liquidityGross += (netDelta > BigInt(0) ? grossDelta : -grossDelta);
             if (existing.liquidityGross <= BigInt(0)) {
                 state.ticks.delete(tickIndex);
-                (0, dist_1.log_debug)(`[TickCache] Tick ${tickIndex} de-initialized (liquidityGross <= 0)`);
+                (0, ttd_core_1.log_debug)(`[TickCache] Tick ${tickIndex} de-initialized (liquidityGross <= 0)`);
             }
             return false;
         }
@@ -94,11 +94,11 @@ class ClmmTickCache {
                     liquidityNet: netDelta,
                     liquidityGross: grossDelta,
                 });
-                (0, dist_1.log_debug)(`[TickCache] New tick ${tickIndex} initialized in cached range`);
+                (0, ttd_core_1.log_debug)(`[TickCache] New tick ${tickIndex} initialized in cached range`);
                 return false;
             }
             else {
-                (0, dist_1.log_debug)(`[TickCache] New tick ${tickIndex} outside cached range, will refresh async`);
+                (0, ttd_core_1.log_debug)(`[TickCache] New tick ${tickIndex} outside cached range, will refresh async`);
                 return true;
             }
         }
@@ -140,7 +140,7 @@ class ClmmTickCache {
             return;
         }
         this.doFullRefresh(poolAddress).catch(err => {
-            (0, dist_1.log_warn)(`[TickCache] Full refresh failed for ${poolAddress}: ${err.message}`);
+            (0, ttd_core_1.log_warn)(`[TickCache] Full refresh failed for ${poolAddress}: ${err.message}`);
         });
     }
     startPeriodicRefresh(poolAddress) {
@@ -152,7 +152,7 @@ class ClmmTickCache {
                 yield this.doFullRefresh(poolAddress);
             }
             catch (err) {
-                (0, dist_1.log_warn)(`[TickCache] Periodic refresh failed for ${poolAddress}: ${err.message}`);
+                (0, ttd_core_1.log_warn)(`[TickCache] Periodic refresh failed for ${poolAddress}: ${err.message}`);
             }
         }), this.config.refreshInterval);
         this.refreshTimers.set(poolAddress, timer);
@@ -174,7 +174,7 @@ class ClmmTickCache {
                 state.bitmapIndexes = bitmapIndexes;
                 state.lastFullLoadTime = Date.now();
                 state.pendingForceRefresh = false;
-                (0, dist_1.log_debug)(`[TickCache] Full refresh for ${poolAddress}: ${ticks.size} ticks, ${bitmapIndexes.length} words`);
+                (0, ttd_core_1.log_debug)(`[TickCache] Full refresh for ${poolAddress}: ${ticks.size} ticks, ${bitmapIndexes.length} words`);
             }
             finally {
                 state.loading = false;

package/dist/quote/tick/tick_lens_loaders.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MulticallTickLensLoader = exports.BSC_TICK_LENS_ADDRESSES = exports.MULTICALL3_ADDRESS = void 0;
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 exports.MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
 exports.BSC_TICK_LENS_ADDRESSES = {
     PANCAKE_V3: '0x9a489505a00cE272eAa5e07Dba6491314CaE3796',
@@ -130,13 +130,13 @@ class MulticallTickLensLoader {
                         }
                     }
                     catch (e) {
-                        (0, dist_1.log_warn)(`[TickLensLoader] Failed to decode bitmap index ${bitmapIndexes[i]}: ${e.message}`);
+                        (0, ttd_core_1.log_warn)(`[TickLensLoader] Failed to decode bitmap index ${bitmapIndexes[i]}: ${e.message}`);
                     }
                 }
-                (0, dist_1.log_debug)(`[TickLensLoader] Loaded ${result.size} ticks from ${bitmapIndexes.length} bitmap words (1 RPC call)`);
+                (0, ttd_core_1.log_debug)(`[TickLensLoader] Loaded ${result.size} ticks from ${bitmapIndexes.length} bitmap words (1 RPC call)`);
             }
             catch (error) {
-                (0, dist_1.log_warn)(`[TickLensLoader] Multicall failed, falling back to individual queries: ${error.message}`);
+                (0, ttd_core_1.log_warn)(`[TickLensLoader] Multicall failed, falling back to individual queries: ${error.message}`);
                 yield this.loadBitmapWordsIndividually(poolAddress, bitmapIndexes, result);
             }
             return result;
@@ -160,7 +160,7 @@ class MulticallTickLensLoader {
                     }
                 }
                 catch (e) {
-                    (0, dist_1.log_warn)(`[TickLensLoader] Bitmap index ${bitmapIndex} query failed for ${poolAddress}`);
+                    (0, ttd_core_1.log_warn)(`[TickLensLoader] Bitmap index ${bitmapIndex} query failed for ${poolAddress}`);
                 }
             }));
             yield Promise.all(promises);

package/dist/redis/redis_client.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimpleRedisClient = void 0;
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 class SimpleRedisClient {
     constructor(lock_prefix) {
         this.lock_prefix = lock_prefix;
@@ -22,7 +22,7 @@ class SimpleRedisClient {
     getRedisClient() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.redisClient) {
-                this.redisClient = (yield (0, dist_1.getRedisCache)());
+                this.redisClient = (yield (0, ttd_core_1.getRedisCache)());
             }
             return this.redisClient;
         });
@@ -37,7 +37,7 @@ class SimpleRedisClient {
                 NX: true,
                 EX: expireSeconds
             });
-            (0, dist_1.log_info)(`try acquireLock: lock_key=${lock_key}, lock_value=${lock_value}, expireSeconds=${expireSeconds}, result=${result}`);
+            (0, ttd_core_1.log_info)(`try acquireLock: lock_key=${lock_key}, lock_value=${lock_value}, expireSeconds=${expireSeconds}, result=${result}`);
             const success = result === 'OK';
             return success;
         });
@@ -85,13 +85,13 @@ class SimpleRedisClient {
                 if (acquired) {
                     const release_delay = parseInt(process.env.NONCE_LOCK_RELEASE_DELAY_MS || String(release_lock_delay_ms));
                     if (release_delay > 0) {
-                        yield (0, dist_1.sleep)(release_delay);
+                        yield (0, ttd_core_1.sleep)(release_delay);
                     }
                     this.releaseLock(lock_key, lock_value);
-                    (0, dist_1.log_info)(`withLock success: lock_key=${lock_key}, lock_value=${lock_value}, retry times=${retries}, get lock take ${get_lock_time - first_try_time}ms, release_delay=${release_delay}ms, hold lock ${Date.now() - get_lock_time}ms`);
+                    (0, ttd_core_1.log_info)(`withLock success: lock_key=${lock_key}, lock_value=${lock_value}, retry times=${retries}, get lock take ${get_lock_time - first_try_time}ms, release_delay=${release_delay}ms, hold lock ${Date.now() - get_lock_time}ms`);
                 }
                 else {
-                    (0, dist_1.log_warn)(`withLock failed: lock_key=${lock_key}, lock_value=${lock_value}, retry times=${retries}, took ${Date.now() - first_try_time}ms`);
+                    (0, ttd_core_1.log_warn)(`withLock failed: lock_key=${lock_key}, lock_value=${lock_value}, retry times=${retries}, took ${Date.now() - first_try_time}ms`);
                     throw new Error(`get lock for ${lock_key} failed`);
                 }
             }

package/dist/trade/abstract_dex_trade.d.ts

@@ -1,4 +1,4 @@
-import { AbastrcatTrade, AppConfig, TradeContext } from "@clonegod/ttd-core/dist";
+import { AbastrcatTrade, AppConfig, TradeContext } from '@clonegod/ttd-core';
 import { ethers } from "ethers";
 import { EvmChainConfig } from "../types";
 import { CallerManager } from "./caller_manager";

package/dist/trade/abstract_dex_trade.js

@@ -14,11 +14,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractDexTrade = void 0;
 exports.buildTradeConfig = buildTradeConfig;
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 const ethers_1 = require("ethers");
 const caller_manager_1 = require("./caller_manager");
 const ttd_bsc_send_tx_1 = require("@clonegod/ttd-bsc-send-tx");
 const redis_1 = require("../redis");
+const trade_direction_1 = require("../utils/trade_direction");
 const decimal_js_1 = __importDefault(require("decimal.js"));
 function buildTradeConfig() {
     const vaultAddress = process.env.VAULT_ADDRESS;
@@ -38,7 +39,7 @@ function buildTradeConfig() {
 const VAULT_ABI = [
     'function delegatecallExecutorToTrade(bytes32 executorId, bytes calldata data, uint256 deadline) external payable returns (bytes memory result)'
 ];
-class AbstractDexTrade extends dist_1.AbastrcatTrade {
+class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
     constructor(appConfig) {
         super();
         this.appConfig = appConfig;
@@ -51,7 +52,8 @@ class AbstractDexTrade extends dist_1.AbastrcatTrade {
         return __awaiter(this, void 0, void 0, function* () {
             this.provider = new ethers_1.ethers.providers.JsonRpcProvider(this.chainConfig.rpcEndpoint);
             this.transactionSender = new ttd_bsc_send_tx_1.TransactionSender(this.appConfig);
-            const callerGroupIds = (process.env.CALLER_GROUP_IDS || '').trim().split(',').filter(Boolean);
+            const defaultCallerId = `${this.chainNameLower.toUpperCase()}-CALLER`;
+            const callerGroupIds = (process.env.CALLER_GROUP_IDS || defaultCallerId).trim().split(',').filter(Boolean);
             this.callerManager = new caller_manager_1.CallerManager({
                 chainName: this.chainNameLower,
                 provider: this.provider,
@@ -60,7 +62,7 @@ class AbstractDexTrade extends dist_1.AbastrcatTrade {
             });
             yield this.callerManager.init();
             this.subscribeTradeMonitor();
-            (0, dist_1.log_info)(`AbstractDexTrade initialized, vault=${this.tradeConfig.vaultAddress}, callers=${this.callerManager.getCallerCount()}`);
+            (0, ttd_core_1.log_info)(`AbstractDexTrade initialized, vault=${this.tradeConfig.vaultAddress}, callers=${this.callerManager.getCallerCount()}`);
         });
     }
     execute(context) {
@@ -69,7 +71,7 @@ class AbstractDexTrade extends dist_1.AbastrcatTrade {
             const { price_msg, order_msg, slippage_bps, order_trace_id, pool_info } = context;
             const { pair } = price_msg;
             const { aToB, amount, unique_order_msg_id } = order_msg;
-            (0, dist_1.log_info)(`执行 Vault 交易, orderId=${order_trace_id}`, {
+            (0, ttd_core_1.log_info)(`执行 Vault 交易, orderId=${order_trace_id}`, {
                 unique_order_msg_id,
                 pair,
                 aToB,
@@ -90,10 +92,10 @@ class AbstractDexTrade extends dist_1.AbastrcatTrade {
                             if (nonce_from_error > 0) {
                                 nonce = nonce_from_error;
                                 nonce_from_error = 0;
-                                (0, dist_1.log_info)(`Attempt ${i}/${maxAttempts}, using nonce from error msg: ${nonce}`, {}, order_trace_id);
+                                (0, ttd_core_1.log_info)(`Attempt ${i}/${maxAttempts}, using nonce from error msg: ${nonce}`, {}, order_trace_id);
                             }
                             else {
-                                (0, dist_1.log_warn)(`Attempt ${i}/${maxAttempts}, no nonce in error msg, abort`, {}, order_trace_id);
+                                (0, ttd_core_1.log_warn)(`Attempt ${i}/${maxAttempts}, no nonce in error msg, abort`, {}, order_trace_id);
                                 break;
                             }
                         }
@@ -113,7 +115,7 @@ class AbstractDexTrade extends dist_1.AbastrcatTrade {
                         };
                         const signedTx = yield caller.signTransaction(tx);
                         txid = ethers_1.ethers.utils.keccak256(signedTx);
-                        (0, dist_1.log_info)(`Vault 交易已签名`, { txid, nonce, gasPriceGwei: realGasPriceGwei }, order_trace_id);
+                        (0, ttd_core_1.log_info)(`Vault 交易已签名`, { txid, nonce, gasPriceGwei: realGasPriceGwei }, order_trace_id);
                         const tipNonce = nonce + 1;
                         const eoa_tip_transaction = (eoa_address) => __awaiter(this, void 0, void 0, function* () {
                             const transfer_amount_gwei = this.getBuilderTipAmoutGwei(context);
@@ -122,7 +124,7 @@ class AbstractDexTrade extends dist_1.AbastrcatTrade {
                         });
                         const only_bundle = order_msg.is_dex_maker;
                         yield this.transactionSender.sendTransaction(signedTx, eoa_tip_transaction, order_trace_id, pair, only_bundle);
-                        (0, dist_1.log_info)(`Vault 交易发送成功`, {
+                        (0, ttd_core_1.log_info)(`Vault 交易发送成功`, {
                             pair, unique_order_msg_id, txid,
                             attempt: i, caller: caller.address
                         }, order_trace_id);
@@ -131,19 +133,19 @@ class AbstractDexTrade extends dist_1.AbastrcatTrade {
                     catch (error) {
                         const errorMessage = ((_a = error.message) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
                         if (errorMessage.includes('rate limit')) {
-                            (0, dist_1.log_warn)(`Rate limit error, no retry! i=${i}`, {}, order_trace_id);
+                            (0, ttd_core_1.log_warn)(`Rate limit error, no retry! i=${i}`, {}, order_trace_id);
                             return txid;
                         }
                         if (errorMessage.includes('replacement transaction underpriced')) {
-                            (0, dist_1.log_warn)(`Replacement tx underpriced, continue! i=${i}`, {}, order_trace_id);
+                            (0, ttd_core_1.log_warn)(`Replacement tx underpriced, continue! i=${i}`, {}, order_trace_id);
                             continue;
                         }
                         const isNonceError = errorMessage.includes('nonce');
                         if (!isNonceError || i >= maxAttempts) {
-                            (0, dist_1.log_warn)(`Non-nonce error or max retries, i=${i}, error: ${errorMessage}`, {}, order_trace_id);
+                            (0, ttd_core_1.log_warn)(`Non-nonce error or max retries, i=${i}, error: ${errorMessage}`, {}, order_trace_id);
                             return txid;
                         }
-                        (0, dist_1.log_info)(`Nonce error detected, will retry! i=${i}`, {}, order_trace_id);
+                        (0, ttd_core_1.log_info)(`Nonce error detected, will retry! i=${i}`, {}, order_trace_id);
                         if (errorMessage.includes('nonce too')) {
                             const correctNonce = this.extractNonceFromErrorMsg(errorMessage);
                             if (correctNonce !== null && correctNonce > 0) {
@@ -165,22 +167,22 @@ class AbstractDexTrade extends dist_1.AbastrcatTrade {
     subscribeTradeMonitor() {
         const wsUrl = process.env.TRADE_MONITOR_WS_URL;
         if (!wsUrl) {
-            (0, dist_1.log_warn)('TRADE_MONITOR_WS_URL not configured, trade result nonce correction disabled');
+            (0, ttd_core_1.log_warn)('TRADE_MONITOR_WS_URL not configured, trade result nonce correction disabled');
             return;
         }
-        const wsClient = new dist_1.WebSocketClient(wsUrl);
+        const wsClient = new ttd_core_1.WebSocketClient(wsUrl);
         wsClient.onOpen(() => {
             wsClient.send(JSON.stringify({
-                vault_address: this.tradeConfig.vaultAddress,
+                address: this.tradeConfig.vaultAddress,
             }));
-            (0, dist_1.log_info)(`Subscribed to trade-monitor for vault=${this.tradeConfig.vaultAddress}`);
+            (0, ttd_core_1.log_info)(`Subscribed to trade-monitor for ${this.tradeConfig.vaultAddress}`);
         });
         wsClient.onMessage((event) => {
             if (event.type === 'TradeResult' && event.data) {
                 const { caller, callerNonce } = event.data;
                 if (caller) {
                     const nextNonce = callerNonce + 2;
-                    this.callerManager.confirmNonce(caller, nextNonce).catch(err => (0, dist_1.log_warn)(`Failed to confirm nonce from trade-monitor`, err));
+                    this.callerManager.confirmNonce(caller, nextNonce).catch(err => (0, ttd_core_1.log_warn)(`Failed to confirm nonce from trade-monitor`, err));
                 }
             }
         });
@@ -214,7 +216,7 @@ class AbstractDexTrade extends dist_1.AbastrcatTrade {
                 chainId: this.chainConfig.chainId
             };
             const signedTx = yield wallet.signTransaction(tx_data);
-            (0, dist_1.log_info)(`构建 tip 转账交易`, {
+            (0, ttd_core_1.log_info)(`构建 tip 转账交易`, {
                 to, nonce,
                 tipGwei: real_transfer_amount_gwei,
                 txhash: ethers_1.ethers.utils.keccak256(signedTx)
@@ -223,34 +225,23 @@ class AbstractDexTrade extends dist_1.AbastrcatTrade {
         });
     }
     determineInputOutputTokens(order_msg, pool_info) {
-        const { aToB } = order_msg;
-        const { tokenA, tokenB, quote_token } = pool_info;
-        const quoteToken = [tokenA, tokenB].find(token => token.symbol === quote_token);
-        const nonQuoteToken = [tokenA, tokenB].find(token => token.symbol !== quote_token);
-        const inputToken = aToB ? nonQuoteToken : quoteToken;
-        const outputToken = aToB ? quoteToken : nonQuoteToken;
-        if (!inputToken || !outputToken) {
-            throw new Error(`无法确定输入/输出代币: ${JSON.stringify({
-                tokenA: tokenA.symbol, tokenB: tokenB.symbol,
-                quote: quote_token, aToB
-            })}`);
-        }
+        const { inputToken, outputToken } = (0, trade_direction_1.resolveTradeDirection)(pool_info, order_msg.isBuy);
         return { inputToken, outputToken };
     }
     calculateAmountOutMin(context, inputToken, outputToken) {
         const { price_msg, slippage_bps, order_msg } = context;
-        const { aToB } = order_msg;
+        const { isBuy } = order_msg;
         const slippage = slippage_bps / 10000;
         const inputAmount = new decimal_js_1.default(order_msg.amount.toString());
         let expectedOut;
-        if (aToB) {
-            const price = new decimal_js_1.default(price_msg.bid.price);
-            expectedOut = inputAmount.mul(price);
-        }
-        else {
+        if (isBuy) {
             const price = new decimal_js_1.default(price_msg.ask.price);
             expectedOut = inputAmount.div(price);
         }
+        else {
+            const price = new decimal_js_1.default(price_msg.bid.price);
+            expectedOut = inputAmount.mul(price);
+        }
         const minOutput = expectedOut.mul(new decimal_js_1.default(1).sub(new decimal_js_1.default(slippage)));
         return ethers_1.ethers.utils.parseUnits(minOutput.toFixed(outputToken.decimals), outputToken.decimals);
     }

package/dist/trade/caller_manager.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CallerManager = void 0;
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 const ethers_1 = require("ethers");
 const redis_1 = require("../redis");
 const CALLER_NONCE_KEY = 'caller:nonce';
@@ -24,9 +24,9 @@ class CallerManager {
     }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
-            const walletInfos = (0, dist_1.load_wallet_multi)(this.config.callerGroupIds, false);
+            const walletInfos = (0, ttd_core_1.load_wallet_multi)(this.config.callerGroupIds, false);
             const allWallets = walletInfos.map(info => new ethers_1.ethers.Wallet(info.private_key, this.config.provider));
-            (0, dist_1.log_info)(`CallerManager: loaded ${allWallets.length} wallets from CALLER_GROUP_IDS`, allWallets.map(w => w.address));
+            (0, ttd_core_1.log_info)(`CallerManager: loaded ${allWallets.length} wallets from CALLER_GROUP_IDS`, allWallets.map(w => w.address));
             const vaultCallersKey = `${this.config.chainName}:${VAULT_CALLERS_KEY}`;
             const allowedAddresses = yield this.redis.lrange(vaultCallersKey);
             if (allowedAddresses && allowedAddresses.length > 0) {
@@ -34,14 +34,14 @@ class CallerManager {
                 this.callers = allWallets.filter(w => allowedSet.has(w.address.toLowerCase()));
                 const matched = this.callers.map(w => w.address);
                 const skipped = allWallets.filter(w => !allowedSet.has(w.address.toLowerCase())).map(w => w.address);
-                (0, dist_1.log_info)(`CallerManager: matched ${this.callers.length} callers with Vault whitelist`, matched);
+                (0, ttd_core_1.log_info)(`CallerManager: matched ${this.callers.length} callers with Vault whitelist`, matched);
                 if (skipped.length > 0) {
-                    (0, dist_1.log_warn)(`CallerManager: skipped ${skipped.length} wallets not in Vault whitelist`, skipped);
+                    (0, ttd_core_1.log_warn)(`CallerManager: skipped ${skipped.length} wallets not in Vault whitelist`, skipped);
                 }
             }
             else {
                 this.callers = allWallets;
-                (0, dist_1.log_warn)(`CallerManager: Vault whitelist not found in Redis (${vaultCallersKey}), using all ${this.callers.length} loaded wallets`);
+                (0, ttd_core_1.log_warn)(`CallerManager: Vault whitelist not found in Redis (${vaultCallersKey}), using all ${this.callers.length} loaded wallets`);
             }
             if (this.callers.length === 0) {
                 throw new Error('CallerManager: no valid callers after whitelist matching');
@@ -51,14 +51,14 @@ class CallerManager {
                 const nonceKey = this.getNonceRedisKey();
                 const existing = yield this.redis.hgetvalue(nonceKey, address);
                 if (existing !== null && existing !== undefined) {
-                    (0, dist_1.log_info)(`Caller ${caller.address} nonce from Redis: ${existing}`);
+                    (0, ttd_core_1.log_info)(`Caller ${caller.address} nonce from Redis: ${existing}`);
                     return;
                 }
                 const nonce = yield this.config.provider.getTransactionCount(caller.address, 'pending');
                 yield this.redis.hsetValue(nonceKey, address, String(nonce), 24 * 60 * 60);
-                (0, dist_1.log_info)(`Caller ${caller.address} nonce from chain: ${nonce}`);
+                (0, ttd_core_1.log_info)(`Caller ${caller.address} nonce from chain: ${nonce}`);
             })));
-            (0, dist_1.log_info)(`CallerManager initialized, ${this.callers.length} active callers`, this.callers.map(w => w.address));
+            (0, ttd_core_1.log_info)(`CallerManager initialized, ${this.callers.length} active callers`, this.callers.map(w => w.address));
         });
     }
     acquireCaller() {
@@ -76,7 +76,7 @@ class CallerManager {
                         continue;
                     const nonce = yield this.getNonce(caller.address);
                     yield this.updateLastUsed(caller.address);
-                    (0, dist_1.log_info)(`acquireCaller: ${caller.address}, nonce=${nonce}, took ${Date.now() - startTime}ms`);
+                    (0, ttd_core_1.log_info)(`acquireCaller: ${caller.address}, nonce=${nonce}, took ${Date.now() - startTime}ms`);
                     const address = caller.address;
                     return {
                         wallet: caller,
@@ -87,7 +87,7 @@ class CallerManager {
                         })
                     };
                 }
-                yield (0, dist_1.sleep)(retryInterval);
+                yield (0, ttd_core_1.sleep)(retryInterval);
             }
             throw new Error(`acquireCaller failed: all ${this.callers.length} callers are busy, waited ${Date.now() - startTime}ms`);
         });
@@ -97,7 +97,7 @@ class CallerManager {
             const current = yield this.getNonce(address);
             if (confirmedNonce > current) {
                 yield this.setNonce(address, confirmedNonce);
-                (0, dist_1.log_info)(`confirmNonce: ${address}, ${current} → ${confirmedNonce}`);
+                (0, ttd_core_1.log_info)(`confirmNonce: ${address}, ${current} → ${confirmedNonce}`);
             }
         });
     }
@@ -106,7 +106,7 @@ class CallerManager {
             const current = yield this.getNonce(address);
             if (nonce !== current) {
                 yield this.setNonce(address, nonce);
-                (0, dist_1.log_info)(`forceSetNonce: ${address}, ${current} → ${nonce}`);
+                (0, ttd_core_1.log_info)(`forceSetNonce: ${address}, ${current} → ${nonce}`);
             }
         });
     }

package/dist/trade/check/tx_websocket_manager.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebSocketManager = void 0;
 const ethers_1 = require("ethers");
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 class WebSocketManager {
     constructor() {
         this.wsProvider = null;
@@ -50,32 +50,32 @@ class WebSocketManager {
     getWsProvider(wsEndpoint, network) {
         var _a;
         if (!wsEndpoint) {
-            (0, dist_1.log_warn)('WebSocket endpoint not configured');
+            (0, ttd_core_1.log_warn)('WebSocket endpoint not configured');
             return null;
         }
         if (!this.wsProvider) {
-            (0, dist_1.log_info)('Creating new WebSocket provider');
+            (0, ttd_core_1.log_info)('Creating new WebSocket provider');
             try {
                 this.wsProvider = new ethers_1.ethers.providers.WebSocketProvider(wsEndpoint, network);
                 this.wsProvider.on('error', (error) => {
-                    (0, dist_1.log_error)('[WS] provider error', Object.assign(Object.assign({}, this.formatConn(wsEndpoint, network)), this.formatErr(error)));
+                    (0, ttd_core_1.log_error)('[WS] provider error', Object.assign(Object.assign({}, this.formatConn(wsEndpoint, network)), this.formatErr(error)));
                     this.handleWsDisconnection(wsEndpoint, network);
                 });
                 const rawWs = (_a = this.wsProvider) === null || _a === void 0 ? void 0 : _a._websocket;
                 if (rawWs === null || rawWs === void 0 ? void 0 : rawWs.on) {
                     rawWs.on('close', (code, reason) => {
                         const reasonText = this.normalizeReason(reason);
-                        (0, dist_1.log_warn)('[WS] socket close', Object.assign(Object.assign({}, this.formatConn(wsEndpoint, network)), { code, reason: reasonText }));
+                        (0, ttd_core_1.log_warn)('[WS] socket close', Object.assign(Object.assign({}, this.formatConn(wsEndpoint, network)), { code, reason: reasonText }));
                         this.handleWsDisconnection(wsEndpoint, network);
                     });
                     rawWs.on('error', (err) => {
-                        (0, dist_1.log_error)('[WS] socket error', Object.assign(Object.assign({}, this.formatConn(wsEndpoint, network)), this.formatErr(err)));
+                        (0, ttd_core_1.log_error)('[WS] socket error', Object.assign(Object.assign({}, this.formatConn(wsEndpoint, network)), this.formatErr(err)));
                         this.handleWsDisconnection(wsEndpoint, network);
                     });
                 }
             }
             catch (error) {
-                (0, dist_1.log_error)('[WS] create provider failed', Object.assign(Object.assign({}, this.formatConn(wsEndpoint, network)), this.formatErr(error)));
+                (0, ttd_core_1.log_error)('[WS] create provider failed', Object.assign(Object.assign({}, this.formatConn(wsEndpoint, network)), this.formatErr(error)));
                 this.wsProvider = null;
             }
         }
@@ -97,16 +97,16 @@ class WebSocketManager {
     }
     incrementConnections() {
         this.wsConnections++;
-        (0, dist_1.log_info)(`WebSocket active connections: ${this.wsConnections}`);
+        (0, ttd_core_1.log_info)(`WebSocket active connections: ${this.wsConnections}`);
     }
     decrementConnections() {
         var _a, _b, _c, _d;
         if (this.wsConnections > 0) {
             this.wsConnections--;
         }
-        (0, dist_1.log_info)(`WebSocket active connections: ${this.wsConnections}`);
+        (0, ttd_core_1.log_info)(`WebSocket active connections: ${this.wsConnections}`);
         if (this.wsConnections === 0 && this.wsProvider) {
-            (0, dist_1.log_info)('No active connections, closing WebSocket');
+            (0, ttd_core_1.log_info)('No active connections, closing WebSocket');
             try {
                 this.wsProvider.removeAllListeners();
                 const rawWs = (_a = this.wsProvider) === null || _a === void 0 ? void 0 : _a._websocket;
@@ -119,7 +119,7 @@ class WebSocketManager {
     }
     listenToEvent(eventName, handler) {
         if (!this.wsProvider) {
-            (0, dist_1.log_warn)('WebSocket provider not available for event listener');
+            (0, ttd_core_1.log_warn)('WebSocket provider not available for event listener');
             return;
         }
         if (!this.eventListeners.has(eventName)) {

package/dist/trade/parse/base_parser.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseTxParser = void 0;
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 const ethers_1 = require("ethers");
 class BaseTxParser {
     constructor(config) {
@@ -66,7 +66,7 @@ class BaseTxParser {
             };
         }
         catch (error) {
-            (0, dist_1.log_error)('calculateGasFee error:', error);
+            (0, ttd_core_1.log_error)('calculateGasFee error:', error);
             return {
                 base_fee: 0,
                 priority_fee: 0,

package/dist/utils/gas_helper.js

@@ -11,18 +11,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EVMGasHelper = void 0;
 const ethers_1 = require("ethers");
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 class EVMGasHelper {
     static wrapNativeToken(provider_1, wallet_1, wrappedTokenAddress_1, amount_1) {
         return __awaiter(this, arguments, void 0, function* (provider, wallet, wrappedTokenAddress, amount, minReserve = "0.1", tokenSymbol = "ETH") {
             const nativeBalance = yield provider.getBalance(wallet.address);
             const nativeBalanceEth = ethers_1.ethers.utils.formatEther(nativeBalance);
-            (0, dist_1.log_info)(`当前${tokenSymbol}余额: ${nativeBalanceEth} ${tokenSymbol}`);
+            (0, ttd_core_1.log_info)(`当前${tokenSymbol}余额: ${nativeBalanceEth} ${tokenSymbol}`);
             let wrapAmount;
             if (amount === "max") {
                 const minReserveBN = ethers_1.ethers.utils.parseEther(minReserve);
                 if (nativeBalance.lte(minReserveBN)) {
-                    (0, dist_1.log_info)(`${tokenSymbol}余额不足最小保留额 ${minReserve} ${tokenSymbol}，不执行转换`);
+                    (0, ttd_core_1.log_info)(`${tokenSymbol}余额不足最小保留额 ${minReserve} ${tokenSymbol}，不执行转换`);
                     return null;
                 }
                 wrapAmount = nativeBalance.sub(minReserveBN);
@@ -31,19 +31,19 @@ class EVMGasHelper {
                 wrapAmount = ethers_1.ethers.utils.parseEther(amount);
                 const minReserveBN = ethers_1.ethers.utils.parseEther(minReserve);
                 if (nativeBalance.sub(wrapAmount).lt(minReserveBN)) {
-                    (0, dist_1.log_info)(`转换后${tokenSymbol}余额将低于最小保留额 ${minReserve} ${tokenSymbol}，调整转换金额`);
+                    (0, ttd_core_1.log_info)(`转换后${tokenSymbol}余额将低于最小保留额 ${minReserve} ${tokenSymbol}，调整转换金额`);
                     wrapAmount = nativeBalance.sub(minReserveBN);
                 }
             }
             if (wrapAmount.lte(ethers_1.ethers.constants.Zero)) {
-                (0, dist_1.log_info)(`计算的转换金额为0或负数，不执行转换`);
+                (0, ttd_core_1.log_info)(`计算的转换金额为0或负数，不执行转换`);
                 return null;
             }
             const wrappedTokenContract = new ethers_1.ethers.Contract(wrappedTokenAddress, [
                 "function deposit() external payable",
                 "function withdraw(uint wad) external"
             ], wallet);
-            (0, dist_1.log_info)(`准备将 ${ethers_1.ethers.utils.formatEther(wrapAmount)} ${tokenSymbol} 转换为 W${tokenSymbol}`);
+            (0, ttd_core_1.log_info)(`准备将 ${ethers_1.ethers.utils.formatEther(wrapAmount)} ${tokenSymbol} 转换为 W${tokenSymbol}`);
             const gasPrice = yield provider.getGasPrice();
             const txOptions = {
                 value: wrapAmount,
@@ -52,13 +52,13 @@ class EVMGasHelper {
             };
             try {
                 const tx = yield wrappedTokenContract.deposit(txOptions);
-                (0, dist_1.log_info)(`${tokenSymbol}转换为W${tokenSymbol}交易已发送，txHash: ${tx.hash}`);
+                (0, ttd_core_1.log_info)(`${tokenSymbol}转换为W${tokenSymbol}交易已发送，txHash: ${tx.hash}`);
                 yield tx.wait();
-                (0, dist_1.log_info)(`${tokenSymbol}转换为W${tokenSymbol}交易已确认，txHash: ${tx.hash}`);
+                (0, ttd_core_1.log_info)(`${tokenSymbol}转换为W${tokenSymbol}交易已确认，txHash: ${tx.hash}`);
                 return tx.hash;
             }
             catch (error) {
-                (0, dist_1.log_error)(`${tokenSymbol}转换为W${tokenSymbol}失败: ${error.message}`, error);
+                (0, ttd_core_1.log_error)(`${tokenSymbol}转换为W${tokenSymbol}失败: ${error.message}`, error);
                 throw error;
             }
         });

package/dist/utils/index.d.ts

@@ -1,6 +1,7 @@
 import { ethers } from "ethers";
 import Decimal from "decimal.js";
 export * from './gas_helper';
+export * from './trade_direction';
 export declare const sleep: (ms: number) => Promise<void>;
 export declare const formatPrice: (price: number, precision?: number) => string;
 export declare const formatUnits: (value: ethers.BigNumber, decimals: number) => Decimal;

package/dist/utils/index.js

@@ -21,6 +21,7 @@ exports.formatNumberHighPrecision = exports.formatUnits = exports.formatPrice =
 const ethers_1 = require("ethers");
 const decimal_js_1 = __importDefault(require("decimal.js"));
 __exportStar(require("./gas_helper"), exports);
+__exportStar(require("./trade_direction"), exports);
 const sleep = (ms) => {
     return new Promise(resolve => setTimeout(resolve, ms));
 };

package/dist/utils/trade_direction.d.ts

@@ -0,0 +1,14 @@
+export interface TradeDirectionResult<T = any> {
+    isBuy: boolean;
+    inputToken: T;
+    outputToken: T;
+    baseToken: T;
+    quoteToken: T;
+}
+export declare function resolveTradeDirection<T = any>(poolInfo: {
+    tokenA: T;
+    tokenB: T;
+    quote_token: string;
+    [key: string]: any;
+}, isBuy: boolean): TradeDirectionResult<T>;
+export declare function calculateStandardPrice(inputAmount: number, outputAmount: number, isBuy: boolean): string;

package/dist/utils/trade_direction.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTradeDirection = resolveTradeDirection;
+exports.calculateStandardPrice = calculateStandardPrice;
+function resolveTradeDirection(poolInfo, isBuy) {
+    const { tokenA, tokenB, quote_token } = poolInfo;
+    const quoteToken = [tokenA, tokenB].find(t => t.symbol === quote_token);
+    const baseToken = [tokenA, tokenB].find(t => t.symbol !== quote_token);
+    if (!quoteToken || !baseToken) {
+        throw new Error(`Cannot resolve tokens: tokenA=${tokenA === null || tokenA === void 0 ? void 0 : tokenA.symbol}, tokenB=${tokenB === null || tokenB === void 0 ? void 0 : tokenB.symbol}, quote_token=${quote_token}`);
+    }
+    const inputToken = isBuy ? quoteToken : baseToken;
+    const outputToken = isBuy ? baseToken : quoteToken;
+    return { isBuy, inputToken, outputToken, baseToken, quoteToken };
+}
+function calculateStandardPrice(inputAmount, outputAmount, isBuy) {
+    if (isBuy) {
+        return (inputAmount / outputAmount).toFixed(18);
+    }
+    else {
+        return (outputAmount / inputAmount).toFixed(18);
+    }
+}

package/dist/ws/event_filter.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventFilter = void 0;
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 class EventFilter {
     static initializeCleanup() {
         if (this.cleanupInitialized) {
@@ -21,7 +21,7 @@ class EventFilter {
         this.initializeCleanup();
         const key = `${poolAddress}-${blockNumber}-${eventType.toUpperCase()}`;
         if (this.poolEventMap.has(key)) {
-            (0, dist_1.log_warn)(`Event ${eventType} already occurred on pool: ${poolAddress}, block: ${blockNumber}`);
+            (0, ttd_core_1.log_warn)(`Event ${eventType} already occurred on pool: ${poolAddress}, block: ${blockNumber}`);
             return false;
         }
         this.poolEventMap.set(key, Date.now());

package/dist/yyws/yyws_client.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.subscribe_pool_price_from_yyws = subscribe_pool_price_from_yyws;
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 const ws_client_1 = require("@clonegod/ttd-core/dist/ws/ws_client");
 function subscribe_pool_price_from_yyws(poolInfoList, callback) {
     const ws_url = process.env.SUBSCIBE_YY_WS_URL || 'ws://43.165.135.114:10100/ws';
@@ -70,7 +70,7 @@ function log_yyws_price_msg(poolInfo, priceData) {
             const { poolAddress, token0, token1, askToken0InToken1, bidToken0InToken1, askToken1InToken0, bidToken1InToken0 } = poolPrice;
             line += `${token0}/${token1} - ${poolAddress} - ${askToken0InToken1} - ${bidToken0InToken1} - ${askToken1InToken0} - ${bidToken1InToken0}\n`;
         }
-        (0, dist_1.appendLogWithPeriodicReset)("logs", `yyws-price-msg-${poolInfo.pool_address}.txt`, line, 10)
+        (0, ttd_core_1.appendLogWithPeriodicReset)("logs", `yyws-price-msg-${poolInfo.pool_address}.txt`, line, 10)
             .catch(err => console.error('log_yyws_price_msg error', err));
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clonegod/ttd-bsc-common",
-  "version": "2.0.1",
+  "version": "3.0.2",
   "description": "BSC common library",
   "license": "UNLICENSED",
   "main": "dist/index.js",
@@ -14,7 +14,7 @@
     "push": "npm run build && npm publish"
   },
   "dependencies": {
-    "@clonegod/ttd-core": "2.1.37",
+    "@clonegod/ttd-core": "3.0.3",
     "@clonegod/ttd-bsc-send-tx": "1.0.0",
     "axios": "^1.12.0",
     "dotenv": "^16.4.7",