@michaleffffff/mcp-trading-server 2.9.9 → 3.0.1

package/dist/server.js

@@ -4,13 +4,14 @@ import "dotenv/config";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { z } from "zod";
+import { ZodError, z } from "zod";
 // Tools & Modules
 import * as baseTools from "./tools/index.js";
 import * as baseResources from "./resources/index.js";
 import * as basePrompts from "./prompts/index.js";
 import { logger } from "./utils/logger.js";
 import { MCPError, ErrorCode } from "./utils/errors.js";
+import { extractErrorMessage, isMeaningfulErrorMessage } from "./utils/errorMessage.js";
 // --- Process Logic Protection ---
 // Catch unhandled promise rejections
 process.on('unhandledRejection', (reason, promise) => {
@@ -33,6 +34,176 @@ process.on('SIGTERM', shutdown);
 const allTools = Object.values(baseTools);
 const allResources = Object.values(baseResources);
 const allPrompts = Object.values(basePrompts);
+function safeJsonStringify(value) {
+    return JSON.stringify(value, (_, item) => (typeof item === "bigint" ? item.toString() : item), 2);
+}
+function inferToolErrorCode(message) {
+    const lower = message.toLowerCase();
+    if (lower.includes("required") || lower.includes("invalid") || lower.includes("must be") || lower.includes("unexpected") || lower.includes("unrecognized")) {
+        return "INVALID_PARAM";
+    }
+    if (lower.includes("insufficient") && (lower.includes("allowance") || lower.includes("approval"))) {
+        return "INSUFFICIENT_ALLOWANCE";
+    }
+    if (lower.includes("insufficient") || lower.includes("not enough balance") || lower.includes("insufficientbalance")) {
+        return "INSUFFICIENT_BALANCE";
+    }
+    if (lower.includes("not found") || lower.includes("unknown tool")) {
+        return "NOT_FOUND";
+    }
+    if (lower.includes("timeout") || lower.includes("not confirmed")) {
+        return "TIMEOUT";
+    }
+    if (lower.includes("network") || lower.includes("rpc")) {
+        return "NETWORK_ERROR";
+    }
+    return "TOOL_EXECUTION_ERROR";
+}
+function defaultHintForErrorCode(code, toolName) {
+    if (code === "INVALID_PARAM") {
+        return `Check required fields/types for "${toolName}" and retry.`;
+    }
+    if (code === "INSUFFICIENT_ALLOWANCE") {
+        return `Run "check_approval" before retrying "${toolName}".`;
+    }
+    if (code === "INSUFFICIENT_BALANCE") {
+        return "Top up wallet/trading-account balance or reduce order size.";
+    }
+    if (code === "NOT_FOUND") {
+        return "Verify identifiers (poolId/orderId/marketId) and retry.";
+    }
+    if (code === "TIMEOUT") {
+        return "Query order/position status first, then retry only if needed.";
+    }
+    if (code === "NETWORK_ERROR") {
+        return "Check RPC/network health and retry.";
+    }
+    return `Check prerequisites for "${toolName}" and retry.`;
+}
+function errorResult(payload) {
+    const body = {
+        status: "error",
+        error: {
+            tool: payload.tool,
+            code: payload.code,
+            message: payload.message,
+            hint: payload.hint,
+            action: payload.action,
+            details: payload.details,
+        },
+    };
+    return {
+        content: [{ type: "text", text: safeJsonStringify(body) }],
+        isError: true,
+    };
+}
+function parseFirstText(result) {
+    if (!result || !Array.isArray(result.content))
+        return null;
+    const firstText = result.content.find((item) => item?.type === "text" && typeof item.text === "string");
+    return firstText?.text ?? null;
+}
+function normalizeToolErrorResult(toolName, result) {
+    const rawText = parseFirstText(result);
+    if (!rawText) {
+        return errorResult({
+            tool: toolName,
+            code: "TOOL_EXECUTION_ERROR",
+            message: `Tool "${toolName}" returned an empty error.`,
+            hint: defaultHintForErrorCode("TOOL_EXECUTION_ERROR", toolName),
+            action: "Inspect server logs for details.",
+        });
+    }
+    let parsed = null;
+    try {
+        parsed = JSON.parse(rawText);
+    }
+    catch {
+        parsed = null;
+    }
+    if (parsed &&
+        parsed.status === "error" &&
+        parsed.error &&
+        typeof parsed.error.code === "string" &&
+        isMeaningfulErrorMessage(parsed.error.message)) {
+        return result;
+    }
+    const plainMessage = extractErrorMessage(typeof parsed?.error?.message === "string"
+        ? parsed.error.message
+        : typeof parsed?.message === "string"
+            ? parsed.message
+            : rawText.replace(/^Error:\s*/i, "").trim(), `Tool "${toolName}" failed.`);
+    const code = typeof parsed?.error?.code === "string"
+        ? parsed.error.code
+        : inferToolErrorCode(plainMessage);
+    return errorResult({
+        tool: toolName,
+        code,
+        message: plainMessage,
+        hint: defaultHintForErrorCode(code, toolName),
+        action: "Adjust parameters/prerequisites and retry.",
+    });
+}
+function validationErrorResult(toolName, error) {
+    const issues = error.issues.map((issue) => {
+        const pathValue = issue.path.length > 0 ? issue.path.map(String).join(".") : "input";
+        return {
+            field: pathValue,
+            code: issue.code,
+            message: issue.message,
+        };
+    });
+    const firstIssue = issues[0];
+    const firstHint = firstIssue
+        ? `Fix "${firstIssue.field}": ${firstIssue.message}`
+        : `Check input schema for "${toolName}".`;
+    return errorResult({
+        tool: toolName,
+        code: "INVALID_PARAM",
+        message: `Invalid arguments for tool "${toolName}".`,
+        hint: firstHint,
+        action: "Call list_tools and resend valid arguments.",
+        details: { issues },
+    });
+}
+function normalizeSdkReadFailure(toolName, result) {
+    const rawText = parseFirstText(result);
+    if (!rawText)
+        return result;
+    let parsed = null;
+    try {
+        parsed = JSON.parse(rawText);
+    }
+    catch {
+        return result;
+    }
+    if (!parsed || parsed.status !== "success")
+        return result;
+    const data = parsed.data;
+    const hasCode = !!data && typeof data === "object" && !Array.isArray(data) && Object.prototype.hasOwnProperty.call(data, "code");
+    if (!hasCode)
+        return result;
+    const code = Number(data.code);
+    if (!Number.isFinite(code) || code === 0)
+        return result;
+    const sdkPayload = data.data;
+    const hasPayload = sdkPayload !== null &&
+        sdkPayload !== undefined &&
+        (!Array.isArray(sdkPayload) || sdkPayload.length > 0);
+    if (code > 0 && hasPayload) {
+        // Some SDK APIs return non-zero positive codes with usable payloads.
+        return result;
+    }
+    const sdkMessage = String(data.msg ?? data.message ?? `SDK read failed with code=${code}.`);
+    return errorResult({
+        tool: toolName,
+        code: "SDK_READ_ERROR",
+        message: `${toolName} failed: code=${code}, msg=${sdkMessage}`,
+        hint: "Check chain/account context and required params, then retry.",
+        action: "Retry or call prerequisite tools to refresh context.",
+        details: { sdk: data },
+    });
+}
 // 将 Zod schema 转换为 JSON Schema (tool listing 用)
 function zodSchemaToJsonSchema(zodSchema) {
     const toPropSchema = (value) => {
@@ -81,7 +252,7 @@ function zodSchemaToJsonSchema(zodSchema) {
     };
 }
 // ─── MCP Server ───
-const server = new Server({ name: "myx-mcp-trading-server", version: "2.9.9" }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
+const server = new Server({ name: "myx-mcp-trading-server", version: "3.0.1" }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
 // List tools
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
@@ -97,30 +268,50 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     const tool = allTools.find((t) => t.name === name);
     if (!tool) {
-        return {
-            content: [{ type: "text", text: `Error: Unknown tool "${name}"` }],
-            isError: true,
-        };
+        return errorResult({
+            tool: name,
+            code: "NOT_FOUND",
+            message: `Unknown tool "${name}".`,
+            hint: "Use list_tools to discover available tool names.",
+            action: "Retry with a valid tool name.",
+        });
     }
     try {
         let validatedArgs = args ?? {};
         if (tool.schema) {
-            validatedArgs = z.object(tool.schema).strict().parse(args ?? {});
+            try {
+                validatedArgs = z.object(tool.schema).strict().parse(args ?? {});
+            }
+            catch (validationError) {
+                if (validationError instanceof ZodError) {
+                    return validationErrorResult(name, validationError);
+                }
+                throw validationError;
+            }
         }
         logger.toolExecution(name, validatedArgs);
         const result = await tool.handler(validatedArgs);
-        if (result && result.content)
-            return result;
+        if (result?.isError) {
+            return normalizeToolErrorResult(name, result);
+        }
+        if (result && result.content) {
+            return normalizeSdkReadFailure(name, result);
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify({ status: "success", data: result }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }],
+            content: [{ type: "text", text: safeJsonStringify({ status: "success", data: result }) }],
         };
     }
     catch (error) {
         logger.error(`Error executing tool: ${name}`, error);
-        return {
-            content: [{ type: "text", text: `Error: ${error.message}` }],
-            isError: true,
-        };
+        const message = extractErrorMessage(error);
+        const code = inferToolErrorCode(message);
+        return errorResult({
+            tool: name,
+            code,
+            message,
+            hint: defaultHintForErrorCode(code, name),
+            action: "Fix inputs/prerequisites and retry.",
+        });
     }
 });
 // Resources Handlers
@@ -181,7 +372,7 @@ server.setRequestHandler(GetPromptRequestSchema, async (request) => {
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    logger.info("🚀 MYX Trading MCP Server v2.9.9 running (stdio, pure on-chain, prod ready)");
+    logger.info("🚀 MYX Trading MCP Server v3.0.1 running (stdio, pure on-chain, prod ready)");
 }
 main().catch((err) => {
     logger.error("Fatal Server Startup Error", err);

package/dist/services/marketService.js

@@ -1,5 +1,65 @@
 import { getChainId } from "../auth/resolveClient.js";
 import { getMarketStateDesc } from "../utils/mappings.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);
+}
+function extractMarketRows(raw, chainId) {
+    if (raw?.contractInfo && Array.isArray(raw.contractInfo.list)) {
+        return raw.contractInfo.list;
+    }
+    if (Array.isArray(raw?.data)) {
+        return raw.data;
+    }
+    if (raw?.data && Array.isArray(raw.data[chainId])) {
+        return raw.data[chainId];
+    }
+    if (Array.isArray(raw)) {
+        return raw;
+    }
+    return collectRows(raw?.data ?? raw);
+}
+function normalizeMarketState(value) {
+    if (value === undefined || value === null || value === "")
+        return null;
+    const casted = Number(value);
+    return Number.isFinite(casted) ? casted : null;
+}
+function normalizePoolId(row) {
+    const poolId = row?.poolId ?? row?.pool_id ?? "";
+    return String(poolId);
+}
+function matchesKeyword(row, keywordUpper) {
+    const poolId = normalizePoolId(row);
+    const haystack = [
+        row?.baseSymbol,
+        row?.quoteSymbol,
+        row?.baseQuoteSymbol,
+        row?.symbolName,
+        row?.name,
+        poolId,
+        row?.baseToken,
+        row?.quoteToken,
+        row?.marketId,
+    ]
+        .map((value) => String(value ?? "").toUpperCase())
+        .join("|");
+    return haystack.includes(keywordUpper);
+}
+async function fetchApiMarketRows(client) {
+    const marketListRes = await client.api.getMarketList().catch(() => null);
+    const marketRows = extractMarketRows(marketListRes, getChainId());
+    const marketRowsWithPoolId = marketRows.filter((row) => normalizePoolId(row));
+    if (marketRowsWithPoolId.length > 0)
+        return marketRowsWithPoolId;
+    const poolListRes = await client.api.getPoolList().catch(() => null);
+    return collectRows(poolListRes?.data ?? poolListRes);
+}
 export async function getMarketPrice(client, poolId, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
     const tickerRes = await client.markets.getTickerList({
@@ -15,28 +75,45 @@ export async function getOraclePrice(client, poolId, chainIdOverride) {
 }
 export async function searchMarket(client, keyword, limit = 1000) {
     const chainId = getChainId();
-    const searchRes = await client.markets.searchMarket({ chainId, keyword, limit });
-    const raw = searchRes;
+    const normalizedKeyword = String(keyword ?? "").trim();
+    const requestedLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 1000;
     let dataList = [];
-    if (raw && raw.contractInfo && Array.isArray(raw.contractInfo.list)) {
-        dataList = raw.contractInfo.list;
+    try {
+        const searchRes = await client.markets.searchMarket({ chainId, keyword: normalizedKeyword, limit: requestedLimit });
+        dataList = extractMarketRows(searchRes, chainId);
     }
-    else if (raw && Array.isArray(raw.data)) {
-        dataList = raw.data;
+    catch {
+        dataList = [];
     }
-    else if (raw && raw.data && Array.isArray(raw.data[chainId])) {
-        dataList = raw.data[chainId];
+    if (dataList.length === 0 || normalizedKeyword.length === 0) {
+        const fallbackRows = await fetchApiMarketRows(client);
+        if (fallbackRows.length > 0) {
+            dataList = fallbackRows;
+        }
     }
-    else if (raw && Array.isArray(raw)) {
-        dataList = raw;
+    const filteredRows = normalizedKeyword
+        ? dataList.filter((row) => matchesKeyword(row, normalizedKeyword.toUpperCase()))
+        : dataList;
+    const dedupedByPoolId = new Map();
+    for (const row of filteredRows) {
+        const poolId = normalizePoolId(row);
+        if (!poolId)
+            continue;
+        if (!dedupedByPoolId.has(poolId)) {
+            dedupedByPoolId.set(poolId, row);
+        }
     }
-    // Filter tradable markets (state=2 => Active)
-    const activeMarkets = dataList.filter(m => Number(m.state) === 2);
+    const activeMarkets = Array.from(dedupedByPoolId.values())
+        .filter((row) => {
+        const state = normalizeMarketState(row?.state ?? row?.poolState);
+        return state === null || state === 2;
+    })
+        .slice(0, requestedLimit);
     // Get tickers for these pools to get price and change24h
     let tickers = [];
     if (activeMarkets.length > 0) {
         try {
-            const poolIds = activeMarkets.map(m => m.poolId);
+            const poolIds = activeMarkets.map((market) => normalizePoolId(market));
             const tickerRes = await client.markets.getTickerList({ chainId, poolIds });
             tickers = Array.isArray(tickerRes) ? tickerRes : (tickerRes?.data || []);
         }
@@ -44,17 +121,20 @@ export async function searchMarket(client, keyword, limit = 1000) {
             console.error("Failed to fetch tickers:", e);
         }
     }
-    return activeMarkets.map(m => {
-        const ticker = tickers.find(t => String(t.poolId).toLowerCase() === String(m.poolId).toLowerCase());
+    return activeMarkets.map((market) => {
+        const poolId = normalizePoolId(market);
+        const state = normalizeMarketState(market?.state ?? market?.poolState);
+        const ticker = tickers.find((t) => String(t.poolId).toLowerCase() === poolId.toLowerCase());
+        const symbol = market?.baseQuoteSymbol || [market?.baseSymbol, market?.quoteSymbol].filter(Boolean).join("/");
         return {
-            symbol: m.baseQuoteSymbol || `${m.baseSymbol}/${m.quoteSymbol}`,
-            name: m.symbolName || m.name,
-            poolId: m.poolId,
+            symbol: symbol || market?.symbolName || poolId,
+            name: market?.symbolName || market?.name || symbol || poolId,
+            poolId,
             price: ticker ? ticker.price : "0",
             change24h: ticker ? ticker.change : "0",
-            tvl: m.tvl || "0",
-            state: m.state,
-            stateDescription: getMarketStateDesc(m.state)
+            tvl: market?.tvl || "0",
+            state: state ?? "unknown",
+            stateDescription: state === null ? "Unknown" : getMarketStateDesc(state)
         };
     });
 }

package/dist/services/poolService.js

@@ -1,5 +1,24 @@
 import { pool, quote, base } from "@myx-trade/sdk";
 import { getChainId, resolveClient } from "../auth/resolveClient.js";
+import { extractErrorMessage } from "../utils/errorMessage.js";
+import { ensureUnits } from "../utils/units.js";
+function isDivideByZeroError(message) {
+    const lower = message.toLowerCase();
+    return (lower.includes("divide_by_zero") ||
+        lower.includes("division by zero") ||
+        lower.includes("panic code 0x12") ||
+        lower.includes("panic code: 0x12") ||
+        lower.includes("0x4e487b71"));
+}
+function toPositiveBigint(input) {
+    try {
+        const value = BigInt(String(input ?? "").trim());
+        return value > 0n ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * 创建合约市场池子
  */
@@ -11,9 +30,64 @@ export async function createPool(baseToken, marketId) {
 /**
  * 获取池子信息
  */
-export async function getPoolInfo(poolId, chainIdOverride) {
+export async function getPoolInfo(poolId, chainIdOverride, clientOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    return pool.getPoolInfo(chainId, poolId);
+    let needOracleFallback = false;
+    try {
+        const direct = await pool.getPoolInfo(chainId, poolId);
+        if (direct)
+            return direct;
+        needOracleFallback = true;
+    }
+    catch (error) {
+        const message = extractErrorMessage(error);
+        if (!isDivideByZeroError(message)) {
+            throw new Error(`get_pool_info failed: ${message}`);
+        }
+        needOracleFallback = true;
+    }
+    if (!needOracleFallback)
+        return undefined;
+    const client = clientOverride ?? (await resolveClient()).client;
+    if (!client?.utils?.getOraclePrice) {
+        throw new Error("get_pool_info failed and oracle fallback is unavailable (client.utils.getOraclePrice missing).");
+    }
+    let oracleRaw = 0n;
+    try {
+        const oracle = await client.utils.getOraclePrice(poolId, chainId);
+        const byValue = toPositiveBigint(oracle?.value);
+        const byPrice = toPositiveBigint(oracle?.price);
+        oracleRaw = byValue ?? byPrice ?? 0n;
+    }
+    catch (error) {
+        throw new Error(`get_pool_info fallback failed to fetch oracle price: ${extractErrorMessage(error)}`);
+    }
+    if (oracleRaw <= 0n) {
+        try {
+            const tickerRes = await client.markets.getTickerList({ chainId, poolIds: [poolId] });
+            const row = Array.isArray(tickerRes) ? tickerRes[0] : tickerRes?.data?.[0];
+            if (row?.price) {
+                const tickerRaw = ensureUnits(row.price, 30, "ticker price");
+                const byTicker = toPositiveBigint(tickerRaw);
+                oracleRaw = byTicker ?? 0n;
+            }
+        }
+        catch {
+        }
+    }
+    if (oracleRaw <= 0n) {
+        throw new Error("get_pool_info fallback requires a positive oracle/ticker price, but both resolved to 0.");
+    }
+    try {
+        const retried = await pool.getPoolInfo(chainId, poolId, oracleRaw);
+        if (!retried) {
+            throw new Error(`Pool info for ${poolId} returned undefined after oracle-price retry.`);
+        }
+        return retried;
+    }
+    catch (error) {
+        throw new Error(`get_pool_info failed after oracle-price retry: ${extractErrorMessage(error)}`);
+    }
 }
 /**
  * 获取池子详情

package/dist/services/tradeService.js

@@ -1,9 +1,10 @@
 import { Direction, OrderType, TriggerType } from "@myx-trade/sdk";
-import { getChainId, getQuoteToken } from "../auth/resolveClient.js";
+import { getChainId, getQuoteToken, getQuoteDecimals } from "../auth/resolveClient.js";
 import { ensureUnits } from "../utils/units.js";
 import { normalizeAddress } from "../utils/address.js";
 import { normalizeSlippagePct4dp } from "../utils/slippage.js";
 import { finalizeMutationResult } from "../utils/mutationResult.js";
+import { extractErrorMessage } from "../utils/errorMessage.js";
 function resolveDirection(direction) {
     if (direction !== 0 && direction !== 1) {
         throw new Error("direction must be 0 (LONG) or 1 (SHORT).");
@@ -51,6 +52,74 @@ function resolveTpSlTriggerType(isTp, direction, triggerType) {
         return direction === 0 ? 2 : 1;
     }
 }
+function collectRows(input) {
+    if (Array.isArray(input))
+        return input.flatMap(collectRows);
+    if (!input || typeof input !== "object")
+        return [];
+    if (input.poolId || input.pool_id || input.marketId || input.market_id)
+        return [input];
+    return Object.values(input).flatMap(collectRows);
+}
+function parseDecimals(value, fallback) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed) && parsed >= 0) {
+        return Math.floor(parsed);
+    }
+    return fallback;
+}
+function normalizeIdentifier(value) {
+    return String(value ?? "").trim().toLowerCase();
+}
+async function resolveDecimalsForUpdateOrder(client, chainId, marketId, poolIdHint) {
+    let baseDecimals = 18;
+    let quoteDecimals = getQuoteDecimals();
+    let resolvedPoolId = String(poolIdHint ?? "").trim();
+    const hydrateFromPoolDetail = async (poolId) => {
+        if (!poolId)
+            return;
+        const detailRes = await client.markets.getMarketDetail({ chainId, poolId });
+        const detail = detailRes?.data || (detailRes?.marketId ? detailRes : null);
+        if (!detail)
+            return;
+        baseDecimals = parseDecimals(detail.baseDecimals, baseDecimals);
+        quoteDecimals = parseDecimals(detail.quoteDecimals, quoteDecimals);
+        resolvedPoolId = String(detail.poolId ?? poolId ?? resolvedPoolId);
+    };
+    if (resolvedPoolId) {
+        try {
+            await hydrateFromPoolDetail(resolvedPoolId);
+            return { baseDecimals, quoteDecimals, poolId: resolvedPoolId };
+        }
+        catch {
+            resolvedPoolId = "";
+        }
+    }
+    try {
+        const marketListRes = await client.api.getMarketList();
+        const rows = collectRows(marketListRes?.data ?? marketListRes);
+        const targetMarketId = normalizeIdentifier(marketId);
+        const row = rows.find((item) => normalizeIdentifier(item?.marketId ?? item?.market_id) === targetMarketId);
+        if (row) {
+            baseDecimals = parseDecimals(row?.baseDecimals ?? row?.base_decimals, baseDecimals);
+            quoteDecimals = parseDecimals(row?.quoteDecimals ?? row?.quote_decimals, quoteDecimals);
+            const fromRowPoolId = String(row?.poolId ?? row?.pool_id ?? "").trim();
+            if (fromRowPoolId) {
+                resolvedPoolId = fromRowPoolId;
+            }
+        }
+    }
+    catch {
+    }
+    if (resolvedPoolId) {
+        try {
+            await hydrateFromPoolDetail(resolvedPoolId);
+        }
+        catch {
+        }
+    }
+    return { baseDecimals, quoteDecimals, poolId: resolvedPoolId || undefined };
+}
 /**
  * 开仓 / 加仓
  */
@@ -249,9 +318,25 @@ export async function setPositionTpSl(client, address, args) {
 export async function adjustMargin(client, address, args) {
     const chainId = getChainId();
     const quoteToken = normalizeAddress(args.quoteToken || getQuoteToken(), "quoteToken");
-    const adjustAmount = String(args.adjustAmount ?? "").trim();
+    const adjustAmountInput = String(args.adjustAmount ?? "").trim();
+    if (!adjustAmountInput) {
+        throw new Error("adjustAmount is required.");
+    }
+    let quoteDecimals = getQuoteDecimals();
+    try {
+        const detailRes = await client.markets.getMarketDetail({ chainId, poolId: args.poolId });
+        const detail = detailRes?.data || (detailRes?.marketId ? detailRes : null);
+        const parsed = Number(detail?.quoteDecimals);
+        if (Number.isFinite(parsed) && parsed >= 0) {
+            quoteDecimals = parsed;
+        }
+    }
+    catch {
+        // Fallback to env quote decimals if market detail is unavailable.
+    }
+    const adjustAmount = ensureUnits(adjustAmountInput, quoteDecimals, "adjustAmount");
     if (!/^-?\d+$/.test(adjustAmount)) {
-        throw new Error("adjustAmount must be an integer string in quote token raw units.");
+        throw new Error("adjustAmount must resolve to an integer string (raw units).");
     }
     const params = {
         poolId: args.poolId,
@@ -319,16 +404,36 @@ export async function closeAllPositions(client, address) {
 export async function updateOrderTpSl(client, address, args) {
     const chainId = getChainId();
     const quoteToken = normalizeAddress(args.quoteToken, "quoteToken");
+    const marketId = String(args.marketId ?? "").trim();
+    const isTpSlOrder = typeof args.isTpSlOrder === "boolean" ? args.isTpSlOrder : true;
+    const { baseDecimals } = await resolveDecimalsForUpdateOrder(client, chainId, marketId, args.poolId);
     const params = {
         orderId: args.orderId,
-        tpSize: args.tpSize,
-        tpPrice: args.tpPrice,
-        slSize: args.slSize,
-        slPrice: args.slPrice,
-        useOrderCollateral: args.useOrderCollateral,
+        tpSize: ensureUnits(args.tpSize, baseDecimals, "tpSize"),
+        tpPrice: ensureUnits(args.tpPrice, 30, "tpPrice"),
+        slSize: ensureUnits(args.slSize, baseDecimals, "slSize"),
+        slPrice: ensureUnits(args.slPrice, 30, "slPrice"),
+        useOrderCollateral: Boolean(args.useOrderCollateral),
         executionFeeToken: quoteToken,
-        size: args.size,
-        price: args.price,
+        size: ensureUnits(args.size, baseDecimals, "size"),
+        price: ensureUnits(args.price, 30, "price"),
     };
-    return client.order.updateOrderTpSl(params, quoteToken, chainId, address, args.marketId, args.isTpSlOrder);
+    try {
+        const result = await client.order.updateOrderTpSl(params, quoteToken, chainId, address, marketId, isTpSlOrder);
+        if (Number(result?.code) === 0) {
+            return result;
+        }
+        const message = extractErrorMessage(result, "Failed to update order");
+        if (/failed to update order/i.test(message)) {
+            throw new Error(`Failed to update TP/SL for order ${args.orderId}. If this is a pending LIMIT/STOP order, wait for fill and then use set_tp_sl on the position.`);
+        }
+        throw new Error(`update_order_tp_sl failed: ${message}`);
+    }
+    catch (error) {
+        const message = extractErrorMessage(error, "Failed to update order");
+        if (/failed to update order/i.test(message)) {
+            throw new Error(`Failed to update TP/SL for order ${args.orderId}. If this is a pending LIMIT/STOP order, wait for fill and then use set_tp_sl on the position.`);
+        }
+        throw new Error(message);
+    }
 }