@clonegod/ttd-bsc-common 3.0.29 → 3.0.31

package/dist/send-tx/types.d.ts

@@ -1,3 +1,4 @@
+import { TradeTrace } from '../trade/trade_trace';
 export interface ITransactionSender {
-    sendTransaction(signedMainTx: string, eoa_tip_transaction: (eoa_address: string) => Promise<string>, order_trace_id: string, pair?: string, only_bundle?: boolean): Promise<string[]>;
+    sendTransaction(signedMainTx: string, eoa_tip_transaction: (eoa_address: string) => Promise<string>, order_trace_id: string, pair?: string, only_bundle?: boolean, trace?: Pick<TradeTrace, 'mark' | 'markProvider'>): Promise<string[]>;
 }

package/dist/trade/abstract_dex_trade.js

@@ -48,6 +48,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractDexTrade = void 0;
 exports.buildTradeConfig = buildTradeConfig;
 const ttd_core_1 = require("@clonegod/ttd-core");
+const logger = (0, ttd_core_1.createLogger)(__filename);
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const caller_manager_1 = require("./caller_manager");
@@ -56,6 +57,7 @@ const base_tx_result_checker_1 = require("./check/base_tx_result_checker");
 const redis_1 = require("../redis");
 const trade_direction_1 = require("../utils/trade_direction");
 const ethers_compat_1 = require("../utils/ethers_compat");
+const trade_trace_1 = require("./trade_trace");
 const decimal_js_1 = __importDefault(require("decimal.js"));
 function buildTradeConfig() {
     const vaultGroupId = process.env.TRADE_GROUP_ID || process.env.VAULT_GROUP_ID;
@@ -105,12 +107,13 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
             }
             this.callerManager = new caller_manager_1.CallerManager({
                 chainName: this.chainNameLower,
+                groupId,
                 provider: this.provider,
                 callerGroupIds,
                 chainId: this.chainConfig.chainId,
             });
             yield this.callerManager.init();
-            (0, ttd_core_1.log_info)(`AbstractDexTrade initialized, vault=${this.tradeConfig.vaultAddress}, callers=${this.callerManager.getCallerCount()}`);
+            logger.info(`AbstractDexTrade initialized, vault=${this.tradeConfig.vaultAddress}, callers=${this.callerManager.getCallerCount()}`);
         });
     }
     execute(context) {
@@ -119,18 +122,17 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
             const { price_msg, order_msg, slippage_bps, order_trace_id, pool_info } = context;
             const { pair } = price_msg;
             const { isBuy, amount } = order_msg;
+            const direction = isBuy ? 'BUY' : 'SELL';
             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,
-                direction: isBuy ? 'BUY' : 'SELL',
-                input: `${amount} ${inputToken.symbol}`,
-                outputMin: `${ethers_compat_1.ethersCompat.formatUnits(amountOutMin, outputToken.decimals)} ${outputToken.symbol}`,
-                slippage: `${slippage_bps / 100}%`,
-            });
+            const trace = new trade_trace_1.TradeTrace(order_trace_id, pair, direction);
+            trace.set('input', `${amount} ${inputToken.symbol}`);
+            trace.set('outputMin', `${ethers_compat_1.ethersCompat.formatUnits(amountOutMin, outputToken.decimals)} ${outputToken.symbol}`);
+            trace.set('slippage', `${slippage_bps / 100}%`);
             let maxAttempts = Math.min(Math.max(parseInt(process.env.NONCE_LOCK_MAX_RETRIES || '3'), 1), 3);
             const { wallet: caller, nonce: initialNonce } = yield this.callerManager.acquireCaller();
+            trace.mark('caller');
+            trace.set('caller', caller.address);
             let nonce = initialNonce;
             let nonce_from_error = -1;
             let txid = '';
@@ -141,14 +143,14 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
                         if (nonce_from_error >= 0) {
                             nonce = nonce_from_error;
                             nonce_from_error = -1;
-                            (0, ttd_core_1.log_info)(`Attempt ${i}/${maxAttempts}, using nonce from error msg: ${nonce}`, {}, order_trace_id);
                         }
                         else {
                             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);
                         }
+                        trace.set('retry', `${i}/${maxAttempts}`);
                     }
                     const { executorId, data } = this.encodeTradeData(context);
+                    trace.mark('encode');
                     const deadline = Math.floor(Date.now() / 1000) + 60;
                     const vaultCalldata = this.vaultInterface.encodeFunctionData('delegatecallExecutorToTrade', [executorId, data, deadline]);
                     const gasPriceGwei = this.getGasPriceGwei(context);
@@ -174,22 +176,24 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
                         caller.signTransaction(mainTx),
                         ...builderAddresses.map(addr => this.buildTipTransferTx(addr, transfer_amount_gwei, realGasPriceGwei, tipNonce, caller)),
                     ]);
+                    trace.mark('sign');
                     const ensure0x = (tx) => tx.startsWith('0x') ? tx : `0x${tx}`;
                     const signedMainTx = ensure0x(rawMainTx);
                     const signedTips = rawTips.map(ensure0x);
                     txid = ethers_compat_1.ethersCompat.keccak256(signedMainTx);
                     const tipTxMap = new Map();
                     builderAddresses.forEach((addr, idx) => tipTxMap.set(addr, signedTips[idx]));
-                    (0, ttd_core_1.log_info)(`交易已签名`, { txid, nonce, caller: caller.address, gasPriceGwei: realGasPriceGwei }, order_trace_id);
+                    trace.set('txid', txid);
+                    trace.set('nonce', nonce);
+                    trace.set('gas', realGasPriceGwei);
+                    trace.set('tip', transfer_amount_gwei);
                     const only_bundle = order_msg.is_dex_maker;
                     const eoa_tip_transaction = (eoa_address) => __awaiter(this, void 0, void 0, function* () {
                         return tipTxMap.get(eoa_address) || (yield this.buildTipTransferTx(eoa_address, transfer_amount_gwei, realGasPriceGwei, tipNonce, caller));
                     });
-                    yield this.transactionSender.sendTransaction(signedMainTx, eoa_tip_transaction, order_trace_id, pair, only_bundle);
-                    (0, ttd_core_1.log_info)(`交易发送成功`, {
-                        pair, direction: isBuy ? 'BUY' : 'SELL',
-                        txid, attempt: i, caller: caller.address
-                    }, order_trace_id);
+                    yield this.transactionSender.sendTransaction(signedMainTx, eoa_tip_transaction, order_trace_id, pair, only_bundle, trace);
+                    trace.mark('sent');
+                    trace.flush();
                     try {
                         base_tx_result_checker_1.TradeResultSubscriber.getInstance().sendNonceWatch(caller.address, txid);
                     }
@@ -199,19 +203,20 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
                 catch (error) {
                     const errorMessage = ((_a = error.message) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
                     if (errorMessage.includes('rate limit')) {
-                        (0, ttd_core_1.log_warn)(`Rate limit error, no retry! i=${i}`, {}, order_trace_id);
+                        trace.markError('send', `rate limit, attempt ${i}`);
+                        trace.flush();
                         return txid;
                     }
                     if (errorMessage.includes('replacement transaction underpriced')) {
-                        (0, ttd_core_1.log_warn)(`Replacement tx underpriced, continue! i=${i}`, {}, order_trace_id);
+                        trace.set('underpriced_retry', i);
                         continue;
                     }
                     const isNonceError = errorMessage.includes('nonce');
                     if (!isNonceError || i >= maxAttempts) {
-                        (0, ttd_core_1.log_warn)(`Non-nonce error or max retries, i=${i}, error: ${errorMessage}`, {}, order_trace_id);
+                        trace.markError('send', `${errorMessage}, attempt ${i}/${maxAttempts}`);
+                        trace.flush();
                         return txid;
                     }
-                    (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) {
@@ -221,6 +226,8 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
                 }
             } while (++i <= maxAttempts);
             if (!txid) {
+                trace.markError('exhaust', `failed after ${maxAttempts} attempts`);
+                trace.flush();
                 throw new Error(`交易执行失败，已重试 ${maxAttempts} 次，orderId: ${order_trace_id}`);
             }
             return txid;
@@ -262,11 +269,6 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
             };
             const rawSignedTx = yield wallet.signTransaction(tx_data);
             const signedTx = rawSignedTx.startsWith('0x') ? rawSignedTx : `0x${rawSignedTx}`;
-            (0, ttd_core_1.log_info)(`构建 tip 转账交易`, {
-                to, nonce,
-                tipGwei: real_transfer_amount_gwei,
-                txhash: ethers_compat_1.ethersCompat.keccak256(signedTx)
-            });
             return signedTx;
         });
     }

package/dist/trade/caller_manager.d.ts

@@ -5,6 +5,7 @@ export interface CallerHandle {
 }
 export interface CallerManagerConfig {
     chainName: string;
+    groupId: string;
     provider: any;
     callerGroupIds: string[];
     chainId: number;

package/dist/trade/caller_manager.js

@@ -11,6 +11,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 logger = (0, dist_1.createLogger)(__filename);
 const ethers_1 = require("ethers");
 const redis_1 = require("../redis");
 const CALLER_NONCE_KEY = 'caller:nonce';
@@ -26,21 +27,30 @@ class CallerManager {
         return __awaiter(this, void 0, void 0, function* () {
             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));
-            (0, dist_1.log_info)(`CallerManager: loaded ${allWallets.length} wallets from CALLER_GROUP_IDS`, allWallets.map(w => w.address));
+            logger.info(`CallerManager: loaded ${allWallets.length} wallets for group ${this.config.groupId}`, 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) {
+            const rawJson = yield this.redis.hgetvalue(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);
+                }
+            }
+            if (allowedAddresses.length > 0) {
                 const allowedSet = new Set(allowedAddresses.map(a => a.toLowerCase()));
                 this.callers = allWallets.filter(w => allowedSet.has(w.address.toLowerCase()));
-                (0, dist_1.log_info)(`CallerManager: matched ${this.callers.length} callers with Vault whitelist`, this.callers.map(w => w.address));
+                logger.info(`CallerManager: matched ${this.callers.length} callers with Vault whitelist for group ${this.config.groupId}`, this.callers.map(w => w.address));
                 const skipped = allWallets.filter(w => !allowedSet.has(w.address.toLowerCase()));
                 if (skipped.length > 0) {
-                    (0, dist_1.log_warn)(`CallerManager: skipped ${skipped.length} wallets not in Vault whitelist`, skipped.map(w => w.address));
+                    logger.warn(`CallerManager: skipped ${skipped.length} wallets not in Vault whitelist`, skipped.map(w => w.address));
                 }
             }
             else {
                 this.callers = allWallets;
-                (0, dist_1.log_warn)(`CallerManager: Vault whitelist not found in Redis (${vaultCallersKey}), using all ${this.callers.length} loaded wallets`);
+                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');
@@ -50,23 +60,21 @@ class CallerManager {
                 const nonceKey = this.getNonceRedisKey();
                 const existing = yield this.redis.hgetvalue(nonceKey, address);
                 if (existing === null || existing === undefined) {
-                    (0, dist_1.log_warn)(`Caller ${caller.address} nonce not found in Redis, stream-trade may not be running`);
+                    logger.warn(`Caller ${caller.address} nonce not found in Redis, stream-trade may not be running`);
                 }
                 else {
-                    (0, dist_1.log_info)(`Caller ${caller.address} nonce=${existing} (from Redis)`);
+                    logger.info(`Caller ${caller.address} nonce=${existing} (from Redis)`);
                 }
             })));
-            (0, dist_1.log_info)(`CallerManager initialized, ${this.callers.length} active callers`, this.callers.map(w => w.address));
+            logger.info(`CallerManager initialized, ${this.callers.length} active callers`, this.callers.map(w => w.address));
         });
     }
     acquireCaller() {
         return __awaiter(this, void 0, void 0, function* () {
-            const startTime = Date.now();
             const sortedCallers = yield this.getCallersSortedByLRU();
             const caller = sortedCallers[0];
             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`);
             return { wallet: caller, nonce };
         });
     }
@@ -75,7 +83,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}`);
+                logger.info(`confirmNonce: ${address}, ${current} → ${confirmedNonce}`);
             }
         });
     }
@@ -84,7 +92,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}`);
+                logger.info(`forceSetNonce: ${address}, ${current} → ${nonce}`);
             }
         });
     }

package/dist/trade/check/base_tx_result_checker.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseTxResultChecker = 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 {
@@ -48,16 +49,20 @@ class TradeResultSubscriber {
         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);
+        const clientName = process.env.APP_NAME
+            || process.env.name
+            || (process.env.pm_id ? `pm2-${process.env.pm_id}` : null)
+            || `pid-${process.pid}`;
         this.ws.onOpen(() => {
             this.connected = true;
             const groupIds = (process.env.TRADE_GROUP_ID || process.env.VAULT_GROUP_ID || '').split(',').map(s => s.trim()).filter(Boolean);
             for (const gid of groupIds) {
                 const w = (0, ttd_core_1.load_wallet)(gid, true);
                 if (w.public_key) {
-                    this.ws.send(JSON.stringify({ address: w.public_key }));
+                    this.ws.send(JSON.stringify({ address: w.public_key, groupId: gid, clientName }));
                 }
             }
-            (0, ttd_core_1.log_info)(`TradeResultSubscriber connected: ${wsUrl}`);
+            logger.info(`TradeResultSubscriber connected: ${wsUrl}`);
         });
         this.ws.onMessage((msg) => {
             if (msg.type !== 'TradeResult' || !msg.data)
@@ -91,13 +96,13 @@ class BaseTxResultChecker extends trade_1.AbstractTransactionResultCheck {
                 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}`);
+                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 = yield this.provider.getTransactionReceipt(this.txid);
                         if (!txReceipt)
                             return;
-                        (0, ttd_core_1.log_info)(`Received transaction result via polling: ${this.txid}`);
+                        logger.info(`Received transaction result via polling: ${this.txid}`);
                         clearInterval(intervalId);
                         yield this.processTransactionResult(txReceipt, 'interval');
                     }
@@ -107,7 +112,7 @@ class BaseTxResultChecker extends trade_1.AbstractTransactionResultCheck {
                 }
                 catch (err) {
                     clearInterval(intervalId);
-                    (0, ttd_core_1.log_error)('parse transaction error!', err);
+                    logger.error('parse transaction error!', err);
                 }
             }), check_interval);
             this.intervalId = intervalId;
@@ -115,11 +120,11 @@ class BaseTxResultChecker extends trade_1.AbstractTransactionResultCheck {
     }
     on_subscibe_transaction() {
         return __awaiter(this, void 0, void 0, function* () {
-            (0, ttd_core_1.log_info)(`Subscribing trade result, txid=${this.txid}`);
+            logger.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}`);
+                logger.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));
+                    .catch(err => logger.error(`Error processing trade result: ${this.txid}`, err));
             });
         });
     }
@@ -129,7 +134,7 @@ class BaseTxResultChecker extends trade_1.AbstractTransactionResultCheck {
                 (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}!`);
+                logger.warn(`trade_result_already_processed, ignore result from ${source}!`);
                 return;
             }
             const parser = this.createParser();

package/dist/trade/index.d.ts

@@ -2,3 +2,4 @@ export * from './parse';
 export * from './check';
 export * from './caller_manager';
 export * from './abstract_dex_trade';
+export * from './trade_trace';

package/dist/trade/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./parse"), exports);
 __exportStar(require("./check"), exports);
 __exportStar(require("./caller_manager"), exports);
 __exportStar(require("./abstract_dex_trade"), exports);
+__exportStar(require("./trade_trace"), exports);

package/dist/trade/parse/base_parser.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseTxParser = void 0;
 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 {
@@ -67,7 +68,7 @@ class BaseTxParser {
             };
         }
         catch (error) {
-            (0, ttd_core_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,16 @@
+export declare class TradeTrace {
+    readonly orderId: string;
+    readonly pair: string;
+    readonly direction: string;
+    private startTime;
+    private marks;
+    private data;
+    private providers;
+    private error;
+    constructor(orderId: string, pair?: string, direction?: string);
+    mark(name: string): void;
+    set(key: string, value: any): void;
+    markProvider(name: string, ok: boolean, error?: string): void;
+    markError(stage: string, message: string): void;
+    flush(): void;
+}

package/dist/trade/trade_trace.js

@@ -0,0 +1,43 @@
+"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.providers = [];
+        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;
+    }
+    markProvider(name, ok, error) {
+        this.providers.push({ name, ok, elapsed: Date.now() - this.startTime, error });
+    }
+    markError(stage, message) {
+        this.error = { stage, message };
+    }
+    flush() {
+        const total = Date.now() - this.startTime;
+        const timeline = this.marks.map(m => `${m.name}=${m.elapsed}ms`).join(' | ');
+        const providerStatus = this.providers
+            .map(p => `${p.name}=${p.ok ? '✓' : '✗'}${p.ok ? '' : '(' + (p.error || 'err') + ')'}`)
+            .join(' ');
+        if (this.error) {
+            logger.info(`[TRADE FAILED] ${this.orderId} | ${this.pair} ${this.direction}`, Object.assign({ timeline, error_stage: this.error.stage, error: this.error.message, total_ms: total }, this.data));
+        }
+        else {
+            logger.info(`[TRADE OK] ${this.orderId} | ${this.pair} ${this.direction}`, Object.assign({ timeline, providers: providerStatus, total_ms: total }, this.data));
+        }
+    }
+}
+exports.TradeTrace = TradeTrace;

package/package.json

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