@michaleffffff/mcp-trading-server 2.6.0 → 2.7.0

package/dist/services/marketService.js

@@ -79,3 +79,63 @@ export async function getPoolLevelConfig(client, poolId, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
     return client.markets.getPoolLevelConfig(poolId, chainId);
 }
+/**
+ * 智能解析 Pool ID (支持 ID 校验与关键词回退)
+ */
+export async function resolvePool(client, poolId, keyword) {
+    const chainId = getChainId();
+    let pid = poolId?.trim();
+    // 1. 如果提供了 poolId，先尝试验证其是否存在
+    if (pid) {
+        try {
+            const detail = await client.markets.getMarketDetail({ chainId, poolId: pid });
+            const marketId = detail?.marketId || detail?.data?.marketId;
+            if (marketId)
+                return pid;
+        }
+        catch {
+            // 验证失败，记录并尝试通过 keyword 寻址
+            console.warn(`[resolvePool] PoolId ${pid} not found, trying keyword fallback...`);
+        }
+    }
+    // 2. 如果提供了 keyword，执行搜索
+    const kw = keyword?.trim();
+    if (kw) {
+        const markets = await searchMarket(client, kw, 10);
+        if (markets.length > 0) {
+            return markets[0].poolId;
+        }
+    }
+    // 3. 最后手段：遍历全量活跃池列表
+    if (kw || pid) {
+        const poolListRes = await client.api.getPoolList().catch(() => null);
+        if (poolListRes) {
+            // 这里的逻辑参考 openPositionSimple 中的 collectPoolRows
+            const collect = (input) => {
+                if (Array.isArray(input))
+                    return input.flatMap(collect);
+                if (!input || typeof input !== "object")
+                    return [];
+                if (input.poolId || input.pool_id)
+                    return [input];
+                return Object.values(input).flatMap(collect);
+            };
+            const rows = collect(poolListRes.data ?? poolListRes);
+            const searchKey = (kw || pid || "").toUpperCase();
+            const match = rows.find((row) => {
+                if (Number(row?.state) !== 2)
+                    return false;
+                const base = String(row?.baseSymbol ?? "").toUpperCase();
+                const pair = String(row?.baseQuoteSymbol ?? "").toUpperCase();
+                const id = String(row?.poolId ?? row?.pool_id ?? "").toUpperCase();
+                return base === searchKey || pair.includes(searchKey) || id === searchKey;
+            });
+            if (match) {
+                return String(match.poolId ?? match.pool_id);
+            }
+        }
+    }
+    if (pid)
+        return pid; // 如果没有更好的选择，返回原 ID
+    throw new Error(`Could not resolve pool for keyword: ${kw} / poolId: ${pid}`);
+}

package/dist/services/tradeService.js

@@ -60,6 +60,32 @@ export async function openPosition(client, address, args) {
     const baseDecimals = poolData.baseDecimals || 18;
     const quoteDecimals = poolData.quoteDecimals || 6;
     const collateralRaw = ensureUnits(args.collateralAmount, quoteDecimals, "collateralAmount");
+    // --- Pre-flight Check: minOrderSizeInUsd ---
+    try {
+        const levelRes = await client.markets.getPoolLevelConfig(args.poolId, chainId);
+        // SDK might return { levelConfig: ... } or { data: { levelConfig: ... } }
+        const levelConfig = levelRes?.levelConfig || levelRes?.data?.levelConfig;
+        const minOrderSizeInUsdRaw = levelConfig?.minOrderSizeInUsd;
+        if (minOrderSizeInUsdRaw) {
+            // If the value is very large (e.g. 100,000,000), it might be scaled by 1e6.
+            // But based on observation, it's often already human-friendly (e.g. 100).
+            let minOrderSizeInUsd = Number(minOrderSizeInUsdRaw);
+            if (minOrderSizeInUsd > 1000000)
+                minOrderSizeInUsd /= 1000000;
+            const leverage = Number(args.leverage || 1);
+            const collateralHuman = Number(collateralRaw) / (10 ** quoteDecimals);
+            const notionalUsd = collateralHuman * leverage;
+            if (notionalUsd > 0 && notionalUsd < minOrderSizeInUsd) {
+                throw new Error(`Order size out of range: Calculated notional ${notionalUsd.toFixed(2)} USD is less than the minimum required ${minOrderSizeInUsd} USD for this pool. ` +
+                    `Please increase your collateral or leverage.`);
+            }
+        }
+    }
+    catch (e) {
+        if (e.message.includes("Order size out of range"))
+            throw e;
+        console.warn(`[tradeService] Limit check skipped: ${e.message}`);
+    }
     const sizeRaw = ensureUnits(args.size, baseDecimals, "size");
     const priceRaw = ensureUnits(args.price, 30, "price");
     const tradingFeeRaw = ensureUnits(args.tradingFee, quoteDecimals, "tradingFee");

package/dist/tools/openPositionSimple.js

@@ -1,10 +1,11 @@
 import { z } from "zod";
 import { OrderType } from "@myx-trade/sdk";
 import { resolveClient, getChainId } from "../auth/resolveClient.js";
-import { searchMarket } from "../services/marketService.js";
+import { resolvePool } from "../services/marketService.js";
 import { openPosition } from "../services/tradeService.js";
 import { normalizeAddress } from "../utils/address.js";
 import { finalizeMutationResult } from "../utils/mutationResult.js";
+import { mapDirection, mapOrderType } from "../utils/mappings.js";
 import { normalizeSlippagePct4dp, SLIPPAGE_PCT_4DP_DESC } from "../utils/slippage.js";
 import { parseUserPrice30, parseUserUnits } from "../utils/units.js";
 import { verifyTradeOutcome } from "../utils/verification.js";
@@ -32,43 +33,18 @@ function pickMarketDetail(res) {
         return res;
     return null;
 }
-function collectPoolRows(input) {
-    if (Array.isArray(input))
-        return input.flatMap(collectPoolRows);
-    if (!input || typeof input !== "object")
-        return [];
-    if (input.poolId || input.pool_id)
-        return [input];
-    return Object.values(input).flatMap(collectPoolRows);
-}
-function resolveOrderType(orderType) {
-    const raw = String(orderType ?? "MARKET").trim().toUpperCase();
-    if (raw === "MARKET")
-        return OrderType.MARKET;
-    if (raw === "LIMIT")
-        return OrderType.LIMIT;
-    if (raw === "STOP")
-        return OrderType.STOP;
-    throw new Error(`orderType must be one of: MARKET, LIMIT, STOP.`);
-}
 export const openPositionSimpleTool = {
     name: "open_position_simple",
     description: "High-level open position helper. Computes size/price/tradingFee and submits an increase order. Human units by default; use 'raw:' prefix for raw units.",
     schema: {
         poolId: z.string().optional().describe("Pool ID. Provide either poolId or keyword."),
         keyword: z.string().optional().describe('Market keyword, e.g. "BTC". Provide either keyword or poolId.'),
-        direction: z.coerce
-            .number()
-            .pipe(z.union([z.literal(0), z.literal(1)]))
-            .describe("0 = LONG, 1 = SHORT"),
+        direction: z.any().describe("LONG (0), SHORT (1) or string BUY/SELL/LONG/SHORT"),
         collateralAmount: z.coerce
             .string()
             .describe("Collateral amount in quote token units (human by default; 'raw:' prefix for raw)."),
         leverage: z.coerce.number().int().positive().describe("Leverage (integer, e.g. 5, 10)."),
-        orderType: z
-            .enum(["MARKET", "LIMIT", "STOP"])
-            .optional()
-            .describe("Order type (default MARKET)."),
+        orderType: z.union([z.string(), z.number()]).optional().describe("MARKET, LIMIT, STOP (default MARKET)."),
         price: z.coerce
             .string()
             .optional()
@@ -102,34 +78,7 @@ export const openPositionSimpleTool = {
             const { client, address, signer } = await resolveClient();
             const chainId = getChainId();
             // 1) Resolve poolId (poolId or keyword)
-            let poolId = String(args.poolId ?? "").trim();
-            if (!poolId) {
-                const keyword = String(args.keyword ?? "").trim();
-                if (!keyword)
-                    throw new Error("Either poolId or keyword is required.");
-                const markets = await searchMarket(client, keyword, 20);
-                if (markets.length) {
-                    poolId = String(markets[0].poolId);
-                }
-                else {
-                    // Fallback: some environments return null for markets.searchMarket; use api.getPoolList instead.
-                    const poolListRes = await client.api.getPoolList().catch(() => null);
-                    const rows = collectPoolRows(poolListRes?.data ?? poolListRes);
-                    const kw = keyword.toUpperCase();
-                    const match = rows.find((row) => {
-                        if (Number(row?.state) !== 2)
-                            return false;
-                        const base = String(row?.baseSymbol ?? "").toUpperCase();
-                        const fallbackPair = row?.baseSymbol && row?.quoteSymbol ? `${row.baseSymbol}/${row.quoteSymbol}` : "";
-                        const pair = String(row?.baseQuoteSymbol ?? fallbackPair).toUpperCase();
-                        return base === kw || pair.includes(kw);
-                    });
-                    if (!match?.poolId && !match?.pool_id) {
-                        throw new Error(`No active market found for keyword: ${keyword}`);
-                    }
-                    poolId = String(match.poolId ?? match.pool_id);
-                }
-            }
+            const poolId = await resolvePool(client, args.poolId, args.keyword);
             // 2) Fetch market detail for decimals, quote token, marketId
             const detailRes = await client.markets.getMarketDetail({ chainId, poolId });
             const detail = pickMarketDetail(detailRes);
@@ -154,9 +103,7 @@ export const openPositionSimpleTool = {
             }
             const defaultAssetClass = Number(poolLevelConfig?.levelConfig?.assetClass ?? 0);
             // 3) Parse & validate primary inputs
-            const dir = Number(args.direction);
-            if (dir !== 0 && dir !== 1)
-                throw new Error("direction must be 0 (LONG) or 1 (SHORT).");
+            const dir = mapDirection(args.direction);
             const collateralRaw = parseUserUnits(args.collateralAmount, quoteDecimals, "collateralAmount");
             const collateralRawBig = asBigint(collateralRaw, "collateralAmount");
             if (collateralRawBig <= 0n)
@@ -169,7 +116,7 @@ export const openPositionSimpleTool = {
                     throw new Error(`collateralAmount exceeds MAX_TRADE_AMOUNT (collateralRaw=${collateralRawBig.toString()} > maxRaw=${maxTradeRawBig.toString()}).`);
                 }
             }
-            const orderType = resolveOrderType(args.orderType);
+            const orderType = mapOrderType(args.orderType ?? 0);
             const postOnly = Boolean(args.postOnly ?? false);
             const slippagePct = normalizeSlippagePct4dp(args.slippagePct ?? "100");
             const executionFeeToken = normalizeAddress(args.executionFeeToken || quoteToken, "executionFeeToken");

package/dist/tools/setTpSl.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { resolveClient } from "../auth/resolveClient.js";
 import { setPositionTpSl } from "../services/tradeService.js";
 import { finalizeMutationResult } from "../utils/mutationResult.js";
+import { mapDirection, mapTriggerType } from "../utils/mappings.js";
 import { isValidSlippagePct4dp, SLIPPAGE_PCT_4DP_DESC } from "../utils/slippage.js";
 export const setTpSlTool = {
     name: "set_tp_sl",
@@ -9,11 +10,11 @@ export const setTpSlTool = {
     schema: {
         poolId: z.string().describe("Pool ID"),
         positionId: z.string().describe("Position ID"),
-        direction: z.coerce.number().pipe(z.union([z.literal(0), z.literal(1)])).describe("0 = LONG, 1 = SHORT"),
+        direction: z.any().describe("LONG (0), SHORT (1) or string BUY/SELL/LONG/SHORT"),
         leverage: z.coerce.number().describe("Leverage"),
         executionFeeToken: z.string().describe("Execution fee token address"),
-        tpTriggerType: z.coerce.number().int().min(0).max(2).describe("TP trigger type"),
-        slTriggerType: z.coerce.number().int().min(0).max(2).describe("SL trigger type"),
+        tpTriggerType: z.union([z.number(), z.string()]).optional().describe("TP trigger type (0=NONE, 1=GTE, 2=LTE)"),
+        slTriggerType: z.union([z.number(), z.string()]).optional().describe("SL trigger type (0=NONE, 1=GTE, 2=LTE)"),
         slippagePct: z.coerce.string().refine(isValidSlippagePct4dp, {
             message: "slippagePct must be an integer in [0, 10000] with 4-decimal precision (1 = 0.01%).",
         }).describe(SLIPPAGE_PCT_4DP_DESC),
@@ -25,7 +26,14 @@ export const setTpSlTool = {
     handler: async (args) => {
         try {
             const { client, address, signer } = await resolveClient();
-            const raw = await setPositionTpSl(client, address, args);
+            // Map inputs
+            const mappedArgs = {
+                ...args,
+                direction: mapDirection(args.direction),
+                tpTriggerType: args.tpTriggerType !== undefined ? mapTriggerType(args.tpTriggerType) : undefined,
+                slTriggerType: args.slTriggerType !== undefined ? mapTriggerType(args.slTriggerType) : undefined,
+            };
+            const raw = await setPositionTpSl(client, address, mappedArgs);
             const data = await finalizeMutationResult(raw, signer, "set_tp_sl");
             return { content: [{ type: "text", text: JSON.stringify({ status: "success", data }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
         }

package/dist/utils/errors.js

@@ -1,3 +1,6 @@
+/**
+ * MCP Standard Error Codes
+ */
 export var ErrorCode;
 (function (ErrorCode) {
     ErrorCode["INVALID_INPUT"] = "INVALID_INPUT";
@@ -7,6 +10,9 @@ export var ErrorCode;
     ErrorCode["UNAUTHORIZED"] = "UNAUTHORIZED";
     ErrorCode["BLOCKCHAIN_ERROR"] = "BLOCKCHAIN_ERROR";
 })(ErrorCode || (ErrorCode = {}));
+/**
+ * MCP Standard Error Class
+ */
 export class MCPError extends Error {
     code;
     constructor(code, message) {
@@ -15,3 +21,236 @@ export class MCPError extends Error {
         this.name = "MCPError";
     }
 }
+/**
+ * Common MYX Contract Error Selectors
+ */
+export const CONTRACT_ERRORS = {
+    "fa52dfc0": "AccountInsufficientFreeAmount()",
+    "e2a1a260": "AccountInsufficientReservedAmount()",
+    "ffd10028": "AccountInsufficientTradableAmount(uint256,uint256)",
+    "9996b315": "AddressEmptyCode(address)",
+    "4c9c8ce3": "ERC1967InvalidImplementation(address)",
+    "b398979f": "ERC1967NonPayable()",
+    "d6bda275": "FailedCall()",
+    "f92ee8a9": "InvalidInitialization()",
+    "44d3438f": "NotAddressManager()",
+    "3fc81f20": "NotDependencyManager()",
+    "d7e6bcf8": "NotInitializing()",
+    "507f487a": "NotProxyAdmin()",
+    "e03f6024": "PermissionDenied(address,address)",
+    "5274afe7": "SafeERC20FailedOperation(address)",
+    "e07c8dba": "UUPSUnauthorizedCallContext()",
+    "aa1d49a4": "UUPSUnsupportedProxiableUUID(bytes32)",
+    "24775e06": "SafeCastOverflowedUintToInt(uint256)",
+    "ba767932": "ConvertAmountMismatch(uint256,uint256)",
+    "d93c0665": "EnforcedPause()",
+    "8dfc202b": "ExpectedPause()",
+    "059e2f49": "InRewindMode()",
+    "db42144d": "InsufficientBalance(address,uint256,uint256)",
+    "42301c23": "InsufficientOutputAmount()",
+    "caa99aac": "MismatchExecuteFee(uint256,uint256,uint256)",
+    "8637dfc0": "NotInRewindMode()",
+    "4578ddb8": "OnlyRelayer()",
+    "1e4fbdf7": "OwnableInvalidOwner(address)",
+    "118cdaa7": "OwnableUnauthorizedAccount(address)",
+    "3ee5aeb5": "ReentrancyGuardReentrantCall()",
+    "90b8ec18": "TransferFailed()",
+    "f4d678b8": "InsufficientBalance()",
+    "6aee3c1a": "InsufficientRiskReserves()",
+    "2c5211c6": "InvalidAmount()",
+    "82cb17ef": "InvalidSplitConfig()",
+    "f645eedf": "ECDSAInvalidSignature()",
+    "fce698f7": "ECDSAInvalidSignatureLength(uint256)",
+    "d78bce0c": "ECDSAInvalidSignatureS(bytes32)",
+    "48834bee": "ExpiredFeeData()",
+    "56d69198": "InvalidFeeRate()",
+    "613970e0": "InvalidParameter()",
+    "80577032": "NoRebateToClaim()",
+    "27d08510": "NotActiveBroker(address)",
+    "6e6b79b0": "NotBrokerSigner(address)",
+    "f6412b5a": "NotOrderOwner()",
+    "70d645e3": "NotPositionOwner()",
+    "ff70343d": "UnsupportedAssetClass(AssetClass)",
+    "185676be": "UnsupportedFeeTier(uint8)",
+    "60b25fe4": "BrokerAlreadyExists()",
+    "7eb4a674": "BrokerNotFound()",
+    "8c3b5bf0": "NotBrokerAdmin()",
+    "3733548a": "InvalidFeeTier()",
+    "192105d7": "InitializationFunctionReverted(address,bytes)",
+    "0dc149f0": "AlreadyInitialized()",
+    "664431a8": "NotAllowedTarget(address)",
+    "03357c6c": "ExceedsMaximumRelayFee()",
+    "0d10f63b": "InconsistentParamsLength()",
+    "38802743": "InsufficientFeeAllowance(address,uint256,uint256)",
+    "d95b4ad5": "InsufficientFeeBalance(address,uint256,uint256)",
+    "a3972305": "MismatchedSender(address)",
+    "c3b80e86": "RelayerRegistered(address)",
+    "ee0844a3": "RemoveRelayerFailed()",
+    "c583a8da": "IncorrectFee(uint256)",
+    "00bfc921": "InvalidPrice()",
+    "d96ce906": "PriceIdMismatch()",
+    "148cd0dd": "VerifyPriceFailed()",
+    "b12d13eb": "ETHTransferFailed()",
+    "a83325d4": "PoolOracleFeeCharged()",
+    "6b75f90d": "PoolOracleFeeNotCharged()",
+    "42a0e2a7": "PoolOracleFeeNotExisted()",
+    "8ee01e1c": "PoolOracleFeeNotSoldOut()",
+    "5e0a829b": "ETHTransferFailed(address,uint256)",
+    "4ba6536f": "GasLimitExceeded(address,uint256,uint256)",
+    "ca1aae4b": "GasLimitNotSet(address)",
+    "3728b83d": "InvalidAmount(uint256)",
+    "3484727e": "BaseFeeNotSoldOut()",
+    "0251bde4": "LPNotFullyMinted()",
+    "7decb035": "PoolDebtNotCleared()",
+    "1acb203e": "PositionNotEmpty()",
+    "2be7b24b": "UnexpectedPoolState()",
+    "7bd42a2e": "NotEmptyAddress()",
+    "6697b232": "AccessControlBadConfirmation()",
+    "e2517d3f": "AccessControlUnauthorizedAccount(address,bytes32)",
+    "7c9a1cf9": "AlreadyVoted()",
+    "796ea3a6": "BondNotReleased()",
+    "6511c20d": "BondZeroAmount()",
+    "f38e5973": "CaseAppealNotFinished()",
+    "1eaa4a59": "CaseDeadlineNotReached()",
+    "e6c67e3a": "CaseDeadlineReached()",
+    "0fc957b1": "CaseNotAccepted()",
+    "3ddb819d": "CaseNotExist(CaseId)",
+    "79eab18d": "CaseRespondentAppealed(CaseId,address)",
+    "a179f8c9": "ChainIdMismatch()",
+    "311c16d3": "DisputeNotAllowed()",
+    "752d88c0": "InvalidAccountNonce(address,uint256)",
+    "a710429d": "InvalidContractAddress()",
+    "8076dd8a": "InvalidFunctionSignature()",
+    "c37906a0": "InvalidPayloadLength(uint256,uint256)",
+    "dcdedda9": "InvalidPoolToken()",
+    "3471a3c2": "InvalidProfitAmount()",
+    "1d9617a0": "InvalidResponseVersion()",
+    "9284b197": "InvalidSourceChain()",
+    "b9021668": "NoChainResponse()",
+    "c546bca4": "NotCaseRespondent(CaseId,address)",
+    "84ae4a30": "NumberOfResponsesMismatch()",
+    "02164961": "RequestTypeMismatch()",
+    "4cf72652": "RiskCloseNotCompleted()",
+    "0819bdcd": "SignatureExpired()",
+    "c00ca938": "UnexpectedCaseState()",
+    "7935e939": "UnexpectedCaseType()",
+    "5e7bd6ec": "UnexpectedNumberOfResults()",
+    "51ee5853": "UnsupportedQueryType(uint8)",
+    "29ca666b": "UntrustfulVoting()",
+    "439cc0cd": "VerificationFailed()",
+    "714f5513": "VersionMismatch()",
+    "96b8e05b": "WrongQueryType(uint8,uint8)",
+    "bb6b170d": "ZeroQueries()",
+    "a9214540": "AlreadyClaimed(CaseId,address)",
+    "d4ac59c1": "InvalidAmount(CaseId,address)",
+    "7a6f5328": "MerkleTreeVerificationFailed(CaseId,address)",
+    "094a5cfe": "ReimbursementValidity(CaseId)",
+    "8b922563": "TreeAlreadySet()",
+    "7b27120a": "InDisputeMode()",
+    "5646203f": "InsufficientCollateral(PositionId,uint256)",
+    "b04111ef": "InsufficientFreeCollateral(PositionId,uint256)",
+    "12f1b11a": "InsufficientLockedCollateral(PositionId,uint256)",
+    "a8ce4432": "SafeCastOverflowedIntToUint(int256)",
+    "6dfcc650": "SafeCastOverflowedUintDowncast(uint8,uint256)",
+    "d24b47fb": "UserProfitFrozen()",
+    "1c151780": "ExceedMinOutput(uint256,uint256)",
+    "e1f0493d": "NotAllowedCaller(address)",
+    "fb8f41b2": "ERC20InsufficientAllowance(address,uint256,uint256)",
+    "e450d38c": "ERC20InsufficientBalance(address,uint256,uint256)",
+    "e602df05": "ERC20InvalidApprover(address)",
+    "ec442f05": "ERC20InvalidReceiver(address)",
+    "96c6fd1e": "ERC20InvalidSender(address)",
+    "94280d62": "ERC20InvalidSpender(address)",
+    "62791302": "ERC2612ExpiredSignature(uint256)",
+    "4b800e46": "ERC2612InvalidSigner(address,address)",
+    "b3512b0c": "InvalidShortString()",
+    "305a27a9": "StringTooLong(string)",
+    "fd0f789d": "ExceedMaxPriceDeviation()",
+    "407b87e5": "ExchangeRateAlreadyApplied()",
+    "5c6c5686": "ExchangeRateAlreadyDisabled()",
+    "1ae17fcd": "InvalidDeviationRatio()",
+    "37bc9350": "InvalidPriceTimestamp()",
+    "7a5c919f": "InvalidRewindPrice()",
+    "18b88897": "InvalidUpdateFee()",
+    "f76740e3": "PriceDeviationBelowMinimum()",
+    "49386283": "PriceDeviationThresholdReached()",
+    "7f84faec": "PublishTimeMismatch()",
+    "19abf40e": "StalePrice()",
+    "e351cd13": "ExceedMaxExchangeableAmount()",
+    "14be833f": "InsufficientReturnAmount(uint256,uint256)",
+    "15912a6f": "NotSupportVersion()",
+    "f1364a74": "ArrayEmpty()",
+    "15ed381d": "ExceedMaxProfit()",
+    "dc82bd68": "ExceedMinOutputAmount()",
+    "ba01b06f": "PoolNotActive(PoolId)",
+    "ba8f5df5": "PoolNotCompoundable(PoolId)",
+    "51aeee6c": "PoolNotExist(PoolId)",
+    "70f6c197": "InvalidQuoteTokenAddress()",
+    "0b8457f4": "InvalidRatioParams()",
+    "29dae146": "MarketAlreadyExisted()",
+    "f040b67a": "MarketNotExisted()",
+    "0e442a4a": "InvalidBaseToken()",
+    "24e219c7": "MarketNotExist(MarketId)",
+    "cc36f935": "PoolExists(PoolId)",
+    "e84c308d": "ExceedBaseReserved(uint256,uint256)",
+    "3e241751": "ExceedQuoteReserved(uint256,uint256)",
+    "de656889": "ExceedReservable(uint256,uint256,uint256)",
+    "d54d0fc4": "InsufficientLiquidity(uint256,uint256,uint256)",
+    "7e562a65": "InvalidDistributionAmount()",
+    "83c7580d": "ReservableNotEnough(uint256,uint256)",
+    "94eef58a": "ERC2771ForwarderExpiredRequest(uint48)",
+    "c845a056": "ERC2771ForwarderInvalidSigner(address,address)",
+    "70647f79": "ERC2771ForwarderMismatchedValue(uint256,uint256)",
+    "d2650cd1": "ERC2771UntrustfulTarget(address,address)",
+    "cf479181": "InsufficientBalance(uint256,uint256)",
+    "4c150d8f": "DifferentMarket(PoolId,PoolId)",
+    "aa98b06a": "InsufficientQuoteIn(uint256,uint256,uint256)",
+    "3e589bee": "InvalidLiquidityAmount()",
+    "aebd3617": "InvalidTpsl(uint256)",
+    "e079169e": "NotReachedPrice(OrderId,uint256,uint256,TriggerType)",
+    "7fe81129": "SamePoolMigration(PoolId)",
+    "71c4efed": "SlippageExceeded(uint256,uint256)",
+    "62b9bc7b": "DesignatedTokenMismatch(address,address)",
+    "49465eb0": "NotForwardAllowedTarget(address)",
+    "e921c36b": "AlreadyMigrated(PositionId,PositionId)",
+    "ddefae28": "AlreadyMinted()",
+    "b4762117": "ExceedMaxLeverage(PositionId)",
+    "97c7f537": "ExcessiveSlippage()",
+    "301b6707": "ExecutionFeeNotCollected()",
+    "1b5305a8": "InsufficientRedeemable()",
+    "c6e8248a": "InsufficientSize()",
+    "700deaad": "InvalidADLPosition(OrderId,PositionId)",
+    "f64fa6a8": "InvalidOrder(OrderId)",
+    "1dab59cf": "InvalidOrderPair(OrderId,OrderId)",
+    "8ea9158f": "InvalidPosition(PositionId)",
+    "d15b4fe2": "InvalidQuoteToken()",
+    "d8daec7c": "MarketNotInitialized()",
+    "419ecd12": "MatchNotSupported()",
+    "d4944235": "NoADLNeeded(OrderId)",
+    "cd4891b6": "NotInDisputeMode()",
+    "17229ec4": "NotMeetEarlyCloseCriteria(PositionId)",
+    "1ad308dc": "OrderExpired(OrderId)",
+    "e75316c6": "OrderNotExist(OrderId)",
+    "230e8e43": "PoolNotInPreBenchState(PoolId)",
+    "486aa307": "PoolNotInitialized()",
+    "a5afd143": "PositionNotHealthy(PositionId,uint256)",
+    "ba0d3752": "PositionNotInitialized(PositionId)",
+    "c53f84e7": "PositionRemainsHealthy(PositionId)",
+    "107dec14": "RiskCloseNotAllowed()",
+    "759b3876": "UnhealthyAfterRiskTierApplied(PositionId)",
+};
+/**
+ * Tries to decode an error data string into a human-readable name.
+ * @param errorData Hex string of the error data (e.g. "0xfa52dfc0...")
+ */
+export function decodeErrorSelector(errorData) {
+    if (!errorData || typeof errorData !== "string")
+        return null;
+    // Clean prefix
+    let hex = errorData.toLowerCase();
+    if (hex.startsWith("0x"))
+        hex = hex.slice(2);
+    // Selector is first 4 bytes (8 hex chars)
+    const selector = hex.slice(0, 8);
+    return CONTRACT_ERRORS[selector] || null;
+}

package/dist/utils/mappings.js

@@ -117,3 +117,48 @@ export const getCloseTypeDesc = (type) => {
     };
     return types[type] || `Unknown(${type})`;
 };
+/**
+ * 映射输入方向为数值
+ */
+export const mapDirection = (input) => {
+    if (input === 0 || input === 1)
+        return input;
+    const s = String(input ?? "").trim().toUpperCase();
+    if (s === "0" || s === "LONG" || s === "BUY")
+        return 0;
+    if (s === "1" || s === "SHORT" || s === "SELL")
+        return 1;
+    throw new Error(`Invalid direction: ${input}. Use 0/LONG or 1/SHORT.`);
+};
+/**
+ * 映射输入订单类型为数值
+ */
+export const mapOrderType = (input) => {
+    if (input === 0 || input === 1 || input === 2 || input === 3)
+        return input;
+    const s = String(input ?? "").trim().toUpperCase();
+    if (s === "0" || s === "MARKET")
+        return 0;
+    if (s === "1" || s === "LIMIT")
+        return 1;
+    if (s === "2" || s === "STOP")
+        return 2;
+    if (s === "3" || s === "CONDITIONAL")
+        return 3;
+    throw new Error(`Invalid orderType: ${input}. Use MARKET, LIMIT, STOP or CONDITIONAL.`);
+};
+/**
+ * 映射输入触发业务类型为数值
+ */
+export const mapTriggerType = (input) => {
+    if (input === 0 || input === 1 || input === 2)
+        return input;
+    const s = String(input ?? "").trim().toUpperCase();
+    if (s === "0" || s === "NONE")
+        return 0;
+    if (s === "1" || s === "GTE" || s === ">=")
+        return 1;
+    if (s === "2" || s === "LTE" || s === "<=")
+        return 2;
+    throw new Error(`Invalid triggerType: ${input}. Use 0/NONE, 1/GTE or 2/LTE.`);
+};

package/dist/utils/mutationResult.js

@@ -1,3 +1,4 @@
+import { decodeErrorSelector } from "./errors.js";
 const TX_HASH_RE = /^0x[0-9a-fA-F]{64}$/;
 const TX_HASH_KEYS = new Set(["hash", "txHash", "transactionHash"]);
 function isObject(value) {
@@ -36,7 +37,22 @@ function assertSdkCode(result, actionName) {
         throw new Error(`${actionName} failed: invalid SDK code.`);
     }
     if (code !== 0) {
-        const msg = result.msg ?? result.message ?? "unknown error";
+        let msg = result.msg ?? result.message ?? "unknown error";
+        // 尝试解码可能存在的自定义错误 (通常在 data 或 msg 中)
+        const data = result.data;
+        if (typeof data === "string" && data.startsWith("0x")) {
+            const decoded = decodeErrorSelector(data);
+            if (decoded)
+                msg = `${msg} (Contract Error: ${decoded})`;
+        }
+        else if (typeof msg === "string" && msg.includes("0x")) {
+            const match = msg.match(/0x[0-9a-f]{8}/i);
+            if (match) {
+                const decoded = decodeErrorSelector(match[0]);
+                if (decoded)
+                    msg = `${msg} (Decoded: ${decoded})`;
+            }
+        }
         throw new Error(`${actionName} failed: code=${code}, msg=${String(msg)}`);
     }
 }

package/dist/utils/verification.js

@@ -1,12 +1,13 @@
 import { getChainId } from "../auth/resolveClient.js";
+import { decodeErrorSelector } from "./errors.js";
 /**
- * 等待后端索引并验证交易结果
+ * 等待后端索引并验证交易结果 (增强版)
  */
 export async function verifyTradeOutcome(client, address, poolId, txHash) {
     const chainId = getChainId();
-    // 给后端索引一定的缓冲时间
-    const maxAttempts = 5;
-    const intervalMs = 1000;
+    // 给后端索引一定的缓冲时间，采用指数退避
+    const maxAttempts = 6;
+    let currentDelay = 1000;
     let matchedOrder = null;
     for (let i = 0; i < maxAttempts; i++) {
         try {
@@ -19,13 +20,22 @@ export async function verifyTradeOutcome(client, address, poolId, txHash) {
             const history = historyRes?.data || historyRes?.data?.data || [];
             matchedOrder = history.find((o) => String(o.orderHash).toLowerCase() === txHash.toLowerCase() ||
                 String(o.txHash).toLowerCase() === txHash.toLowerCase());
-            if (matchedOrder)
-                break;
+            // 如果找到了订单且已经有最终状态，则退出轮询
+            if (matchedOrder) {
+                const status = Number(matchedOrder.status);
+                if (status === 1 || status === 9 || status === 2) {
+                    // 1: Cancelled, 9: Successful, 2: Expired
+                    break;
+                }
+            }
         }
         catch (e) {
             console.warn(`[verifyTradeOutcome] Attempt ${i + 1} failed:`, e);
         }
-        await new Promise(resolve => setTimeout(resolve, intervalMs));
+        if (i < maxAttempts - 1) {
+            await new Promise(resolve => setTimeout(resolve, currentDelay));
+            currentDelay *= 2; // 指数退避 (1s, 2s, 4s...)
+        }
     }
     // 查询当前持仓
     let positions = [];
@@ -36,9 +46,16 @@ export async function verifyTradeOutcome(client, address, poolId, txHash) {
     catch (e) {
         console.warn(`[verifyTradeOutcome] Failed to fetch positions:`, e);
     }
+    let cancelReason = matchedOrder?.cancelReason || (matchedOrder?.status === 1 ? "Unknown cancellation" : null);
+    if (cancelReason && cancelReason.startsWith("0x")) {
+        const decoded = decodeErrorSelector(cancelReason);
+        if (decoded)
+            cancelReason = `${cancelReason} (${decoded})`;
+    }
     return {
         order: matchedOrder,
         positions: positions,
-        verified: !!matchedOrder
+        verified: !!matchedOrder,
+        cancelReason
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@michaleffffff/mcp-trading-server",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "type": "module",
   "bin": {
     "myx-mcp": "dist/server.js"