@michaleffffff/mcp-trading-server 3.0.5 → 3.0.7

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 3.0.7 - 2026-03-18
+
+### Changed
+- Updated server runtime version banner and MCP server version to `3.0.7`.
+- Hardened `get_pool_metadata` warning output by compacting long low-level errors into concise warnings.
+- Optimized `get_pool_info` read path:
+  - Prefer resolving a positive oracle/ticker market price and use it directly for pool info reads.
+  - Return clearer domain error for empty-liquidity / unresolved-price scenarios.
+- Refined `get_user_trading_fee_rate` error handling:
+  - Return structured MCP error envelope (`INVALID_PARAM` / `SDK_READ_ERROR`) instead of raw error strings.
+  - Include normalized concise error messages and request context details.
+- Enhanced `account_deposit` usability by making `tokenAddress` optional (defaults to `QUOTE_TOKEN_ADDRESS`).
+
+## 3.0.6 - 2026-03-18
+
+### Changed
+- Upgraded SDK dependency to `@myx-trade/sdk@^1.0.2`.
+- Updated client bootstrap to provide a viem-compatible `walletClient` shim (`json-rpc` account + `getAddresses/request/signMessage`) for SDK v1.0.2.
+- Moved `get_trade_flow` to SDK v1.0.2 native path (`client.api.getTradeFlow`).
+- Moved `account_withdraw` to SDK v1.0.2 native path (`account.updateAndWithdraw`).
+- Normalized `baseToken` address before `pool.createPool` to satisfy stricter typed input.
+- Updated account balance parsing to SDK v1.0.2 `getAccountInfo` fields (`freeMargin`, `walletBalance`).
+- Hardened type guards for account snapshot and fee-rate parsing under SDK union return types.
+
 ## 3.0.5 - 2026-03-18
 
 ### Changed

package/README.md

@@ -6,7 +6,8 @@ A production-ready MCP (Model Context Protocol) server for deep integration with
 
 # Release Notes
 
-- **Current release: 3.0.4**
+- **Current release: 3.0.7**
+- **SDK baseline**: `@myx-trade/sdk@^1.0.2` compatibility completed.
 - **Refinement**: Consolidated 40+ specialized tools into ~26 high-level unified tools.
 - **Improved UX**: Enhanced AI parameter parsing, automated unit conversion, and structured error reporting.
 - **Breaking changes**: Many low-level tools (e.g., `get_market_price`, `get_oracle_price`, `get_open_orders`) have been merged into unified counterparts.

package/dist/auth/resolveClient.js

@@ -24,6 +24,8 @@ export async function resolveClient() {
     const rpcUrl = process.env.RPC_URL || "https://rpc.sepolia.linea.build";
     const privateKey = process.env.PRIVATE_KEY;
     const chainId = Number(process.env.CHAIN_ID) || 59141;
+    const isTestnet = process.env.IS_TESTNET !== "false";
+    const isBetaMode = String(process.env.IS_BETA_MODE ?? "").trim().toLowerCase() === "true";
     const brokerAddressRaw = process.env.BROKER_ADDRESS || getDefaultBrokerByChainId(chainId);
     const quoteTokenRaw = process.env.QUOTE_TOKEN_ADDRESS || getDefaultQuoteTokenByChainId(chainId);
     const quoteDecimals = Number(process.env.QUOTE_TOKEN_DECIMALS) || 6;
@@ -42,12 +44,27 @@ export async function resolveClient() {
     // Inject the EIP-1193 mock so SDK can sign transactions seamlessly
     const { injectBrowserProviderMock } = await import("../utils/injectProvider.js");
     injectBrowserProviderMock(chainId, provider, signer);
+    const ethereumProvider = globalThis.window.ethereum;
+    const walletClient = {
+        transport: ethereumProvider,
+        chain: { id: chainId },
+        account: { address: signer.address, type: "json-rpc" },
+        getAddresses: async () => [signer.address],
+        request: async (args) => ethereumProvider.request(args),
+        signMessage: async ({ message }) => {
+            const payload = typeof message === "string"
+                ? message
+                : (message?.raw ?? message?.message ?? "");
+            return signer.signMessage(payload);
+        },
+    };
     const client = new MyxClient({
         chainId,
         signer: signer,
         brokerAddress,
-        isTestnet: process.env.IS_TESTNET !== "false",
-        walletClient: { transport: globalThis.window.ethereum }
+        isTestnet,
+        isBetaMode,
+        walletClient: walletClient
     });
     cached = { client, address: signer.address, signer, chainId, quoteToken, quoteDecimals };
     return cached;

package/dist/server.js

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

package/dist/services/poolService.js

@@ -2,6 +2,7 @@ import { pool, quote, base } from "@myx-trade/sdk";
 import { getChainId, resolveClient } from "../auth/resolveClient.js";
 import { extractErrorMessage } from "../utils/errorMessage.js";
 import { ensureUnits } from "../utils/units.js";
+import { normalizeAddress } from "../utils/address.js";
 function isDivideByZeroError(message) {
     const lower = message.toLowerCase();
     return (lower.includes("divide_by_zero") ||
@@ -19,74 +20,74 @@ function toPositiveBigint(input) {
         return null;
     }
 }
+async function resolvePositiveMarketPrice30(client, poolId, chainId) {
+    if (!client)
+        return null;
+    try {
+        const oracle = await client.utils?.getOraclePrice?.(poolId, chainId);
+        const byValue = toPositiveBigint(oracle?.value);
+        const byPrice = toPositiveBigint(oracle?.price);
+        if (byValue)
+            return byValue;
+        if (byPrice)
+            return byPrice;
+    }
+    catch {
+    }
+    try {
+        const tickerRes = await client.markets?.getTickerList?.({ chainId, poolIds: [poolId] });
+        const row = Array.isArray(tickerRes) ? tickerRes[0] : tickerRes?.data?.[0];
+        if (row?.price) {
+            const tickerRaw = ensureUnits(row.price, 30, "ticker price");
+            const byTicker = toPositiveBigint(tickerRaw);
+            if (byTicker)
+                return byTicker;
+        }
+    }
+    catch {
+    }
+    return null;
+}
 /**
  * 创建合约市场池子
  */
 export async function createPool(baseToken, marketId) {
     await resolveClient();
     const chainId = getChainId();
-    return pool.createPool({ chainId, baseToken, marketId });
+    return pool.createPool({ chainId, baseToken: normalizeAddress(baseToken, "baseToken"), marketId });
 }
 /**
  * 获取池子信息
  */
 export async function getPoolInfo(poolId, chainIdOverride, clientOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    let needOracleFallback = false;
+    const client = clientOverride ?? (await resolveClient()).client;
     try {
-        const direct = await pool.getPoolInfo(chainId, poolId);
-        if (direct)
-            return direct;
-        needOracleFallback = true;
+        const marketPrice30 = await resolvePositiveMarketPrice30(client, poolId, chainId);
+        if (marketPrice30 && marketPrice30 > 0n) {
+            const withPrice = await pool.getPoolInfo(chainId, poolId, marketPrice30);
+            if (withPrice)
+                return withPrice;
+        }
     }
     catch (error) {
         const message = extractErrorMessage(error);
         if (!isDivideByZeroError(message)) {
             throw new Error(`get_pool_info failed: ${message}`);
         }
-        needOracleFallback = true;
-    }
-    if (!needOracleFallback)
-        return undefined;
-    const client = clientOverride ?? (await resolveClient()).client;
-    if (!client?.utils?.getOraclePrice) {
-        throw new Error("get_pool_info failed and oracle fallback is unavailable (client.utils.getOraclePrice missing).");
     }
-    let oracleRaw = 0n;
     try {
-        const oracle = await client.utils.getOraclePrice(poolId, chainId);
-        const byValue = toPositiveBigint(oracle?.value);
-        const byPrice = toPositiveBigint(oracle?.price);
-        oracleRaw = byValue ?? byPrice ?? 0n;
+        const direct = await pool.getPoolInfo(chainId, poolId);
+        if (direct)
+            return direct;
+        throw new Error(`Pool info for ${poolId} returned undefined.`);
     }
     catch (error) {
-        throw new Error(`get_pool_info fallback failed to fetch oracle price: ${extractErrorMessage(error)}`);
-    }
-    if (oracleRaw <= 0n) {
-        try {
-            const tickerRes = await client.markets.getTickerList({ chainId, poolIds: [poolId] });
-            const row = Array.isArray(tickerRes) ? tickerRes[0] : tickerRes?.data?.[0];
-            if (row?.price) {
-                const tickerRaw = ensureUnits(row.price, 30, "ticker price");
-                const byTicker = toPositiveBigint(tickerRaw);
-                oracleRaw = byTicker ?? 0n;
-            }
-        }
-        catch {
-        }
-    }
-    if (oracleRaw <= 0n) {
-        throw new Error("get_pool_info fallback requires a positive oracle/ticker price, but both resolved to 0.");
-    }
-    try {
-        const retried = await pool.getPoolInfo(chainId, poolId, oracleRaw);
-        if (!retried) {
-            throw new Error(`Pool info for ${poolId} returned undefined after oracle-price retry.`);
+        const message = extractErrorMessage(error);
+        if (isDivideByZeroError(message)) {
+            throw new Error("get_pool_info unavailable: pool reserves are currently empty or market price context is unresolved.");
         }
-        return retried;
-    }
-    catch (error) {
-        throw new Error(`get_pool_info failed after oracle-price retry: ${extractErrorMessage(error)}`);
+        throw new Error(`get_pool_info failed: ${message}`);
     }
 }
 /**

package/dist/services/tradeService.js

@@ -93,6 +93,17 @@ function parseDecimals(value, fallback) {
 function normalizeIdentifier(value) {
     return String(value ?? "").trim().toLowerCase();
 }
+function toBigIntOrZero(value) {
+    try {
+        const text = String(value ?? "").trim();
+        if (!text)
+            return 0n;
+        return BigInt(text);
+    }
+    catch {
+        return 0n;
+    }
+}
 async function resolveDecimalsForUpdateOrder(client, chainId, marketId, poolIdHint) {
     let baseDecimals = 18;
     let quoteDecimals = getQuoteDecimals();
@@ -193,16 +204,10 @@ export async function openPosition(client, address, args) {
     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);
-    let walletBalanceRaw = BigInt(0); // Using availableMargin as wallet balance per user
-    if (marginInfo?.code === 0) {
-        if (Array.isArray(marginInfo.data)) {
-            marginBalanceRaw = BigInt(marginInfo.data[0] || "0");
-            walletBalanceRaw = BigInt(marginInfo.data[1] || "0");
-        }
-        else {
-            marginBalanceRaw = BigInt(marginInfo.data?.marginBalance || "0");
-            walletBalanceRaw = BigInt(marginInfo.data?.availableMargin || "0");
-        }
+    let walletBalanceRaw = BigInt(0);
+    if (marginInfo?.code === 0 && marginInfo?.data) {
+        marginBalanceRaw = toBigIntOrZero(marginInfo.data.freeMargin);
+        walletBalanceRaw = toBigIntOrZero(marginInfo.data.walletBalance);
     }
     const requiredRaw = BigInt(collateralRaw);
     if (marginBalanceRaw < requiredRaw) {
@@ -213,15 +218,15 @@ export async function openPosition(client, address, args) {
         const neededRaw = requiredRaw - marginBalanceRaw;
         console.log(`[tradeService] marginBalance (${marginBalanceRaw.toString()}) < Required (${requiredRaw.toString()}). Need to deposit: ${neededRaw.toString()}`);
         if (walletBalanceRaw < neededRaw) {
-            // Also check real wallet balance just in case user's availableMargin is truly empty
+            // Also check real wallet balance just in case account info wallet field is stale.
             const realWalletRes = await client.account.getWalletQuoteTokenBalance(chainId, address);
             const realWalletRaw = BigInt(realWalletRes?.data || "0");
             if (realWalletRaw < neededRaw) {
-                throw new Error(`Insufficient funds: marginBalance (${marginBalanceRaw.toString()}) + availableMargin (as wallet: ${walletBalanceRaw.toString()}) + real wallet (${realWalletRaw.toString()}) is less than required collateral (${requiredRaw.toString()}).`);
+                throw new Error(`Insufficient funds: marginBalance (${marginBalanceRaw.toString()}) + walletBalance (${walletBalanceRaw.toString()}) + realWallet (${realWalletRaw.toString()}) is less than required collateral (${requiredRaw.toString()}).`);
             }
             walletBalanceRaw = realWalletRaw;
         }
-        console.log(`[tradeService] Depositing ${neededRaw.toString()} ${poolData.quoteSymbol} from wallet (availableMargin)...`);
+        console.log(`[tradeService] Depositing ${neededRaw.toString()} ${poolData.quoteSymbol} from wallet...`);
         const depositRaw = await client.account.deposit({
             amount: neededRaw.toString(),
             tokenAddress: poolData.quoteToken,

package/dist/tools/accountInfo.js

@@ -1,57 +1,6 @@
 import { z } from "zod";
 import { resolveClient, getChainId } from "../auth/resolveClient.js";
 import { getTradeFlowTypeDesc } from "../utils/mappings.js";
-function readErrorMessage(error) {
-    if (error instanceof Error)
-        return error.message;
-    if (typeof error === "string")
-        return error;
-    if (error && typeof error === "object" && "message" in error) {
-        return String(error.message);
-    }
-    return String(error ?? "unknown error");
-}
-function assertSdkReadSuccess(result, actionName) {
-    if (!result || typeof result !== "object" || Array.isArray(result))
-        return;
-    if (!Object.prototype.hasOwnProperty.call(result, "code"))
-        return;
-    const code = Number(result.code);
-    if (!Number.isFinite(code) || code === 0)
-        return;
-    const payload = result.data;
-    const hasPayload = payload !== null &&
-        payload !== undefined &&
-        (!Array.isArray(payload) || payload.length > 0);
-    if (code > 0 && hasPayload) {
-        // Keep aligned with server-side read normalization:
-        // positive non-zero code with usable payload is warning-like.
-        return;
-    }
-    const message = String(result.msg ?? result.message ?? "unknown error");
-    throw new Error(`${actionName} failed: code=${code}, msg=${message}`);
-}
-function normalizeAccountInfo(result) {
-    if (!(result && result.code === 0 && Array.isArray(result.data))) {
-        return result;
-    }
-    const values = result.data;
-    return {
-        ...result,
-        data: {
-            freeMargin: values[0],
-            walletBalance: values[1],
-            freeBaseAmount: values[2],
-            baseProfit: values[3],
-            quoteProfit: values[4],
-            reservedAmount: values[5],
-            releaseTime: values[6],
-            tradeableMargin: (BigInt(values[0]) + BigInt(values[1]) + (BigInt(values[6]) === 0n ? BigInt(values[4]) : 0n)).toString(),
-            baseProfitStatus: "base token to be unlocked",
-            quoteProfitStatus: BigInt(values[6]) > 0n ? "quote token to be unlocked" : "quote token unlocked/available"
-        }
-    };
-}
 export const getTradeFlowTool = {
     name: "get_trade_flow",
     description: "[ACCOUNT] Get account trade flow / transaction history.",
@@ -64,7 +13,10 @@ export const getTradeFlowTool = {
             const { client, address } = await resolveClient();
             const chainId = getChainId();
             const query = { chainId, poolId: args.poolId, limit: args.limit ?? 20 };
-            const result = await client.account.getTradeFlow(query, address);
+            const accessToken = typeof client?.getAccessToken === "function"
+                ? (await client.getAccessToken()) || ""
+                : "";
+            const result = await client.api.getTradeFlow({ ...query, address, accessToken });
             const enhancedData = (result?.data || []).map((flow) => ({
                 ...flow,
                 typeDesc: getTradeFlowTypeDesc(flow.type)

package/dist/tools/accountTransfer.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { resolveClient, getChainId } from "../auth/resolveClient.js";
+import { resolveClient, getChainId, getQuoteToken } from "../auth/resolveClient.js";
 import { normalizeAddress } from "../utils/address.js";
 import { finalizeMutationResult } from "../utils/mutationResult.js";
 const MAX_UINT256 = "115792089237316195423570985008687907853269984665640564039457584007913129639935";
@@ -42,7 +42,7 @@ export const accountDepositTool = {
     description: "[ACCOUNT] Deposit funds from wallet into the MYX trading account.",
     schema: {
         amount: z.union([z.string(), z.number()]).describe("Amount to deposit (human-readable or raw units)"),
-        tokenAddress: z.string().describe("Token address"),
+        tokenAddress: z.string().optional().describe("Token address (optional, default: QUOTE_TOKEN_ADDRESS)"),
         autoApprove: z.coerce.boolean().optional().describe("If true, auto-approve token allowance when needed (default false)."),
         approveMax: z.coerce.boolean().optional().describe("If autoApprove=true, approve MaxUint256 instead of exact amount."),
     },
@@ -50,7 +50,8 @@ export const accountDepositTool = {
         try {
             const { client, signer, address } = await resolveClient();
             const chainId = getChainId();
-            const tokenAddress = normalizeAddress(args.tokenAddress, "tokenAddress");
+            const tokenAddressInput = String(args.tokenAddress ?? "").trim() || getQuoteToken();
+            const tokenAddress = normalizeAddress(tokenAddressInput, "tokenAddress");
             // For deposit, we default to quote decimals (6) as it's the most common use case.
             // ensureUnits handles 'raw:' prefix if absolute precision is needed.
             const { ensureUnits } = await import("../utils/units.js");
@@ -128,13 +129,7 @@ export const accountWithdrawTool = {
                 throw new Error(`Account has locked funds until releaseTime=${formatUnixTimestamp(releaseTime)}. ` +
                     `Retry after unlock or reduce withdraw amount.`);
             }
-            const raw = await client.account.withdraw({
-                chainId,
-                receiver: address,
-                amount,
-                poolId: args.poolId,
-                isQuoteToken: args.isQuoteToken,
-            });
+            const raw = await client.account.updateAndWithdraw(address, args.poolId, Boolean(args.isQuoteToken), amount, chainId);
             const data = await finalizeMutationResult(raw, signer, "account_withdraw");
             const preflight = {
                 requestedAmountRaw: amountRaw.toString(),

package/dist/tools/checkAccountReady.js

@@ -3,6 +3,17 @@ import { resolveClient, getChainId } from "../auth/resolveClient.js";
 import { resolvePool } from "../services/marketService.js";
 import { parseUserUnits } from "../utils/units.js";
 import { ethers } from "ethers";
+function toBigIntOrZero(value) {
+    try {
+        const text = String(value ?? "").trim();
+        if (!text)
+            return 0n;
+        return BigInt(text);
+    }
+    catch {
+        return 0n;
+    }
+}
 export const checkAccountReadyTool = {
     name: "check_account_ready",
     description: "[TRADE] Check if the account has sufficient funds (margin + wallet) for a planned trade.",
@@ -22,16 +33,10 @@ export const checkAccountReadyTool = {
             const quoteSymbol = detail?.quoteSymbol || "USDC";
             const marginInfo = await client.account.getAccountInfo(chainId, address, poolId);
             let marginBalanceRaw = 0n;
-            let availableMarginRaw = 0n;
-            if (marginInfo?.code === 0) {
-                if (Array.isArray(marginInfo.data)) {
-                    marginBalanceRaw = BigInt(marginInfo.data[0] || "0");
-                    availableMarginRaw = BigInt(marginInfo.data[1] || "0");
-                }
-                else {
-                    marginBalanceRaw = BigInt(marginInfo.data?.marginBalance || "0");
-                    availableMarginRaw = BigInt(marginInfo.data?.availableMargin || "0");
-                }
+            let accountWalletBalanceRaw = 0n;
+            if (marginInfo?.code === 0 && marginInfo?.data) {
+                marginBalanceRaw = toBigIntOrZero(marginInfo.data.freeMargin);
+                accountWalletBalanceRaw = toBigIntOrZero(marginInfo.data.walletBalance);
             }
             const walletRes = await client.account.getWalletQuoteTokenBalance(chainId, address);
             const walletBalanceRaw = BigInt(walletRes?.data || "0");
@@ -55,6 +60,7 @@ export const checkAccountReadyTool = {
                                     hasEnoughInMargin: marginBalanceRaw >= requiredRaw,
                                     needDepositFromWallet,
                                     walletSufficientForDeposit: walletSufficient,
+                                    accountInfoWalletBalance: format(accountWalletBalanceRaw),
                                     quoteSymbol
                                 }
                             }

package/dist/tools/closePosition.js

@@ -5,23 +5,30 @@ import { finalizeMutationResult } from "../utils/mutationResult.js";
 import { SLIPPAGE_PCT_4DP_DESC } from "../utils/slippage.js";
 import { verifyTradeOutcome } from "../utils/verification.js";
 import { mapDirection, mapOrderType, mapTriggerType } from "../utils/mappings.js";
+import { parseUserUnits } from "../utils/units.js";
 const FULL_CLOSE_MARKERS = new Set(["ALL", "FULL", "MAX"]);
 const INTEGER_RE = /^\d+$/;
 function wantsFullCloseMarker(input) {
     const value = String(input ?? "").trim().toUpperCase();
     return FULL_CLOSE_MARKERS.has(value);
 }
-function readRawPositionField(position, primary, fallback) {
-    const first = String(position?.[primary] ?? "").trim();
-    if (INTEGER_RE.test(first))
-        return first;
-    if (fallback) {
-        const second = String(position?.[fallback] ?? "").trim();
-        if (INTEGER_RE.test(second))
-            return second;
+function readFirstPositionField(position, fields) {
+    for (const field of fields) {
+        const value = String(position?.[field] ?? "").trim();
+        if (value)
+            return value;
     }
     return "";
 }
+function resolvePositionRaw(position, rawFields, humanFields, decimals, label) {
+    const raw = readFirstPositionField(position, rawFields);
+    if (INTEGER_RE.test(raw))
+        return raw;
+    const human = readFirstPositionField(position, humanFields);
+    if (!human)
+        return "";
+    return parseUserUnits(human, decimals, label);
+}
 export const closePositionTool = {
     name: "close_position",
     description: "[TRADE] Create a decrease order (close or reduce position) using SDK-native parameters.",
@@ -67,14 +74,14 @@ export const closePositionTool = {
                     throw new Error(`Could not find live position snapshot for positionId=${preparedArgs.positionId} in poolId=${poolId}.`);
                 }
                 if (needAutoSize) {
-                    const rawSize = readRawPositionField(target, "size", "positionSize");
+                    const rawSize = resolvePositionRaw(target, ["sizeRaw", "positionSizeRaw"], ["size", "positionSize"], Number(poolData.baseDecimals ?? 18), "position.size");
                     if (!rawSize || rawSize === "0") {
                         throw new Error(`Resolved position size is empty/zero for positionId=${preparedArgs.positionId}.`);
                     }
                     preparedArgs.size = `raw:${rawSize}`;
                 }
                 if (needAutoCollateral) {
-                    const rawCollateral = readRawPositionField(target, "collateral", "collateralAmount");
+                    const rawCollateral = resolvePositionRaw(target, ["collateralRaw", "collateralAmountRaw"], ["collateral", "collateralAmount"], Number(poolData.quoteDecimals ?? 6), "position.collateralAmount");
                     if (!rawCollateral) {
                         throw new Error(`Resolved position collateral is empty for positionId=${preparedArgs.positionId}.`);
                     }

package/dist/tools/getAccountSnapshot.js

@@ -1,5 +1,11 @@
 import { z } from "zod";
 import { resolveClient, getChainId } from "../auth/resolveClient.js";
+function unwrapData(result) {
+    if (result && typeof result === "object" && "data" in result) {
+        return result.data;
+    }
+    return result;
+}
 export const getAccountSnapshotTool = {
     name: "get_account_snapshot",
     description: "[ACCOUNT] Get unified account snapshot (balances, trading metrics, and VIP tier).",
@@ -23,14 +29,14 @@ export const getAccountSnapshotTool = {
                     getMarginBalance(client, address, args.poolId, chainId).catch(() => null)
                 ]);
                 tradingAccount = {
-                    info: info?.data || info,
-                    margin: margin?.data || margin
+                    info: unwrapData(info),
+                    margin: unwrapData(margin)
                 };
             }
             const results = {
-                wallet: walletRes?.data || walletRes,
+                wallet: unwrapData(walletRes),
                 tradingAccount,
-                vip: vipRes?.data || vipRes,
+                vip: unwrapData(vipRes),
             };
             return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: results }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
         }

package/dist/tools/getPoolMetadata.js

@@ -17,6 +17,18 @@ function normalizeMarketPrice30Input(value) {
     }
     return parseUserPrice30(text, "marketPrice");
 }
+function compactWarning(scope, err) {
+    const raw = extractErrorMessage(err);
+    const flat = raw.replace(/\s+/g, " ").trim();
+    const lower = flat.toLowerCase();
+    if (lower.includes("division or modulo by zero") || lower.includes("panic code 0x12")) {
+        return `${scope}: unavailable for this pool at current liquidity/price context.`;
+    }
+    if (flat.length > 220) {
+        return `${scope}: ${flat.slice(0, 220)}...`;
+    }
+    return `${scope}: ${flat}`;
+}
 export const getPoolMetadataTool = {
     name: "get_pool_metadata",
     description: "[MARKET] Get comprehensive metadata for a pool (market detail, on-chain info, liquidity, and limits).",
@@ -40,14 +52,14 @@ export const getPoolMetadataTool = {
                 results.marketDetail = await getMarketDetail(client, poolId, chainId);
             }
             catch (err) {
-                errors.push(`marketDetail: ${extractErrorMessage(err)}`);
+                errors.push(compactWarning("marketDetail", err));
             }
             // 2. Pool Info (Reserves, Utilization)
             try {
                 results.poolInfo = await getPoolInfo(poolId, chainId, client);
             }
             catch (err) {
-                errors.push(`poolInfo: ${extractErrorMessage(err)}`);
+                errors.push(compactWarning("poolInfo", err));
             }
             // 3. Optional: Liquidity Info
             if (args.includeLiquidity) {
@@ -58,7 +70,7 @@ export const getPoolMetadataTool = {
                     results.liquidityInfo = await getLiquidityInfo(client, poolId, price, chainId);
                 }
                 catch (err) {
-                    errors.push(`liquidityInfo: ${extractErrorMessage(err)}`);
+                    errors.push(compactWarning("liquidityInfo", err));
                 }
             }
             // 4. Optional: Config / Limits
@@ -68,7 +80,7 @@ export const getPoolMetadataTool = {
                     results.levelConfig = await getPoolLevelConfig(client, poolId, chainId);
                 }
                 catch (err) {
-                    errors.push(`levelConfig: ${extractErrorMessage(err)}`);
+                    errors.push(compactWarning("levelConfig", err));
                 }
             }
             if (errors.length > 0) {

package/dist/tools/getUserTradingFeeRate.js

@@ -1,5 +1,62 @@
 import { z } from "zod";
 import { resolveClient, getChainId } from "../auth/resolveClient.js";
+import { extractErrorMessage } from "../utils/errorMessage.js";
+function compactMessage(message) {
+    const flat = String(message ?? "").replace(/\s+/g, " ").trim();
+    if (!flat)
+        return "Unknown fee-rate read error.";
+    if (flat.length <= 240)
+        return flat;
+    return `${flat.slice(0, 240)}...`;
+}
+async function withMutedSdkFeeRateLogs(runner) {
+    const original = console.error;
+    console.error = (...args) => {
+        const first = args?.[0];
+        const firstText = typeof first === "string"
+            ? first
+            : first instanceof Error
+                ? first.message
+                : String(first ?? "");
+        const lower = firstText.toLowerCase();
+        if (lower.includes("myx-sdk-error") ||
+            (lower.includes("getuserfeerate") && (lower.includes("revert") || lower.includes("contractfunctionexecutionerror")))) {
+            return;
+        }
+        original(...args);
+    };
+    try {
+        return await runner();
+    }
+    finally {
+        console.error = original;
+    }
+}
+function buildErrorPayload(args, messageLike) {
+    const message = compactMessage(extractErrorMessage(messageLike));
+    const lower = message.toLowerCase();
+    const code = lower.includes("invalidparameter") || lower.includes("invalid parameter")
+        ? "INVALID_PARAM"
+        : "SDK_READ_ERROR";
+    const hint = code === "INVALID_PARAM"
+        ? "Check assetClass/riskTier for this pool and retry."
+        : "Fee tier may be unavailable for current account/market context. Retry with valid assetClass/riskTier or provide tradingFee manually.";
+    return {
+        status: "error",
+        error: {
+            tool: "get_user_trading_fee_rate",
+            code,
+            message,
+            hint,
+            action: "Adjust params/context and retry.",
+            details: {
+                assetClass: args.assetClass,
+                riskTier: args.riskTier,
+                chainId: args.chainId ?? getChainId(),
+            },
+        },
+    };
+}
 export const getUserTradingFeeRateTool = {
     name: "get_user_trading_fee_rate",
     description: "[TRADE] Get maker/taker fee rates for a given assetClass and riskTier.",
@@ -12,11 +69,17 @@ export const getUserTradingFeeRateTool = {
         try {
             const { client } = await resolveClient();
             const chainId = args.chainId ?? getChainId();
-            const result = await client.utils.getUserTradingFeeRate(args.assetClass, args.riskTier, chainId);
+            const result = await withMutedSdkFeeRateLogs(() => client.utils.getUserTradingFeeRate(args.assetClass, args.riskTier, chainId));
+            const maybeCode = Number(result?.code);
+            if (Number.isFinite(maybeCode) && maybeCode !== 0) {
+                const body = buildErrorPayload(args, result?.msg ?? result?.message ?? result);
+                return { content: [{ type: "text", text: JSON.stringify(body, (_, v) => typeof v === "bigint" ? v.toString() : v, 2) }], isError: true };
+            }
             return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: result }, (_, v) => typeof v === "bigint" ? v.toString() : v, 2) }] };
         }
         catch (error) {
-            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+            const body = buildErrorPayload(args, error);
+            return { content: [{ type: "text", text: JSON.stringify(body, (_, v) => typeof v === "bigint" ? v.toString() : v, 2) }], isError: true };
         }
     },
 };

package/dist/tools/manageTpSl.js

@@ -1,6 +1,8 @@
 import { z } from "zod";
 import { resolveClient, getChainId } from "../auth/resolveClient.js";
 import { finalizeMutationResult } from "../utils/mutationResult.js";
+import { parseUserUnits } from "../utils/units.js";
+const INTEGER_RE = /^\d+$/;
 function normalizeDirectionInput(value) {
     if (value === undefined || value === null || value === "")
         return undefined;
@@ -60,6 +62,44 @@ async function findOrderSnapshot(client, address, chainId, orderId, poolId) {
         return null;
     }
 }
+async function findPositionSnapshot(client, address, poolId, positionId) {
+    const targetPos = String(positionId ?? "").trim().toLowerCase();
+    const targetPool = String(poolId ?? "").trim().toLowerCase();
+    if (!targetPos || !targetPool)
+        return null;
+    try {
+        const positionsRes = await client.position.listPositions(address);
+        const positions = Array.isArray(positionsRes?.data) ? positionsRes.data : [];
+        return positions.find((position) => {
+            const pid = String(position?.positionId ?? position?.position_id ?? "").trim().toLowerCase();
+            const pool = String(position?.poolId ?? position?.pool_id ?? "").trim().toLowerCase();
+            return pid === targetPos && pool === targetPool;
+        }) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolvePositionSizeRaw(positionSnapshot, baseDecimals) {
+    const rawCandidates = [positionSnapshot?.sizeRaw, positionSnapshot?.positionSizeRaw];
+    for (const value of rawCandidates) {
+        const text = String(value ?? "").trim();
+        if (INTEGER_RE.test(text))
+            return text;
+    }
+    const humanCandidates = [positionSnapshot?.size, positionSnapshot?.positionSize];
+    for (const value of humanCandidates) {
+        const text = String(value ?? "").trim();
+        if (!text)
+            continue;
+        try {
+            return parseUserUnits(text, baseDecimals, "position.size");
+        }
+        catch {
+        }
+    }
+    return "";
+}
 export const manageTpSlTool = {
     name: "manage_tp_sl",
     description: "[TRADE] Set or update Take Profit (TP) and Stop Loss (SL) for a position.",
@@ -87,12 +127,16 @@ export const manageTpSlTool = {
             const direction = normalizeDirectionInput(args.direction);
             const slippagePct = args.slippagePct ?? "100";
             const { setPositionTpSl, updateOrderTpSl } = await import("../services/tradeService.js");
+            const { getMarketDetail } = await import("../services/marketService.js");
+            const marketRes = await getMarketDetail(client, args.poolId, chainId);
+            const market = marketRes?.data ?? marketRes;
+            if (!market?.marketId) {
+                throw new Error(`Could not resolve market metadata for poolId=${args.poolId}.`);
+            }
+            const baseDecimals = Number(market.baseDecimals ?? 18);
             let raw;
             if (args.orderId) {
                 // Update existing
-                const { getMarketDetail } = await import("../services/marketService.js");
-                const marketRes = await getMarketDetail(client, args.poolId, chainId);
-                const market = marketRes.data ?? marketRes;
                 const orderSnapshot = await findOrderSnapshot(client, address, chainId, args.orderId, args.poolId);
                 const snapshotSize = readSnapshotText(orderSnapshot, ["size", "orderSize", "positionSize"]);
                 const snapshotPrice = readSnapshotText(orderSnapshot, ["price", "orderPrice", "triggerPrice"]);
@@ -134,23 +178,50 @@ export const manageTpSlTool = {
             }
             else {
                 // Create new
-                if (direction === undefined || !args.leverage) {
+                if (!args.positionId)
+                    throw new Error("positionId is required when creating new TP/SL.");
+                const positionSnapshot = await findPositionSnapshot(client, address, args.poolId, args.positionId);
+                let resolvedDirection = direction;
+                if (resolvedDirection === undefined && positionSnapshot?.direction !== undefined) {
+                    resolvedDirection = normalizeDirectionInput(positionSnapshot.direction);
+                }
+                let resolvedLeverage = args.leverage;
+                if ((!resolvedLeverage || Number(resolvedLeverage) <= 0) && positionSnapshot) {
+                    const leverageCandidate = Number(positionSnapshot?.userLeverage ??
+                        positionSnapshot?.leverage ??
+                        positionSnapshot?.positionLeverage);
+                    if (Number.isFinite(leverageCandidate) && leverageCandidate > 0) {
+                        resolvedLeverage = leverageCandidate;
+                    }
+                }
+                if (resolvedDirection === undefined || !resolvedLeverage || Number(resolvedLeverage) <= 0) {
                     throw new Error("direction and leverage are required when creating new TP/SL.");
                 }
-                if (!args.positionId) {
-                    throw new Error("positionId is required when creating new TP/SL.");
+                let tpSizeInput = isNonEmpty(args.tpSize) ? String(args.tpSize) : "";
+                let slSizeInput = isNonEmpty(args.slSize) ? String(args.slSize) : "";
+                const needsTpSize = isNonEmpty(args.tpPrice) && !tpSizeInput;
+                const needsSlSize = isNonEmpty(args.slPrice) && !slSizeInput;
+                if (needsTpSize || needsSlSize) {
+                    const positionSizeRaw = resolvePositionSizeRaw(positionSnapshot, baseDecimals);
+                    if (!positionSizeRaw) {
+                        throw new Error("tpSize/slSize missing and unable to infer position size from live snapshot. Please provide tpSize/slSize explicitly.");
+                    }
+                    if (needsTpSize)
+                        tpSizeInput = `raw:${positionSizeRaw}`;
+                    if (needsSlSize)
+                        slSizeInput = `raw:${positionSizeRaw}`;
                 }
                 raw = await setPositionTpSl(client, address, {
                     poolId: args.poolId,
                     positionId: args.positionId,
-                    direction,
-                    leverage: args.leverage,
-                    executionFeeToken: args.executionFeeToken,
+                    direction: resolvedDirection,
+                    leverage: Number(resolvedLeverage),
+                    executionFeeToken: args.executionFeeToken || market.quoteToken,
                     slippagePct,
                     tpPrice: args.tpPrice,
-                    tpSize: args.tpSize,
+                    tpSize: tpSizeInput || undefined,
                     slPrice: args.slPrice,
-                    slSize: args.slSize
+                    slSize: slSizeInput || undefined
                 }, chainId);
             }
             const data = await finalizeMutationResult(raw, signer, "manage_tp_sl");

package/dist/tools/openPositionSimple.js

@@ -185,15 +185,17 @@ export const openPositionSimpleTool = {
                 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;
+                    const hasData = feeRes && typeof feeRes === "object" && "data" in feeRes && feeRes.data;
+                    if (feeRes && Number(feeRes.code) === 0 && hasData) {
+                        const feeData = feeRes.data;
+                        const rateRaw = postOnly ? feeData.makerFeeRate : feeData.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";
+                        tradingFeeMeta.error = String((feeRes && (feeRes.message ?? feeRes.msg)) || "fee_rate_unavailable");
                     }
                 }
                 catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@michaleffffff/mcp-trading-server",
-  "version": "3.0.5",
+  "version": "3.0.7",
   "type": "module",
   "bin": {
     "myx-mcp": "dist/server.js"
@@ -20,7 +20,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
-    "@myx-trade/sdk": "^0.1.270",
+    "@myx-trade/sdk": "^1.0.2",
     "dotenv": "^17.3.1",
     "ethers": "^6.13.1",
     "zod": "^4.3.6"