@michaleffffff/mcp-trading-server 3.0.2 → 3.0.4

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 3.0.4 - 2026-03-17
+
+### Added
+- `get_my_lp_holdings` tool for listing all wallet LP balances with standardized naming.
+- Enriched `manage_liquidity` response with `lpAssetNames` (e.g., `mBTC.USDC`).
+
+### Changed
+- Improved `close_all_positions` with more robust automated price fetching.
+- `get_liquidity_info` now accepts human-readable prices and `raw:` prefixes.
+- Updated `TOOL_EXAMPLES.md` to include LP holding and management samples.
+
+## 3.0.3 - 2026-03-17
+
+### Changed
+- Enhanced `create_perp_market` tool description to better explain `marketId` requirements.
+- Added usage hints to `execute_trade` schema for improved AI coordination.
+- Internal: `resolvePool` now supports `chainIdOverride` for more flexible market resolution.
+
 ## 3.0.2 - 2026-03-17
 
 ### Added

package/README.md

@@ -124,7 +124,8 @@ 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` (or `get_market_list`) 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.
+5. **Common flow**: Use `search_market` (or `get_pool_list`) 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.  
+   Note: `open_position_simple` does not accept `tpPrice` / `tpSize` / `slPrice` / `slSize`. Use `set_tp_sl` (for positions) or `update_order_tp_sl` (for orders).
 6. **Tool examples**: See `TOOL_EXAMPLES.md` for practical examples for every tool, common workflows, and parameter-unit guidance.
 
 **Minimal open position example:**
@@ -160,7 +161,12 @@ The server will run using `stdio` transport and can be connected by any MCP-comp
 - **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**.
+- **close_all_positions slippage**: Supports raw 4dp (`100`) and human percent strings (`"1.0"` or `"1%"`).
+- **get_liquidity_info marketPrice**: Supports raw 30-dec integer, `raw:...`, and human price inputs (`"2172.5"` / `human:2172.5`).
+- **close_position full-close helper**: `size` and `collateralAmount` accept `ALL` / `FULL` / `MAX` to auto-use exact live raw values.
+- **manage_liquidity action**: Case-insensitive (`ADD`, `add`, `Increase` all supported).
+- **account_deposit approval**: `account_deposit` now supports `autoApprove` and `approveMax` to auto-handle allowance when required.
+- **Note**: `check_approval.amount` still expects **raw integer strings**.
 - **`adjust_margin` units**: human amount is supported (e.g. `"1"` means 1 quote token). For exact atomic amount, use `raw:` (e.g. `"raw:1"`).
 
 ## P0 Reliability Contract (AI-friendly)
@@ -200,7 +206,7 @@ Common error codes:
 Search behavior in P0:
 - `search_market` now accepts empty `keyword` and returns active markets.
 - When `search_market` returns empty/unstable data, server-side fallback uses SDK `api.getMarketList()` and `api.getPoolList()` to rebuild active-market results.
-- For robust discovery, you can also call `get_market_list` directly.
+- For robust discovery, you can also call `get_pool_list` directly.
 
 Example:
 
@@ -285,12 +291,12 @@ Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
 
 # Tools
 
-The server exposes 39 tools categorized for AI:
+The server exposes tools categorized for AI:
 
 For practical tool-by-tool examples, see: `TOOL_EXAMPLES.md`
 
 ### Trading Operations
-* **open_position_simple**: High-level open position helper (recommended). Computes price/size/tradingFee internally.
+* **open_position_simple**: High-level open position helper (recommended). Computes price/size/tradingFee internally. It only handles open/increase parameters and does **not** accept TP/SL fields (`tpPrice`, `tpSize`, `slPrice`, `slSize`); unknown keys are rejected by strict schema validation.
 * **execute_trade**: Execute a new trade or add to an existing position (includes parameter preflight, supports `human:`/`raw:` amount prefixes, auto-computes `tradingFee` when omitted).
 * **close_position**: Close an open position.
 * **close_all_positions**: Emergency: close ALL open positions in a pool at once.
@@ -308,12 +314,13 @@ For practical tool-by-tool examples, see: `TOOL_EXAMPLES.md`
 * **get_oracle_price**: Get the current EVM oracle price for a specific pool.
 * **get_kline_latest_bar**: Get only the latest bar for an interval.
 * **get_all_tickers**: Get all ticker snapshots in one request.
-* **get_market_list**, **get_market_list_raw**, **get_kline**, **get_pool_info**... (`get_pool_info` auto-retries with oracle/ticker price on divide-by-zero reads)
+* **get_kline**, **get_pool_info**... (`get_pool_info` auto-retries with oracle/ticker price on divide-by-zero reads)
 * **get_pool_symbol_all**, **get_base_detail**, **get_pool_level_config**...
 
 ### Account & Portfolio
 * **get_positions**: Get all open positions for the current account.
 * **get_account**: Unified account snapshot. Clearly separates **wallet balance** and **trading-account balance** (provide `poolId` for full trading-account metrics).
+* **get_my_lp_holdings**: Scan pools and return your base/quote LP token balances on the current chain, with standardized LP asset names (`base: mBASE.QUOTE`, `quote: mQUOTE.BASE`).
 * **get_account_vip_info**: Query account VIP tier details.
 * **get_position_history**, **get_open_orders**, **get_order_history**...
 
@@ -323,7 +330,8 @@ For practical tool-by-tool examples, see: `TOOL_EXAMPLES.md`
 - If one section fails (wallet or trading-account), the tool may return a **partial** snapshot with `meta.partial=true` and section-level `error` details.
 
 ### Liquidity Provision (LP)
-* **manage_liquidity**: Add or withdraw liquidity from a BASE or QUOTE pool (aliases: `add/remove/increase/decrease` are supported).
+* **manage_liquidity**: Add or withdraw liquidity from a BASE or QUOTE pool (aliases: `add/remove/increase/decrease` are supported). `poolId` is pre-validated on target `chainId` for clearer errors. Response includes LP naming metadata (`baseLpAssetName=mBASE.QUOTE`, `quoteLpAssetName=mQUOTE.BASE`, `operatedLpAssetName`).
+  - Example (`BTC/USDC`, `poolType=QUOTE`): `operatedLpAssetName = mUSDC.BTC`.
 * **create_perp_market**: Create a new perpetual trading pair.
 
 ---

package/TOOL_EXAMPLES.md

@@ -62,6 +62,10 @@ It includes:
   }
 }
 ```
+Notes:
+- `open_position_simple` only accepts open/increase parameters and does not support `tpPrice`, `tpSize`, `slPrice`, `slSize` in the same call.
+- If those TP/SL keys are included, the server rejects them as unrecognized fields (strict schema validation).
+- Recommended flow: open with `open_position_simple` first, then use `set_tp_sl` (position-level) or `update_order_tp_sl` (order-level).
 
 ### `execute_trade`
 ```json
@@ -296,24 +300,6 @@ Success payload includes normalized raw amount under `data.normalized.adjustAmou
 ```
 Note: this tool may internally fallback to SDK `api.getMarketList()` / `api.getPoolList()` when direct search is empty.
 
-### `get_market_list`
-```json
-{
-  "name": "get_market_list",
-  "arguments": {
-    "limit": 50
-  }
-}
-```
-
-### `get_market_list_raw`
-```json
-{
-  "name": "get_market_list_raw",
-  "arguments": {}
-}
-```
-
 ### `get_pool_list`
 ```json
 {
@@ -455,6 +441,31 @@ If one section fails, check `data.meta.partial` and section-level `error` fields
 }
 ```
 
+### `get_my_lp_holdings`
+```json
+{
+  "name": "get_my_lp_holdings",
+  "arguments": {}
+}
+```
+LP asset naming rule in each item:
+- `baseLpAssetName`: `mBASE.QUOTE` (e.g. `mBTC.USDC`)
+- `quoteLpAssetName`: `mQUOTE.BASE` (e.g. `mUSDC.BTC`)
+Include zero-balance pools and optional filtering:
+```json
+{
+  "name": "get_my_lp_holdings",
+  "arguments": {
+    "includeZero": true,
+    "poolIds": [
+      "0xPOOL_ID_1",
+      "0xPOOL_ID_2"
+    ],
+    "maxPools": 50
+  }
+}
+```
+
 ### `get_positions`
 ```json
 {
@@ -563,6 +574,31 @@ Alias action example (`remove` == `withdraw`):
 }
 ```
 If operation fails, check `error.message` for concrete reasons (for example `Insufficient Balance`) instead of generic `undefined`.
+`poolId` must be valid on the target `chainId`; if uncertain, resolve with `search_market` / `get_pool_list` first.
+Success response includes `data.lpAssetNames`:
+- `baseLpAssetName`: `mBASE.QUOTE` (e.g. `mBTC.USDC`)
+- `quoteLpAssetName`: `mQUOTE.BASE` (e.g. `mUSDC.BTC`)
+- `operatedLpAssetName`: LP asset name matching current `poolType`
+Example success payload (abridged):
+```json
+{
+  "status": "success",
+  "data": {
+    "confirmation": {
+      "confirmed": true,
+      "txHash": "0x..."
+    },
+    "lpAssetNames": {
+      "baseSymbol": "BTC",
+      "quoteSymbol": "USDC",
+      "baseLpAssetName": "mBTC.USDC",
+      "quoteLpAssetName": "mUSDC.BTC",
+      "operatedPoolType": "QUOTE",
+      "operatedLpAssetName": "mUSDC.BTC"
+    }
+  }
+}
+```
 
 ### `get_lp_price`
 ```json

package/dist/prompts/tradingGuide.js

@@ -17,7 +17,7 @@ export const tradingGuidePrompt = {
 You are an expert crypto trader using the MYX Protocol. To ensure successful execution and safe handling of user funds, follow these patterns:
 
 ## 1. The Standard Workflow
-1. **Discovery**: Use \`search_market\` with a keyword (or empty keyword) to find active \`poolId\` values. If needed, fallback to \`get_market_list\`.
+1. **Discovery**: Use \`search_market\` with a keyword (or empty keyword) to find active \`poolId\` values. If needed, fallback to \`get_pool_list\`.
 2. **Context**: Use \`get_market_price\` and \`get_account\` (with \`poolId\`) to check market state, wallet balance, and trading-account margin.
 3. **Execution**: Prefer \`open_position_simple\` for new trades. It handles unit conversions and pool resolution automatically.
 4. **Validation**: Always check the \`verification.verified\` flag in the output. If \`false\`, read the \`cancelReason\` to explain the failure to the user.
@@ -31,9 +31,15 @@ You are an expert crypto trader using the MYX Protocol. To ensure successful exe
 - **Fees**: Use \`get_user_trading_fee_rate\` to estimate fees before large trades.
 - **execute_trade**: Has built-in preflight normalization and can auto-compute \`tradingFee\` when omitted.
 - **Balances**: Use \`get_account\` to clearly separate wallet balance vs trading-account balance (pass \`poolId\` for trading-account metrics).
+- **LP Holdings**: Use \`get_my_lp_holdings\` to scan base/quote LP token balances across pools on the current chain; naming convention is \`baseLpAssetName=mBASE.QUOTE\`, \`quoteLpAssetName=mQUOTE.BASE\` (e.g., \`mBTC.USDC\`, \`mUSDC.BTC\`).
+- **Liquidity Mutation Output**: \`manage_liquidity\` success output includes \`data.lpAssetNames\` with \`baseLpAssetName\`, \`quoteLpAssetName\`, and \`operatedLpAssetName\`.
 - **Adjust Margin**: \`adjust_margin.adjustAmount\` supports human amount (e.g. "1"), and also supports exact raw amount via \`raw:\` prefix.
 - **TP/SL Updates**: \`update_order_tp_sl\` accepts boolean-like values for \`useOrderCollateral\` and \`isTpSlOrder\`, but pending LIMIT/STOP orders can still be rejected by protocol rules; after fill, prefer \`set_tp_sl\`.
 - **Pool Reads**: \`get_pool_info\` auto-retries with oracle/ticker price when direct on-chain read returns divide-by-zero.
+- **Liquidity Price Input**: \`get_liquidity_info.marketPrice\` accepts raw 30-dec price and human price strings (e.g. \`2172.5\`, \`human:2172.5\`).
+- **close_all_positions Slippage**: accepts both raw 4dp and human percent strings (e.g. \`"100"\`, \`"1.0"\`, \`"1%"\`).
+- **close_position Full Close**: \`size\`/\`collateralAmount\` can use \`ALL\`/\`FULL\`/\`MAX\` to auto-fill exact live raw values from the current position snapshot.
+- **Deposits & Approval**: \`account_deposit\` supports \`autoApprove\` + \`approveMax\`; without auto-approve, allowance errors should be handled via \`check_approval\`.
 - **Examples**: Follow \`TOOL_EXAMPLES.md\` payload patterns when building tool arguments.
 
 ## 3. Self-Healing

package/dist/server.js

@@ -352,7 +352,7 @@ function zodSchemaToJsonSchema(zodSchema) {
     };
 }
 // ─── MCP Server ───
-const server = new Server({ name: "myx-mcp-trading-server", version: "3.0.2" }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
+const server = new Server({ name: "myx-mcp-trading-server", version: "3.0.4" }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
 // List tools
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
@@ -473,7 +473,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.2 running (stdio, pure on-chain, prod ready)");
+    logger.info("🚀 MYX Trading MCP Server v3.0.4 running (stdio, pure on-chain, prod ready)");
 }
 main().catch((err) => {
     logger.error("Fatal Server Startup Error", err);

package/dist/services/marketService.js

@@ -162,8 +162,8 @@ export async function getPoolLevelConfig(client, poolId, chainIdOverride) {
 /**
  * 智能解析 Pool ID (支持 ID 校验与关键词回退)
  */
-export async function resolvePool(client, poolId, keyword) {
-    const chainId = getChainId();
+export async function resolvePool(client, poolId, keyword, chainIdOverride) {
+    const chainId = chainIdOverride ?? getChainId();
     let pid = poolId?.trim();
     // 1. 如果提供了 poolId，先尝试验证其是否存在
     if (pid) {

package/dist/tools/accountTransfer.js

@@ -2,16 +2,53 @@ import { z } from "zod";
 import { resolveClient, getChainId } from "../auth/resolveClient.js";
 import { normalizeAddress } from "../utils/address.js";
 import { finalizeMutationResult } from "../utils/mutationResult.js";
+const MAX_UINT256 = "115792089237316195423570985008687907853269984665640564039457584007913129639935";
+function asBigintOrNull(value) {
+    try {
+        const normalized = String(value ?? "").trim();
+        if (!normalized)
+            return null;
+        if (!/^-?\d+$/.test(normalized))
+            return null;
+        return BigInt(normalized);
+    }
+    catch {
+        return null;
+    }
+}
+function readReleaseTime(accountInfo) {
+    const data = accountInfo?.data;
+    if (Array.isArray(data)) {
+        return asBigintOrNull(data[6]) ?? 0n;
+    }
+    return asBigintOrNull(data?.releaseTime ?? data?.release_time) ?? 0n;
+}
+function readAvailableMarginRaw(raw) {
+    if (raw === null || raw === undefined)
+        return null;
+    if (typeof raw === "object" && "data" in raw) {
+        return asBigintOrNull(raw.data);
+    }
+    return asBigintOrNull(raw);
+}
+function formatUnixTimestamp(timestamp) {
+    const numeric = Number(timestamp);
+    if (!Number.isFinite(numeric) || numeric <= 0)
+        return String(timestamp);
+    return `${timestamp.toString()} (${new Date(numeric * 1000).toISOString()})`;
+}
 export const accountDepositTool = {
     name: "account_deposit",
     description: "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"),
+        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."),
     },
     handler: async (args) => {
         try {
-            const { client, signer } = await resolveClient();
+            const { client, signer, address } = await resolveClient();
             const chainId = getChainId();
             const tokenAddress = normalizeAddress(args.tokenAddress, "tokenAddress");
             // For deposit, we default to quote decimals (6) as it's the most common use case.
@@ -19,13 +56,32 @@ export const accountDepositTool = {
             const { ensureUnits } = await import("../utils/units.js");
             const { getQuoteDecimals } = await import("../auth/resolveClient.js");
             const amount = ensureUnits(args.amount, getQuoteDecimals(), "amount", { allowImplicitRaw: false });
+            let approval = null;
+            const needApproval = await client.utils.needsApproval(address, chainId, tokenAddress, amount);
+            if (needApproval) {
+                if (!args.autoApprove) {
+                    throw new Error(`Insufficient token allowance for deposit amount ${amount}. ` +
+                        `Run check_approval (token=${tokenAddress}) or retry with autoApprove=true.`);
+                }
+                const approveAmount = args.approveMax ? MAX_UINT256 : amount;
+                const rawApproval = await client.utils.approveAuthorization({
+                    chainId,
+                    quoteAddress: tokenAddress,
+                    amount: approveAmount,
+                });
+                approval = await finalizeMutationResult(rawApproval, signer, "account_deposit_approval");
+            }
             const raw = await client.account.deposit({
                 amount,
                 tokenAddress,
                 chainId,
             });
             const data = await finalizeMutationResult(raw, signer, "account_deposit");
-            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
+            const payload = {
+                ...data,
+                approval: approval ? { performed: true, details: approval } : { performed: false, needApproval: !!needApproval },
+            };
+            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 };
@@ -49,6 +105,29 @@ export const accountWithdrawTool = {
             // Assuming 18 decimals for base and quoteDecimals for quote
             const decimals = args.isQuoteToken ? getQuoteDecimals() : 18;
             const amount = ensureUnits(args.amount, decimals, "amount", { allowImplicitRaw: false });
+            const amountRaw = asBigintOrNull(amount);
+            if (amountRaw === null || amountRaw <= 0n) {
+                throw new Error(`amount must be a positive integer raw value after normalization, got: ${amount}`);
+            }
+            // Preflight to avoid avoidable AccountInsufficientFreeAmount reverts caused by locked funds.
+            const [accountInfoRaw, availableMarginRawResult] = await Promise.all([
+                client.account.getAccountInfo(chainId, address, args.poolId).catch(() => null),
+                client.account.getAvailableMarginBalance({ poolId: args.poolId, chainId, address }).catch(() => null),
+            ]);
+            const releaseTime = readReleaseTime(accountInfoRaw);
+            const availableMarginRaw = readAvailableMarginRaw(availableMarginRawResult);
+            const nowSec = BigInt(Math.floor(Date.now() / 1000));
+            if (availableMarginRaw !== null && amountRaw > availableMarginRaw) {
+                const lockHint = releaseTime > nowSec
+                    ? ` Funds are partially locked until releaseTime=${formatUnixTimestamp(releaseTime)}.`
+                    : "";
+                throw new Error(`Requested withdraw amount ${amountRaw.toString()} exceeds current withdrawable margin ${availableMarginRaw.toString()}.` +
+                    lockHint);
+            }
+            if (releaseTime > nowSec && availableMarginRaw !== null && availableMarginRaw <= 0n) {
+                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,
@@ -57,7 +136,14 @@ export const accountWithdrawTool = {
                 isQuoteToken: args.isQuoteToken,
             });
             const data = await finalizeMutationResult(raw, signer, "account_withdraw");
-            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
+            const preflight = {
+                requestedAmountRaw: amountRaw.toString(),
+                availableMarginRaw: availableMarginRaw?.toString() ?? null,
+                releaseTime: releaseTime.toString(),
+                releaseTimeIso: Number(releaseTime) > 0 ? new Date(Number(releaseTime) * 1000).toISOString() : null,
+                locked: releaseTime > nowSec,
+            };
+            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: { ...data, preflight } }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
         }
         catch (error) {
             return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };

package/dist/tools/closeAllPositions.js

@@ -3,15 +3,13 @@ import { resolveClient, getChainId, getQuoteToken } from "../auth/resolveClient.
 import { getOraclePrice } from "../services/marketService.js";
 import { ensureUnits } from "../utils/units.js";
 import { finalizeMutationResult } from "../utils/mutationResult.js";
-import { normalizeSlippagePct4dp, isValidSlippagePct4dp, SLIPPAGE_PCT_4DP_DESC } from "../utils/slippage.js";
+import { normalizeSlippagePct4dpFlexible, SLIPPAGE_PCT_4DP_DESC } from "../utils/slippage.js";
 export const closeAllPositionsTool = {
     name: "close_all_positions",
     description: "Emergency: close ALL open positions in a pool at once. Use for risk management.",
     schema: {
         poolId: z.string().describe("Pool ID to close all positions in"),
-        slippagePct: z.coerce.string().refine(isValidSlippagePct4dp, {
-            message: "slippagePct must be an integer in [0, 10000] with 4-decimal precision (1 = 0.01%).",
-        }).optional().describe(SLIPPAGE_PCT_4DP_DESC),
+        slippagePct: z.union([z.string(), z.number()]).optional().describe(`${SLIPPAGE_PCT_4DP_DESC}. Also supports human percent format like "1.0" or "1%".`),
     },
     handler: async (args) => {
         try {
@@ -28,7 +26,7 @@ export const closeAllPositionsTool = {
                 return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: { message: "No open positions in this pool.", closed: 0 } }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
             }
             // 2) 为每个仓位构建平仓参数
-            const slippagePct = normalizeSlippagePct4dp(args.slippagePct ?? "200");
+            const slippagePct = normalizeSlippagePct4dpFlexible(args.slippagePct ?? "200");
             // 3) We need actual oracle prices to avoid Revert 0x613970e0 (InvalidParameter)
             const oraclePriceReq = await getOraclePrice(client, args.poolId).catch(() => null);
             let fallbackPrice = "0";

package/dist/tools/closePosition.js

@@ -1,10 +1,27 @@
 import { z } from "zod";
-import { resolveClient } from "../auth/resolveClient.js";
+import { resolveClient, getChainId } from "../auth/resolveClient.js";
 import { closePosition as closePos } from "../services/tradeService.js";
 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";
+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;
+    }
+    return "";
+}
 export const closePositionTool = {
     name: "close_position",
     description: "Create a decrease order using SDK-native parameters.",
@@ -14,8 +31,8 @@ export const closePositionTool = {
         orderType: z.union([z.number(), z.string()]).describe("Order type: 0/MARKET or 1/LIMIT"),
         triggerType: z.union([z.number(), z.string()]).optional().describe("Trigger type: 0/NONE, 1/GTE, 2/LTE"),
         direction: z.union([z.number(), z.string()]).describe("Position direction: 0/LONG or 1/SHORT"),
-        collateralAmount: z.union([z.string(), z.number()]).describe("Collateral amount (human or raw units)"),
-        size: z.union([z.string(), z.number()]).describe("Position size (human or raw units)"),
+        collateralAmount: z.union([z.string(), z.number()]).describe("Collateral amount (human/raw). Also supports ALL/FULL/MAX to use live position collateral raw."),
+        size: z.union([z.string(), z.number()]).describe("Position size (human/raw). Also supports ALL/FULL/MAX for exact full-close raw size."),
         price: z.union([z.string(), z.number()]).describe("Price (human or 30-dec raw units)"),
         timeInForce: z.coerce.number().int().describe("TimeInForce: 0=GTC, 1=IOC, 2=FOK"),
         postOnly: z.coerce.boolean().describe("Post-only flag"),
@@ -26,26 +43,57 @@ export const closePositionTool = {
     handler: async (args) => {
         try {
             const { client, address, signer } = await resolveClient();
-            const { chainId } = await resolveClient();
-            const poolId = args.poolId;
+            const chainId = getChainId();
+            const preparedArgs = { ...args };
+            const poolId = preparedArgs.poolId;
             // Fetch pool detail to get quoteToken for execution fee
             const poolResponse = await client.markets.getMarketDetail({ chainId, poolId });
             const poolData = poolResponse?.data || (poolResponse?.marketId ? poolResponse : null);
             if (!poolData)
                 throw new Error(`Could not find pool metadata for ID: ${poolId}`);
+            // Precision helper for full close: align with exact raw position values.
+            const needAutoSize = wantsFullCloseMarker(preparedArgs.size);
+            const needAutoCollateral = wantsFullCloseMarker(preparedArgs.collateralAmount);
+            if (needAutoSize || needAutoCollateral) {
+                const positionsRes = await client.position.listPositions(address);
+                const positions = Array.isArray(positionsRes?.data) ? positionsRes.data : [];
+                const positionId = String(preparedArgs.positionId ?? "").trim().toLowerCase();
+                const target = 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 === positionId && pool === String(poolId).toLowerCase();
+                });
+                if (!target) {
+                    throw new Error(`Could not find live position snapshot for positionId=${preparedArgs.positionId} in poolId=${poolId}.`);
+                }
+                if (needAutoSize) {
+                    const rawSize = readRawPositionField(target, "size", "positionSize");
+                    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");
+                    if (!rawCollateral) {
+                        throw new Error(`Resolved position collateral is empty for positionId=${preparedArgs.positionId}.`);
+                    }
+                    preparedArgs.collateralAmount = `raw:${rawCollateral}`;
+                }
+            }
             const mappedArgs = {
-                ...args,
-                direction: mapDirection(args.direction),
-                orderType: mapOrderType(args.orderType),
-                triggerType: args.triggerType !== undefined ? mapTriggerType(args.triggerType) : undefined,
-                executionFeeToken: poolData.quoteToken || args.executionFeeToken
+                ...preparedArgs,
+                direction: mapDirection(preparedArgs.direction),
+                orderType: mapOrderType(preparedArgs.orderType),
+                triggerType: preparedArgs.triggerType !== undefined ? mapTriggerType(preparedArgs.triggerType) : undefined,
+                executionFeeToken: poolData.quoteToken || preparedArgs.executionFeeToken
             };
             const raw = await closePos(client, address, mappedArgs);
             const data = await finalizeMutationResult(raw, signer, "close_position");
             const txHash = data.confirmation?.txHash;
             let verification = null;
             if (txHash) {
-                verification = await verifyTradeOutcome(client, address, args.poolId, txHash);
+                verification = await verifyTradeOutcome(client, address, preparedArgs.poolId, txHash);
             }
             const payload = { ...data, verification };
             return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: payload }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };

package/dist/tools/createPerpMarket.js

@@ -4,7 +4,7 @@ import { resolveClient } from "../auth/resolveClient.js";
 import { finalizeMutationResult } from "../utils/mutationResult.js";
 export const createPerpMarketTool = {
     name: "create_perp_market",
-    description: "Create a new perpetual contract pool on MYX. IMPORTANT: marketId cannot be randomly generated. It must be a valid 66-character config hash (0x...) tied to a supported quote token (like USDC). Use get_market_list to fetch an existing marketId if you don't have a specific newly allocated one.",
+    description: "Create a new perpetual contract pool on MYX. IMPORTANT: marketId cannot be randomly generated. It must be a valid 66-character config hash (0x...) tied to a supported quote token (like USDC). Use get_market_detail (after search_market/get_pool_list) to fetch an existing marketId if you don't have a specific newly allocated one.",
     schema: {
         baseToken: z.string().describe("Base token contract address (e.g., 0xb40aaadc43...)"),
         marketId: z.string().describe("MUST be a valid 66-char config hash (e.g., existing USDC marketId: 0x7f6727d8026fd2c87ccc745846c83cd0b68e886c73e1e05a54a675bcadd8adb6). Do NOT generate randomly."),

package/dist/tools/executeTrade.js

@@ -35,7 +35,7 @@ export const executeTradeTool = {
         tradingFee: z.union([z.string(), z.number()]).optional().describe("Trading fee in quote token units. Supports human/raw prefix. Optional: auto-computed via get_user_trading_fee_rate."),
         assetClass: z.coerce.number().int().nonnegative().optional().describe("Optional fee lookup assetClass (default from pool config or 1)."),
         riskTier: z.coerce.number().int().nonnegative().optional().describe("Optional fee lookup riskTier (default from pool config or 1)."),
-        marketId: z.string().describe("Specific Market Config Hash. Fetch via get_market_list."),
+        marketId: z.string().describe("Specific Market Config Hash. Fetch via get_market_detail (resolve poolId first with search_market/get_pool_list)."),
     },
     handler: async (args) => {
         try {

package/dist/tools/getMyLpHoldings.js

@@ -0,0 +1,265 @@
+import { z } from "zod";
+import { resolveClient, getChainId } from "../auth/resolveClient.js";
+import { COMMON_LP_AMOUNT_DECIMALS } from "@myx-trade/sdk";
+import { Contract, formatUnits } from "ethers";
+import { extractErrorMessage } from "../utils/errorMessage.js";
+const ADDRESS_RE = /^0x[a-fA-F0-9]{40}$/;
+const ERC20_BALANCE_ABI = ["function balanceOf(address owner) view returns (uint256)"];
+function collectRows(input) {
+    if (Array.isArray(input))
+        return input.flatMap(collectRows);
+    if (!input || typeof input !== "object")
+        return [];
+    if (input.poolId || input.pool_id)
+        return [input];
+    return Object.values(input).flatMap(collectRows);
+}
+function readAddress(value) {
+    const text = String(value ?? "").trim();
+    if (!text || !ADDRESS_RE.test(text))
+        return null;
+    return text;
+}
+function normalizePoolId(value) {
+    return String(value ?? "").trim();
+}
+function normalizeAssetSymbol(value) {
+    const text = String(value ?? "").trim();
+    if (!text)
+        return "";
+    return text.replace(/\s+/g, "").replace(/\//g, "").toUpperCase();
+}
+function parsePairSymbols(value) {
+    const text = String(value ?? "").trim();
+    if (!text)
+        return null;
+    const parts = text
+        .split(/[\/:_-]/)
+        .map((item) => normalizeAssetSymbol(item))
+        .filter(Boolean);
+    if (parts.length >= 2) {
+        return { base: parts[0], quote: parts[1] };
+    }
+    return null;
+}
+function resolveBaseQuoteSymbols(row, detail) {
+    const baseCandidates = [
+        row?.baseSymbol,
+        detail?.baseSymbol,
+        row?.base_symbol,
+        detail?.base_symbol,
+    ];
+    const quoteCandidates = [
+        row?.quoteSymbol,
+        detail?.quoteSymbol,
+        row?.quote_symbol,
+        detail?.quote_symbol,
+    ];
+    let baseSymbol = baseCandidates.map((item) => normalizeAssetSymbol(item)).find(Boolean) || "";
+    let quoteSymbol = quoteCandidates.map((item) => normalizeAssetSymbol(item)).find(Boolean) || "";
+    if (!baseSymbol || !quoteSymbol) {
+        const pairCandidate = row?.baseQuoteSymbol ??
+            detail?.baseQuoteSymbol ??
+            row?.symbol ??
+            detail?.symbol ??
+            row?.symbolName ??
+            detail?.symbolName;
+        const parsed = parsePairSymbols(pairCandidate);
+        if (parsed) {
+            baseSymbol = baseSymbol || parsed.base;
+            quoteSymbol = quoteSymbol || parsed.quote;
+        }
+    }
+    return {
+        baseSymbol: baseSymbol || null,
+        quoteSymbol: quoteSymbol || null,
+    };
+}
+function buildLpAssetNames(baseSymbol, quoteSymbol) {
+    if (!baseSymbol || !quoteSymbol) {
+        return { baseLpAssetName: null, quoteLpAssetName: null };
+    }
+    return {
+        baseLpAssetName: `m${baseSymbol}.${quoteSymbol}`,
+        quoteLpAssetName: `m${quoteSymbol}.${baseSymbol}`,
+    };
+}
+function normalizePoolIdsInput(input) {
+    if (Array.isArray(input)) {
+        return input.map((item) => normalizePoolId(item)).filter(Boolean);
+    }
+    if (typeof input !== "string")
+        return [];
+    const text = input.trim();
+    if (!text)
+        return [];
+    if (text.startsWith("[") && text.endsWith("]")) {
+        try {
+            const parsed = JSON.parse(text);
+            if (Array.isArray(parsed)) {
+                return parsed.map((item) => normalizePoolId(item)).filter(Boolean);
+            }
+        }
+        catch {
+        }
+    }
+    if (text.includes(",")) {
+        return text.split(",").map((item) => normalizePoolId(item)).filter(Boolean);
+    }
+    return [text];
+}
+function toSymbol(row) {
+    const baseQuote = String(row?.baseQuoteSymbol ?? row?.symbol ?? "").trim();
+    if (baseQuote)
+        return baseQuote;
+    const base = String(row?.baseSymbol ?? "").trim();
+    const quote = String(row?.quoteSymbol ?? "").trim();
+    if (base && quote)
+        return `${base}/${quote}`;
+    if (base)
+        return base;
+    return normalizePoolId(row?.poolId ?? row?.pool_id);
+}
+function sumRaw(baseRaw, quoteRaw) {
+    return BigInt(baseRaw || "0") + BigInt(quoteRaw || "0");
+}
+async function readErc20Balance(provider, tokenAddress, holder) {
+    const contract = new Contract(tokenAddress, ERC20_BALANCE_ABI, provider);
+    const balance = await contract.balanceOf(holder);
+    return BigInt(balance).toString();
+}
+export const getMyLpHoldingsTool = {
+    name: "get_my_lp_holdings",
+    description: "List your LP holdings across pools on the current chain by reading base/quote LP token balances. Includes standardized LP asset names: base LP `mBASE.QUOTE`, quote LP `mQUOTE.BASE`.",
+    schema: {
+        includeZero: z.coerce.boolean().optional().describe("If true, include pools with zero LP balances (default false)."),
+        poolIds: z.union([z.array(z.string()).min(1), z.string().min(1)]).optional().describe("Optional poolId filter. Supports array, JSON-array string, comma string, or single poolId."),
+        maxPools: z.coerce.number().int().positive().max(2000).optional().describe("Optional cap for scanned pools (default all)."),
+    },
+    handler: async (args) => {
+        try {
+            const { client, address, signer } = await resolveClient();
+            const chainId = getChainId();
+            const provider = signer?.provider;
+            if (!provider) {
+                throw new Error("Provider is unavailable for LP balance reads.");
+            }
+            const includeZero = !!args.includeZero;
+            const poolIdsFilter = normalizePoolIdsInput(args.poolIds);
+            const filterSet = new Set(poolIdsFilter.map((item) => item.toLowerCase()));
+            const maxPools = Number.isFinite(Number(args.maxPools)) ? Math.floor(Number(args.maxPools)) : null;
+            const poolListRes = await client.api.getPoolList();
+            const rows = collectRows(poolListRes?.data ?? poolListRes);
+            const deduped = new Map();
+            for (const row of rows) {
+                const poolId = normalizePoolId(row?.poolId ?? row?.pool_id);
+                if (!poolId)
+                    continue;
+                if (filterSet.size > 0 && !filterSet.has(poolId.toLowerCase()))
+                    continue;
+                if (!deduped.has(poolId.toLowerCase())) {
+                    deduped.set(poolId.toLowerCase(), row);
+                }
+            }
+            const selectedRows = Array.from(deduped.values());
+            const scannedRows = maxPools ? selectedRows.slice(0, maxPools) : selectedRows;
+            const items = [];
+            const warnings = [];
+            let totalBaseLpRaw = 0n;
+            let totalQuoteLpRaw = 0n;
+            for (const row of scannedRows) {
+                const poolId = normalizePoolId(row?.poolId ?? row?.pool_id);
+                let basePoolToken = readAddress(row?.basePoolToken ?? row?.base_pool_token);
+                let quotePoolToken = readAddress(row?.quotePoolToken ?? row?.quote_pool_token);
+                let detail = null;
+                if (!basePoolToken || !quotePoolToken) {
+                    try {
+                        const detailRes = await client.markets.getMarketDetail({ chainId, poolId });
+                        detail = detailRes?.data || (detailRes?.marketId ? detailRes : null);
+                        basePoolToken = basePoolToken ?? readAddress(detail?.basePoolToken ?? detail?.base_pool_token);
+                        quotePoolToken = quotePoolToken ?? readAddress(detail?.quotePoolToken ?? detail?.quote_pool_token);
+                    }
+                    catch (error) {
+                        warnings.push(`pool ${poolId}: failed to enrich pool detail (${extractErrorMessage(error)})`);
+                    }
+                }
+                const { baseSymbol, quoteSymbol } = resolveBaseQuoteSymbols(row, detail);
+                const { baseLpAssetName, quoteLpAssetName } = buildLpAssetNames(baseSymbol, quoteSymbol);
+                let baseLpRaw = "0";
+                let quoteLpRaw = "0";
+                if (basePoolToken) {
+                    try {
+                        baseLpRaw = await readErc20Balance(provider, basePoolToken, address);
+                    }
+                    catch (error) {
+                        warnings.push(`pool ${poolId}: failed to read base LP balance (${extractErrorMessage(error)})`);
+                    }
+                }
+                if (quotePoolToken) {
+                    try {
+                        quoteLpRaw = await readErc20Balance(provider, quotePoolToken, address);
+                    }
+                    catch (error) {
+                        warnings.push(`pool ${poolId}: failed to read quote LP balance (${extractErrorMessage(error)})`);
+                    }
+                }
+                const hasAnyLp = BigInt(baseLpRaw) > 0n || BigInt(quoteLpRaw) > 0n;
+                if (!includeZero && !hasAnyLp)
+                    continue;
+                totalBaseLpRaw += BigInt(baseLpRaw);
+                totalQuoteLpRaw += BigInt(quoteLpRaw);
+                items.push({
+                    poolId,
+                    symbol: toSymbol(row),
+                    state: row?.state ?? row?.poolState ?? null,
+                    baseSymbol,
+                    quoteSymbol,
+                    baseLpAssetName,
+                    quoteLpAssetName,
+                    basePoolToken: basePoolToken ?? null,
+                    quotePoolToken: quotePoolToken ?? null,
+                    baseLpBalanceRaw: baseLpRaw,
+                    baseLpBalance: formatUnits(baseLpRaw, COMMON_LP_AMOUNT_DECIMALS),
+                    quoteLpBalanceRaw: quoteLpRaw,
+                    quoteLpBalance: formatUnits(quoteLpRaw, COMMON_LP_AMOUNT_DECIMALS),
+                    hasAnyLp,
+                });
+            }
+            items.sort((left, right) => {
+                const leftSum = sumRaw(left.baseLpBalanceRaw, left.quoteLpBalanceRaw);
+                const rightSum = sumRaw(right.baseLpBalanceRaw, right.quoteLpBalanceRaw);
+                if (leftSum === rightSum)
+                    return 0;
+                return rightSum > leftSum ? 1 : -1;
+            });
+            const payload = {
+                meta: {
+                    address,
+                    chainId,
+                    includeZero,
+                    requestedPoolIds: poolIdsFilter,
+                    scannedPools: scannedRows.length,
+                    totalDiscoveredPools: selectedRows.length,
+                    maxPools: maxPools ?? null,
+                },
+                summary: {
+                    heldPools: items.length,
+                    totalBaseLpRaw: totalBaseLpRaw.toString(),
+                    totalBaseLp: formatUnits(totalBaseLpRaw, COMMON_LP_AMOUNT_DECIMALS),
+                    totalQuoteLpRaw: totalQuoteLpRaw.toString(),
+                    totalQuoteLp: formatUnits(totalQuoteLpRaw, COMMON_LP_AMOUNT_DECIMALS),
+                },
+                items,
+            };
+            if (warnings.length > 0) {
+                payload.warnings = warnings.slice(0, 100);
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify({ status: "success", data: payload }, (_, value) => typeof value === "bigint" ? value.toString() : value, 2) }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${extractErrorMessage(error)}` }], isError: true };
+        }
+    },
+};

package/dist/tools/index.js

@@ -31,7 +31,6 @@ export { getPositionsTool } from "./getPositions.js";
 export { getOpenOrdersTool, getOrderHistoryTool } from "./orderQueries.js";
 export { getPositionHistoryTool } from "./positionHistory.js";
 export { getAccountTool, getTradeFlowTool } from "./accountInfo.js";
+export { getMyLpHoldingsTool } from "./getMyLpHoldings.js";
 export { getAccountVipInfoTool } from "./getAccountVipInfo.js";
 export { accountDepositTool, accountWithdrawTool } from "./accountTransfer.js";
-export { getMarketListTool } from "./getMarketList.js";
-export { getMarketListRawTool } from "./getMarketListRaw.js";

package/dist/tools/manageLiquidity.js

@@ -1,14 +1,55 @@
 import { z } from "zod";
 import { quoteDeposit, quoteWithdraw, baseDeposit, baseWithdraw, getLpPrice, } from "../services/poolService.js";
-import { resolveClient } from "../auth/resolveClient.js";
+import { resolveClient, getChainId } from "../auth/resolveClient.js";
 import { resolvePool } from "../services/marketService.js";
 import { finalizeMutationResult } from "../utils/mutationResult.js";
 import { extractErrorMessage } from "../utils/errorMessage.js";
+function normalizeAssetSymbol(value) {
+    const text = String(value ?? "").trim();
+    if (!text)
+        return "";
+    return text.replace(/\s+/g, "").replace(/\//g, "").toUpperCase();
+}
+function parsePairSymbols(value) {
+    const text = String(value ?? "").trim();
+    if (!text)
+        return null;
+    const parts = text
+        .split(/[\/:_-]/)
+        .map((item) => normalizeAssetSymbol(item))
+        .filter(Boolean);
+    if (parts.length >= 2) {
+        return { base: parts[0], quote: parts[1] };
+    }
+    return null;
+}
+function resolveLpAssetNames(detail) {
+    let baseSymbol = normalizeAssetSymbol(detail?.baseSymbol ?? detail?.base_symbol);
+    let quoteSymbol = normalizeAssetSymbol(detail?.quoteSymbol ?? detail?.quote_symbol);
+    if (!baseSymbol || !quoteSymbol) {
+        const pairCandidate = detail?.baseQuoteSymbol ?? detail?.symbol ?? detail?.symbolName;
+        const parsed = parsePairSymbols(pairCandidate);
+        if (parsed) {
+            baseSymbol = baseSymbol || parsed.base;
+            quoteSymbol = quoteSymbol || parsed.quote;
+        }
+    }
+    const normalizedBase = baseSymbol || null;
+    const normalizedQuote = quoteSymbol || null;
+    const baseLpAssetName = normalizedBase && normalizedQuote ? `m${normalizedBase}.${normalizedQuote}` : null;
+    const quoteLpAssetName = normalizedBase && normalizedQuote ? `m${normalizedQuote}.${normalizedBase}` : null;
+    return {
+        baseSymbol: normalizedBase,
+        quoteSymbol: normalizedQuote,
+        baseLpAssetName,
+        quoteLpAssetName,
+    };
+}
 export const manageLiquidityTool = {
     name: "manage_liquidity",
-    description: "Add or withdraw liquidity from a BASE or QUOTE pool.",
+    description: "Add or withdraw liquidity from a BASE or QUOTE pool. Success response includes LP naming metadata: base `mBASE.QUOTE`, quote `mQUOTE.BASE`, plus `operatedLpAssetName` based on poolType.",
     schema: {
-        action: z.enum(["deposit", "withdraw", "add", "remove", "increase", "decrease"]).describe("'deposit' or 'withdraw' (aliases: add, remove, increase, decrease)"),
+        action: z.coerce.string().describe("'deposit' or 'withdraw' (aliases: add/remove/increase/decrease; case-insensitive)"),
         poolType: z.enum(["BASE", "QUOTE"]).describe("'BASE' or 'QUOTE'"),
         poolId: z.string().describe("Pool ID or Base Token Address"),
         amount: z.coerce.number().positive().describe("Amount in human-readable units"),
@@ -20,23 +61,36 @@ export const manageLiquidityTool = {
             const { client, signer } = await resolveClient();
             let { action, poolType, poolId } = args;
             const { amount, slippage } = args;
+            const chainId = args.chainId ?? getChainId();
+            action = String(action ?? "").trim().toLowerCase();
+            const validActions = new Set(["deposit", "withdraw", "add", "remove", "increase", "decrease"]);
+            if (!validActions.has(action)) {
+                throw new Error(`Invalid action: ${args.action}. Use deposit/withdraw or aliases add/remove/increase/decrease.`);
+            }
             // 1. Action Alias Mapping
             if (action === "add" || action === "increase")
                 action = "deposit";
             if (action === "remove" || action === "decrease")
                 action = "withdraw";
             // 2. Smart Pool Resolution (Handles PoolId, Token Address, or Keywords)
-            poolId = await resolvePool(client, poolId);
+            poolId = await resolvePool(client, poolId, undefined, chainId);
+            // 3. Preflight pool validation for target chain (avoid opaque SDK "Invalid Params")
+            const detailRes = await client.markets.getMarketDetail({ chainId, poolId }).catch(() => null);
+            const detail = detailRes?.data || (detailRes?.marketId ? detailRes : null);
+            if (!detail?.marketId) {
+                throw new Error(`Pool ${poolId} not found on chainId ${chainId}. ` +
+                    `Please query a valid active pool via search_market/get_pool_list first.`);
+            }
             let raw;
             if (poolType === "QUOTE") {
                 raw = action === "deposit"
-                    ? await quoteDeposit(poolId, amount, slippage, args.chainId)
-                    : await quoteWithdraw(poolId, amount, slippage, args.chainId);
+                    ? await quoteDeposit(poolId, amount, slippage, chainId)
+                    : await quoteWithdraw(poolId, amount, slippage, chainId);
             }
             else {
                 raw = action === "deposit"
-                    ? await baseDeposit(poolId, amount, slippage, args.chainId)
-                    : await baseWithdraw(poolId, amount, slippage, args.chainId);
+                    ? await baseDeposit(poolId, amount, slippage, chainId)
+                    : await baseWithdraw(poolId, amount, slippage, chainId);
             }
             if (!raw) {
                 throw new Error(`SDK returned an empty result for liquidity ${action}. This usually occurs if the pool is not in an Active state (state: 2) or if there is a contract-level restriction. Please check pool_info.`);
@@ -45,7 +99,26 @@ export const manageLiquidityTool = {
                 throw new Error(`Liquidity ${action} failed: ${extractErrorMessage(raw)}`);
             }
             const data = await finalizeMutationResult(raw, signer, "manage_liquidity");
-            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
+            const lpAssetNames = resolveLpAssetNames(detail);
+            const operatedLpAssetName = poolType === "BASE" ? lpAssetNames.baseLpAssetName : lpAssetNames.quoteLpAssetName;
+            const payload = data && typeof data === "object" && !Array.isArray(data)
+                ? {
+                    ...data,
+                    lpAssetNames: {
+                        ...lpAssetNames,
+                        operatedPoolType: poolType,
+                        operatedLpAssetName,
+                    },
+                }
+                : {
+                    result: data,
+                    lpAssetNames: {
+                        ...lpAssetNames,
+                        operatedPoolType: poolType,
+                        operatedLpAssetName,
+                    },
+                };
+            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: ${extractErrorMessage(error)}` }], isError: true };

package/dist/tools/marketInfo.js

@@ -3,6 +3,21 @@ import { resolveClient, getChainId } from "../auth/resolveClient.js";
 import { getMarketDetail, resolvePool } from "../services/marketService.js";
 import { getPoolInfo, getLiquidityInfo } from "../services/poolService.js";
 import { extractErrorMessage } from "../utils/errorMessage.js";
+import { parseUserPrice30 } from "../utils/units.js";
+const INTEGER_RE = /^\d+$/;
+const DECIMAL_RE = /^\d+(\.\d+)?$/;
+function normalizeMarketPrice30Input(value) {
+    const text = String(value ?? "").trim();
+    if (!text)
+        throw new Error("marketPrice is required.");
+    // Keep backward compatibility: plain integers are treated as already-raw 30-dec units.
+    if (INTEGER_RE.test(text))
+        return text;
+    if (!DECIMAL_RE.test(text) && !/^raw:/i.test(text) && !/^human:/i.test(text)) {
+        throw new Error("marketPrice must be numeric, or prefixed with raw:/human:.");
+    }
+    return parseUserPrice30(text, "marketPrice");
+}
 export const getMarketDetailTool = {
     name: "get_market_detail",
     description: "Get detailed information for a specific trading pool (fee rates, open interest, etc.). Supports PoolId, Token Address, or Keywords.",
@@ -52,7 +67,7 @@ export const getLiquidityInfoTool = {
     description: "Get pool liquidity utilization and depth information. Supports PoolId, Token Address, or Keywords.",
     schema: {
         poolId: z.string().describe("Pool ID, Token Address, or Keyword"),
-        marketPrice: z.string().regex(/^\d+$/).describe("Current market price in 30-decimal raw units"),
+        marketPrice: z.union([z.string(), z.number()]).describe("Current market price. Supports raw 30-dec integer, raw:..., or human price like 2172.5 / human:2172.5."),
         chainId: z.number().int().positive().optional().describe("Optional chainId override"),
     },
     handler: async (args) => {
@@ -60,7 +75,8 @@ export const getLiquidityInfoTool = {
             const { client } = await resolveClient();
             const poolId = await resolvePool(client, args.poolId);
             const chainId = args.chainId ?? getChainId();
-            const data = await getLiquidityInfo(client, poolId, args.marketPrice, chainId);
+            const marketPrice = normalizeMarketPrice30Input(args.marketPrice);
+            const data = await getLiquidityInfo(client, poolId, marketPrice, chainId);
             if (!data)
                 throw new Error(`Liquidity info for ${poolId} not available.`);
             return { content: [{ type: "text", text: JSON.stringify({ status: "success", data }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };

package/dist/utils/slippage.js

@@ -1,6 +1,7 @@
 const SLIPPAGE_PCT_4DP_RE = /^\d+$/;
 export const SLIPPAGE_PCT_4DP_MAX = 10000n;
 export const SLIPPAGE_PCT_4DP_DESC = "Slippage in 4-decimal precision raw units (1 = 0.01%, 10000 = 100%)";
+const SLIPPAGE_PERCENT_HUMAN_RE = /^\d+(\.\d{1,2})?$/;
 export function isValidSlippagePct4dp(value) {
     if (!SLIPPAGE_PCT_4DP_RE.test(value))
         return false;
@@ -13,3 +14,25 @@ export function normalizeSlippagePct4dp(value, label = "slippagePct") {
     }
     return raw;
 }
+export function normalizeSlippagePct4dpFlexible(value, label = "slippagePct") {
+    const raw = String(value ?? "").trim();
+    if (!raw) {
+        throw new Error(`${label} is required.`);
+    }
+    // Keep backward-compatible behavior: integer values remain raw 4dp units.
+    if (isValidSlippagePct4dp(raw)) {
+        return raw;
+    }
+    // Human percent helper: "1.0" / "1.25" / "1%"
+    const percentText = raw.endsWith("%") ? raw.slice(0, -1).trim() : raw;
+    if (!SLIPPAGE_PERCENT_HUMAN_RE.test(percentText)) {
+        throw new Error(`${label} must be raw 4dp integer (e.g. 100=1%) or human percent like "1.0" / "1%".`);
+    }
+    const [intPart, fracPart = ""] = percentText.split(".");
+    const frac2 = (fracPart + "00").slice(0, 2);
+    const converted = BigInt(intPart) * 100n + BigInt(frac2);
+    if (converted > SLIPPAGE_PCT_4DP_MAX) {
+        throw new Error(`${label} must be <= 100% (raw <= 10000).`);
+    }
+    return converted.toString();
+}

package/package.json

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

package/dist/tools/getMarketList.js

@@ -1,20 +0,0 @@
-import { resolveClient } from "../auth/resolveClient.js";
-import { searchMarket } from "../services/marketService.js";
-import { z } from "zod";
-export const getMarketListTool = {
-    name: "get_market_list",
-    description: "Get tradable markets/pools (state=2 Active). Supports configurable result limit; backend may still enforce its own cap.",
-    schema: {
-        limit: z.coerce.number().int().positive().optional().describe("Max results to request (default 1000)."),
-    },
-    handler: async (args) => {
-        try {
-            const { client } = await resolveClient();
-            const activeMarkets = await searchMarket(client, "", args.limit ?? 1000);
-            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: activeMarkets }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
-        }
-        catch (error) {
-            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
-        }
-    },
-};

package/dist/tools/getMarketListRaw.js

@@ -1,16 +0,0 @@
-import { resolveClient } from "../auth/resolveClient.js";
-export const getMarketListRawTool = {
-    name: "get_market_list_raw",
-    description: "Get raw market list directly from MYX API without MCP-side filtering.",
-    schema: {},
-    handler: async () => {
-        try {
-            const { client } = await resolveClient();
-            const result = await client.api.getMarketList();
-            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 };
-        }
-    },
-};