@clonegod/ttd-base-common 1.0.26 → 1.1.1

package/dist/trade/abstract_dex_trade.js

@@ -1,153 +1,367 @@
 "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());
-    });
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractEvmDexTrade = void 0;
-const dist_1 = require("@clonegod/ttd-core/dist");
-const ethers_1 = require("ethers");
-const common_1 = require("../common");
-class AbstractEvmDexTrade extends dist_1.AbastrcatTrade {
+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 constants_1 = require("../common/constants");
+const BLOCKRAZOR_DEFAULT_TIP_ADDRESS = '0x9D70AC39166ca154307a93fa6b595CF7962fe8e5';
+const caller_manager_1 = require("./caller_manager");
+const abstract_tx_result_checker_1 = require("./check/abstract_tx_result_checker");
+const ttd_core_2 = require("@clonegod/ttd-core");
+const trade_direction_1 = require("../utils/trade_direction");
+const ethers_compat_1 = require("../utils/ethers_compat");
+const fast_signer_1 = require("../utils/fast_signer");
+const trade_trace_1 = require("./trade_trace");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+function buildTradeConfig(envArgs) {
+    const vaultGroupId = envArgs.group_id;
+    if (!vaultGroupId) {
+        throw new Error('GROUP_ID 未配置（envArgs.group_id 为空）');
+    }
+    const vaultWallet = (0, ttd_core_1.load_wallet)(vaultGroupId, true);
+    if (!vaultWallet.public_key) {
+        throw new Error(`load_wallet(${vaultGroupId}) 未返回 public_key`);
+    }
+    return {
+        vaultAddress: vaultWallet.public_key,
+        executorIds: {
+            aerodrome: ethers_compat_1.ethersCompat.id(envArgs.aerodrome_executor_id),
+            uniswap: ethers_compat_1.ethersCompat.id(envArgs.uniswap_executor_id),
+        },
+    };
+}
+const VAULT_ABI = [
+    'function delegatecallExecutorToTrade(bytes32 executorId, bytes calldata data, uint256 deadline, uint256 tipAmount, address tipReceiver) external payable returns (bytes memory result)'
+];
+const BLOCKRAZOR_CHANNEL_NAME = 'blockrazor';
+class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
     constructor(appConfig) {
         super();
         this.appConfig = appConfig;
-        this.approvedTokens = new Map();
-        this.pairContracts = new Map();
-        this.tokenContracts = new Map();
-        this.approvedTokens = new Map();
-        this.pairContracts = new Map();
-        this.tokenContracts = new Map();
         this.initConfigs();
+        this.chainNameLower = this.appConfig.env_args.chain_id.toLowerCase();
+        this.redisClient = new ttd_core_2.RedisClient(`${this.chainNameLower}:tx`);
+        this.vaultInterface = new ethers_compat_1.ethersCompat.Interface(VAULT_ABI);
     }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.provider = new ethers_1.ethers.providers.JsonRpcProvider(this.chainConfig.rpcEndpoint);
-            this.wallet = new ethers_1.ethers.Wallet(this.appConfig.trade_runtime.wallet.private_key, this.provider);
-            (0, dist_1.log_info)(`钱包已初始化，地址: ${this.wallet.address}`);
-            this.routerContract = new ethers_1.ethers.Contract(this.dexConfig.routerAddress, this.dexConfig.routerAbi, this.wallet);
-            (0, dist_1.log_info)(`${this.dexConfig.dexName} Router已初始化, 地址: ${this.dexConfig.routerAddress}`);
-        });
+    initConfigs() {
+        const env = this.appConfig.env_args;
+        this.chainConfig = {
+            chainId: 8453,
+            nativeCurrency: 'ETH',
+            wrappedNativeCurrencyAddress: constants_1.WETH_ADDRESS,
+            chainName: 'Base',
+            rpcEndpoint: env.rpc_endpoint,
+            blockConfirmations: 12,
+            gasOptions: {
+                gasLimit: env.gas_limit,
+                defaultGasPriceGwei: env.gas_price_gwei,
+                maxGasLimit: env.gas_max_limit,
+                maxGasPriceGwei: env.gas_max_price_gwei,
+                maxFeePerGasGwei: env.gas_max_fee_per_gas_gwei,
+                maxPriorityFeePerGasGwei: env.gas_max_priority_fee_gwei,
+                defaultTipAmountGwei: env.tip_amount_gwei,
+                maxTipAmountGwei: env.gas_max_tip_amount_gwei,
+            }
+        };
+        this.tradeConfig = buildTradeConfig(env);
     }
-    getTokenContract(tokenAddress) {
-        if (!this.tokenContracts.has(tokenAddress)) {
-            const tokenContract = new ethers_1.ethers.Contract(tokenAddress, common_1.ERC20_ABI, this.wallet);
-            this.tokenContracts.set(tokenAddress, tokenContract);
+    async init(transactionSender) {
+        (0, fast_signer_1.patchEthersV5Signer)();
+        this.provider = new ethers_compat_1.ethersCompat.JsonRpcProvider(this.chainConfig.rpcEndpoint);
+        if (transactionSender) {
+            this.transactionSender = transactionSender;
         }
-        return this.tokenContracts.get(tokenAddress);
-    }
-    getGasPriceGwei(context) {
-        let { evm_gas_limit, evm_gas_price_gwei, evm_tip_amount_gwei } = context.trade_runtime.settings.strategy;
-        if (evm_gas_price_gwei === undefined || evm_gas_price_gwei === null || evm_gas_price_gwei <= 0) {
-            evm_gas_price_gwei = this.chainConfig.gasOptions.defaultGasPriceGwei;
+        const groupId = this.appConfig.trade_runtime?.group?.id;
+        if (!groupId) {
+            throw new Error('trade_runtime.group.id 未初始化，请确保 init_trade_runtime() 已调用');
         }
-        (0, dist_1.log_info)(`getGasPriceGwei: ${evm_gas_price_gwei} Gwei`);
-        return evm_gas_price_gwei.toString();
-    }
-    getBuilderTipAmoutGwei(context) {
-        let { evm_gas_limit, evm_gas_price_gwei, evm_tip_amount_gwei } = context.trade_runtime.settings.strategy;
-        if (evm_tip_amount_gwei === undefined || evm_tip_amount_gwei === null || evm_tip_amount_gwei <= 0) {
-            evm_tip_amount_gwei = this.chainConfig.gasOptions.defaultTipAmountGwei;
+        const callerGroupIds = this.scanCallerFiles(groupId);
+        if (callerGroupIds.length === 0) {
+            throw new Error(`未找到分组 ${groupId} 的 Caller 钱包文件（${groupId}-CALLER-*.json）`);
         }
-        (0, dist_1.log_info)(`getGasTipAmoutGwei: ${evm_tip_amount_gwei} Gwei`);
-        return evm_tip_amount_gwei.toString();
-    }
-    checkTradeTokenApprove(context, routerAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { pool_info } = context;
-            const { tokenA, tokenB } = pool_info;
-            const router = routerAddress || this.dexConfig.routerAddress;
-            yield Promise.all([tokenA, tokenB].map((_a) => __awaiter(this, [_a], void 0, function* ({ symbol, address }) {
-                const tokenContract = this.getTokenContract(address);
-                yield this.checkTokenApprove(address, symbol, tokenContract, router);
-            })));
+        this.callerManager = new caller_manager_1.CallerManager({
+            chainName: this.chainNameLower,
+            groupId,
+            provider: this.provider,
+            callerGroupIds,
+            chainId: this.chainConfig.chainId,
         });
+        await this.callerManager.init();
+        logger.info(`AbstractDexTrade initialized, vault=${this.tradeConfig.vaultAddress}, callers=${this.callerManager.getCallerCount()}`);
     }
-    checkTokenApprove(tokenAddress, tokenSymbol, tokenContract, spenderAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.approvedTokens.get(tokenAddress)) {
-                (0, dist_1.log_info)(`代币 ${tokenSymbol} 已授权，跳过授权检查`);
-                return true;
-            }
-            const allowance = yield tokenContract.allowance(this.wallet.address, spenderAddress);
-            const maxAllowance = ethers_1.ethers.constants.MaxUint256.div(2);
-            (0, dist_1.log_info)(`代币授权检查:`, {
-                tokenSymbol,
-                currentAllowance: allowance.toString(),
-                maxAllowance: maxAllowance.toString(),
-                isSufficient: allowance.gte(maxAllowance)
-            });
-            if (allowance.lt(maxAllowance)) {
-                const maxApprovalAmount = ethers_1.ethers.utils.formatUnits(ethers_1.ethers.constants.MaxUint256, yield tokenContract.decimals());
-                const tokenSymbolDisplay = tokenSymbol || `${tokenAddress.substring(0, 6)}...`;
-                (0, dist_1.log_info)(`正在为合约授权代币 ${tokenSymbolDisplay}`, {
-                    tokenAddress,
-                    tokenSymbol: tokenSymbolDisplay,
-                    currentAllowance: ethers_1.ethers.utils.formatUnits(allowance, yield tokenContract.decimals()),
-                    newAllowance: maxApprovalAmount
-                });
-                const tx = yield tokenContract.approve(spenderAddress, ethers_1.ethers.constants.MaxUint256, {
-                    gasLimit: this.chainConfig.gasOptions.gasLimit
-                });
-                yield tx.wait();
-                this.approvedTokens.set(tokenAddress, true);
-                (0, dist_1.log_info)(`代币 ${tokenSymbolDisplay} 授权完成，数量: ${maxApprovalAmount} ${tokenSymbolDisplay}, 交易哈希: ${tx.hash}`);
-                return true;
+    async execute(context) {
+        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);
+        context._precomputed = { inputToken, outputToken, amountOutMin };
+        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}%`);
+        const maxAttempts = 3;
+        const { wallet: caller, nonce: initialNonce } = await this.callerManager.acquireCaller();
+        trace.mark('caller');
+        trace.set('caller', caller.address);
+        let nonce = initialNonce;
+        let nonce_from_error = -1;
+        let txid = '';
+        let i = 1;
+        do {
+            try {
+                if (i > 1) {
+                    if (nonce_from_error >= 0) {
+                        nonce = nonce_from_error;
+                        nonce_from_error = -1;
+                    }
+                    else {
+                        nonce = await this.provider.getTransactionCount(caller.address, 'pending');
+                    }
+                    trace.set('retry', `${i}/${maxAttempts}`);
+                }
+                const { executorId, data } = this.encodeTradeData(context);
+                trace.mark('encode');
+                const deadline = Math.floor(Date.now() / 1000) + 60;
+                const vaultCalldataNoTip = this.vaultInterface.encodeFunctionData('delegatecallExecutorToTrade', [executorId, data, deadline, 0, constants_1.NATIVE_ETH_ADDRESS]);
+                const { mainGasFields } = this.buildGasFields(context);
+                const gasLimit = this.getGasLimit(context);
+                const mainTx = {
+                    to: this.tradeConfig.vaultAddress,
+                    data: vaultCalldataNoTip,
+                    gasLimit,
+                    ...mainGasFields,
+                    nonce,
+                    chainId: this.chainConfig.chainId,
+                    value: 0,
+                };
+                const env = this.appConfig.env_args;
+                const tipChannelTxs = [];
+                if (env.send_tx_blockrazor && env.blockrazor_tip_amount_wei && env.blockrazor_tip_amount_wei > 0) {
+                    const tipAmountWei = BigInt(env.blockrazor_tip_amount_wei);
+                    const tipReceiver = env.blockrazor_tip_address || BLOCKRAZOR_DEFAULT_TIP_ADDRESS;
+                    const vaultCalldataWithTip = this.vaultInterface.encodeFunctionData('delegatecallExecutorToTrade', [executorId, data, deadline, tipAmountWei.toString(), tipReceiver]);
+                    tipChannelTxs.push({
+                        channel: BLOCKRAZOR_CHANNEL_NAME,
+                        tx: {
+                            to: this.tradeConfig.vaultAddress,
+                            data: vaultCalldataWithTip,
+                            gasLimit,
+                            ...mainGasFields,
+                            nonce,
+                            chainId: this.chainConfig.chainId,
+                            value: tipAmountWei.toString(),
+                        },
+                    });
+                    context.ui_tip_amount = new decimal_js_1.default(tipAmountWei.toString()).div(1e18).toNumber();
+                }
+                else {
+                    context.ui_tip_amount = 0;
+                }
+                const [rawMainTx, ...rawTips] = await Promise.all([
+                    caller.signTransaction(mainTx),
+                    ...tipChannelTxs.map(({ tx }) => caller.signTransaction(tx)),
+                ]);
+                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();
+                tipChannelTxs.forEach(({ channel }, idx) => tipTxMap.set(channel, signedTips[idx]));
+                trace.set('txid', txid);
+                trace.set('nonce', nonce);
+                trace.set('gasType', mainGasFields.type === 2 ? 'EIP1559' : 'Legacy');
+                trace.set('tip', context.ui_tip_amount);
+                const only_bundle = order_msg.is_dex_maker;
+                trace.mark('sent');
+                await this.transactionSender.sendTransaction(signedMainTx, tipTxMap, order_trace_id, pair, only_bundle, trace);
+                trace.mark('send_complete');
+                trace.flush();
+                context._execution_marks = trace.getAbsoluteMarks();
+                context._execution_start_time = trace.getStartTime();
+                try {
+                    abstract_tx_result_checker_1.TradeResultSubscriber.getInstance().sendNonceWatch(caller.address, txid);
+                }
+                catch { }
+                return txid;
             }
-            else {
-                this.approvedTokens.set(tokenAddress, true);
-                return true;
+            catch (error) {
+                const errorMessage = error.message?.toLowerCase() || '';
+                if (errorMessage.includes('rate limit')) {
+                    trace.markError('send', `rate limit, attempt ${i}`);
+                    trace.flush();
+                    return txid;
+                }
+                if (errorMessage.includes('replacement transaction underpriced')) {
+                    trace.set('underpriced_retry', i);
+                    continue;
+                }
+                const isNonceError = errorMessage.includes('nonce');
+                if (!isNonceError || i >= maxAttempts) {
+                    trace.markError('send', `${errorMessage}, attempt ${i}/${maxAttempts}`);
+                    trace.flush();
+                    return txid;
+                }
+                if (errorMessage.includes('nonce too')) {
+                    const correctNonce = this.extractNonceFromErrorMsg(errorMessage);
+                    if (correctNonce !== null && correctNonce >= 0) {
+                        nonce_from_error = correctNonce;
+                    }
+                }
             }
-        });
+        } while (++i <= maxAttempts);
+        if (!txid) {
+            trace.markError('exhaust', `failed after ${maxAttempts} attempts`);
+            trace.flush();
+            const groupId = this.appConfig.trade_runtime?.group?.id;
+            ttd_core_1.ALERT_TYPES.TRADE_BUILDER_REJECTED.report({
+                identity: caller.address.toLowerCase(),
+                scope: { caller_address: caller.address.toLowerCase(), group_id: groupId },
+                title: `Trade execution exhausted after ${maxAttempts} attempts (order ${order_trace_id})`,
+                detail: { order_trace_id, attempts: maxAttempts, last_nonce: nonce, last_error_nonce: nonce_from_error },
+            });
+            throw new Error(`交易执行失败，已重试 ${maxAttempts} 次，orderId: ${order_trace_id}`);
+        }
+        return txid;
+    }
+    scanCallerFiles(groupId) {
+        const walletDir = this.appConfig.env_args.wallet_dir || path.join((0, ttd_core_1.home_dir)(), 'data', 'keypairs');
+        const prefix = `${groupId}-CALLER-`;
+        const files = fs.readdirSync(walletDir)
+            .filter(f => f.startsWith(prefix) && f.endsWith('.json'))
+            .sort();
+        return files.map(f => f.replace('.json', ''));
+    }
+    computeEvmGasArgs(context) {
+        const env = this.appConfig.env_args;
+        const defaults = {
+            gasLimit: env.gas_limit,
+            gasPriceGwei: env.gas_price_gwei,
+            tipAmountGwei: env.tip_amount_gwei,
+        };
+        const caps = {
+            gasLimit: env.gas_max_limit,
+            gasPriceGwei: env.gas_max_price_gwei,
+            maxFeePerGasGwei: env.gas_max_fee_per_gas_gwei,
+            maxPriorityFeePerGasGwei: env.gas_max_priority_fee_gwei,
+            tipAmountGwei: env.gas_max_tip_amount_gwei,
+        };
+        return (0, ttd_core_1.buildEvmGasArgs)(context.trade_runtime.settings.strategy, defaults, caps);
     }
-    isNonceRelatedError(error) {
-        if (!error)
-            return false;
-        const errorMessage = error.message ? error.message.toLowerCase() : '';
-        const nonceErrorKeywords = [
-            'nonce',
-            'nonce too low',
-            'nonce too high',
-            'nonce has already been used',
-            'already known',
-            'replacement transaction underpriced',
-            'transaction with same nonce',
-            'transaction nonce is too low',
-            'invalid transaction nonce',
-            'insufficient funds',
-            'sign bundle to get failure details',
-        ];
-        return nonceErrorKeywords.some(keyword => errorMessage.includes(keyword));
-    }
-    isNativeCurrency(symbol) {
-        return symbol.toUpperCase() === this.chainConfig.nativeCurrency;
-    }
-    getWrappedNativeAddress() {
-        return this.chainConfig.wrappedNativeCurrencyAddress;
-    }
-    buildTipTransferTx(to, transfer_amount_gwei, gas_price_gwei, transfer_nonce) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let real_transfer_amount_gwei = Math.min(Number(transfer_amount_gwei), this.chainConfig.gasOptions.maxTipAmountGwei).toString();
-            let real_gas_price_gwei = Math.min(Number(gas_price_gwei), this.chainConfig.gasOptions.maxGasPriceGwei).toString();
-            let tx_data = {
-                from: this.wallet.address,
-                to,
-                value: ethers_1.ethers.utils.parseUnits(real_transfer_amount_gwei, 'gwei'),
-                gasLimit: 21000,
-                gasPrice: ethers_1.ethers.utils.parseUnits(real_gas_price_gwei, 'gwei'),
-                nonce: transfer_nonce,
-                chainId: this.chainConfig.chainId
+    gasArgsToMainFields(args) {
+        if (args.txType === 2) {
+            return {
+                type: 2,
+                maxFeePerGas: ethers_compat_1.ethersCompat.parseUnits(args.maxFeePerGasGwei.toString(), 'gwei'),
+                maxPriorityFeePerGas: ethers_compat_1.ethersCompat.parseUnits(args.maxPriorityFeePerGasGwei.toString(), 'gwei'),
             };
-            let signedTx = yield this.wallet.signTransaction(tx_data);
-            (0, dist_1.log_info)(`构建转账交易: `, Object.assign(Object.assign({}, tx_data), { real_transfer_amount_gwei,
-                real_gas_price_gwei, txhash: ethers_1.ethers.utils.keccak256(signedTx) }));
-            return signedTx;
-        });
+        }
+        return {
+            gasPrice: ethers_compat_1.ethersCompat.parseUnits(args.gasPriceGwei.toString(), 'gwei'),
+        };
+    }
+    buildGasFields(context) {
+        const args = this.computeEvmGasArgs(context);
+        return {
+            mainGasFields: this.gasArgsToMainFields(args),
+            tipGasPriceGwei: args.tipGasPriceGwei.toString(),
+        };
+    }
+    getGasLimit(context) {
+        return this.computeEvmGasArgs(context).gasLimit;
+    }
+    getLegacyGasPriceGwei(context) {
+        return this.computeEvmGasArgs(context).tipGasPriceGwei.toString();
+    }
+    getBuilderTipAmoutGwei(context) {
+        return this.computeEvmGasArgs(context).tipAmountGwei.toString();
+    }
+    async buildTipTransferTx(to, transfer_amount_gwei, gas_price_gwei, nonce, wallet) {
+        const real_transfer_amount_gwei = Math.min(Number(transfer_amount_gwei), this.chainConfig.gasOptions.maxTipAmountGwei).toString();
+        const real_gas_price_gwei = Math.min(Number(gas_price_gwei), this.chainConfig.gasOptions.maxGasPriceGwei).toString();
+        const tx_data = {
+            to,
+            value: ethers_compat_1.ethersCompat.parseUnits(real_transfer_amount_gwei, 'gwei'),
+            gasLimit: 21000,
+            gasPrice: ethers_compat_1.ethersCompat.parseUnits(real_gas_price_gwei, 'gwei'),
+            nonce,
+            chainId: this.chainConfig.chainId
+        };
+        const rawSignedTx = await wallet.signTransaction(tx_data);
+        const signedTx = rawSignedTx.startsWith('0x') ? rawSignedTx : `0x${rawSignedTx}`;
+        return signedTx;
+    }
+    determineInputOutputTokens(order_msg, pool_info) {
+        const { inputToken, outputToken } = (0, trade_direction_1.resolveTradeDirection)(pool_info, order_msg.isBuy);
+        return { inputToken, outputToken };
+    }
+    calculateAmountOutMin(context, _inputToken, outputToken) {
+        const { price_msg, slippage_bps, order_msg } = context;
+        const { isBuy } = order_msg;
+        const slippage = slippage_bps / 10000;
+        const inputAmount = new decimal_js_1.default(order_msg.amount.toString());
+        let expectedOut;
+        if (isBuy) {
+            const price = new decimal_js_1.default(price_msg.ask.price);
+            expectedOut = inputAmount.div(price);
+        }
+        else {
+            const price = new decimal_js_1.default(price_msg.bid.price);
+            expectedOut = inputAmount.mul(price);
+        }
+        const minOutput = expectedOut.mul(new decimal_js_1.default(1).sub(new decimal_js_1.default(slippage)));
+        return ethers_compat_1.ethersCompat.parseUnits(minOutput.toFixed(outputToken.decimals), outputToken.decimals);
+    }
+    extractNonceFromErrorMsg(errorMessage) {
+        try {
+            const match = errorMessage.match(/tx:\s*(\d+)\s*state:\s*(\d+)/);
+            if (match) {
+                return parseInt(match[2]);
+            }
+        }
+        catch { }
+        return null;
     }
 }
-exports.AbstractEvmDexTrade = AbstractEvmDexTrade;
+exports.AbstractDexTrade = AbstractDexTrade;

package/dist/trade/caller_manager.d.ts

@@ -0,0 +1,31 @@
+import { ethers } from "ethers";
+export interface CallerHandle {
+    wallet: ethers.Wallet;
+    nonce: number;
+}
+export interface CallerManagerConfig {
+    chainName: string;
+    groupId: string;
+    provider: any;
+    callerGroupIds: string[];
+    chainId: number;
+}
+export declare class CallerManager {
+    private callers;
+    private redis;
+    private config;
+    constructor(config: CallerManagerConfig);
+    init(): Promise<void>;
+    acquireCaller(): Promise<CallerHandle>;
+    private acquireCallerWithLock;
+    private acquireCallerWithLuaCas;
+    private readNonce;
+    confirmNonce(address: string, confirmedNonce: number): Promise<void>;
+    forceSetNonce(address: string, nonce: number): Promise<void>;
+    getCallerCount(): number;
+    getCallerAddresses(): string[];
+    private getNonceRedisKey;
+    private getLastUsedRedisKey;
+    private getNonce;
+    private setNonce;
+}