@clonegod/ttd-base-common 1.0.25 → 1.1.1

package/dist/trade/caller_manager.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallerManager = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const logger = (0, dist_1.createLogger)(__filename);
+const ethers_1 = require("ethers");
+const ttd_core_1 = require("@clonegod/ttd-core");
+const LUA_ACQUIRE_CALLER = `
+local last_used_key = KEYS[1]
+local now = tonumber(ARGV[#ARGV])
+local count = #ARGV - 1
+
+local min_ts = nil
+local min_addr = nil
+for i = 1, count do
+    local addr = ARGV[i]
+    local ts_raw = redis.call('HGET', last_used_key, addr)
+    local ts = ts_raw and tonumber(ts_raw) or 0
+    if min_ts == nil or ts < min_ts then
+        min_ts = ts
+        min_addr = addr
+    end
+end
+if min_addr then
+    redis.call('HSET', last_used_key, min_addr, tostring(now))
+end
+return min_addr
+`;
+const CALLER_NONCE_KEY = 'caller:nonce';
+const CALLER_LAST_USED_KEY = 'caller:last_used';
+const VAULT_CALLERS_KEY = 'vault:callers';
+class CallerManager {
+    constructor(config) {
+        this.callers = [];
+        this.config = config;
+        this.redis = new ttd_core_1.RedisClient(`${config.chainName}:caller`);
+    }
+    async init() {
+        const walletInfos = (0, dist_1.load_wallet_multi)(this.config.callerGroupIds, false);
+        const allWallets = walletInfos.map(info => new ethers_1.ethers.Wallet(info.private_key, this.config.provider));
+        const vaultCallersKey = `${this.config.chainName}:${VAULT_CALLERS_KEY}`;
+        const rawJson = await this.redis.hget(vaultCallersKey, this.config.groupId);
+        let allowedAddresses = [];
+        if (rawJson) {
+            try {
+                allowedAddresses = JSON.parse(rawJson);
+            }
+            catch (err) {
+                logger.error(`CallerManager: failed to parse vault whitelist for group ${this.config.groupId}`, err);
+            }
+        }
+        let skipped = [];
+        if (allowedAddresses.length > 0) {
+            const allowedSet = new Set(allowedAddresses.map(a => a.toLowerCase()));
+            this.callers = allWallets.filter(w => allowedSet.has(w.address.toLowerCase()));
+            skipped = allWallets.filter(w => !allowedSet.has(w.address.toLowerCase()));
+        }
+        else {
+            this.callers = allWallets;
+            logger.warn(`CallerManager: Vault whitelist not found in Redis (${vaultCallersKey} -> ${this.config.groupId}), using all ${this.callers.length} loaded wallets`);
+        }
+        if (this.callers.length === 0) {
+            throw new Error('CallerManager: no valid callers after whitelist matching');
+        }
+        const nonceKey = this.getNonceRedisKey();
+        const callerAddresses = this.callers.map(c => c.address.toLowerCase());
+        const nonces = await this.redis.hmget(nonceKey, callerAddresses);
+        const callerSummary = {};
+        let missingNonceCount = 0;
+        this.callers.forEach((caller, i) => {
+            const nonce = nonces[i];
+            if (nonce === null || nonce === undefined) {
+                callerSummary[caller.address] = 'MISSING';
+                missingNonceCount++;
+            }
+            else {
+                callerSummary[caller.address] = `nonce=${nonce}`;
+            }
+        });
+        if (missingNonceCount > 0) {
+            logger.warn(`CallerManager: ${missingNonceCount} callers nonce not found in Redis, stream-trade may not be running`);
+        }
+        logger.info(`CallerManager initialized for ${this.config.groupId}: loaded=${allWallets.length}, active=${this.callers.length}, skipped=${skipped.length}`, callerSummary);
+    }
+    async acquireCaller() {
+        const strategy = (0, dist_1.getCoreEnv)()?.caller_select_strategy;
+        if (strategy === 'lua_cas') {
+            return this.acquireCallerWithLuaCas();
+        }
+        return this.acquireCallerWithLock();
+    }
+    async acquireCallerWithLock() {
+        const lockKey = `${this.config.chainName}:caller:lock:select`;
+        const lockValue = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        const lockExpireSeconds = 1;
+        const maxRetries = 20;
+        const retryDelayMs = 10;
+        const startTime = Date.now();
+        let acquired = false;
+        let retries = 0;
+        for (; retries < maxRetries; retries++) {
+            acquired = await this.redis.acquireLock(lockKey, lockValue, lockExpireSeconds);
+            if (acquired)
+                break;
+            await new Promise(r => setTimeout(r, retryDelayMs));
+        }
+        if (!acquired) {
+            throw new Error(`acquireCaller: failed to acquire lock after ${maxRetries} retries (${Date.now() - startTime}ms)`);
+        }
+        const lockAcquiredTime = Date.now();
+        let callerAddr;
+        let selectedIdx;
+        try {
+            const addresses = this.callers.map(w => w.address.toLowerCase());
+            const lastUsedKey = this.getLastUsedRedisKey();
+            const lastUsedData = await this.redis.hgetall(lastUsedKey);
+            selectedIdx = 0;
+            let minLastUsed = Number.MAX_SAFE_INTEGER;
+            for (let i = 0; i < this.callers.length; i++) {
+                const redisTs = parseInt(lastUsedData?.[addresses[i]] || '0', 10);
+                if (redisTs < minLastUsed) {
+                    minLastUsed = redisTs;
+                    selectedIdx = i;
+                }
+            }
+            callerAddr = addresses[selectedIdx];
+            await this.redis.hset(lastUsedKey, callerAddr, String(Date.now()), 24 * 60 * 60);
+        }
+        finally {
+            this.redis.releaseLock(lockKey, lockValue).catch(() => { });
+        }
+        const nonce = await this.readNonce(callerAddr);
+        const totalMs = Date.now() - startTime;
+        const lockWaitMs = lockAcquiredTime - startTime;
+        logger.info(`acquireCaller[lock]: ${callerAddr} nonce=${nonce}, lock_wait=${lockWaitMs}ms, total=${totalMs}ms${retries > 0 ? `, retries=${retries}` : ''}`);
+        return { wallet: this.callers[selectedIdx], nonce };
+    }
+    async acquireCallerWithLuaCas() {
+        const startTime = Date.now();
+        const lastUsedKey = this.getLastUsedRedisKey();
+        const addresses = this.callers.map(w => w.address.toLowerCase());
+        const now = Date.now();
+        const selectedAddr = await this.redis.eval(LUA_ACQUIRE_CALLER, [lastUsedKey], [...addresses, String(now)]);
+        if (!selectedAddr) {
+            throw new Error('acquireCaller[lua_cas]: script returned no caller');
+        }
+        const selectedIdx = addresses.indexOf(selectedAddr);
+        if (selectedIdx < 0) {
+            throw new Error(`acquireCaller[lua_cas]: selected addr ${selectedAddr} not in pool`);
+        }
+        const nonce = await this.readNonce(selectedAddr);
+        logger.info(`acquireCaller[lua_cas]: ${selectedAddr} nonce=${nonce}, total=${Date.now() - startTime}ms`);
+        return { wallet: this.callers[selectedIdx], nonce };
+    }
+    async readNonce(callerAddr) {
+        const nonceKey = this.getNonceRedisKey();
+        const nonceStr = await this.redis.hget(nonceKey, callerAddr);
+        if (nonceStr === null || nonceStr === undefined) {
+            throw new Error(`Caller ${callerAddr} nonce not found in Redis, stream-trade may not be running`);
+        }
+        return parseInt(nonceStr, 10);
+    }
+    async confirmNonce(address, confirmedNonce) {
+        const current = await this.getNonce(address);
+        if (confirmedNonce > current) {
+            await this.setNonce(address, confirmedNonce);
+            logger.info(`confirmNonce: ${address}, ${current} → ${confirmedNonce}`);
+        }
+    }
+    async forceSetNonce(address, nonce) {
+        const current = await this.getNonce(address);
+        if (nonce !== current) {
+            await this.setNonce(address, nonce);
+            logger.info(`forceSetNonce: ${address}, ${current} → ${nonce}`);
+        }
+    }
+    getCallerCount() {
+        return this.callers.length;
+    }
+    getCallerAddresses() {
+        return this.callers.map(w => w.address);
+    }
+    getNonceRedisKey() {
+        return `${this.config.chainName}:${CALLER_NONCE_KEY}`;
+    }
+    getLastUsedRedisKey() {
+        return `${this.config.chainName}:${CALLER_LAST_USED_KEY}`;
+    }
+    async getNonce(address) {
+        const nonceKey = this.getNonceRedisKey();
+        const val = await this.redis.hget(nonceKey, address.toLowerCase());
+        if (val !== null && val !== undefined) {
+            return parseInt(val, 10);
+        }
+        throw new Error(`Caller ${address} nonce not found in Redis, init() may not have been called`);
+    }
+    async setNonce(address, nonce) {
+        const nonceKey = this.getNonceRedisKey();
+        await this.redis.hset(nonceKey, address.toLowerCase(), String(nonce), 24 * 60 * 60);
+    }
+}
+exports.CallerManager = CallerManager;

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

@@ -0,0 +1,28 @@
+import { EnvArgs } from '@clonegod/ttd-core';
+import { AbstractTransactionResultCheck } from "@clonegod/ttd-core/dist/trade";
+import { EventEmitter } from 'events';
+export declare class TradeResultSubscriber {
+    private static instance;
+    private ws;
+    private connected;
+    private listeners;
+    static getInstance(): TradeResultSubscriber;
+    listen(txHash: string, callback: (receipt: any) => void, timeoutMs?: number): void;
+    remove(txHash: string): void;
+    sendNonceWatch(caller: string, txHash: string): void;
+    private cachedSubscriptions;
+    private cachedClientName;
+    private getSubscriptions;
+    private getClientName;
+    private ensureConnected;
+}
+export declare abstract class AbstractTxResultChecker extends AbstractTransactionResultCheck {
+    protected provider: any;
+    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/abstract_tx_result_checker.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractTxResultChecker = exports.TradeResultSubscriber = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const logger = (0, ttd_core_1.createLogger)(__filename);
+const trade_1 = require("@clonegod/ttd-core/dist/trade");
+const ethers_compat_1 = require("../../utils/ethers_compat");
+class TradeResultSubscriber {
+    constructor() {
+        this.ws = null;
+        this.connected = false;
+        this.listeners = new Map();
+        this.cachedSubscriptions = null;
+        this.cachedClientName = null;
+    }
+    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());
+    }
+    sendNonceWatch(caller, txHash) {
+        this.ensureConnected();
+        if (this.ws && this.connected) {
+            this.ws.send(JSON.stringify({ type: 'nonceWatch', caller, txHash }));
+        }
+    }
+    getSubscriptions() {
+        if (this.cachedSubscriptions)
+            return this.cachedSubscriptions;
+        const groupIds = ((0, ttd_core_1.getCoreEnv)()?.group_id || '').split(',').map(s => s.trim()).filter(Boolean);
+        const subs = [];
+        for (const gid of groupIds) {
+            const w = (0, ttd_core_1.load_wallet)(gid, true);
+            if (w.public_key) {
+                subs.push({ address: w.public_key, groupId: gid });
+            }
+        }
+        this.cachedSubscriptions = subs;
+        return subs;
+    }
+    getClientName() {
+        if (this.cachedClientName)
+            return this.cachedClientName;
+        this.cachedClientName = process.env.APP_NAME
+            || process.env.name
+            || (process.env.pm_id ? `pm2-${process.env.pm_id}` : null)
+            || `pid-${process.pid}`;
+        return this.cachedClientName;
+    }
+    ensureConnected() {
+        if (this.ws)
+            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 subs = this.getSubscriptions();
+            const clientName = this.getClientName();
+            for (const { address, groupId } of subs) {
+                this.ws.send(JSON.stringify({ address, groupId, clientName }));
+            }
+            logger.info(`TradeResultSubscriber connected: ${wsUrl}, subscribed=${subs.length}`);
+        });
+        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();
+    }
+}
+exports.TradeResultSubscriber = TradeResultSubscriber;
+TradeResultSubscriber.instance = null;
+class AbstractTxResultChecker extends trade_1.AbstractTransactionResultCheck {
+    constructor(env_args, event_emitter) {
+        super(env_args, event_emitter);
+        this.provider = new ethers_compat_1.ethersCompat.JsonRpcProvider(this.env_args.rpc_endpoint);
+    }
+    async check_tx_result_interval() {
+        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(async () => {
+            this.check_count += 1;
+            logger.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 = await this.provider.getTransactionReceipt(this.txid);
+                    if (!txReceipt)
+                        return;
+                    logger.info(`Received transaction result via polling: ${this.txid}`);
+                    clearInterval(intervalId);
+                    await this.processTransactionResult(txReceipt, 'interval');
+                }
+                else {
+                    clearInterval(intervalId);
+                    ttd_core_1.ALERT_TYPES.TRADE_TX_PENDING_TOO_LONG.report({
+                        identity: String(this.txid).toLowerCase(),
+                        scope: { pool_address: this.pool_info?.pool_address?.toLowerCase() },
+                        title: `Tx pending > ${check_timeout}ms: ${this.txid}`,
+                        detail: { txid: this.txid, timeout_ms: check_timeout, checks: this.check_count },
+                    });
+                }
+            }
+            catch (err) {
+                clearInterval(intervalId);
+                logger.error('parse transaction error!', err);
+            }
+        }, check_interval);
+        this.intervalId = intervalId;
+    }
+    async on_subscibe_transaction() {
+        logger.info(`Subscribing trade result, txid=${this.txid}`);
+        TradeResultSubscriber.getInstance().listen(this.txid, (receipt) => {
+            logger.info(`Received transaction result via stream-trade: ${this.txid}`);
+            this.processTransactionResult(receipt, 'websocket')
+                .catch(err => logger.error(`Error processing trade result: ${this.txid}`, err));
+        });
+    }
+    async processTransactionResult(txReceipt, source) {
+        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) {
+            logger.info(`trade_result_already_processed, ignore result from ${source}`);
+            return;
+        }
+        const parser = this.createParser();
+        const swap_detail = await 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);
+            const status = txReceipt?.status;
+            if (status === 0) {
+                ttd_core_1.ALERT_TYPES.TRADE_VAULT_REVERT.report({
+                    identity: String(this.txid).toLowerCase(),
+                    scope: { pool_address: this.pool_info?.pool_address?.toLowerCase() },
+                    title: `Vault revert: tx=${this.txid}`,
+                    detail: { txid: this.txid, status, source, gas_used: txReceipt?.gasUsed?.toString?.() },
+                });
+            }
+            else {
+                ttd_core_1.ALERT_TYPES.TRADE_RESULT_MISSING.report({
+                    identity: String(this.txid).toLowerCase(),
+                    scope: { pool_address: this.pool_info?.pool_address?.toLowerCase() },
+                    title: `TradeResult event missing: tx=${this.txid}`,
+                    detail: { txid: this.txid, status, source, parse_result: 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.AbstractTxResultChecker = AbstractTxResultChecker;

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

@@ -1 +1 @@
-export * from "./tx_websocket_manager";
+export * from "./abstract_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("./abstract_tx_result_checker"), exports);

package/dist/trade/index.d.ts

@@ -1,5 +1,5 @@
-export * from './send';
 export * from './parse';
 export * from './check';
+export * from './caller_manager';
 export * from './abstract_dex_trade';
-export * from './abstract_dex_trade_plus';
+export * from './trade_trace';

package/dist/trade/index.js

@@ -14,8 +14,8 @@ 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("./send"), exports);
 __exportStar(require("./parse"), exports);
 __exportStar(require("./check"), exports);
+__exportStar(require("./caller_manager"), exports);
 __exportStar(require("./abstract_dex_trade"), exports);
-__exportStar(require("./abstract_dex_trade_plus"), exports);
+__exportStar(require("./trade_trace"), exports);

package/dist/trade/parse/base_parser.d.ts

@@ -1,11 +1,10 @@
 import { StandardPoolInfoType, StandardSwapDetailType } from "@clonegod/ttd-core";
 import { TransactionReceipt } from '@ethersproject/providers';
-import { ethers } from 'ethers';
 import { ITxParser } from "./abstract_parser";
 import { ParserConfig } from "../../types";
 export declare abstract class BaseTxParser implements ITxParser {
     protected config: ParserConfig;
-    protected provider: ethers.providers.JsonRpcProvider;
+    protected provider: any;
     protected blockTimeCache: Map<number, number>;
     protected readonly CACHE_EXPIRY: number;
     constructor(config: ParserConfig);

package/dist/trade/parse/base_parser.js

@@ -1,53 +1,53 @@
 "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.BaseTxParser = void 0;
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
+const logger = (0, ttd_core_1.createLogger)(__filename);
 const ethers_1 = require("ethers");
+const ethers_compat_1 = require("../../utils/ethers_compat");
 class BaseTxParser {
     constructor(config) {
         this.blockTimeCache = new Map();
         this.CACHE_EXPIRY = 1000 * 60 * 60;
         this.config = config;
-        this.provider = new ethers_1.ethers.providers.JsonRpcProvider(config.rpcEndpoint);
+        this.provider = new ethers_compat_1.ethersCompat.JsonRpcProvider(config.rpcEndpoint);
     }
-    getBlockTime(blockNumber) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (process.env.NEED_BLOCK_TIME_INFO !== 'true') {
-                return 0;
-            }
-            try {
-                if (this.blockTimeCache.has(blockNumber)) {
-                    return this.blockTimeCache.get(blockNumber);
-                }
-                const block = yield this.provider.getBlock(blockNumber);
-                const timestamp = block.timestamp * 1000;
-                this.blockTimeCache.set(blockNumber, timestamp);
-                setTimeout(() => {
-                    this.blockTimeCache.delete(blockNumber);
-                }, this.CACHE_EXPIRY);
-                return timestamp;
-            }
-            catch (error) {
-                console.error('获取区块时间失败:', error);
-                return 0;
+    async getBlockTime(blockNumber) {
+        if (!(0, ttd_core_1.getCoreEnv)().trade_parse_fetch_block_time) {
+            return 0;
+        }
+        try {
+            if (this.blockTimeCache.has(blockNumber)) {
+                return this.blockTimeCache.get(blockNumber);
             }
-        });
+            const block = await this.provider.getBlock(blockNumber);
+            const timestamp = block.timestamp * 1000;
+            this.blockTimeCache.set(blockNumber, timestamp);
+            setTimeout(() => {
+                this.blockTimeCache.delete(blockNumber);
+            }, this.CACHE_EXPIRY);
+            return timestamp;
+        }
+        catch (error) {
+            console.error('获取区块时间失败:', error);
+            return 0;
+        }
     }
     calculateGasFee(txReceipt) {
         try {
-            const gasUsed = txReceipt.gasUsed || ethers_1.ethers.BigNumber.from(0);
-            const effectiveGasPrice = txReceipt.effectiveGasPrice || 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 base_fee = Number(ethers_compat_1.ethersCompat.formatEther(gasFeeBN));
             const priority_fee = 0;
             const total_fee = base_fee + priority_fee;
             return {
@@ -57,7 +57,7 @@ class BaseTxParser {
             };
         }
         catch (error) {
-            (0, dist_1.log_error)('calculateGasFee error:', error);
+            logger.error('calculateGasFee error:', error);
             return {
                 base_fee: 0,
                 priority_fee: 0,

package/dist/trade/trade_trace.d.ts

@@ -0,0 +1,17 @@
+export declare class TradeTrace {
+    readonly orderId: string;
+    readonly pair: string;
+    readonly direction: string;
+    private startTime;
+    private marks;
+    private data;
+    private error;
+    constructor(orderId: string, pair?: string, direction?: string);
+    mark(name: string): void;
+    set(key: string, value: any): void;
+    markError(stage: string, message: string): void;
+    private buildTimeline;
+    getAbsoluteMarks(): Record<string, number>;
+    getStartTime(): number;
+    flush(): void;
+}

package/dist/trade/trade_trace.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradeTrace = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const logger = (0, ttd_core_1.createLogger)(__filename);
+class TradeTrace {
+    constructor(orderId, pair = '', direction = '') {
+        this.orderId = orderId;
+        this.pair = pair;
+        this.direction = direction;
+        this.marks = [];
+        this.data = {};
+        this.error = null;
+        this.startTime = Date.now();
+    }
+    mark(name) {
+        this.marks.push({ name, elapsed: Date.now() - this.startTime });
+    }
+    set(key, value) {
+        this.data[key] = value;
+    }
+    markError(stage, message) {
+        this.error = { stage, message };
+    }
+    buildTimeline() {
+        if (this.marks.length === 0)
+            return 'recv';
+        let prev = 0;
+        const parts = this.marks.map(m => {
+            const delta = m.elapsed - prev;
+            prev = m.elapsed;
+            return `${m.name}(${delta}ms)`;
+        });
+        const total = this.marks[this.marks.length - 1].elapsed;
+        return `recv -> ${parts.join(' -> ')} = ${total}ms`;
+    }
+    getAbsoluteMarks() {
+        const result = {};
+        for (const m of this.marks) {
+            result[m.name] = this.startTime + m.elapsed;
+        }
+        return result;
+    }
+    getStartTime() {
+        return this.startTime;
+    }
+    flush() {
+        const timeline = this.buildTimeline();
+        if (this.error) {
+            logger.error(`[TRADE FAILED] ${this.orderId} | ${this.pair} ${this.direction} | stage=${this.error.stage} | ${this.error.message}`, new Error(this.error.message));
+            logger.info(`[TRADE FAILED detail] ${this.orderId}`, {
+                timeline,
+                error_stage: this.error.stage,
+                ...this.data,
+            });
+        }
+        else {
+            logger.info(`[TRADE OK] ${this.orderId} | ${this.pair} ${this.direction}`, {
+                timeline,
+                ...this.data,
+            });
+        }
+    }
+}
+exports.TradeTrace = TradeTrace;

package/dist/types/config_types.d.ts

@@ -1,12 +1,12 @@
 export interface GasOptions {
     gasLimit: number;
+    maxGasLimit: number;
     defaultGasPriceGwei: number;
     maxGasPriceGwei: number;
+    maxFeePerGasGwei: number;
+    maxPriorityFeePerGasGwei: number;
     defaultTipAmountGwei: number;
     maxTipAmountGwei: number;
-    txStatusCheckIntervalMills: number;
-    txCancelTimeoutMills: number;
-    txCancelGasBoostFactor: number;
 }
 export interface EvmChainConfig {
     chainId: number;