@michaleffffff/mcp-trading-server 2.5.3 → 2.6.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();

package/dist/services/tradeService.js

@@ -64,6 +64,7 @@ export async function openPosition(client, address, args) {
     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 +81,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,345 @@
+import { z } from "zod";
+import { OrderType } from "@myx-trade/sdk";
+import { resolveClient, getChainId } from "../auth/resolveClient.js";
+import { searchMarket } from "../services/marketService.js";
+import { openPosition } from "../services/tradeService.js";
+import { normalizeAddress } from "../utils/address.js";
+import { finalizeMutationResult } from "../utils/mutationResult.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;
+}
+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"),
+        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)."),
+        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)
+            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);
+                }
+            }
+            // 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 = Number(args.direction);
+            if (dir !== 0 && dir !== 1)
+                throw new Error("direction must be 0 (LONG) or 1 (SHORT).");
+            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 = resolveOrderType(args.orderType);
+            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

@@ -17,10 +17,10 @@ export const setTpSlTool = {
         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 {

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@michaleffffff/mcp-trading-server",
-  "version": "2.5.3",
+  "version": "2.6.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"