@clonegod/ttd-bsc-common 3.0.5 → 3.0.7

package/dist/trade/abstract_dex_trade.js

@@ -69,13 +69,16 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
             var _a;
             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, ttd_core_1.log_info)(`执行 Vault 交易, orderId=${order_trace_id}`, {
-                unique_order_msg_id,
+            const { isBuy, amount } = order_msg;
+            const { inputToken, outputToken } = this.determineInputOutputTokens(order_msg, pool_info);
+            const amountOutMin = this.calculateAmountOutMin(context, inputToken, outputToken);
+            (0, ttd_core_1.log_info)(`执行交易`, {
+                orderId: order_trace_id,
                 pair,
-                aToB,
-                amount,
-                slippage_bps
+                direction: isBuy ? 'BUY' : 'SELL',
+                input: `${amount} ${inputToken.symbol}`,
+                outputMin: `${ethers_1.ethers.utils.formatUnits(amountOutMin, outputToken.decimals)} ${outputToken.symbol}`,
+                slippage: `${slippage_bps / 100}%`,
             });
             let maxAttempts = Math.min(Math.max(parseInt(process.env.NONCE_LOCK_MAX_RETRIES || '3'), 1), 3);
             const callerHandle = yield this.callerManager.acquireCaller();
@@ -114,7 +117,7 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
                         };
                         const signedTx = yield caller.signTransaction(tx);
                         txid = ethers_1.ethers.utils.keccak256(signedTx);
-                        (0, ttd_core_1.log_info)(`Vault 交易已签名`, { txid, nonce, gasPriceGwei: realGasPriceGwei }, order_trace_id);
+                        (0, ttd_core_1.log_info)(`交易已签名`, { txid, nonce, caller: caller.address, 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);
@@ -123,9 +126,9 @@ class AbstractDexTrade extends ttd_core_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, ttd_core_1.log_info)(`Vault 交易发送成功`, {
-                            pair, unique_order_msg_id, txid,
-                            attempt: i, caller: caller.address
+                        (0, ttd_core_1.log_info)(`交易发送成功`, {
+                            pair, direction: isBuy ? 'BUY' : 'SELL',
+                            txid, attempt: i, caller: caller.address
                         }, order_trace_id);
                         return txid;
                     }
@@ -154,7 +157,7 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
                     }
                 } while (++i <= maxAttempts);
                 if (!txid) {
-                    throw new Error(`Vault 交易执行失败，已重试 ${maxAttempts} 次，orderId: ${order_trace_id}`);
+                    throw new Error(`交易执行失败，已重试 ${maxAttempts} 次，orderId: ${order_trace_id}`);
                 }
                 return txid;
             }

package/dist/trade/check/base_tx_result_checker.d.ts

@@ -10,6 +10,5 @@ export declare abstract class BaseTxResultChecker extends AbstractTransactionRes
     };
     check_tx_result_interval(): Promise<void>;
     on_subscibe_transaction(): Promise<void>;
-    start_ws_listener(): Promise<void>;
     private processTransactionResult;
 }

package/dist/trade/check/base_tx_result_checker.js

@@ -13,6 +13,60 @@ exports.BaseTxResultChecker = void 0;
 const ttd_core_1 = require("@clonegod/ttd-core");
 const trade_1 = require("@clonegod/ttd-core/dist/trade");
 const ethers_1 = require("ethers");
+class TradeResultSubscriber {
+    constructor() {
+        this.ws = null;
+        this.connected = false;
+        this.listeners = new Map();
+    }
+    static getInstance() {
+        if (!TradeResultSubscriber.instance) {
+            TradeResultSubscriber.instance = new TradeResultSubscriber();
+        }
+        return TradeResultSubscriber.instance;
+    }
+    listen(txHash, callback, timeoutMs = 30000) {
+        const key = txHash.toLowerCase();
+        this.listeners.set(key, callback);
+        setTimeout(() => {
+            this.listeners.delete(key);
+        }, timeoutMs);
+        this.ensureConnected();
+    }
+    remove(txHash) {
+        this.listeners.delete(txHash.toLowerCase());
+    }
+    ensureConnected() {
+        if (this.ws && this.connected)
+            return;
+        const host = process.env.STREAM_TRADE_WS_HOST || '127.0.0.1';
+        const wsUrl = `ws://${host}:${ttd_core_1.SERVICE_PORT.STREAM_TRADE_WS}`;
+        this.ws = new ttd_core_1.WebSocketClient(wsUrl);
+        this.ws.onOpen(() => {
+            this.connected = true;
+            const addresses = (process.env.VAULT_ADDRESS || '').split(',').map(a => a.trim()).filter(Boolean);
+            for (const addr of addresses) {
+                this.ws.send(JSON.stringify({ address: addr }));
+            }
+            (0, ttd_core_1.log_info)(`TradeResultSubscriber connected: ${wsUrl}`);
+        });
+        this.ws.onMessage((msg) => {
+            if (msg.type !== 'TradeResult' || !msg.data)
+                return;
+            const { txHash, receipt } = msg.data;
+            if (!txHash || !receipt)
+                return;
+            const key = txHash.toLowerCase();
+            const callback = this.listeners.get(key);
+            if (callback) {
+                this.listeners.delete(key);
+                callback(receipt);
+            }
+        });
+        this.ws.connect();
+    }
+}
+TradeResultSubscriber.instance = null;
 class BaseTxResultChecker extends trade_1.AbstractTransactionResultCheck {
     constructor(env_args, event_emitter) {
         super(env_args, event_emitter);
@@ -51,39 +105,12 @@ class BaseTxResultChecker extends trade_1.AbstractTransactionResultCheck {
     }
     on_subscibe_transaction() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.start_ws_listener();
-        });
-    }
-    start_ws_listener() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const host = process.env.STREAM_TRADE_WS_HOST || '127.0.0.1';
-            const wsUrl = `ws://${host}:${ttd_core_1.SERVICE_PORT.STREAM_TRADE_WS}`;
-            (0, ttd_core_1.log_info)(`Subscribing trade result from stream-trade: ${wsUrl}, txid=${this.txid}`);
-            const ws = new ttd_core_1.WebSocketClient(wsUrl);
-            ws.onOpen(() => {
-                const vaultAddress = process.env.VAULT_ADDRESS || '';
-                if (vaultAddress) {
-                    ws.send(JSON.stringify({ address: vaultAddress }));
-                }
-            });
-            ws.onMessage((msg) => {
-                var _a;
-                if (msg.type !== 'TradeResult' || !msg.data)
-                    return;
-                const { txHash, receipt } = msg.data;
-                if ((txHash === null || txHash === void 0 ? void 0 : txHash.toLowerCase()) !== ((_a = this.txid) === null || _a === void 0 ? void 0 : _a.toLowerCase()))
-                    return;
-                if (!receipt) {
-                    (0, ttd_core_1.log_warn)(`TradeResult received but no receipt: ${txHash}`);
-                    return;
-                }
-                (0, ttd_core_1.log_info)(`Received transaction result via stream-trade: ${txHash}`);
+            (0, ttd_core_1.log_info)(`Subscribing trade result, txid=${this.txid}`);
+            TradeResultSubscriber.getInstance().listen(this.txid, (receipt) => {
+                (0, ttd_core_1.log_info)(`Received transaction result via stream-trade: ${this.txid}`);
                 this.processTransactionResult(receipt, 'websocket')
-                    .catch(err => (0, ttd_core_1.log_error)(`Error processing trade result: ${txHash}`, err))
-                    .finally(() => ws.disconnect());
+                    .catch(err => (0, ttd_core_1.log_error)(`Error processing trade result: ${this.txid}`, err));
             });
-            ws.connect();
-            setTimeout(() => { ws.disconnect(); }, 30000);
         });
     }
     processTransactionResult(txReceipt, source) {

package/dist/utils/index.d.ts

@@ -2,6 +2,7 @@ import { ethers } from "ethers";
 import Decimal from "decimal.js";
 export * from './gas_helper';
 export * from './trade_direction';
+export * from './pool_filter';
 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

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

package/dist/utils/pool_filter.d.ts

@@ -0,0 +1,8 @@
+import { StandardPoolInfoType } from '@clonegod/ttd-core';
+export interface PoolFilterParams {
+    poolAddress?: string;
+    poolName?: string;
+    feeRate?: number;
+}
+export declare function buildPoolFilterFromEnv(envArgs: any): PoolFilterParams;
+export declare function filterPools(pools: StandardPoolInfoType[], filter: PoolFilterParams, label?: string): StandardPoolInfoType[];

package/dist/utils/pool_filter.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPoolFilterFromEnv = buildPoolFilterFromEnv;
+exports.filterPools = filterPools;
+const ttd_core_1 = require("@clonegod/ttd-core");
+function buildPoolFilterFromEnv(envArgs) {
+    return {
+        poolAddress: envArgs.quote_pool_address || undefined,
+        poolName: envArgs.quote_pool_name || undefined,
+        feeRate: envArgs.quote_pool_fee_rate || undefined,
+    };
+}
+function filterPools(pools, filter, label = '') {
+    const prefix = label ? `[${label}] ` : '';
+    let result = pools;
+    if (filter.poolAddress) {
+        result = pools.filter(p => p.pool_address.toLowerCase() === filter.poolAddress.toLowerCase());
+    }
+    else if (filter.poolName || filter.feeRate) {
+        result = pools.filter(p => {
+            if (filter.poolName && p.pool_name !== filter.poolName)
+                return false;
+            if (filter.feeRate && p.fee_rate !== filter.feeRate)
+                return false;
+            return true;
+        });
+    }
+    if (result.length === 0 && pools.length > 0) {
+        (0, ttd_core_1.log_warn)(`${prefix}Pool filter matched 0 pools from ${pools.length}`, {
+            filter,
+            available: pools.map(p => `${p.pool_name}(${p.pool_address}, fee=${p.fee_rate})`),
+        });
+    }
+    else {
+        (0, ttd_core_1.log_info)(`${prefix}Pool filter: ${pools.length} → ${result.length}`, result.map(p => `${p.pool_name}(${p.pool_address}, fee=${p.fee_rate})`));
+    }
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clonegod/ttd-bsc-common",
-  "version": "3.0.5",
+  "version": "3.0.7",
   "description": "BSC common library",
   "license": "UNLICENSED",
   "main": "dist/index.js",