@michaleffffff/mcp-trading-server 2.5.3 → 2.7.0

package/README.md

@@ -62,6 +62,13 @@ Copy the example configuration:
 cp .env.example .env
 ```
 
+## Non-Auth Mode (No AccessToken)
+
+This MCP server runs in **non-auth mode**:
+
+- It does **not** call `myxClient.auth()` and does **not** manage AccessTokens.
+- All tools are designed to work without AccessToken authentication.
+
 ## User Key Configuration (Safe Practices)
 
 - **Local dev**: Put `PRIVATE_KEY` in a local `.env` (ignored by `.gitignore`) and never commit it.
@@ -108,19 +115,43 @@ The server will run using `stdio` transport and can be connected by any MCP-comp
 2. **Configure env**: Copy `.env.example` to `.env` and fill in `PRIVATE_KEY`, `RPC_URL`, etc.
 3. **Start the server**: Run `npm run build` then `npm run start` (use `npm run dev` for development).
 4. **Configure your MCP client**: Set `command/args/env` in your MCP client (see Claude Desktop example below).
-5. **Common flow**: Use `search_market` to get `poolId`, then `get_market_price` / `get_oracle_price` to view prices, and finally `execute_trade` to open a position (`direction: 0`=LONG, `1`=SHORT; `collateralAmount` is human‑readable).
+5. **Common flow**: Use `search_market` to get `poolId`, then optionally `get_market_price` / `get_oracle_price` to view prices, and finally use `open_position_simple` (recommended) to open a position.
 
 **Minimal open position example:**
 
 ```json
 {
-  "poolId": "0x...",
+  "keyword": "BTC",
   "direction": 0,
   "collateralAmount": "100",
-  "leverage": 5
+  "leverage": 5,
+  "orderType": "MARKET",
+  "autoDeposit": false
 }
 ```
 
+**Dry run (no transaction) example:**
+
+```json
+{
+  "keyword": "BTC",
+  "direction": 0,
+  "collateralAmount": "100",
+  "leverage": 5,
+  "orderType": "MARKET",
+  "autoDeposit": false,
+  "dryRun": true
+}
+```
+
+## Units & Precision
+
+- **Human by default**: For trading tools (e.g. `open_position_simple`), amounts like `"100"` mean **human-readable units**.
+- **Raw units (explicit)**: Prefix with `raw:` to pass raw units exactly (e.g. `raw:100000000` for 100 USDC with 6 decimals).
+- **Price**: `"price"` is human by default and will be converted to **30-decimal** format internally. Use `raw:` to pass a 30-decimal integer directly.
+- **Slippage**: `slippagePct` uses 4-decimal raw units: `100` = `1%`, `50` = `0.5%`, `1000` = `10%`.
+- **Note**: Some account-transfer tools (e.g. `account_deposit`, `account_withdraw`, `check_approval`) use **raw integer strings**.
+
 ---
 
 ## Secure Deployment Template (Systemd Example)
@@ -192,14 +223,15 @@ Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
 
 # Tools
 
-The server exposes 37 tools categorized for AI:
+The server exposes 38 tools categorized for AI:
 
 ### Trading Operations
+* **open_position_simple**: High-level open position helper (recommended). Computes price/size/tradingFee internally.
 * **execute_trade**: Execute a new trade or add to an existing position.
 * **close_position**: Close an open position.
 * **close_all_positions**: Emergency: close ALL open positions in a pool at once.
 * **cancel_order**: Cancel an open order by its order ID.
-* **cancel_all_orders**: Cancel all open orders at once (or a provided order ID list).
+* **cancel_all_orders**: Cancel multiple open orders by order IDs (use `get_open_orders` first to get IDs).
 * **set_tp_sl**: Set take profit and stop loss prices for an open position.
 * **adjust_margin**: Adjust the margin (collateral) of an open position.
 * **get_user_trading_fee_rate**: Query current maker/taker fee rates by asset class and risk tier.
@@ -263,7 +295,7 @@ Example MCP client usage workflow:
 1. Connect to the MCP server.
 2. Read the `system://state` resource to confirm wallet connectivity.
 3. Call the `search_market` tool (e.g., `keyword: "ETH"`) to retrieve the `poolId`.
-4. Call `execute_trade` passing the retrieved `poolId` to open a 10x long position.
+4. Call `open_position_simple` passing the retrieved `poolId` to open a 10x long position.
 
 Example integration scripts are located in:
 `examples/basicUsage.ts`

package/dist/server.js

@@ -81,7 +81,7 @@ function zodSchemaToJsonSchema(zodSchema) {
     };
 }
 // ─── MCP Server ───
-const server = new Server({ name: "myx-mcp-trading-server", version: "2.5.3" }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
+const server = new Server({ name: "myx-mcp-trading-server", version: "2.6.0" }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
 // List tools
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
@@ -181,7 +181,7 @@ server.setRequestHandler(GetPromptRequestSchema, async (request) => {
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    logger.info("🚀 MYX Trading MCP Server v2.5.3 running (stdio, pure on-chain, prod ready)");
+    logger.info("🚀 MYX Trading MCP Server v2.6.0 running (stdio, pure on-chain, prod ready)");
 }
 main().catch((err) => {
     logger.error("Fatal Server Startup Error", err);

package/dist/services/marketService.js

@@ -2,11 +2,12 @@ import { getChainId } from "../auth/resolveClient.js";
 import { getMarketStateDesc } from "../utils/mappings.js";
 export async function getMarketPrice(client, poolId, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    const ticker = await client.markets.getTickerList({
+    const tickerRes = await client.markets.getTickerList({
         chainId,
         poolIds: [poolId],
     });
-    return ticker?.data?.[0] ?? null;
+    const rows = Array.isArray(tickerRes) ? tickerRes : (tickerRes?.data ?? []);
+    return rows?.[0] ?? null;
 }
 export async function getOraclePrice(client, poolId, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
@@ -78,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,10 +60,37 @@ 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");
     // --- Auto-Deposit Logic (Strict) ---
+    const allowAutoDeposit = args.autoDeposit !== false;
     console.log(`[tradeService] Checking marginBalance for ${address} in pool ${args.poolId}...`);
     const marginInfo = await client.account.getAccountInfo(chainId, address, args.poolId);
     let marginBalanceRaw = BigInt(0);
@@ -80,6 +107,10 @@ export async function openPosition(client, address, args) {
     }
     const requiredRaw = BigInt(collateralRaw);
     if (marginBalanceRaw < requiredRaw) {
+        if (!allowAutoDeposit) {
+            throw new Error(`Insufficient marginBalance (${marginBalanceRaw.toString()}) for required collateral (${requiredRaw.toString()}). ` +
+                `Deposit to trading account first (account_deposit) or retry with autoDeposit=true.`);
+        }
         const neededRaw = requiredRaw - marginBalanceRaw;
         console.log(`[tradeService] marginBalance (${marginBalanceRaw.toString()}) < Required (${requiredRaw.toString()}). Need to deposit: ${neededRaw.toString()}`);
         if (walletBalanceRaw < neededRaw) {

package/dist/tools/index.js

@@ -1,4 +1,5 @@
 // Tools — 交易
+export { openPositionSimpleTool } from "./openPositionSimple.js";
 export { executeTradeTool } from "./executeTrade.js";
 export { cancelOrderTool } from "./cancelOrder.js";
 export { cancelAllOrdersTool } from "./cancelAllOrders.js";

package/dist/tools/openPositionSimple.js

@@ -0,0 +1,292 @@
+import { z } from "zod";
+import { OrderType } from "@myx-trade/sdk";
+import { resolveClient, getChainId } from "../auth/resolveClient.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";
+const MAX_UINT256 = "115792089237316195423570985008687907853269984665640564039457584007913129639935";
+function pow10(decimals) {
+    if (!Number.isInteger(decimals) || decimals < 0) {
+        throw new Error(`Invalid decimals: ${decimals}`);
+    }
+    return 10n ** BigInt(decimals);
+}
+function asBigint(raw, label) {
+    try {
+        return BigInt(raw);
+    }
+    catch {
+        throw new Error(`${label} must be an integer string.`);
+    }
+}
+function pickMarketDetail(res) {
+    if (!res)
+        return null;
+    if (res.data && typeof res.data === "object")
+        return res.data;
+    if (res.marketId)
+        return res;
+    return null;
+}
+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.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.union([z.string(), z.number()]).optional().describe("MARKET, LIMIT, STOP (default MARKET)."),
+        price: z.coerce
+            .string()
+            .optional()
+            .describe("Price (human by default; 30-dec raw with 'raw:' prefix). Required for LIMIT/STOP."),
+        size: z.coerce
+            .string()
+            .optional()
+            .describe("Position size in base token units (human by default; 'raw:' prefix for raw). If omitted, computed from collateral*leverage/price."),
+        slippagePct: z.coerce
+            .string()
+            .optional()
+            .describe(`${SLIPPAGE_PCT_4DP_DESC} Default 100 (=1%).`),
+        postOnly: z.coerce.boolean().optional().describe("Post-only (default false)."),
+        executionFeeToken: z.string().optional().describe("Execution fee token address (default quoteToken)."),
+        assetClass: z.coerce.number().int().nonnegative().optional().describe("Fee query assetClass (default 1)."),
+        riskTier: z.coerce.number().int().nonnegative().optional().describe("Fee query riskTier (default 1)."),
+        tradingFee: z.coerce
+            .string()
+            .optional()
+            .describe("Trading fee in quote token units (human by default; 'raw:' prefix for raw). If omitted, computed via getUserTradingFeeRate."),
+        autoApprove: z.coerce.boolean().optional().describe("If true, auto-approve quote token spend when needed (default false)."),
+        approveMax: z.coerce.boolean().optional().describe("If autoApprove, approve MaxUint256 (default false approves exact amount)."),
+        autoDeposit: z.coerce
+            .boolean()
+            .optional()
+            .describe("If true, auto-deposit to margin account when marginBalance is insufficient (default false)."),
+        dryRun: z.coerce.boolean().optional().describe("If true, only compute params; do not send a transaction."),
+    },
+    handler: async (args) => {
+        try {
+            const { client, address, signer } = await resolveClient();
+            const chainId = getChainId();
+            // 1) Resolve poolId (poolId or keyword)
+            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);
+            if (!detail) {
+                throw new Error(`Could not resolve market detail for poolId=${poolId}`);
+            }
+            const marketId = String(detail.marketId ?? "").trim();
+            if (!marketId)
+                throw new Error(`marketId missing from market detail for poolId=${poolId}`);
+            const baseDecimals = Number(detail.baseDecimals ?? 18);
+            const quoteDecimals = Number(detail.quoteDecimals ?? 6);
+            const quoteToken = String(detail.quoteToken ?? "").trim();
+            if (!quoteToken)
+                throw new Error(`quoteToken missing from market detail for poolId=${poolId}`);
+            // Optional: read pool level config (best-effort) for defaults like assetClass
+            let poolLevelConfig = null;
+            try {
+                poolLevelConfig = await client.markets.getPoolLevelConfig(poolId, chainId);
+            }
+            catch {
+                poolLevelConfig = null;
+            }
+            const defaultAssetClass = Number(poolLevelConfig?.levelConfig?.assetClass ?? 0);
+            // 3) Parse & validate primary inputs
+            const dir = mapDirection(args.direction);
+            const collateralRaw = parseUserUnits(args.collateralAmount, quoteDecimals, "collateralAmount");
+            const collateralRawBig = asBigint(collateralRaw, "collateralAmount");
+            if (collateralRawBig <= 0n)
+                throw new Error("collateralAmount must be > 0.");
+            const maxTradeAmountHuman = String(process.env.MAX_TRADE_AMOUNT ?? "").trim();
+            if (maxTradeAmountHuman) {
+                const maxTradeRaw = parseUserUnits(maxTradeAmountHuman, quoteDecimals, "MAX_TRADE_AMOUNT");
+                const maxTradeRawBig = asBigint(maxTradeRaw, "MAX_TRADE_AMOUNT");
+                if (collateralRawBig > maxTradeRawBig) {
+                    throw new Error(`collateralAmount exceeds MAX_TRADE_AMOUNT (collateralRaw=${collateralRawBig.toString()} > maxRaw=${maxTradeRawBig.toString()}).`);
+                }
+            }
+            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");
+            // 4) Determine reference price (30 decimals)
+            let price30;
+            let priceMeta = { source: "user", publishTime: null, oracleType: null, human: null };
+            if (orderType === OrderType.MARKET) {
+                try {
+                    const oracle = await client.utils.getOraclePrice(poolId, chainId);
+                    price30 = parseUserPrice30(oracle.price, "oraclePrice");
+                    priceMeta = { source: "oracle", publishTime: oracle.publishTime, oracleType: oracle.oracleType, human: oracle.price };
+                }
+                catch (e) {
+                    const tickers = await client.markets.getTickerList({ chainId, poolIds: [poolId] });
+                    const row = Array.isArray(tickers) ? tickers[0] : tickers?.data?.[0];
+                    if (!row?.price)
+                        throw new Error(`Failed to fetch oracle and ticker price for poolId=${poolId}: ${e?.message || e}`);
+                    price30 = parseUserPrice30(row.price, "marketPrice");
+                    priceMeta = { source: "ticker", publishTime: null, oracleType: null, human: row.price };
+                }
+            }
+            else {
+                const userPrice = String(args.price ?? "").trim();
+                if (!userPrice)
+                    throw new Error("price is required for LIMIT/STOP.");
+                price30 = parseUserPrice30(userPrice, "price");
+                priceMeta = { source: "user", publishTime: null, oracleType: null, human: userPrice };
+            }
+            const price30Big = asBigint(price30, "price");
+            if (price30Big <= 0n)
+                throw new Error("price must be > 0.");
+            // 5) Compute or parse size (base raw units)
+            let sizeRaw = "";
+            let sizeMeta = { source: "computed" };
+            const userSize = String(args.size ?? "").trim();
+            if (userSize) {
+                sizeRaw = parseUserUnits(userSize, baseDecimals, "size");
+                sizeMeta = { source: "user" };
+            }
+            else {
+                const notionalQuoteRaw = collateralRawBig * BigInt(args.leverage);
+                const numerator = notionalQuoteRaw * pow10(30 + baseDecimals);
+                const denominator = price30Big * pow10(quoteDecimals);
+                const computed = numerator / denominator;
+                if (computed <= 0n) {
+                    throw new Error("Computed size is 0. Increase collateralAmount/leverage or check price.");
+                }
+                sizeRaw = computed.toString();
+                sizeMeta = { source: "computed", notionalQuoteRaw: notionalQuoteRaw.toString() };
+            }
+            // 6) Compute tradingFee (quote raw units)
+            let tradingFeeRaw = null;
+            let tradingFeeMeta = { source: "computed" };
+            const userTradingFee = String(args.tradingFee ?? "").trim();
+            if (userTradingFee) {
+                tradingFeeRaw = parseUserUnits(userTradingFee, quoteDecimals, "tradingFee");
+                tradingFeeMeta = { source: "user" };
+            }
+            else {
+                const assetClass = Number(args.assetClass ?? defaultAssetClass);
+                const riskTier = Number(args.riskTier ?? 0);
+                tradingFeeMeta = { source: "computed", assetClass, riskTier, feeRate: null, error: null };
+                try {
+                    const feeRes = await client.utils.getUserTradingFeeRate(assetClass, riskTier, chainId);
+                    if (feeRes && Number(feeRes.code) === 0 && feeRes.data) {
+                        const rateRaw = postOnly ? feeRes.data.makerFeeRate : feeRes.data.takerFeeRate;
+                        tradingFeeMeta.feeRate = rateRaw;
+                        const rate = asBigint(String(rateRaw), "feeRate");
+                        const fee = (collateralRawBig * rate) / 1000000n;
+                        tradingFeeRaw = fee.toString();
+                    }
+                    else {
+                        tradingFeeMeta.error = feeRes?.message ?? "fee_rate_unavailable";
+                    }
+                }
+                catch (e) {
+                    tradingFeeMeta.error = e?.message || String(e);
+                }
+                if (tradingFeeRaw === null && !args.dryRun) {
+                    throw new Error(`Failed to fetch user trading fee rate (assetClass=${assetClass}, riskTier=${riskTier}). Provide tradingFee manually if needed.`);
+                }
+            }
+            const prep = {
+                chainId,
+                poolId,
+                marketId,
+                baseDecimals,
+                quoteDecimals,
+                quoteToken,
+                direction: dir,
+                collateralRaw,
+                sizeRaw,
+                price30,
+                leverage: Number(args.leverage),
+                orderType,
+                triggerType: 0,
+                timeInForce: 0,
+                postOnly,
+                slippagePct,
+                executionFeeToken,
+                tradingFeeRaw,
+                tradingFeeMeta,
+                autoDeposit: Boolean(args.autoDeposit ?? false),
+                priceMeta,
+                sizeMeta,
+            };
+            if (args.dryRun) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({ status: "success", data: { dryRun: true, prepared: prep } }, (_, v) => typeof v === "bigint" ? v.toString() : v, 2),
+                        },
+                    ],
+                };
+            }
+            // 7) Optional approval
+            let approval = null;
+            if (args.autoApprove) {
+                const requiredApprovalRaw = tradingFeeRaw && /^\d+$/.test(String(tradingFeeRaw))
+                    ? (collateralRawBig + asBigint(String(tradingFeeRaw), "tradingFee")).toString()
+                    : collateralRaw;
+                const needApproval = await client.utils.needsApproval(address, chainId, quoteToken, requiredApprovalRaw);
+                if (needApproval) {
+                    const approveAmount = args.approveMax ? MAX_UINT256 : requiredApprovalRaw;
+                    const rawApprove = await client.utils.approveAuthorization({
+                        chainId,
+                        quoteAddress: quoteToken,
+                        amount: approveAmount,
+                    });
+                    approval = await finalizeMutationResult(rawApprove, signer, "approve_authorization");
+                }
+                else {
+                    approval = { needApproval: false };
+                }
+            }
+            // 8) Submit increase order using existing trade service
+            const raw = await openPosition(client, address, {
+                poolId,
+                positionId: "",
+                orderType,
+                triggerType: 0,
+                direction: dir,
+                collateralAmount: `raw:${collateralRaw}`,
+                size: `raw:${sizeRaw}`,
+                price: `raw:${price30}`,
+                timeInForce: 0,
+                postOnly,
+                slippagePct,
+                executionFeeToken,
+                leverage: Number(args.leverage),
+                tradingFee: `raw:${String(tradingFeeRaw)}`,
+                marketId,
+                autoDeposit: Boolean(args.autoDeposit ?? false),
+            });
+            const data = await finalizeMutationResult(raw, signer, "open_position_simple");
+            const txHash = data.confirmation?.txHash;
+            const verification = txHash ? await verifyTradeOutcome(client, address, poolId, txHash) : null;
+            const payload = { prepared: prep, approval, ...data, verification };
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ status: "success", data: payload }, (_, v) => (typeof v === "bigint" ? v.toString() : v), 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+        }
+    },
+};

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,23 +10,30 @@ 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),
-        tpPrice: z.coerce.string().regex(/^\d+$/).optional().describe("TP price raw units (30 decimals)"),
-        tpSize: z.coerce.string().regex(/^\d+$/).optional().describe("TP size raw units"),
-        slPrice: z.coerce.string().regex(/^\d+$/).optional().describe("SL price raw units (30 decimals)"),
-        slSize: z.coerce.string().regex(/^\d+$/).optional().describe("SL size raw units"),
+        tpPrice: z.coerce.string().optional().describe("TP price (raw or human-readable, 30 decimals)"),
+        tpSize: z.coerce.string().optional().describe("TP size (raw or human-readable)"),
+        slPrice: z.coerce.string().optional().describe("SL price (raw or human-readable, 30 decimals)"),
+        slSize: z.coerce.string().optional().describe("SL size (raw or human-readable)"),
     },
     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/tools/updateOrderTpSl.js

@@ -8,12 +8,12 @@ export const updateOrderTpSlTool = {
     schema: {
         orderId: z.string().describe("The ID of the order to update"),
         marketId: z.string().describe("The market ID (config hash) for the order"),
-        size: z.string().regex(/^\d+$/).describe("Order size raw units"),
-        price: z.string().regex(/^\d+$/).describe("Order price raw units (30 decimals)"),
-        tpPrice: z.string().regex(/^\d+$/).describe("TP price raw units (30 decimals)"),
-        tpSize: z.string().regex(/^\d+$/).describe("TP size raw units"),
-        slPrice: z.string().regex(/^\d+$/).describe("SL price raw units (30 decimals)"),
-        slSize: z.string().regex(/^\d+$/).describe("SL size raw units"),
+        size: z.string().describe("Order size (raw or human-readable)"),
+        price: z.string().describe("Order price (raw or human-readable, 30 decimals)"),
+        tpPrice: z.string().describe("TP price (raw or human-readable, 30 decimals)"),
+        tpSize: z.string().describe("TP size (raw or human-readable)"),
+        slPrice: z.string().describe("SL price (raw or human-readable, 30 decimals)"),
+        slSize: z.string().describe("SL size (raw or human-readable)"),
         useOrderCollateral: z.boolean().describe("Whether to use order collateral"),
         isTpSlOrder: z.boolean().optional().describe("Whether this is a TP/SL order"),
         quoteToken: z.string().describe("Quote token address"),

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/units.js

@@ -1,5 +1,7 @@
 import { parseUnits } from "ethers";
 const DECIMAL_RE = /^-?\d+(\.\d+)?$/;
+const RAW_PREFIX_RE = /^raw:/i;
+const INTEGER_RE = /^-?\d+$/;
 function normalizeDecimal(input) {
     let value = input.trim();
     let sign = "";
@@ -21,6 +23,12 @@ export function ensureUnits(value, decimals, label = "value") {
     const str = String(value).trim();
     if (!str)
         throw new Error(`${label} is required.`);
+    if (RAW_PREFIX_RE.test(str)) {
+        const raw = str.replace(RAW_PREFIX_RE, "").trim();
+        if (!INTEGER_RE.test(raw))
+            throw new Error(`${label} must be an integer raw units string.`);
+        return raw;
+    }
     if (!DECIMAL_RE.test(str))
         throw new Error(`${label} must be a numeric string.`);
     // If it's already a very large integer (e.g. > 12 digits or > decimals digits), 
@@ -36,6 +44,23 @@ export function ensureUnits(value, decimals, label = "value") {
         return str;
     }
 }
+export function parseUserUnits(value, decimals, label = "value") {
+    const str = String(value).trim();
+    if (!str)
+        throw new Error(`${label} is required.`);
+    if (RAW_PREFIX_RE.test(str)) {
+        const raw = str.replace(RAW_PREFIX_RE, "").trim();
+        if (!INTEGER_RE.test(raw))
+            throw new Error(`${label} must be an integer raw units string.`);
+        return raw;
+    }
+    if (!DECIMAL_RE.test(str))
+        throw new Error(`${label} must be a numeric string.`);
+    return parseUnits(str, decimals).toString();
+}
+export function parseUserPrice30(value, label = "price") {
+    return parseUserUnits(value, 30, label);
+}
 export function parseHumanUnits(value, decimals, label = "value") {
     const str = String(value).trim();
     if (!str)

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.5.3",
+  "version": "2.7.0",
   "type": "module",
   "bin": {
     "myx-mcp": "dist/server.js"
@@ -17,7 +17,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
-    "@myx-trade/sdk": "^0.1.269",
+    "@myx-trade/sdk": "^0.1.270",
     "dotenv": "^17.3.1",
     "ethers": "^6.13.1",
     "zod": "^4.3.6"