@michaleffffff/mcp-trading-server 3.0.4 → 3.0.7

package/dist/tools/getBaseDetail.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { resolveClient, getChainId } from "../auth/resolveClient.js";
 export const getBaseDetailTool = {
     name: "get_base_detail",
-    description: "Get base token details.",
+    description: "[MARKET] Get base token details.",
     schema: {
         baseAddress: z.string().describe("Base token address"),
         chainId: z.number().int().positive().optional().describe("Optional chainId override"),

package/dist/tools/getKline.js

@@ -3,18 +3,21 @@ import { resolveClient, getChainId } from "../auth/resolveClient.js";
 const klineIntervalSchema = z.enum(["1m", "5m", "15m", "30m", "1h", "4h", "1d", "1w", "1M"]);
 export const getKlineTool = {
     name: "get_kline",
-    description: "Get K-line / candlestick data for a pool. Essential for price analysis.",
+    description: "[MARKET] Get K-line / candlestick data for a pool. Supports PoolId or Keyword. Set limit=1 for the latest bar.",
     schema: {
-        poolId: z.string().describe("Pool ID"),
+        poolId: z.string().optional().describe("Pool ID"),
+        keyword: z.string().optional().describe("Market keyword (e.g. 'BTC')"),
         interval: klineIntervalSchema.describe("K-line interval"),
-        limit: z.number().int().positive().optional().describe("Number of bars (default 100)"),
+        limit: z.number().int().positive().optional().describe("Number of bars (default 100). Set to 1 for the latest price bar."),
     },
     handler: async (args) => {
         try {
             const { client } = await resolveClient();
             const chainId = getChainId();
+            const { resolvePool } = await import("../services/marketService.js");
+            const poolId = await resolvePool(client, args.poolId, args.keyword);
             const result = await client.markets.getKlineList({
-                poolId: args.poolId,
+                poolId,
                 chainId,
                 interval: args.interval,
                 limit: args.limit ?? 100,

package/dist/tools/getMyLpHoldings.js

@@ -3,6 +3,7 @@ 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";
+import { getPoolList } from "../services/marketService.js";
 const ADDRESS_RE = /^0x[a-fA-F0-9]{40}$/;
 const ERC20_BALANCE_ABI = ["function balanceOf(address owner) view returns (uint256)"];
 function collectRows(input) {
@@ -130,7 +131,7 @@ async function readErc20Balance(provider, tokenAddress, holder) {
 }
 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`.",
+    description: "[ACCOUNT] 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."),
@@ -148,7 +149,7 @@ export const getMyLpHoldingsTool = {
             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 poolListRes = await getPoolList(client, chainId);
             const rows = collectRows(poolListRes?.data ?? poolListRes);
             const deduped = new Map();
             for (const row of rows) {

package/dist/tools/getNetworkFee.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { resolveClient, getChainId } from "../auth/resolveClient.js";
 export const getNetworkFeeTool = {
     name: "get_network_fee",
-    description: "Estimate network fee requirements for a market.",
+    description: "[TRADE] Estimate network fee requirements for a market.",
     schema: {
         marketId: z.string().describe("Market ID"),
         chainId: z.number().int().positive().optional().describe("Optional chainId override"),

package/dist/tools/getOrders.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { resolveClient, getChainId } from "../auth/resolveClient.js";
+import { getOrderTypeDesc, getOrderStatusDesc, getDirectionDesc, getHistoryOrderStatusDesc, getExecTypeDesc } from "../utils/mappings.js";
+export const getOrdersTool = {
+    name: "get_orders",
+    description: "[ACCOUNT] Get orders (open or history) with optional filters.",
+    schema: {
+        status: z.enum(["OPEN", "HISTORY", "ALL"]).default("OPEN").describe("Filter by status: 'OPEN' (default), 'HISTORY', or 'ALL'"),
+        poolId: z.string().optional().describe("Filter by pool ID"),
+        limit: z.number().int().positive().optional().describe("Results per page (default 20)"),
+    },
+    handler: async (args) => {
+        try {
+            const { client, address } = await resolveClient();
+            const chainId = getChainId();
+            const results = {};
+            if (args.status === "OPEN" || args.status === "ALL") {
+                const openRes = await client.order.getOrders(address);
+                results.open = (openRes?.data || []).map((order) => ({
+                    ...order,
+                    orderTypeDesc: getOrderTypeDesc(order.orderType),
+                    statusDesc: getOrderStatusDesc(order.status),
+                    directionDesc: getDirectionDesc(order.direction)
+                }));
+                if (args.poolId) {
+                    results.open = results.open.filter((o) => String(o.poolId).toLowerCase() === args.poolId.toLowerCase());
+                }
+            }
+            if (args.status === "HISTORY" || args.status === "ALL") {
+                const query = { chainId, poolId: args.poolId, limit: args.limit ?? 20 };
+                const historyRes = await client.order.getOrderHistory(query, address);
+                results.history = (historyRes?.data || []).map((order) => ({
+                    ...order,
+                    orderTypeDesc: getOrderTypeDesc(order.orderType),
+                    orderStatusDesc: getHistoryOrderStatusDesc(order.orderStatus),
+                    directionDesc: getDirectionDesc(order.direction),
+                    execTypeDesc: getExecTypeDesc(order.execType)
+                }));
+            }
+            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: results }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+        }
+    },
+};

package/dist/tools/getPoolMetadata.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+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)
+        return "";
+    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");
+}
+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).",
+    schema: {
+        poolId: z.string().optional().describe("Pool ID, Token Address, or Keyword"),
+        keyword: z.string().optional().describe("Market keyword (e.g. 'BTC')"),
+        includeLiquidity: z.boolean().default(false).describe("Whether to include liquidity depth (requires marketPrice)"),
+        marketPrice: z.union([z.string(), z.number()]).optional().describe("Current price (required if includeLiquidity is true)"),
+        includeConfig: z.boolean().default(false).describe("Whether to include pool level configuration/limits"),
+        chainId: z.number().int().positive().optional().describe("Optional chainId override"),
+    },
+    handler: async (args) => {
+        try {
+            const { client } = await resolveClient();
+            const chainId = args.chainId ?? getChainId();
+            const poolId = await resolvePool(client, args.poolId, args.keyword, chainId);
+            const results = { poolId, chainId };
+            const errors = [];
+            // 1. Market Detail (Fee rates, OI, etc.)
+            try {
+                results.marketDetail = await getMarketDetail(client, poolId, chainId);
+            }
+            catch (err) {
+                errors.push(compactWarning("marketDetail", err));
+            }
+            // 2. Pool Info (Reserves, Utilization)
+            try {
+                results.poolInfo = await getPoolInfo(poolId, chainId, client);
+            }
+            catch (err) {
+                errors.push(compactWarning("poolInfo", err));
+            }
+            // 3. Optional: Liquidity Info
+            if (args.includeLiquidity) {
+                try {
+                    const price = normalizeMarketPrice30Input(args.marketPrice);
+                    if (!price)
+                        throw new Error("marketPrice is required for liquidity info.");
+                    results.liquidityInfo = await getLiquidityInfo(client, poolId, price, chainId);
+                }
+                catch (err) {
+                    errors.push(compactWarning("liquidityInfo", err));
+                }
+            }
+            // 4. Optional: Config / Limits
+            if (args.includeConfig) {
+                try {
+                    const { getPoolLevelConfig } = await import("../services/marketService.js");
+                    results.levelConfig = await getPoolLevelConfig(client, poolId, chainId);
+                }
+                catch (err) {
+                    errors.push(compactWarning("levelConfig", err));
+                }
+            }
+            if (errors.length > 0) {
+                results.warnings = errors;
+            }
+            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: results }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${extractErrorMessage(error)}` }], isError: true };
+        }
+    },
+};

package/dist/tools/getPositionsAll.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { resolveClient, getChainId } from "../auth/resolveClient.js";
+import { getPositions } from "../services/positionService.js";
+import { getDirectionDesc } from "../utils/mappings.js";
+export const getPositionsAllTool = {
+    name: "get_positions_all",
+    description: "[ACCOUNT] Get positions (open or history) with optional filters and ROI/PnL metrics.",
+    schema: {
+        status: z.enum(["OPEN", "HISTORY", "ALL"]).default("OPEN").describe("Filter by status: 'OPEN' (default), 'HISTORY', or 'ALL'"),
+        poolId: z.string().optional().describe("Filter by pool ID"),
+        limit: z.number().int().positive().optional().describe("Results per page (default 20, for history)"),
+    },
+    handler: async (args) => {
+        try {
+            const { client, address } = await resolveClient();
+            const chainId = getChainId();
+            const results = {};
+            if (args.status === "OPEN" || args.status === "ALL") {
+                const data = await getPositions(client, address);
+                const positions = Array.isArray(data) ? data : (Array.isArray(data?.data) ? data.data : []);
+                // Enhance open positions with metrics
+                const filtered = args.poolId ? positions.filter((p) => String(p.poolId).toLowerCase() === args.poolId.toLowerCase()) : positions;
+                if (filtered.length > 0) {
+                    const poolIds = [...new Set(filtered.map((p) => p.poolId))];
+                    const [tickersRes, configs] = await Promise.all([
+                        client.markets.getTickerList({ chainId, poolIds }),
+                        Promise.all(poolIds.map(async (pid) => {
+                            try {
+                                const { getPoolLevelConfig } = await import("../services/marketService.js");
+                                const res = await getPoolLevelConfig(client, pid, chainId);
+                                return { poolId: pid, config: res?.levelConfig || res?.data?.levelConfig || res };
+                            }
+                            catch {
+                                return { poolId: pid, config: null };
+                            }
+                        }))
+                    ]);
+                    const tickers = Array.isArray(tickersRes) ? tickersRes : (tickersRes?.data ?? []);
+                    results.open = filtered.map((pos) => {
+                        const ticker = tickers.find((t) => t.poolId === pos.poolId);
+                        const currentPrice = Number(ticker?.price || 0);
+                        const entryPrice = Number(pos.entryPrice || 0);
+                        const size = Number(pos.size || 0);
+                        const collateral = Number(pos.collateralAmount || 0);
+                        const direction = pos.direction;
+                        const mm = configs.find(c => c.poolId === pos.poolId)?.config?.maintainCollateralRate || 0.02;
+                        let estimatedPnl = direction === 0 ? (currentPrice - entryPrice) * size : (entryPrice - currentPrice) * size;
+                        const roi = collateral > 0 ? (estimatedPnl / collateral) * 100 : 0;
+                        let liqPrice = size > 0 ? (direction === 0 ? (entryPrice * size - collateral) / (size * (1 - mm)) : (entryPrice * size + collateral) / (size * (1 + mm))) : 0;
+                        if (liqPrice < 0)
+                            liqPrice = 0;
+                        return {
+                            ...pos,
+                            directionDesc: getDirectionDesc(pos.direction),
+                            currentPrice: currentPrice.toString(),
+                            estimatedPnl: estimatedPnl.toFixed(4),
+                            roi: roi.toFixed(2) + "%",
+                            liquidationPrice: liqPrice.toFixed(4)
+                        };
+                    });
+                }
+                else {
+                    results.open = [];
+                }
+            }
+            if (args.status === "HISTORY" || args.status === "ALL") {
+                const query = { chainId, poolId: args.poolId, limit: args.limit ?? 20 };
+                const historyRes = await client.position.getPositionHistory(query, address);
+                results.history = (historyRes?.data || []).map((pos) => ({
+                    ...pos,
+                    directionDesc: getDirectionDesc(pos.direction)
+                }));
+            }
+            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: results }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+        }
+    },
+};

package/dist/tools/{getMarketPrice.js → getPrice.js}

@@ -1,18 +1,21 @@
 import { z } from "zod";
 import { resolveClient, getChainId } from "../auth/resolveClient.js";
-import { getMarketPrice } from "../services/marketService.js";
-export const getMarketPriceTool = {
-    name: "get_market_price",
-    description: "Get the current market price for a specific pool.",
+import { getMarketPrice, getOraclePrice } from "../services/marketService.js";
+export const getPriceTool = {
+    name: "get_price",
+    description: "[MARKET] Get the current price for a specific pool. Support both market (impact) and oracle prices.",
     schema: {
         poolId: z.string().describe("Pool ID to get price for"),
+        priceType: z.enum(["market", "oracle"]).default("market").describe("Type of price to fetch: 'market' (default) or 'oracle'"),
         chainId: z.number().int().positive().optional().describe("Optional chainId override"),
     },
     handler: async (args) => {
         try {
             const { client } = await resolveClient();
             const chainId = args.chainId ?? getChainId();
-            const data = await getMarketPrice(client, args.poolId, chainId);
+            const data = args.priceType === "oracle"
+                ? await getOraclePrice(client, args.poolId, chainId)
+                : await getMarketPrice(client, args.poolId, chainId);
             return { content: [{ type: "text", text: JSON.stringify({ status: "success", data }, (k, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
         }
         catch (error) {

package/dist/tools/getUserTradingFeeRate.js

@@ -1,8 +1,65 @@
 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: "Get maker/taker fee rates for a given assetClass and riskTier.",
+    description: "[TRADE] Get maker/taker fee rates for a given assetClass and riskTier.",
     schema: {
         assetClass: z.coerce.number().int().nonnegative().describe("Asset class ID"),
         riskTier: z.coerce.number().int().nonnegative().describe("Risk tier"),
@@ -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/index.js

@@ -1,36 +1,32 @@
 // Tools — 交易
 export { openPositionSimpleTool } from "./openPositionSimple.js";
 export { executeTradeTool } from "./executeTrade.js";
-export { cancelOrderTool } from "./cancelOrder.js";
-export { cancelAllOrdersTool } from "./cancelAllOrders.js";
+export { cancelOrdersTool } from "./cancelOrders.js"; // Unified
 export { closePositionTool } from "./closePosition.js";
-export { setTpSlTool } from "./setTpSl.js";
-export { updateOrderTpSlTool } from "./updateOrderTpSl.js";
+export { manageTpSlTool } from "./manageTpSl.js"; // Unified
 export { adjustMarginTool } from "./adjustMargin.js";
 export { closeAllPositionsTool } from "./closeAllPositions.js";
 export { checkApprovalTool } from "./checkApproval.js";
 export { getUserTradingFeeRateTool } from "./getUserTradingFeeRate.js";
 export { getNetworkFeeTool } from "./getNetworkFee.js";
+export { checkAccountReadyTool } from "./checkAccountReady.js";
 // Tools — 市场数据
-export { getMarketPriceTool } from "./getMarketPrice.js";
-export { getOraclePriceTool } from "./getOraclePrice.js";
-export { searchMarketTool } from "./searchMarket.js";
-export { getKlineTool } from "./getKline.js";
-export { getKlineLatestBarTool } from "./getKlineLatestBar.js";
-export { getAllTickersTool } from "./getAllTickers.js";
-export { getMarketDetailTool, getPoolInfoTool, getLiquidityInfoTool } from "./marketInfo.js";
-export { getPoolListTool } from "./getPoolList.js";
-export { getPoolSymbolAllTool } from "./getPoolSymbolAll.js";
-export { getPoolLevelConfigTool } from "./poolConfig.js";
+export { getPriceTool } from "./getPrice.js"; // Unified
+export { getKlineTool } from "./getKline.js"; // Enhanced
+export { listPoolsTool } from "./listPools.js"; // Unified
+export { findPoolTool } from "./findPool.js"; // Unified
+export { getPoolMetadataTool } from "./getPoolMetadata.js"; // Unified
 export { getBaseDetailTool } from "./getBaseDetail.js";
+export { getAllTickersTool } from "./getAllTickers.js";
 // Tools — 池子 & 流动性
 export { createPerpMarketTool } from "./createPerpMarket.js";
 export { manageLiquidityTool, getLpPriceTool } from "./manageLiquidity.js";
 // Tools — 账户 & 查询
-export { getPositionsTool } from "./getPositions.js";
-export { getOpenOrdersTool, getOrderHistoryTool } from "./orderQueries.js";
-export { getPositionHistoryTool } from "./positionHistory.js";
-export { getAccountTool, getTradeFlowTool } from "./accountInfo.js";
+export { getPositionsAllTool } from "./getPositionsAll.js"; // Unified
+export { getOrdersTool } from "./getOrders.js"; // Unified
+export { getAccountSnapshotTool } from "./getAccountSnapshot.js"; // Unified
+export { getTradeFlowTool } from "./accountInfo.js"; // Kept for trade flow detail
 export { getMyLpHoldingsTool } from "./getMyLpHoldings.js";
-export { getAccountVipInfoTool } from "./getAccountVipInfo.js";
 export { accountDepositTool, accountWithdrawTool } from "./accountTransfer.js";
+// Tools — 系统
+export { searchToolsTool } from "./searchTools.js";

package/dist/tools/listPools.js

@@ -0,0 +1,53 @@
+import { resolveClient } from "../auth/resolveClient.js";
+import { getPoolList } from "../services/marketService.js";
+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);
+}
+export const listPoolsTool = {
+    name: "list_pools",
+    description: "[MARKET] Get the complete list of all available tradable pools, including symbol and icon metadata.",
+    schema: {},
+    handler: async () => {
+        try {
+            const { client } = await resolveClient();
+            // Fetch both list and symbols
+            const [poolListRes, symbolsRes] = await Promise.all([
+                getPoolList(client),
+                client.markets.getPoolSymbolAll().catch(() => ({ data: [] }))
+            ]);
+            const poolsRaw = collectRows(poolListRes?.data ?? poolListRes);
+            const symbolsRaw = collectRows(symbolsRes?.data ?? symbolsRes);
+            const symbolMap = new Map(symbolsRaw
+                .filter((row) => row?.poolId || row?.pool_id)
+                .map((s) => [String(s.poolId ?? s.pool_id).toLowerCase(), s]));
+            const deduped = new Map();
+            for (const row of poolsRaw) {
+                const poolId = String(row?.poolId ?? row?.pool_id ?? "").trim().toLowerCase();
+                if (!poolId)
+                    continue;
+                if (!deduped.has(poolId)) {
+                    deduped.set(poolId, row);
+                }
+            }
+            const enriched = Array.from(deduped.values()).map(pool => {
+                const poolId = String(pool.poolId ?? pool.pool_id ?? "").toLowerCase();
+                const symbolData = symbolMap.get(poolId);
+                return {
+                    ...pool,
+                    icon: symbolData?.icon || null,
+                    symbolName: symbolData?.symbolName || pool.symbolName || pool.baseQuoteSymbol || pool.symbol || null,
+                };
+            });
+            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: enriched }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+        }
+    },
+};

package/dist/tools/manageLiquidity.js

@@ -47,7 +47,7 @@ function resolveLpAssetNames(detail) {
 }
 export const manageLiquidityTool = {
     name: "manage_liquidity",
-    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.",
+    description: "[LIQUIDITY] 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.coerce.string().describe("'deposit' or 'withdraw' (aliases: add/remove/increase/decrease; case-insensitive)"),
         poolType: z.enum(["BASE", "QUOTE"]).describe("'BASE' or 'QUOTE'"),
@@ -79,7 +79,7 @@ export const manageLiquidityTool = {
             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.`);
+                    `Please query a valid active pool via find_pool/list_pools first.`);
             }
             let raw;
             if (poolType === "QUOTE") {
@@ -93,7 +93,7 @@ export const manageLiquidityTool = {
                     : 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.`);
+                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 get_pool_metadata.`);
             }
             if (raw && typeof raw === "object" && "code" in raw && Number(raw.code) !== 0) {
                 throw new Error(`Liquidity ${action} failed: ${extractErrorMessage(raw)}`);
@@ -127,7 +127,7 @@ export const manageLiquidityTool = {
 };
 export const getLpPriceTool = {
     name: "get_lp_price",
-    description: "Get the current internal net asset value (NAV) price of an LP token for a BASE or QUOTE pool. Note: This is NOT the underlying token's external Oracle market price (e.g. WETH's price), but rather the internal exchange rate / net worth of the LP token itself which fluctuates based on pool PnL and fees.",
+    description: "[LIQUIDITY] Get the current internal net asset value (NAV) price of an LP token for a BASE or QUOTE pool. Note: This is NOT the underlying token's external Oracle market price (e.g. WETH's price), but rather the internal exchange rate / net worth of the LP token itself which fluctuates based on pool PnL and fees.",
     schema: {
         poolType: z.enum(["BASE", "QUOTE"]).describe("'BASE' or 'QUOTE'"),
         poolId: z.string().describe("Pool ID"),