@michaleffffff/mcp-trading-server 3.0.3 → 3.0.5

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

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { resolveClient, getChainId } from "../auth/resolveClient.js";
 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"),

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,9 +47,9 @@ 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.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"),
@@ -62,6 +62,11 @@ export const manageLiquidityTool = {
             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";
@@ -74,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") {
@@ -88,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)}`);
@@ -122,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"),

package/dist/tools/manageTpSl.js

@@ -0,0 +1,163 @@
+import { z } from "zod";
+import { resolveClient, getChainId } from "../auth/resolveClient.js";
+import { finalizeMutationResult } from "../utils/mutationResult.js";
+function normalizeDirectionInput(value) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    if (typeof value === "number") {
+        if (value === 0 || value === 1)
+            return value;
+        throw new Error("direction must be LONG/SHORT or 0/1.");
+    }
+    const text = String(value).trim().toUpperCase();
+    if (text === "0" || text === "LONG" || text === "BUY")
+        return 0;
+    if (text === "1" || text === "SHORT" || text === "SELL")
+        return 1;
+    throw new Error("direction must be LONG/SHORT or 0/1.");
+}
+function isNonEmpty(value) {
+    return value !== undefined && value !== null && String(value).trim().length > 0;
+}
+function readSnapshotText(snapshot, keys) {
+    for (const key of keys) {
+        const value = snapshot?.[key];
+        if (isNonEmpty(value))
+            return String(value).trim();
+    }
+    return "";
+}
+function normalizeUnitsInput(text) {
+    const raw = String(text ?? "").trim();
+    if (!raw)
+        return "";
+    if (/^(raw|human):/i.test(raw))
+        return raw;
+    if (/^\d+$/.test(raw))
+        return `raw:${raw}`;
+    return raw;
+}
+async function findOrderSnapshot(client, address, chainId, orderId, poolId) {
+    const target = String(orderId).toLowerCase();
+    try {
+        const openRes = await client.order.getOrders(address);
+        const openOrders = Array.isArray(openRes?.data) ? openRes.data : [];
+        const found = openOrders.find((order) => String(order?.orderId ?? order?.id ?? "").toLowerCase() === target);
+        if (found)
+            return found;
+    }
+    catch {
+    }
+    try {
+        const historyQuery = { chainId, limit: 50, page: 1 };
+        if (poolId)
+            historyQuery.poolId = poolId;
+        const historyRes = await client.order.getOrderHistory(historyQuery, address);
+        const historyOrders = Array.isArray(historyRes?.data) ? historyRes.data : [];
+        return historyOrders.find((order) => String(order?.orderId ?? order?.id ?? "").toLowerCase() === target) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export const manageTpSlTool = {
+    name: "manage_tp_sl",
+    description: "[TRADE] Set or update Take Profit (TP) and Stop Loss (SL) for a position.",
+    schema: {
+        poolId: z.string().describe("Pool ID"),
+        positionId: z.string().optional().describe("Position ID (required for creating TP/SL on a position)"),
+        orderId: z.string().optional().describe("Existing TP/SL Order ID to update (optional)"),
+        size: z.union([z.string(), z.number()]).optional().describe("Order size (required for update if cannot be auto-resolved from order snapshot)"),
+        price: z.union([z.string(), z.number()]).optional().describe("Order price (required for update if cannot be auto-resolved from order snapshot)"),
+        tpPrice: z.union([z.string(), z.number()]).optional().describe("New TP price"),
+        tpSize: z.union([z.string(), z.number()]).optional().describe("New TP size"),
+        slPrice: z.union([z.string(), z.number()]).optional().describe("New SL price"),
+        slSize: z.union([z.string(), z.number()]).optional().describe("New SL size"),
+        direction: z.union([z.enum(["LONG", "SHORT"]), z.number().int()]).optional().describe("Position direction (LONG/SHORT or 0/1; required for new TP/SL)"),
+        leverage: z.number().optional().describe("Position leverage"),
+        executionFeeToken: z.string().optional().describe("Fee token address"),
+        slippagePct: z.union([z.string(), z.number()]).optional().describe("Slippage in 4dp raw units. Default 100 (1%)."),
+        useOrderCollateral: z.boolean().optional().describe("Whether updateOrderTpSl should use order collateral (default true)."),
+        chainId: z.number().int().positive().optional().describe("Optional chainId override"),
+    },
+    handler: async (args) => {
+        try {
+            const { client, address, signer } = await resolveClient();
+            const chainId = args.chainId ?? getChainId();
+            const direction = normalizeDirectionInput(args.direction);
+            const slippagePct = args.slippagePct ?? "100";
+            const { setPositionTpSl, updateOrderTpSl } = await import("../services/tradeService.js");
+            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"]);
+                const snapshotTpPrice = readSnapshotText(orderSnapshot, ["tpPrice", "takeProfitPrice", "tpTriggerPrice"]);
+                const snapshotTpSize = readSnapshotText(orderSnapshot, ["tpSize", "takeProfitSize"]);
+                const snapshotSlPrice = readSnapshotText(orderSnapshot, ["slPrice", "stopLossPrice", "slTriggerPrice"]);
+                const snapshotSlSize = readSnapshotText(orderSnapshot, ["slSize", "stopLossSize"]);
+                const size = isNonEmpty(args.size) ? String(args.size) : snapshotSize;
+                const price = isNonEmpty(args.price) ? String(args.price) : snapshotPrice;
+                const tpPrice = isNonEmpty(args.tpPrice) ? String(args.tpPrice) : snapshotTpPrice;
+                const tpSize = isNonEmpty(args.tpSize) ? String(args.tpSize) : snapshotTpSize;
+                const slPrice = isNonEmpty(args.slPrice) ? String(args.slPrice) : snapshotSlPrice;
+                const slSize = isNonEmpty(args.slSize) ? String(args.slSize) : snapshotSlSize;
+                if (!size || !price) {
+                    throw new Error("size and price are required for update. Provide them explicitly, or ensure orderId can be found via get_orders so they can be auto-resolved.");
+                }
+                if (!tpPrice && !slPrice) {
+                    throw new Error("At least one of tpPrice or slPrice is required when updating TP/SL.");
+                }
+                if ((tpPrice && !tpSize) || (!tpPrice && tpSize)) {
+                    throw new Error("TP update requires both tpPrice and tpSize (or resolvable existing TP fields).");
+                }
+                if ((slPrice && !slSize) || (!slPrice && slSize)) {
+                    throw new Error("SL update requires both slPrice and slSize (or resolvable existing SL fields).");
+                }
+                raw = await updateOrderTpSl(client, address, {
+                    orderId: args.orderId,
+                    marketId: market.marketId,
+                    poolId: args.poolId,
+                    size: normalizeUnitsInput(size),
+                    price: normalizeUnitsInput(price),
+                    tpPrice: tpPrice ? normalizeUnitsInput(tpPrice) : "0",
+                    tpSize: tpSize ? normalizeUnitsInput(tpSize) : "0",
+                    slPrice: slPrice ? normalizeUnitsInput(slPrice) : "0",
+                    slSize: slSize ? normalizeUnitsInput(slSize) : "0",
+                    quoteToken: market.quoteToken,
+                    useOrderCollateral: args.useOrderCollateral ?? true
+                }, chainId);
+            }
+            else {
+                // Create new
+                if (direction === undefined || !args.leverage) {
+                    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.");
+                }
+                raw = await setPositionTpSl(client, address, {
+                    poolId: args.poolId,
+                    positionId: args.positionId,
+                    direction,
+                    leverage: args.leverage,
+                    executionFeeToken: args.executionFeeToken,
+                    slippagePct,
+                    tpPrice: args.tpPrice,
+                    tpSize: args.tpSize,
+                    slPrice: args.slPrice,
+                    slSize: args.slSize
+                }, chainId);
+            }
+            const data = await finalizeMutationResult(raw, signer, "manage_tp_sl");
+            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+        }
+    },
+};

package/dist/tools/openPositionSimple.js

@@ -35,7 +35,7 @@ function pickMarketDetail(res) {
 }
 export const openPositionSimpleTool = {
     name: "open_position_simple",
-    description: "High-level open position helper. Computes size/price/tradingFee and submits an increase order. Human units by default; use 'raw:' prefix for raw units.",
+    description: "[TRADE] High-level open position helper. Computes size/price/tradingFee and submits an increase order. Human units by default; use 'raw:' prefix for raw units.",
     schema: {
         poolId: z.string().optional().describe("Hex Pool ID. Provide either poolId or keyword."),
         keyword: z.string().optional().describe('Recommended: Market keyword, e.g. "BTC", "ETH", "XRP".'),
@@ -56,7 +56,7 @@ export const openPositionSimpleTool = {
         slippagePct: z.coerce
             .string()
             .optional()
-            .describe(`${SLIPPAGE_PCT_4DP_DESC} Default 100 (=1%).`),
+            .describe(`${SLIPPAGE_PCT_4DP_DESC} Default 50 (=0.5%).`),
         postOnly: z.coerce.boolean().optional().describe("Post-only (default false)."),
         executionFeeToken: z.string().optional().describe("Execution fee token address (default quoteToken)."),
         assetClass: z.coerce.number().int().nonnegative().optional().describe("Fee query assetClass (default 1)."),
@@ -65,6 +65,10 @@ export const openPositionSimpleTool = {
             .string()
             .optional()
             .describe("Trading fee. e.g. '0.2' USDC or 'raw:...'. Default: computed via getUserTradingFeeRate."),
+        tpPrice: z.coerce.string().optional().describe("Take Profit trigger price."),
+        tpSize: z.coerce.string().optional().describe("Take Profit size (base units). If omitted but tpPrice set, uses full position size."),
+        slPrice: z.coerce.string().optional().describe("Stop Loss trigger price."),
+        slSize: z.coerce.string().optional().describe("Stop Loss size (base units). If omitted but slPrice set, uses full position size."),
         autoApprove: z.coerce.boolean().optional().describe("If true, auto-approve token spend (default false)."),
         approveMax: z.coerce.boolean().optional().describe("If autoApprove, approve MaxUint256 (default false)."),
         autoDeposit: z.coerce
@@ -118,7 +122,7 @@ export const openPositionSimpleTool = {
             }
             const orderType = mapOrderType(args.orderType ?? 0);
             const postOnly = Boolean(args.postOnly ?? false);
-            const slippagePct = normalizeSlippagePct4dp(args.slippagePct ?? "100");
+            const slippagePct = normalizeSlippagePct4dp(args.slippagePct ?? "50");
             const executionFeeToken = normalizeAddress(args.executionFeeToken || quoteToken, "executionFeeToken");
             // 4) Determine reference price (30 decimals)
             let price30;
@@ -222,6 +226,10 @@ export const openPositionSimpleTool = {
                 autoDeposit: Boolean(args.autoDeposit ?? false),
                 priceMeta,
                 sizeMeta,
+                tpPrice: args.tpPrice ? parseUserPrice30(args.tpPrice, "tpPrice") : null,
+                tpSize: args.tpSize ? parseUserUnits(args.tpSize, baseDecimals, "tpSize") : (args.tpPrice ? sizeRaw : null),
+                slPrice: args.slPrice ? parseUserPrice30(args.slPrice, "slPrice") : null,
+                slSize: args.slSize ? parseUserUnits(args.slSize, baseDecimals, "slSize") : (args.slPrice ? sizeRaw : null),
             };
             if (args.dryRun) {
                 return {
@@ -254,7 +262,7 @@ export const openPositionSimpleTool = {
                 }
             }
             // 8) Submit increase order using existing trade service
-            const raw = await openPosition(client, address, {
+            const openArgs = {
                 poolId,
                 positionId: "",
                 orderType,
@@ -271,7 +279,16 @@ export const openPositionSimpleTool = {
                 tradingFee: `raw:${String(tradingFeeRaw)}`,
                 marketId,
                 autoDeposit: Boolean(args.autoDeposit ?? false),
-            });
+            };
+            if (prep.tpPrice) {
+                openArgs.tpPrice = `raw:${prep.tpPrice}`;
+                openArgs.tpSize = `raw:${prep.tpSize}`;
+            }
+            if (prep.slPrice) {
+                openArgs.slPrice = `raw:${prep.slPrice}`;
+                openArgs.slSize = `raw:${prep.slSize}`;
+            }
+            const raw = await openPosition(client, address, openArgs);
             const data = await finalizeMutationResult(raw, signer, "open_position_simple");
             const txHash = data.confirmation?.txHash;
             const verification = txHash ? await verifyTradeOutcome(client, address, poolId, txHash) : null;

package/dist/tools/searchTools.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import * as allTools from "./index.js";
+export const searchToolsTool = {
+    name: "search_tools",
+    description: "[UTILS] Search for available tools by keyword in their name or description.",
+    schema: {
+        keyword: z.string().describe("Keyword to search for in tool names or descriptions."),
+    },
+    handler: async (args) => {
+        try {
+            const keyword = args.keyword.toLowerCase();
+            const tools = Object.values(allTools);
+            const matches = tools
+                .filter(t => (t.name && t.name.toLowerCase().includes(keyword)) ||
+                (t.description && t.description.toLowerCase().includes(keyword)))
+                .map(t => ({
+                name: t.name,
+                description: t.description,
+                // We only return name and description to keep it concise
+            }));
+            if (matches.length === 0) {
+                return { content: [{ type: "text", text: `No tools found matching: ${args.keyword}` }] };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ status: "success", count: matches.length, tools: matches }, null, 2)
+                    }]
+            };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+        }
+    },
+};

package/dist/utils/mappings.js

@@ -50,13 +50,16 @@ export const getHistoryOrderStatusDesc = (status) => {
  * MarketPoolState
  */
 export const getMarketStateDesc = (state) => {
-    switch (state) {
-        case 0: return "Created";
-        case 1: return "WaitOracle";
-        case 2: return "Active";
-        case 3: return "PreDelisting";
-        case 4: return "Delisted";
-        default: return `Unknown(${state})`;
+    if (state === undefined || state === null || state === "")
+        return "Unknown";
+    const s = Number(state);
+    switch (s) {
+        case 0: return "Created (Pending Setup)";
+        case 1: return "WaitOracle (Waiting for Price)";
+        case 2: return "Active (Tradable)";
+        case 3: return "PreDelisting (Closing Only)";
+        case 4: return "Delisted (Closed)";
+        default: return `Other(${s})`;
     }
 };
 /**

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.3",
+  "version": "3.0.5",
   "type": "module",
   "bin": {
     "myx-mcp": "dist/server.js"