@michaleffffff/mcp-trading-server 3.0.7 → 3.0.10

package/CHANGELOG.md

@@ -1,5 +1,56 @@
 # Changelog
 
+## 3.0.10 - 2026-03-18
+
+### Fixed
+- Hardened `manage_tp_sl` delete behavior (`tpPrice=0` + `slPrice=0`):
+  - Added a unified cancellation path helper to always map delete intent to `cancelAllOrders` (by `orderId` or by `positionId`).
+  - Added fallback recovery for SDK/contract `InvalidParameter` reverts (including selector `0x613970e0`) so zero-price delete intent will still downgrade to explicit cancellation instead of failing.
+
+## 3.0.9 - 2026-03-18
+
+### Fixed
+- Fixed `create_perp_market` observability and compatibility:
+  - Added strict `marketId` (66-char hash) and `baseToken` address validation.
+  - Added structured error payloads with decoded contract selector hints (e.g. `PoolExists(PoolId)`).
+  - Added fallback for SDK v1.0.2 write-path incompatibility (`deployPool is not a function`) by directly calling `PoolManager.deployPool`.
+- Fixed `manage_tp_sl` delete semantics:
+  - `tpPrice=0` + `slPrice=0` now maps to explicit TP/SL order cancellation (by `orderId` or by `positionId`) instead of sending invalid on-chain TP/SL orders.
+- Fixed `get_base_detail` null-read behavior:
+  - `success + null` is now returned as a structured error (`NOT_FOUND`) with chain/base context.
+- Fixed `get_orders` OPEN status mapping:
+  - Removed `Unknown(undefined)` and normalized missing OPEN status to `Open`.
+- Fixed LP SDK wait incompatibility:
+  - Added submitted tx-hash recovery path when SDK returns `...wait is not a function` after broadcast (e.g., BASE withdraw).
+- Hardened direct LP router fallback:
+  - Added token allowance auto-approval before fallback deposit.
+
+### Verified (Real Funds, Arbitrum Sepolia 421614)
+- Deployed and minted new base token to active wallet:
+  - token: `0xDae49922Ff1699CA2A6cc4eE835B2c5a9f3Fe870`
+  - deploy tx: `0x99e69d66cac1b3a033281bae45dd421bba37794e1a80c1a12eddded99c48acce`
+- Created new perp pool for the token (marketId: `0x2a3fee38e8beba148141bea5cab0bcbbb0cf24fd5509117346991cc438cb2fe6`):
+  - create tx: `0x97266886c673cee13531837bcf9a0524034bd85a018036f3557c4d126fef3771`
+  - derived poolId: `0x6c1a8af5123a0cf636293aff3fce2ea6addd4bce172c39c6467d4dc95ac3f83e`
+- BASE LP add/remove validated on the new pool:
+  - add approval tx: `0xa2739346558f43f474953c7c93be05f0c66f2659f80d8b07804823f03926bdb0`
+  - add tx: `0x6a10d7dc5d2794643b10bc2b53080bfa8df1c99eedf35cd48a46edaa6d97d832`
+  - remove tx: `0x4148585452d259f6a9928404c7b8d324013e7ee13859392302ab78aa34fab2bc`
+
+## 3.0.8 - 2026-03-18
+
+### Fixed
+- Fixed `manage_liquidity` QUOTE pool ABI mismatch (`Expected length params=1, values=2`) by adding a safe fallback path:
+  - Keep SDK LP call as primary path.
+  - On SDK ABI-overload mismatch, switch to explicit-signature router transaction path (`depositQuote`/`withdrawQuote`) to avoid overloaded function ambiguity.
+- Added the same overload-mismatch fallback for BASE pool LP operations (`depositBase`/`withdrawBase`) to prevent the same class of failure.
+- Added SDK ABI-mismatch log suppression for LP calls to avoid noisy stack traces when fallback is activated.
+
+### Verified
+- Executed a real QUOTE remove liquidity transaction via MCP after the fix:
+  - txHash: `0x69e089b805cccd3b14d0c511309a0ce2aecf988344ec23ae27df929ad99af390`
+  - status: success (confirmed on-chain)
+
 ## 3.0.7 - 2026-03-18
 
 ### Changed

package/README.md

@@ -6,7 +6,7 @@ A production-ready MCP (Model Context Protocol) server for deep integration with
 
 # Release Notes
 
-- **Current release: 3.0.7**
+- **Current release: 3.0.10**
 - **SDK baseline**: `@myx-trade/sdk@^1.0.2` compatibility completed.
 - **Refinement**: Consolidated 40+ specialized tools into ~26 high-level unified tools.
 - **Improved UX**: Enhanced AI parameter parsing, automated unit conversion, and structured error reporting.
@@ -54,7 +54,7 @@ QUOTE_TOKEN_DECIMALS=18
 * **`close_position`**: Strategy-based closing of specific positions.
 * **`close_all_positions`**: Emergency exit for all positions in a specific pool.
 * **`cancel_orders`**: Unified cancellation (Single ID, Pool-wide, or Account-wide).
-* **`manage_tp_sl`**: Adjust protection orders for active positions or pending orders.
+* **`manage_tp_sl`**: Adjust protection orders for active positions or pending orders. Deletion is supported via `tpPrice=0` + `slPrice=0`.
 * **`adjust_margin`**: Add or remove collateral to manage liquidation risk.
 
 ### 📁 Account & Portfolio

package/TOOL_EXAMPLES.md

@@ -60,6 +60,19 @@ Update existing protection orders or set new ones for a position.
 }
 ```
 
+Delete both TP/SL for a position:
+```json
+{
+  "name": "manage_tp_sl",
+  "arguments": {
+    "poolId": "BTC",
+    "positionId": "0xABC...",
+    "tpPrice": "0",
+    "slPrice": "0"
+  }
+}
+```
+
 ---
 
 ## 🔵 Market Data

package/dist/server.js

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

package/dist/services/poolService.js

@@ -3,6 +3,74 @@ import { getChainId, resolveClient } from "../auth/resolveClient.js";
 import { extractErrorMessage } from "../utils/errorMessage.js";
 import { ensureUnits } from "../utils/units.js";
 import { normalizeAddress } from "../utils/address.js";
+import { Contract, parseUnits, MaxUint256 } from "ethers";
+import { logger } from "../utils/logger.js";
+const LP_DECIMALS = 18;
+const POOL_MANAGER_BY_CHAIN = {
+    421614: "0xf268D9FeD3Bd56fd9aBdb4FeEb993338613678A8",
+};
+const POOL_MANAGER_ABI = [
+    "function deployPool((bytes32 marketId,address baseToken))",
+    "function getMarketPool(bytes32 marketId,address asset) view returns ((bytes32 marketId,bytes32 poolId,address baseToken,address quoteToken,uint8 riskTier,uint8 state,address basePoolToken,address quotePoolToken,uint16 maxPriceDeviation,bool compoundEnabled,uint64 windowCapUsd,address poolVault,address tradingVault))",
+];
+const LP_ROUTER_BY_CHAIN = {
+    421614: {
+        router: "0x5E16C0699de2Ee5D69a620AB38AE2c81A29a58df",
+        basePool: "0xDb41D850e9b30fc0417F488D1aB64fdc1d0DdFdc",
+        quotePool: "0xF0784c1023C051Bf1D5b8470A896c536039B06B9",
+    },
+    59141: {
+        router: "0xf1395643D77DD839E4b8d3Bb122fd0275Cf07631",
+        basePool: "0x31b093BBADbb2A3Bcd7E433E8Ed5bcdD76fFAFFe",
+        quotePool: "0xFF8A6797E2063A7a4cd1468eB7cC0db9798C753f",
+    },
+    97: {
+        router: "0xe9F2E58562aD1D50AfB1eD92EAa6D367A6D0e552",
+        basePool: "0x39506f97D1c1A91EAfD59368697E20dC1fE5eEDB",
+        quotePool: "0x80DAa474e7e2C9c86708e434B80636b92fb4e9EE",
+    },
+    56: {
+        router: "0x06d76c78B56D361de01A8903deA8aCEFFe6251d6",
+        basePool: "0x59E365A627C5A1CE459e8e3489C97Ab2BEd56FEa",
+        quotePool: "0xB1E6df749A602892FafB27bb39Fd4F044527121E",
+    },
+};
+const LP_ROUTER_BY_CHAIN_BETA = {
+    421614: {
+        router: "0xfb790ECE13Cd9e296b4a06ABF38D10431360c236",
+        basePool: "0x1F767BEa83EDe5E0C18904f439C579f52c2c0F1b",
+        quotePool: "0x50ad7da312c58c6689bEF028954a366cb5b8ee13",
+    },
+    59141: {
+        router: "0x0AE31989318565620c03d35889a0B2536b8fba5C",
+        basePool: "0xc9e3826c42183207B418116A16827C1605132c51",
+        quotePool: "0x9A9934D3b22103dE822d94A22A3177d728FE0e5a",
+    },
+    97: {
+        router: "0x0F4C6f18Fb136DD1eBd6Da3C5d86a86597CF79a3",
+        basePool: "0x51B62554a76197d5DF2D5dC4D57FF54d40775938",
+        quotePool: "0x783Ed065a12e1C1D33c2a8d6408385C1843D3084",
+    },
+};
+const PREVIEW_POOL_ABI = [
+    "function previewLpAmountOut(bytes32,uint256,uint256) view returns (uint256)",
+    "function previewQuoteAmountOut(bytes32,uint256,uint256) view returns (uint256)",
+    "function previewBaseAmountOut(bytes32,uint256,uint256) view returns (uint256)",
+];
+const ROUTER_ABI = [
+    "function depositQuote((bytes32,uint256,uint256,address,(uint256,uint256,uint8,uint256)[]))",
+    "function depositQuote((bytes32,uint8,uint64,bytes)[],(bytes32,uint256,uint256,address,(uint256,uint256,uint8,uint256)[])) payable",
+    "function withdrawQuote((bytes32,uint256,uint256,address))",
+    "function withdrawQuote((bytes32,uint8,uint64,bytes)[],(bytes32,uint256,uint256,address)) payable",
+    "function depositBase((bytes32,uint256,uint256,address,(uint256,uint256,uint8,uint256)[]))",
+    "function depositBase((bytes32,uint8,uint64,bytes)[],(bytes32,uint256,uint256,address,(uint256,uint256,uint8,uint256)[])) payable",
+    "function withdrawBase((bytes32,uint256,uint256,address))",
+    "function withdrawBase((bytes32,uint8,uint64,bytes)[],(bytes32,uint256,uint256,address)) payable",
+];
+const ERC20_ABI = [
+    "function allowance(address,address) view returns (uint256)",
+    "function approve(address,uint256) returns (bool)",
+];
 function isDivideByZeroError(message) {
     const lower = message.toLowerCase();
     return (lower.includes("divide_by_zero") ||
@@ -20,6 +88,264 @@ function toPositiveBigint(input) {
         return null;
     }
 }
+function isAbiLengthMismatchError(message) {
+    const lower = message.toLowerCase();
+    return lower.includes("abi encoding params/values length mismatch");
+}
+function isSdkWaitNotFunctionError(message) {
+    return message.toLowerCase().includes("wait is not a function");
+}
+function readLastMockTxHash() {
+    const hash = String(globalThis?.__MCP_LAST_TX_HASH ?? "").trim();
+    if (!hash.startsWith("0x") || hash.length !== 66)
+        return null;
+    return hash;
+}
+function recoverSdkSubmittedTxHash(beforeHash, message, context) {
+    if (!isSdkWaitNotFunctionError(message))
+        return null;
+    const recovered = readLastMockTxHash();
+    if (!recovered || recovered === beforeHash)
+        return null;
+    logger.warn(`Recovered SDK-submitted tx hash for ${context.poolType} ${context.action} after wait() incompatibility: ${recovered}`);
+    return {
+        transactionHash: recovered,
+        fallback: {
+            mode: "sdk_submitted_txhash_recovery",
+            reason: "sdk_wait_not_function",
+            poolType: context.poolType,
+            action: context.action,
+        },
+    };
+}
+async function withMutedSdkAbiMismatchLogs(runner) {
+    const original = console.error;
+    console.error = (...args) => {
+        const first = args?.[0];
+        const firstText = typeof first === "string"
+            ? first
+            : first instanceof Error
+                ? first.message
+                : (first && typeof first === "object"
+                    ? JSON.stringify(first)
+                    : String(first ?? ""));
+        const lower = firstText.toLowerCase();
+        if (isAbiLengthMismatchError(firstText) || lower.includes("abiencodinglengthmismatcherror")) {
+            return;
+        }
+        original(...args);
+    };
+    try {
+        return await runner();
+    }
+    finally {
+        console.error = original;
+    }
+}
+function isBetaModeEnabled() {
+    return String(process.env.IS_BETA_MODE ?? "").trim().toLowerCase() === "true";
+}
+function getPoolManagerAddress(chainId) {
+    const envAddress = String(process.env.POOL_MANAGER_ADDRESS ?? "").trim();
+    if (envAddress) {
+        return normalizeAddress(envAddress, "POOL_MANAGER_ADDRESS");
+    }
+    const mapped = POOL_MANAGER_BY_CHAIN[chainId];
+    if (!mapped) {
+        throw new Error(`Pool manager address is not configured for chainId=${chainId}. Set POOL_MANAGER_ADDRESS env var.`);
+    }
+    return mapped;
+}
+function getLpAddresses(chainId) {
+    const source = isBetaModeEnabled() ? LP_ROUTER_BY_CHAIN_BETA : LP_ROUTER_BY_CHAIN;
+    const matched = source[chainId];
+    if (!matched) {
+        throw new Error(`Liquidity router config not found for chainId=${chainId}.`);
+    }
+    return matched;
+}
+function normalizeSlippageRatio(slippage) {
+    if (!Number.isFinite(slippage) || slippage < 0)
+        return 0;
+    if (slippage > 1 && slippage <= 100)
+        return slippage / 100;
+    if (slippage > 1)
+        return 1;
+    return slippage;
+}
+function applyMinOutBySlippage(amountOut, slippage) {
+    if (amountOut <= 0n)
+        return 0n;
+    const ratio = normalizeSlippageRatio(slippage);
+    const scale = 1000000n;
+    const ratioScaled = BigInt(Math.round(ratio * 1_000_000));
+    const effective = ratioScaled >= scale ? 0n : (scale - ratioScaled);
+    return (amountOut * effective) / scale;
+}
+function shouldUseOraclePriceByState(state) {
+    const numeric = Number(state);
+    if (!Number.isFinite(numeric))
+        return true;
+    return numeric !== 0 && numeric !== 1;
+}
+async function getMarketDetailOrThrow(client, chainId, poolId) {
+    const raw = await client.markets.getMarketDetail({ chainId, poolId });
+    const detail = raw?.data ?? raw;
+    if (!detail || !detail.poolId) {
+        throw new Error(`Failed to fetch market detail for poolId=${poolId}.`);
+    }
+    return detail;
+}
+async function buildOraclePricePayload(client, chainId, poolId, fallbackOracleType) {
+    const oracle = await client.utils.getOraclePrice(poolId, chainId);
+    const vaa = String(oracle?.vaa ?? "").trim();
+    if (!vaa || !vaa.startsWith("0x")) {
+        throw new Error(`Oracle VAA unavailable for pool ${poolId}.`);
+    }
+    const publishTime = toPositiveBigint(oracle?.publishTime) ?? BigInt(Math.floor(Date.now() / 1000));
+    const oracleType = Number.isFinite(Number(oracle?.oracleType)) ? Number(oracle.oracleType) : fallbackOracleType;
+    const value = toPositiveBigint(oracle?.value) ?? 0n;
+    const referencePrice30 = BigInt(ensureUnits(String(oracle?.price ?? "0"), 30, "oracle price"));
+    return {
+        prices: [[poolId, oracleType, publishTime, vaa]],
+        value,
+        referencePrice30,
+    };
+}
+async function previewAmountOutForLiquidity(signer, chainId, poolId, poolType, action, amountIn, referencePrice30) {
+    try {
+        const addresses = getLpAddresses(chainId);
+        const poolAddress = poolType === "QUOTE" ? addresses.quotePool : addresses.basePool;
+        const previewContract = new Contract(poolAddress, PREVIEW_POOL_ABI, signer);
+        if (action === "deposit") {
+            const out = await previewContract.previewLpAmountOut(poolId, amountIn, referencePrice30);
+            return toPositiveBigint(out) ?? 0n;
+        }
+        if (poolType === "QUOTE") {
+            const out = await previewContract.previewQuoteAmountOut(poolId, amountIn, referencePrice30);
+            return toPositiveBigint(out) ?? 0n;
+        }
+        const out = await previewContract.previewBaseAmountOut(poolId, amountIn, referencePrice30);
+        return toPositiveBigint(out) ?? 0n;
+    }
+    catch (error) {
+        logger.warn("LP preview call failed; fallback to minAmountOut=0.", extractErrorMessage(error));
+        return 0n;
+    }
+}
+async function executeLiquidityTxViaRouter(params) {
+    const { chainId, poolId, poolType, action, amount, slippage } = params;
+    const { client, signer, address } = await resolveClient();
+    const marketDetail = await getMarketDetailOrThrow(client, chainId, poolId);
+    const addresses = getLpAddresses(chainId);
+    const decimals = action === "deposit"
+        ? Number(poolType === "QUOTE" ? marketDetail.quoteDecimals : marketDetail.baseDecimals)
+        : LP_DECIMALS;
+    if (!Number.isFinite(decimals) || decimals < 0) {
+        throw new Error(`Invalid decimals while preparing ${poolType} ${action} transaction.`);
+    }
+    const amountIn = parseUnits(String(amount), decimals);
+    if (amountIn <= 0n) {
+        throw new Error(`Liquidity ${poolType.toLowerCase()} ${action} amount must be > 0.`);
+    }
+    let approvalTxHash = null;
+    if (action === "deposit") {
+        const tokenAddress = normalizeAddress(poolType === "QUOTE" ? marketDetail.quoteToken : marketDetail.baseToken, poolType === "QUOTE" ? "quoteToken" : "baseToken");
+        const tokenContract = new Contract(tokenAddress, ERC20_ABI, signer);
+        const allowance = toPositiveBigint(await tokenContract.allowance(address, addresses.router)) ?? 0n;
+        if (allowance < amountIn) {
+            logger.info(`[LP fallback] allowance insufficient for ${poolType} deposit, approving router. required=${amountIn.toString()}, current=${allowance.toString()}`);
+            const approveTx = await tokenContract.approve(addresses.router, MaxUint256);
+            approvalTxHash = String(approveTx?.hash ?? "").trim() || null;
+            const approveReceipt = await approveTx?.wait?.();
+            if (approveReceipt && approveReceipt.status !== 1) {
+                throw new Error(`Router approval transaction reverted for ${poolType} deposit.`);
+            }
+        }
+    }
+    const needOraclePrice = shouldUseOraclePriceByState(marketDetail.state);
+    let oraclePayload = {
+        prices: [],
+        value: 0n,
+        referencePrice30: 0n,
+    };
+    if (needOraclePrice) {
+        oraclePayload = await buildOraclePricePayload(client, chainId, poolId, Number(marketDetail.oracleType ?? 1));
+    }
+    const amountOut = await previewAmountOutForLiquidity(signer, chainId, poolId, poolType, action, amountIn, oraclePayload.referencePrice30);
+    const minAmountOut = applyMinOutBySlippage(amountOut, slippage);
+    const routerContract = new Contract(addresses.router, ROUTER_ABI, signer);
+    const txOverrides = {};
+    if (oraclePayload.value > 0n) {
+        txOverrides.value = oraclePayload.value;
+    }
+    let tx;
+    if (poolType === "QUOTE" && action === "deposit") {
+        const paramsTuple = [
+            poolId,
+            amountIn,
+            minAmountOut,
+            address,
+            [],
+        ];
+        if (oraclePayload.prices.length > 0) {
+            tx = await routerContract["depositQuote((bytes32,uint8,uint64,bytes)[],(bytes32,uint256,uint256,address,(uint256,uint256,uint8,uint256)[]))"](oraclePayload.prices, paramsTuple, txOverrides);
+        }
+        else {
+            tx = await routerContract["depositQuote((bytes32,uint256,uint256,address,(uint256,uint256,uint8,uint256)[]))"](paramsTuple, txOverrides);
+        }
+    }
+    else if (poolType === "QUOTE" && action === "withdraw") {
+        const paramsTuple = [poolId, amountIn, minAmountOut, address];
+        if (oraclePayload.prices.length > 0) {
+            tx = await routerContract["withdrawQuote((bytes32,uint8,uint64,bytes)[],(bytes32,uint256,uint256,address))"](oraclePayload.prices, paramsTuple, txOverrides);
+        }
+        else {
+            tx = await routerContract["withdrawQuote((bytes32,uint256,uint256,address))"](paramsTuple, txOverrides);
+        }
+    }
+    else if (poolType === "BASE" && action === "deposit") {
+        const paramsTuple = [
+            poolId,
+            amountIn,
+            minAmountOut,
+            address,
+            [],
+        ];
+        if (oraclePayload.prices.length > 0) {
+            tx = await routerContract["depositBase((bytes32,uint8,uint64,bytes)[],(bytes32,uint256,uint256,address,(uint256,uint256,uint8,uint256)[]))"](oraclePayload.prices, paramsTuple, txOverrides);
+        }
+        else {
+            tx = await routerContract["depositBase((bytes32,uint256,uint256,address,(uint256,uint256,uint8,uint256)[]))"](paramsTuple, txOverrides);
+        }
+    }
+    else {
+        const paramsTuple = [poolId, amountIn, minAmountOut, address];
+        if (oraclePayload.prices.length > 0) {
+            tx = await routerContract["withdrawBase((bytes32,uint8,uint64,bytes)[],(bytes32,uint256,uint256,address))"](oraclePayload.prices, paramsTuple, txOverrides);
+        }
+        else {
+            tx = await routerContract["withdrawBase((bytes32,uint256,uint256,address))"](paramsTuple, txOverrides);
+        }
+    }
+    const txHash = String(tx?.hash ?? "").trim();
+    if (!txHash || !txHash.startsWith("0x")) {
+        throw new Error(`${poolType} ${action} fallback sent transaction but no hash was returned.`);
+    }
+    return {
+        transactionHash: txHash,
+        fallback: {
+            mode: "router_explicit_signature",
+            action,
+            poolType,
+            amountIn: amountIn.toString(),
+            minAmountOut: minAmountOut.toString(),
+            usedOraclePrice: oraclePayload.prices.length > 0,
+            oracleValue: oraclePayload.value.toString(),
+            approvalTxHash,
+        },
+    };
+}
 async function resolvePositiveMarketPrice30(client, poolId, chainId) {
     if (!client)
         return null;
@@ -52,9 +378,55 @@ async function resolvePositiveMarketPrice30(client, poolId, chainId) {
  * 创建合约市场池子
  */
 export async function createPool(baseToken, marketId) {
-    await resolveClient();
+    const { signer } = await resolveClient();
     const chainId = getChainId();
-    return pool.createPool({ chainId, baseToken: normalizeAddress(baseToken, "baseToken"), marketId });
+    const normalizedBaseToken = normalizeAddress(baseToken, "baseToken");
+    const normalizedMarketId = String(marketId ?? "").trim();
+    try {
+        return await pool.createPool({ chainId, baseToken: normalizedBaseToken, marketId: normalizedMarketId });
+    }
+    catch (error) {
+        const message = extractErrorMessage(error).toLowerCase();
+        if (!message.includes("deploypool is not a function")) {
+            throw error;
+        }
+        logger.warn("SDK pool.createPool write path unavailable; falling back to direct PoolManager.deployPool.");
+        const poolManagerAddress = getPoolManagerAddress(chainId);
+        const contract = new Contract(poolManagerAddress, POOL_MANAGER_ABI, signer);
+        const tx = await contract.deployPool([normalizedMarketId, normalizedBaseToken]);
+        const txHash = String(tx?.hash ?? "").trim();
+        if (!txHash.startsWith("0x")) {
+            throw new Error("Direct deployPool fallback submitted transaction but no hash was returned.");
+        }
+        return {
+            transactionHash: txHash,
+            fallback: {
+                mode: "pool_manager_direct_deploy",
+                chainId,
+                poolManagerAddress,
+            },
+        };
+    }
+}
+export async function getMarketPoolByBaseToken(marketId, baseToken, chainIdOverride) {
+    const { signer } = await resolveClient();
+    const chainId = chainIdOverride ?? getChainId();
+    const normalizedBaseToken = normalizeAddress(baseToken, "baseToken");
+    const normalizedMarketId = String(marketId ?? "").trim();
+    const poolManagerAddress = getPoolManagerAddress(chainId);
+    const contract = new Contract(poolManagerAddress, POOL_MANAGER_ABI, signer);
+    const record = await contract.getMarketPool(normalizedMarketId, normalizedBaseToken);
+    return {
+        poolManagerAddress,
+        chainId,
+        marketId: String(record?.marketId ?? normalizedMarketId),
+        poolId: String(record?.poolId ?? ""),
+        baseToken: String(record?.baseToken ?? normalizedBaseToken),
+        quoteToken: String(record?.quoteToken ?? ""),
+        state: Number(record?.state ?? -1),
+        basePoolToken: String(record?.basePoolToken ?? ""),
+        quotePoolToken: String(record?.quotePoolToken ?? ""),
+    };
 }
 /**
  * 获取池子信息
@@ -109,28 +481,80 @@ export async function getLiquidityInfo(client, poolId, marketPrice, chainIdOverr
  */
 export async function quoteDeposit(poolId, amount, slippage, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    return quote.deposit({ chainId, poolId, amount, slippage });
+    const txHashBefore = readLastMockTxHash();
+    try {
+        return await withMutedSdkAbiMismatchLogs(() => quote.deposit({ chainId, poolId, amount, slippage }));
+    }
+    catch (error) {
+        const message = extractErrorMessage(error);
+        const recovered = recoverSdkSubmittedTxHash(txHashBefore, message, { poolType: "QUOTE", action: "deposit" });
+        if (recovered)
+            return recovered;
+        if (!isAbiLengthMismatchError(message))
+            throw error;
+        logger.warn("quote.deposit hit SDK ABI mismatch; switching to explicit router path.");
+        return executeLiquidityTxViaRouter({ chainId, poolId, poolType: "QUOTE", action: "deposit", amount, slippage });
+    }
 }
 /**
  * Quote 池 withdraw
  */
 export async function quoteWithdraw(poolId, amount, slippage, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    return quote.withdraw({ chainId, poolId, amount, slippage });
+    const txHashBefore = readLastMockTxHash();
+    try {
+        return await withMutedSdkAbiMismatchLogs(() => quote.withdraw({ chainId, poolId, amount, slippage }));
+    }
+    catch (error) {
+        const message = extractErrorMessage(error);
+        const recovered = recoverSdkSubmittedTxHash(txHashBefore, message, { poolType: "QUOTE", action: "withdraw" });
+        if (recovered)
+            return recovered;
+        if (!isAbiLengthMismatchError(message))
+            throw error;
+        logger.warn("quote.withdraw hit SDK ABI mismatch; switching to explicit router path.");
+        return executeLiquidityTxViaRouter({ chainId, poolId, poolType: "QUOTE", action: "withdraw", amount, slippage });
+    }
 }
 /**
  * Base 池 deposit
  */
 export async function baseDeposit(poolId, amount, slippage, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    return base.deposit({ chainId, poolId, amount, slippage });
+    const txHashBefore = readLastMockTxHash();
+    try {
+        return await withMutedSdkAbiMismatchLogs(() => base.deposit({ chainId, poolId, amount, slippage }));
+    }
+    catch (error) {
+        const message = extractErrorMessage(error);
+        const recovered = recoverSdkSubmittedTxHash(txHashBefore, message, { poolType: "BASE", action: "deposit" });
+        if (recovered)
+            return recovered;
+        if (!isAbiLengthMismatchError(message))
+            throw error;
+        logger.warn("base.deposit hit SDK ABI mismatch; switching to explicit router path.");
+        return executeLiquidityTxViaRouter({ chainId, poolId, poolType: "BASE", action: "deposit", amount, slippage });
+    }
 }
 /**
  * Base 池 withdraw
  */
 export async function baseWithdraw(poolId, amount, slippage, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    return base.withdraw({ chainId, poolId, amount, slippage });
+    const txHashBefore = readLastMockTxHash();
+    try {
+        return await withMutedSdkAbiMismatchLogs(() => base.withdraw({ chainId, poolId, amount, slippage }));
+    }
+    catch (error) {
+        const message = extractErrorMessage(error);
+        const recovered = recoverSdkSubmittedTxHash(txHashBefore, message, { poolType: "BASE", action: "withdraw" });
+        if (recovered)
+            return recovered;
+        if (!isAbiLengthMismatchError(message))
+            throw error;
+        logger.warn("base.withdraw hit SDK ABI mismatch; switching to explicit router path.");
+        return executeLiquidityTxViaRouter({ chainId, poolId, poolType: "BASE", action: "withdraw", amount, slippage });
+    }
 }
 /**
  * 获取 LP 价格

package/dist/tools/createPerpMarket.js

@@ -1,7 +1,115 @@
 import { z } from "zod";
-import { createPool } from "../services/poolService.js";
-import { resolveClient } from "../auth/resolveClient.js";
+import { createPool, getMarketPoolByBaseToken } from "../services/poolService.js";
+import { resolveClient, getChainId } from "../auth/resolveClient.js";
 import { finalizeMutationResult } from "../utils/mutationResult.js";
+import { normalizeAddress } from "../utils/address.js";
+import { extractErrorMessage } from "../utils/errorMessage.js";
+import { decodeErrorSelector } from "../utils/errors.js";
+const MARKET_ID_RE = /^0x[0-9a-fA-F]{64}$/;
+function compactMessage(message) {
+    const flat = String(message ?? "").replace(/\s+/g, " ").trim();
+    if (!flat)
+        return "Unknown create_perp_market error.";
+    if (flat.length <= 420)
+        return flat;
+    return `${flat.slice(0, 420)}...`;
+}
+function extractSelectorCandidate(input) {
+    const queue = [input];
+    const visited = new Set();
+    const LONG_HEX_RE = /0x[0-9a-fA-F]{8,}/g;
+    const EXACT_SELECTOR_RE = /0x[0-9a-fA-F]{8}\b/g;
+    const KEYED_SELECTOR_RE = /\b(?:data|selector|error|revert)\s*[:=]\s*["']?(0x[0-9a-fA-F]{8,})/gi;
+    let fallback = null;
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current === null || current === undefined)
+            continue;
+        if (visited.has(current))
+            continue;
+        visited.add(current);
+        if (typeof current === "string") {
+            const exactMatches = current.match(EXACT_SELECTOR_RE) ?? [];
+            for (const candidate of exactMatches) {
+                const normalized = candidate.toLowerCase();
+                if (decodeErrorSelector(normalized))
+                    return normalized;
+                if (!fallback)
+                    fallback = normalized;
+            }
+            for (const match of current.matchAll(KEYED_SELECTOR_RE)) {
+                const raw = String(match[1] ?? "").toLowerCase();
+                if (raw.length < 10)
+                    continue;
+                const selector = `0x${raw.slice(2, 10)}`;
+                if (decodeErrorSelector(selector))
+                    return selector;
+                if (!fallback)
+                    fallback = selector;
+            }
+            const matches = current.match(LONG_HEX_RE) ?? [];
+            for (const hex of matches) {
+                const normalized = hex.toLowerCase();
+                if (normalized.length === 42)
+                    continue; // likely plain address
+                if (normalized.length < 10)
+                    continue;
+                const selector = `0x${normalized.slice(2, 10)}`;
+                if (decodeErrorSelector(selector)) {
+                    return selector;
+                }
+                if (!fallback)
+                    fallback = selector;
+            }
+            continue;
+        }
+        if (typeof current !== "object")
+            continue;
+        const record = current;
+        for (const value of Object.values(record)) {
+            queue.push(value);
+        }
+    }
+    return fallback;
+}
+function buildCreateMarketErrorPayload(args, messageLike) {
+    const message = compactMessage(extractErrorMessage(messageLike, "create_perp_market failed."));
+    const selectorCandidate = extractSelectorCandidate(messageLike);
+    const decodedSelector = selectorCandidate ? decodeErrorSelector(selectorCandidate) : null;
+    const lower = message.toLowerCase();
+    const code = lower.includes("marketid") && lower.includes("66")
+        ? "INVALID_PARAM"
+        : lower.includes("not a valid evm address")
+            ? "INVALID_PARAM"
+            : lower.includes("abi") && lower.includes("size")
+                ? "INVALID_PARAM"
+                : lower.includes("reverted")
+                    ? "CONTRACT_REVERT"
+                    : "TOOL_EXECUTION_ERROR";
+    const decoratedMessage = decodedSelector
+        ? `${message} (Decoded Contract Error: ${decodedSelector})`
+        : message;
+    const hint = code === "INVALID_PARAM"
+        ? "Use a valid baseToken address and a 66-char marketId config hash (0x + 64 hex)."
+        : "Check market allocation / permissions / duplicate pool status, then retry.";
+    return {
+        status: "error",
+        error: {
+            tool: "create_perp_market",
+            code,
+            message: decoratedMessage,
+            hint,
+            action: "Adjust parameters or prerequisites and retry.",
+            details: {
+                chainId: getChainId(),
+                baseToken: args?.baseToken ?? null,
+                marketId: args?.marketId ?? null,
+                selector: selectorCandidate,
+                decodedSelector,
+            },
+        },
+    };
+}
 export const createPerpMarketTool = {
     name: "create_perp_market",
     description: "[LIQUIDITY] Create a new perpetual contract pool on MYX. IMPORTANT: marketId cannot be randomly generated. It must be a valid 66-character config hash (0x...) tied to a supported quote token (like USDC). Use get_pool_metadata (after find_pool/list_pools) to fetch an existing marketId if you don't have a specific newly allocated one.",
@@ -13,13 +121,32 @@ export const createPerpMarketTool = {
         try {
             if (!args.baseToken || !args.marketId)
                 throw new Error("baseToken and marketId are required.");
+            const baseToken = normalizeAddress(args.baseToken, "baseToken");
+            const marketId = String(args.marketId).trim();
+            if (!MARKET_ID_RE.test(marketId)) {
+                throw new Error(`marketId must be a 66-character config hash (0x + 64 hex). Received: ${marketId}`);
+            }
             const { signer } = await resolveClient();
-            const raw = await createPool(args.baseToken, args.marketId);
+            const raw = await createPool(baseToken, marketId);
             const data = await finalizeMutationResult(raw, signer, "create_perp_market");
-            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
+            let onChainPool = null;
+            try {
+                const resolved = await getMarketPoolByBaseToken(marketId, baseToken, getChainId());
+                if (resolved?.poolId && !/^0x0{64}$/i.test(String(resolved.poolId))) {
+                    onChainPool = resolved;
+                }
+            }
+            catch {
+                onChainPool = null;
+            }
+            const payload = onChainPool
+                ? { ...data, onChainPool }
+                : data;
+            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: payload }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
         }
         catch (error) {
-            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+            const payload = buildCreateMarketErrorPayload(args, error);
+            return { content: [{ type: "text", text: JSON.stringify(payload, (_, v) => typeof v === "bigint" ? v.toString() : v, 2) }], isError: true };
         }
     },
 };

package/dist/tools/getBaseDetail.js

@@ -1,5 +1,28 @@
 import { z } from "zod";
 import { resolveClient, getChainId } from "../auth/resolveClient.js";
+import { normalizeAddress } from "../utils/address.js";
+import { extractErrorMessage } from "../utils/errorMessage.js";
+function isNonEmptyObject(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+function buildReadErrorPayload(args, messageLike, code = "SDK_READ_ERROR") {
+    const chainId = args.chainId ?? getChainId();
+    const message = extractErrorMessage(messageLike, "Failed to read base token detail.");
+    return {
+        status: "error",
+        error: {
+            tool: "get_base_detail",
+            code,
+            message,
+            hint: "Check baseAddress validity and market availability on current chain.",
+            action: "Use list_pools/find_pool/get_pool_metadata to confirm base token, then retry.",
+            details: {
+                chainId,
+                baseAddress: args.baseAddress ?? null,
+            },
+        },
+    };
+}
 export const getBaseDetailTool = {
     name: "get_base_detail",
     description: "[MARKET] Get base token details.",
@@ -11,11 +34,28 @@ export const getBaseDetailTool = {
         try {
             const { client } = await resolveClient();
             const chainId = args.chainId ?? getChainId();
-            const result = await client.markets.getBaseDetail({ chainId, baseAddress: args.baseAddress });
-            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: result }, (_, v) => typeof v === "bigint" ? v.toString() : v, 2) }] };
+            const baseAddress = normalizeAddress(args.baseAddress, "baseAddress");
+            const result = await client.markets.getBaseDetail({ chainId, baseAddress });
+            const hasCode = !!result && typeof result === "object" && !Array.isArray(result) && Object.prototype.hasOwnProperty.call(result, "code");
+            const code = hasCode ? Number(result.code) : 0;
+            const payload = hasCode ? result.data : result;
+            if (hasCode && Number.isFinite(code) && code !== 0) {
+                const body = buildReadErrorPayload({ ...args, baseAddress }, result.msg ?? result.message ?? result, "SDK_READ_ERROR");
+                return { content: [{ type: "text", text: JSON.stringify(body, (_, v) => typeof v === "bigint" ? v.toString() : v, 2) }], isError: true };
+            }
+            if (payload === null || payload === undefined) {
+                const body = buildReadErrorPayload({ ...args, baseAddress }, "get_base_detail returned empty data.", "NOT_FOUND");
+                return { content: [{ type: "text", text: JSON.stringify(body, null, 2) }], isError: true };
+            }
+            if (typeof payload === "object" && !Array.isArray(payload) && !isNonEmptyObject(payload)) {
+                const body = buildReadErrorPayload({ ...args, baseAddress }, "get_base_detail returned an empty object.", "NOT_FOUND");
+                return { content: [{ type: "text", text: JSON.stringify(body, null, 2) }], isError: true };
+            }
+            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: payload }, (_, v) => typeof v === "bigint" ? v.toString() : v, 2) }] };
         }
         catch (error) {
-            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+            const body = buildReadErrorPayload(args, error, "TOOL_EXECUTION_ERROR");
+            return { content: [{ type: "text", text: JSON.stringify(body, (_, v) => typeof v === "bigint" ? v.toString() : v, 2) }], isError: true };
         }
     },
 };

package/dist/tools/getOrders.js

@@ -1,6 +1,34 @@
 import { z } from "zod";
 import { resolveClient, getChainId } from "../auth/resolveClient.js";
 import { getOrderTypeDesc, getOrderStatusDesc, getDirectionDesc, getHistoryOrderStatusDesc, getExecTypeDesc } from "../utils/mappings.js";
+function pickFirstDefined(...values) {
+    for (const value of values) {
+        if (value !== undefined && value !== null && String(value).trim() !== "") {
+            return value;
+        }
+    }
+    return undefined;
+}
+function toMaybeNumber(value) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? numeric : undefined;
+}
+function resolveOpenOrderStatus(order) {
+    const statusRaw = toMaybeNumber(pickFirstDefined(order?.status, order?.orderStatus, order?.order_status));
+    if (statusRaw === undefined) {
+        return { statusRaw: undefined, statusDesc: "Open" };
+    }
+    return { statusRaw, statusDesc: getOrderStatusDesc(statusRaw) };
+}
+function resolveHistoryOrderStatus(order) {
+    const orderStatusRaw = toMaybeNumber(pickFirstDefined(order?.orderStatus, order?.order_status, order?.status));
+    return {
+        orderStatusRaw,
+        orderStatusDesc: getHistoryOrderStatusDesc(orderStatusRaw),
+    };
+}
 export const getOrdersTool = {
     name: "get_orders",
     description: "[ACCOUNT] Get orders (open or history) with optional filters.",
@@ -19,7 +47,7 @@ export const getOrdersTool = {
                 results.open = (openRes?.data || []).map((order) => ({
                     ...order,
                     orderTypeDesc: getOrderTypeDesc(order.orderType),
-                    statusDesc: getOrderStatusDesc(order.status),
+                    ...resolveOpenOrderStatus(order),
                     directionDesc: getDirectionDesc(order.direction)
                 }));
                 if (args.poolId) {
@@ -32,7 +60,7 @@ export const getOrdersTool = {
                 results.history = (historyRes?.data || []).map((order) => ({
                     ...order,
                     orderTypeDesc: getOrderTypeDesc(order.orderType),
-                    orderStatusDesc: getHistoryOrderStatusDesc(order.orderStatus),
+                    ...resolveHistoryOrderStatus(order),
                     directionDesc: getDirectionDesc(order.direction),
                     execTypeDesc: getExecTypeDesc(order.execType)
                 }));

package/dist/tools/manageTpSl.js

@@ -39,6 +39,66 @@ function normalizeUnitsInput(text) {
         return `raw:${raw}`;
     return raw;
 }
+function isExplicitZeroValue(value) {
+    if (value === undefined || value === null)
+        return false;
+    if (typeof value === "number") {
+        return Number.isFinite(value) && value === 0;
+    }
+    const text = String(value).trim();
+    if (!text)
+        return false;
+    const payload = /^(raw|human):/i.test(text) ? text.replace(/^(raw|human):/i, "").trim() : text;
+    if (!payload)
+        return false;
+    if (!/^[-+]?\d+(\.\d+)?$/.test(payload))
+        return false;
+    return Number(payload) === 0;
+}
+function normalizeId(value) {
+    return String(value ?? "").trim().toLowerCase();
+}
+function hasOwnKey(input, key) {
+    return !!input && typeof input === "object" && Object.prototype.hasOwnProperty.call(input, key);
+}
+function isDeleteTpSlIntent(args) {
+    if (!hasOwnKey(args, "tpPrice") || !hasOwnKey(args, "slPrice"))
+        return false;
+    return isExplicitZeroValue(args.tpPrice) && isExplicitZeroValue(args.slPrice);
+}
+function isInvalidParameterRevert(error) {
+    const message = String(error?.message ?? error ?? "").toLowerCase();
+    return (message.includes("0x613970e0") ||
+        message.includes("invalidparameter") ||
+        message.includes("invalid parameter"));
+}
+function readOrderId(order) {
+    const id = String(order?.orderId ?? order?.id ?? "").trim();
+    return id;
+}
+function isTpSlOrder(order) {
+    const orderType = Number(order?.orderType ?? order?.type);
+    const operation = Number(order?.operation ?? order?.op);
+    if (Number.isFinite(orderType) && Number.isFinite(operation)) {
+        return orderType === 2 && operation === 1;
+    }
+    // Fallback: when operation/orderType are missing, try TP/SL related shape.
+    return isNonEmpty(order?.triggerType) && isNonEmpty(order?.positionId);
+}
+async function findOpenTpSlOrderIdsForPosition(client, address, poolId, positionId) {
+    const targetPool = normalizeId(poolId);
+    const targetPosition = normalizeId(positionId);
+    if (!targetPool || !targetPosition)
+        return [];
+    const openRes = await client.order.getOrders(address);
+    const openOrders = Array.isArray(openRes?.data) ? openRes.data : [];
+    return openOrders
+        .filter((order) => normalizeId(order?.poolId ?? order?.pool_id) === targetPool)
+        .filter((order) => normalizeId(order?.positionId ?? order?.position_id) === targetPosition)
+        .filter((order) => isTpSlOrder(order))
+        .map((order) => readOrderId(order))
+        .filter((id) => id.length > 0);
+}
 async function findOrderSnapshot(client, address, chainId, orderId, poolId) {
     const target = String(orderId).toLowerCase();
     try {
@@ -100,6 +160,63 @@ function resolvePositionSizeRaw(positionSnapshot, baseDecimals) {
     }
     return "";
 }
+async function cancelTpSlByIntent(client, address, signer, chainId, args) {
+    if (args.orderId) {
+        const raw = await client.order.cancelAllOrders([String(args.orderId)], chainId);
+        const data = await finalizeMutationResult(raw, signer, "manage_tp_sl_delete");
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        status: "success",
+                        data: {
+                            mode: "delete_tpsl_by_order",
+                            cancelledCount: 1,
+                            orderIds: [String(args.orderId)],
+                            result: data
+                        }
+                    }, (_, v) => typeof v === "bigint" ? v.toString() : v, 2)
+                }]
+        };
+    }
+    if (!args.positionId) {
+        throw new Error("positionId (or orderId) is required when deleting TP/SL with tpPrice=0 and slPrice=0.");
+    }
+    const orderIds = await findOpenTpSlOrderIdsForPosition(client, address, args.poolId, args.positionId);
+    if (orderIds.length === 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        status: "success",
+                        data: {
+                            mode: "delete_tpsl_by_position",
+                            cancelledCount: 0,
+                            positionId: args.positionId,
+                            message: "No open TP/SL orders found for this position."
+                        }
+                    }, null, 2)
+                }]
+        };
+    }
+    const raw = await client.order.cancelAllOrders(orderIds, chainId);
+    const data = await finalizeMutationResult(raw, signer, "manage_tp_sl_delete");
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    status: "success",
+                    data: {
+                        mode: "delete_tpsl_by_position",
+                        cancelledCount: orderIds.length,
+                        positionId: args.positionId,
+                        orderIds,
+                        result: data
+                    }
+                }, (_, v) => typeof v === "bigint" ? v.toString() : v, 2)
+            }]
+    };
+}
 export const manageTpSlTool = {
     name: "manage_tp_sl",
     description: "[TRADE] Set or update Take Profit (TP) and Stop Loss (SL) for a position.",
@@ -126,6 +243,10 @@ export const manageTpSlTool = {
             const chainId = args.chainId ?? getChainId();
             const direction = normalizeDirectionInput(args.direction);
             const slippagePct = args.slippagePct ?? "100";
+            const wantsDeleteTpSl = isDeleteTpSlIntent(args);
+            if (wantsDeleteTpSl) {
+                return await cancelTpSlByIntent(client, address, signer, chainId, args);
+            }
             const { setPositionTpSl, updateOrderTpSl } = await import("../services/tradeService.js");
             const { getMarketDetail } = await import("../services/marketService.js");
             const marketRes = await getMarketDetail(client, args.poolId, chainId);
@@ -162,19 +283,27 @@ export const manageTpSlTool = {
                 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);
+                try {
+                    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);
+                }
+                catch (updateError) {
+                    if (isDeleteTpSlIntent(args) || (isInvalidParameterRevert(updateError) && isExplicitZeroValue(args.tpPrice) && isExplicitZeroValue(args.slPrice))) {
+                        return await cancelTpSlByIntent(client, address, signer, chainId, args);
+                    }
+                    throw updateError;
+                }
             }
             else {
                 // Create new
@@ -211,18 +340,26 @@ export const manageTpSlTool = {
                     if (needsSlSize)
                         slSizeInput = `raw:${positionSizeRaw}`;
                 }
-                raw = await setPositionTpSl(client, address, {
-                    poolId: args.poolId,
-                    positionId: args.positionId,
-                    direction: resolvedDirection,
-                    leverage: Number(resolvedLeverage),
-                    executionFeeToken: args.executionFeeToken || market.quoteToken,
-                    slippagePct,
-                    tpPrice: args.tpPrice,
-                    tpSize: tpSizeInput || undefined,
-                    slPrice: args.slPrice,
-                    slSize: slSizeInput || undefined
-                }, chainId);
+                try {
+                    raw = await setPositionTpSl(client, address, {
+                        poolId: args.poolId,
+                        positionId: args.positionId,
+                        direction: resolvedDirection,
+                        leverage: Number(resolvedLeverage),
+                        executionFeeToken: args.executionFeeToken || market.quoteToken,
+                        slippagePct,
+                        tpPrice: args.tpPrice,
+                        tpSize: tpSizeInput || undefined,
+                        slPrice: args.slPrice,
+                        slSize: slSizeInput || undefined
+                    }, chainId);
+                }
+                catch (setError) {
+                    if (isDeleteTpSlIntent(args) || (isInvalidParameterRevert(setError) && isExplicitZeroValue(args.tpPrice) && isExplicitZeroValue(args.slPrice))) {
+                        return await cancelTpSlByIntent(client, address, signer, chainId, args);
+                    }
+                    throw setError;
+                }
             }
             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) }] };

package/dist/utils/injectProvider.js

@@ -28,6 +28,7 @@ export function injectBrowserProviderMock(chainId, provider, signer) {
                     tx.from = signer.address;
                 const txRes = await signer.sendTransaction(tx);
                 console.error(`[MCP Router] 交易已提交，哈希: ${txRes.hash}`);
+                g.__MCP_LAST_TX_HASH = txRes.hash;
                 return txRes.hash;
             }
             if (method === "eth_estimateGas" || method === "eth_gasPrice" || method === "eth_getBalance" || method === "eth_call") {

package/dist/utils/mappings.js

@@ -1,11 +1,16 @@
 /**
  * Direction: LONG=0, SHORT=1
  */
+function formatUnknown(value) {
+    if (value === undefined || value === null || value === "")
+        return "Unknown";
+    return `Unknown(${String(value)})`;
+}
 export const getDirectionDesc = (direction) => {
     switch (direction) {
         case 0: return "Long";
         case 1: return "Short";
-        default: return `Unknown(${direction})`;
+        default: return formatUnknown(direction);
     }
 };
 /**
@@ -17,7 +22,7 @@ export const getOrderTypeDesc = (type) => {
         case 1: return "Limit";
         case 2: return "Stop";
         case 3: return "Conditional";
-        default: return `Unknown(${type})`;
+        default: return formatUnknown(type);
     }
 };
 /**
@@ -31,7 +36,7 @@ export const getOrderStatusDesc = (status) => {
         case 3: return "Cancelled";
         case 4: return "Rejected";
         case 5: return "Expired";
-        default: return `Unknown(${status})`;
+        default: return formatUnknown(status);
     }
 };
 /**
@@ -43,7 +48,7 @@ export const getHistoryOrderStatusDesc = (status) => {
         case 2: return "Expired";
         case 9: return "Successful";
         case 8: return "PartialFilled";
-        default: return `Unknown(${status})`;
+        default: return formatUnknown(status);
     }
 };
 /**
@@ -83,7 +88,7 @@ export const getTradeFlowTypeDesc = (type) => {
         13: "ReferralReward",
         14: "ReferralRewardClaim"
     };
-    return types[type] || `Unknown(${type})`;
+    return types[type] || formatUnknown(type);
 };
 /**
  * ExecTypeEnum
@@ -100,7 +105,7 @@ export const getExecTypeDesc = (type) => {
         8: "EarlyClose",
         9: "MarketClose"
     };
-    return types[type] || `Unknown(${type})`;
+    return types[type] || formatUnknown(type);
 };
 /**
  * CloseTypeEnum
@@ -118,7 +123,7 @@ export const getCloseTypeDesc = (type) => {
         8: "SL",
         9: "Increase"
     };
-    return types[type] || `Unknown(${type})`;
+    return types[type] || formatUnknown(type);
 };
 /**
  * 映射输入方向为数值

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@michaleffffff/mcp-trading-server",
-  "version": "3.0.7",
+  "version": "3.0.10",
   "type": "module",
   "bin": {
     "myx-mcp": "dist/server.js"
@@ -16,7 +16,8 @@
     "start": "node dist/server.js",
     "dev": "tsx src/server.ts",
     "test": "tsx tests/test_sepolia.ts",
-    "test:new-tools": "tsx tests/test_new_tools_p0_p1.ts"
+    "test:new-tools": "tsx tests/test_new_tools_p0_p1.ts",
+    "test:manage-tpsl-delete": "tsx tests/test_manage_tpsl_delete_live.ts"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",