@clonegod/ttd-bsc-common 3.0.4 → 3.0.5

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()}`);
         });
     }
@@ -83,20 +82,20 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
             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);
@@ -148,7 +147,7 @@ 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;
                             }
                         }
@@ -164,27 +163,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,15 @@
+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>;
+    start_ws_listener(): Promise<void>;
+    private processTransactionResult;
+}

package/dist/trade/check/base_tx_result_checker.js

@@ -0,0 +1,123 @@
+"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 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* () {
+            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}`);
+                this.processTransactionResult(receipt, 'websocket')
+                    .catch(err => (0, ttd_core_1.log_error)(`Error processing trade result: ${txHash}`, err))
+                    .finally(() => ws.disconnect());
+            });
+            ws.connect();
+            setTimeout(() => { ws.disconnect(); }, 30000);
+        });
+    }
+    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.5",
   "description": "BSC common library",
   "license": "UNLICENSED",
   "main": "dist/index.js",