@clonegod/ttd-bsc-common 3.0.4 → 3.0.6

package/dist/trade/abstract_dex_trade.d.ts

@@ -28,7 +28,6 @@ export declare abstract class AbstractDexTrade extends AbastrcatTrade {
     abstract encodeTradeData(context: TradeContext): TradeCalldata;
     init(): Promise<void>;
     execute(context: TradeContext): Promise<string>;
-    private subscribeTradeMonitor;
     protected getGasPriceGwei(context: TradeContext): string;
     protected getBuilderTipAmoutGwei(context: TradeContext): string;
     protected buildTipTransferTx(to: string, transfer_amount_gwei: string, gas_price_gwei: string, nonce: number, wallet: ethers.Wallet): Promise<string>;

package/dist/trade/abstract_dex_trade.js

@@ -61,7 +61,6 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
                 chainId: this.chainConfig.chainId,
             });
             yield this.callerManager.init();
-            this.subscribeTradeMonitor();
             (0, ttd_core_1.log_info)(`AbstractDexTrade initialized, vault=${this.tradeConfig.vaultAddress}, callers=${this.callerManager.getCallerCount()}`);
         });
     }
@@ -70,33 +69,36 @@ 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();
             const { wallet: caller, nonce: initialNonce } = callerHandle;
             try {
                 let nonce = initialNonce;
-                let nonce_from_error = 0;
+                let nonce_from_error = -1;
                 let txid = '';
                 let i = 1;
                 do {
                     try {
                         if (i > 1) {
-                            if (nonce_from_error > 0) {
+                            if (nonce_from_error >= 0) {
                                 nonce = nonce_from_error;
-                                nonce_from_error = 0;
+                                nonce_from_error = -1;
                                 (0, ttd_core_1.log_info)(`Attempt ${i}/${maxAttempts}, using nonce from error msg: ${nonce}`, {}, order_trace_id);
                             }
                             else {
-                                (0, ttd_core_1.log_warn)(`Attempt ${i}/${maxAttempts}, no nonce in error msg, abort`, {}, order_trace_id);
-                                break;
+                                nonce = yield this.provider.getTransactionCount(caller.address, 'pending');
+                                (0, ttd_core_1.log_info)(`Attempt ${i}/${maxAttempts}, using nonce from chain: ${nonce}`, {}, order_trace_id);
                             }
                         }
                         const { executorId, data } = this.encodeTradeData(context);
@@ -115,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);
@@ -124,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;
                     }
@@ -148,14 +150,14 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
                         (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) {
+                            if (correctNonce !== null && correctNonce >= 0) {
                                 nonce_from_error = correctNonce;
                             }
                         }
                     }
                 } while (++i <= maxAttempts);
                 if (!txid) {
-                    throw new Error(`Vault 交易执行失败，已重试 ${maxAttempts} 次，orderId: ${order_trace_id}`);
+                    throw new Error(`交易执行失败，已重试 ${maxAttempts} 次，orderId: ${order_trace_id}`);
                 }
                 return txid;
             }
@@ -164,27 +166,6 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
             }
         });
     }
-    subscribeTradeMonitor() {
-        const host = process.env.STREAM_TRADE_HOST || '127.0.0.1';
-        const wsUrl = `ws://${host}:${ttd_core_1.SERVICE_PORT.STREAM_TRADE_WS}`;
-        const wsClient = new ttd_core_1.WebSocketClient(wsUrl);
-        wsClient.onOpen(() => {
-            wsClient.send(JSON.stringify({
-                address: 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, ttd_core_1.log_warn)(`Failed to confirm nonce from trade-monitor`, err));
-                }
-            }
-        });
-        wsClient.connect();
-    }
     getGasPriceGwei(context) {
         let { evm_gas_price_gwei } = context.trade_runtime.settings.strategy;
         if (!evm_gas_price_gwei || evm_gas_price_gwei <= 0) {

package/dist/trade/caller_manager.js

@@ -82,7 +82,6 @@ class CallerManager {
                         wallet: caller,
                         nonce,
                         release: () => __awaiter(this, void 0, void 0, function* () {
-                            yield this.advanceNonce(address, nonce + 2);
                             yield this.redis.releaseLock(lockKey, lockValue);
                         })
                     };

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

@@ -0,0 +1,14 @@
+import { EnvArgs } from '@clonegod/ttd-core';
+import { AbstractTransactionResultCheck } from "@clonegod/ttd-core/dist/trade";
+import { ethers } from 'ethers';
+import { EventEmitter } from 'events';
+export declare abstract class BaseTxResultChecker extends AbstractTransactionResultCheck {
+    protected provider: ethers.providers.JsonRpcProvider;
+    constructor(env_args: EnvArgs, event_emitter: EventEmitter);
+    protected abstract createParser(): {
+        parseTransaction(txReceipt: any, poolInfo: any): Promise<any>;
+    };
+    check_tx_result_interval(): Promise<void>;
+    on_subscibe_transaction(): Promise<void>;
+    private processTransactionResult;
+}

package/dist/trade/check/base_tx_result_checker.js

@@ -0,0 +1,150 @@
+"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.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);
+        this.provider = new ethers_1.ethers.providers.JsonRpcProvider(this.env_args.rpc_endpoint);
+    }
+    check_tx_result_interval() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const check_start_time = Date.now();
+            const check_interval = parseInt(process.env.CHECK_TX_RESULT_INTERVAL_MILLS || '3000');
+            const check_timeout = parseInt(process.env.CHECK_TX_RESULT_TIMEOUT_MILLS || '15000');
+            if (check_interval >= check_timeout)
+                return;
+            const intervalId = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                this.check_count += 1;
+                (0, ttd_core_1.log_info)(`check transaction start: seq=[${this.check_count}], txhash=${this.txid}, trace_id=${this.trace_id}`);
+                try {
+                    if (Date.now() - check_start_time < check_timeout) {
+                        let txReceipt = yield this.provider.getTransactionReceipt(this.txid);
+                        if (!txReceipt)
+                            return;
+                        (0, ttd_core_1.log_info)(`Received transaction result via polling: ${this.txid}`);
+                        clearInterval(intervalId);
+                        yield this.processTransactionResult(txReceipt, 'interval');
+                    }
+                    else {
+                        clearInterval(intervalId);
+                    }
+                }
+                catch (err) {
+                    clearInterval(intervalId);
+                    (0, ttd_core_1.log_error)('parse transaction error!', err);
+                }
+            }), check_interval);
+            this.intervalId = intervalId;
+        });
+    }
+    on_subscibe_transaction() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (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: ${this.txid}`, err));
+            });
+        });
+    }
+    processTransactionResult(txReceipt, source) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ttd_core_1.LOG.debug) {
+                (0, ttd_core_1.writeFile)(`./dist/tx_receipt_${this.txid}_${source}.json`, JSON.stringify(txReceipt, null, 2));
+            }
+            if (this.trade_result_already_processed) {
+                (0, ttd_core_1.log_warn)(`trade_result_already_processed, ignore result from ${source}!`);
+                return;
+            }
+            const parser = this.createParser();
+            const swap_detail = yield parser.parseTransaction(txReceipt, this.pool_info);
+            let trade_result = this.map_swap_result_to_tx_result(swap_detail);
+            this.trade_result_already_processed = true;
+            if (this.intervalId) {
+                clearInterval(this.intervalId);
+                this.intervalId = null;
+            }
+            if (trade_result.success) {
+                this.event_emitter.emit(ttd_core_1.TRANSACTION_STATE_SUCCESS, trade_result);
+            }
+            else {
+                this.event_emitter.emit(ttd_core_1.TRANSACTION_STATE_FAILED, trade_result);
+            }
+            if (source === 'interval') {
+                console.log('--------------------- Transaction Result from Polling ---------------------');
+            }
+            else {
+                console.log('===================== Transaction Result from stream-trade =====================');
+            }
+            console.log(JSON.stringify(trade_result, null, 2));
+            console.log('-----------------------------------------------------------------------------');
+        });
+    }
+}
+exports.BaseTxResultChecker = BaseTxResultChecker;

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

@@ -1 +1 @@
-export * from "./tx_websocket_manager";
+export * from "./base_tx_result_checker";

package/dist/trade/check/index.js

@@ -14,4 +14,4 @@ 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("./tx_websocket_manager"), exports);
+__exportStar(require("./base_tx_result_checker"), exports);

package/dist/trade/parse/base_parser.js

@@ -44,17 +44,17 @@ class BaseTxParser {
     }
     calculateGasFee(txReceipt) {
         try {
-            const gasUsed = txReceipt.gasUsed
-                ? (typeof txReceipt.gasUsed === 'string' || typeof txReceipt.gasUsed === 'number'
-                    ? ethers_1.ethers.BigNumber.from(txReceipt.gasUsed)
-                    : txReceipt.gasUsed)
-                : ethers_1.ethers.BigNumber.from(0);
-            const gasPriceValue = txReceipt.effectiveGasPrice || txReceipt.gasPrice;
-            const effectiveGasPrice = gasPriceValue
-                ? (typeof gasPriceValue === 'string' || typeof gasPriceValue === 'number'
-                    ? ethers_1.ethers.BigNumber.from(gasPriceValue)
-                    : gasPriceValue)
-                : ethers_1.ethers.BigNumber.from(0);
+            const toBN = (val) => {
+                if (!val)
+                    return ethers_1.ethers.BigNumber.from(0);
+                if (ethers_1.ethers.BigNumber.isBigNumber(val))
+                    return val;
+                if (val.hex)
+                    return ethers_1.ethers.BigNumber.from(val.hex);
+                return ethers_1.ethers.BigNumber.from(val);
+            };
+            const gasUsed = toBN(txReceipt.gasUsed);
+            const effectiveGasPrice = toBN(txReceipt.effectiveGasPrice || txReceipt.gasPrice);
             const gasFeeBN = gasUsed.mul(effectiveGasPrice);
             const base_fee = Number(ethers_1.ethers.utils.formatEther(gasFeeBN));
             const priority_fee = 0;

package/package.json

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