@michaleffffff/mcp-trading-server 3.0.24 → 3.0.27

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## 3.0.27 - 2026-03-20
+
+### Fixed
+- Hardened LP MCP behavior for mismatched token metadata and non-standard ERC20 approvals:
+  - `get_my_lp_holdings` now retries balance discovery against live `poolInfo` LP token addresses when market detail addresses are stale.
+  - LP router fallback now treats SDK `allowance()` read reverts as recoverable and attempts direct router approval/execution.
+  - Removed the MCP-side 5% LP slippage business cap; `manage_liquidity.slippage` now only normalizes ratio input and leaves risk tolerance to the caller / downstream contracts.
+
+### Changed
+- Refreshed operator docs and examples to match current LP execution semantics:
+  - `TOOL_EXAMPLES.md` clarifies LP `slippage` ratio semantics and removal of the business cap.
+  - `trading_best_practices` prompt now aligns with release `v3.0.27`.
+
+## 3.0.26 - 2026-03-20
+
+### Fixed
+- Removed MCP-side increase-order margin reconciliation that could conflict with SDK `createIncreaseOrder`:
+  - `open_position_simple` / `execute_trade` now validate parameters locally but delegate deposit-delta handling entirely to the SDK write path.
+  - Deprecated `autoDeposit` as a compatibility-only flag in `open_position_simple`.
+- Realigned `check_account_ready` with SDK trading semantics:
+  - Uses SDK `getAvailableMarginBalance` as the primary trading-account source instead of trusting raw `freeMargin`.
+  - Returns degraded diagnostics (`summary.degraded`, `diagnostics.availableMarginError`) when SDK margin reads fail.
+
+### Changed
+- Refreshed operator docs and examples to match current execution semantics:
+  - `README.md` now documents explicit `price` in the quick-start trade example, SDK-delegated increase-order funding deltas, and the new `check_account_ready` degraded diagnostics.
+  - `TOOL_EXAMPLES.md` now marks `autoDeposit` as deprecated and updates `MARKET` examples to provide `price`.
+  - `trading_best_practices` prompt now explains that pre-checks use SDK `availableMarginBalance`, that increase-order funding reconciliation lives in the SDK, and that LP holdings may be resolved from live pool token addresses.
+- Updated stale tests to match current MCP semantics:
+  - `tests/test_trading.ts` now provides `price` for `open_position_simple` market dry runs.
+  - `tests/verify_tp_sl_close_invalid_param.mjs` no longer relies on legacy `autoDeposit` semantics and now supplies `price` when opening a market position.
+
+## 3.0.25 - 2026-03-19
+
+### Fixed
+- Improved MCP compatibility and diagnostics for current testnet brokers:
+  - `resolveClient` now auto-detects beta mode for Arbitrum Sepolia broker `0x895C4ae2A22bB26851011d733A9355f663a1F939`
+  - `resolveClient` now auto-detects beta mode for Linea Sepolia broker `0x634EfDC9dC76D7AbF6E49279875a31B02E9891e2`
+  - nested viem / SDK revert payloads now decode common selectors like `AccountInsufficientTradableAmount(uint256,uint256)`
+  - `open_position_simple` now returns decoded nested contract errors instead of only raw error text
+
 ## 3.0.24 - 2026-03-19
 
 ### Fixed
@@ -8,6 +49,7 @@
   - `get_pool_info` MCP-side market price resolution no longer falls back from fresh Oracle to ticker-derived price.
   - Beta LP router / `PoolManager` fallback mappings were completed for MCP-managed LP and create-market paths.
   - `get_my_lp_holdings` no longer ranks rows by mixed BASE/QUOTE LP raw balances.
+  - `open_position_simple` no longer auto-fills a fresh Oracle price for `MARKET` orders; callers must provide `price` explicitly.
 
 ### Changed
 - Synced release metadata and operator docs for `v3.0.24`:

package/README.md

@@ -10,7 +10,7 @@ A production-ready MCP (Model Context Protocol) server for deep integration with
 - **SDK baseline**: `@myx-trade/sdk@^1.0.4-beta.4` 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.
-- **Safety refresh**: Docs and prompt guidance now reflect Oracle-only execution, exact-approval defaults, notional-based fee checks, TP/SL semantic validation, and LP preview fail-close behavior.
+- **Safety refresh**: Docs and prompt guidance now reflect explicit-price execution for `open_position_simple`, exact-approval defaults, notional-based fee checks, TP/SL semantic validation, and LP preview fail-close behavior.
 - **Breaking changes**: Many low-level tools (e.g., `get_market_price`, `get_oracle_price`, `get_open_orders`) have been merged into unified counterparts.
 
 ---
@@ -37,6 +37,7 @@ CHAIN_ID=...
 BROKER_ADDRESS=0x...
 QUOTE_TOKEN_ADDRESS=0x...
 QUOTE_TOKEN_DECIMALS=...
+IS_BETA_MODE=true
 ```
 
 ## Testnet `MYXBroker` Reference
@@ -45,6 +46,7 @@ QUOTE_TOKEN_DECIMALS=...
 - Linea test: `0x634EfDC9dC76D7AbF6E49279875a31B02E9891e2`
 
 Use the broker that matches your active RPC and chain configuration.
+If `IS_BETA_MODE` is omitted, MCP now auto-detects beta mode for the two testnet brokers above.
 
 ---
 
@@ -72,7 +74,7 @@ Use the broker that matches your active RPC and chain configuration.
 * **`get_orders`**: Historical and active order ledger.
 * **`get_positions_all`**: Currently open and recently closed positions.
 * **`get_trade_flow`**: Granular transaction history.
-* **`check_account_ready`**: Pre-trade balance validator with auto-deposit support.
+* **`check_account_ready`**: Pre-trade balance validator aligned with SDK `availableMarginBalance` semantics.
 
 ---
 
@@ -80,21 +82,27 @@ Use the broker that matches your active RPC and chain configuration.
 
 1. **Find Target**: `find_pool(keyword="BTC")`
 2. **Check State**: `get_account_snapshot(poolId="...")`
-3. **Execute**: `open_position_simple(poolId="...", direction="LONG", leverage=5, collateralAmount="100")`
+3. **Execute**: `open_position_simple(poolId="...", direction="LONG", leverage=5, collateralAmount="100", price="2500")`
 4. **Monitor**: `get_positions_all(status="OPEN")`
 
 ---
 
 # Safety Defaults
 
-- **Oracle-only execution**: trading paths now require a fresh Oracle price and reject stale / missing execution prices.
+- **Explicit execution price**: `open_position_simple` no longer auto-fills a fresh Oracle price for `MARKET` orders; provide `price` explicitly when opening a position.
+- **SDK-delegated funding delta**: MCP no longer performs its own increase-order margin/deposit reconciliation. New increase orders delegate collateral shortfall handling to SDK `createIncreaseOrder`.
+- **Beta broker compatibility**: current Arbitrum Sepolia / Linea Sepolia test brokers auto-enable beta mode when `IS_BETA_MODE` is unset.
 - **Exact approvals by default**: local fallback flows now prefer exact approvals instead of implicit unlimited approval.
 - **Size semantics**: `size` always means base-asset quantity, not USD notional.
+- **Pre-check semantics**: `check_account_ready` now uses SDK `getAvailableMarginBalance`. When that read fails, the response marks `summary.degraded=true` and includes diagnostics instead of silently trusting stale `freeMargin`.
 - **Direction validation**: when a tool operates on an existing `positionId`, the supplied `direction` must match the live position.
 - **TP/SL semantics**: LONG requires `tpPrice > entryPrice` and `slPrice < entryPrice`; SHORT uses the inverse.
 - **LP safety**: LP preview failures are fail-close and no longer downgrade to `minAmountOut=0`.
+- **LP slippage input**: `manage_liquidity.slippage` only validates numeric format and ratio normalization; MCP no longer imposes its own 5% business cap.
 - **LP metadata safety**: `get_pool_metadata(includeLiquidity=true)` now ignores caller-supplied `marketPrice` and derives liquidity depth from a fresh Oracle price only.
 - **LP holdings semantics**: `get_my_lp_holdings` is an inventory view; returned rows are no longer ranked by mixed BASE/QUOTE LP raw balances.
+- **LP token-source safety**: `get_my_lp_holdings` now falls back to live `poolInfo.basePool.poolToken` / `poolInfo.quotePool.poolToken` when market-detail token addresses are stale or mismatched.
+- **LP approval fallback**: when SDK LP deposit paths fail on non-standard `allowance()` reads, MCP falls back to direct router approval/execution instead of stopping at the SDK error.
 
 ---
 
@@ -168,7 +176,7 @@ For `get_pool_metadata(includeLiquidity=true)`, do not rely on a custom `marketP
     "direction": "LONG",
     "collateralAmount": "100",
     "leverage": 5,
-    "orderType": "LIMIT",
+    "orderType": "MARKET",
     "price": "2.5"
   }
 }

package/TOOL_EXAMPLES.md

@@ -1,4 +1,4 @@
-# MYX MCP Tool Examples Handbook (v3.0.24)
+# MYX MCP Tool Examples Handbook
 
 This guide provides practical MCP payload examples for the current unified toolset.
 All examples use the MCP format:
@@ -82,8 +82,9 @@ Recommended high-level entry tool.
 `marketId` is optional on `open_position_simple`. If supplied, it is validated against the market resolved from `poolId` or `keyword`.
 `size` is always the base-asset quantity, not the USD notional. For example, a 500 USD order at price 1200 implies `size ≈ 0.416666...`.
 `collateralAmount` remains required on `open_position_simple`; if omitted, MCP now returns an actionable suggestion instead of a generic parse error.
-If `price` is omitted, the tool uses a fresh Oracle price only; stale or unresolved execution prices are rejected.
+Provide `price` explicitly for both `MARKET` and `LIMIT/STOP` on `open_position_simple`. MCP no longer auto-fills a fresh Oracle price for `MARKET`.
 Auto-computed `tradingFee` follows notional semantics rather than raw collateral-only estimation.
+`autoDeposit` is now a deprecated compatibility flag. MCP delegates increase-order funding deltas to the SDK during `createIncreaseOrder`.
 
 Raw-units example:
 
@@ -95,7 +96,8 @@ Raw-units example:
     "direction": "SHORT",
     "collateralAmount": "raw:100000000",
     "leverage": 10,
-    "orderType": "MARKET"
+    "orderType": "MARKET",
+    "price": "raw:2000000000000000000000000000000000"
   }
 }
 ```
@@ -302,6 +304,9 @@ Alias-friendly form also works:
 
 LP preview failures now fail closed; the server no longer downgrades to `minAmountOut=0`.
 Oracle-backed LP pricing requires a fresh price snapshot before execution.
+`slippage` here is a ratio, so `0.01 = 1%` and `0.005 = 0.5%`.
+MCP no longer adds its own 5% LP slippage business cap on top of the provided value.
+When the SDK LP path fails on a non-standard token `allowance()` read, MCP falls back to the direct router path automatically.
 
 ### `get_lp_price`
 Read LP NAV price for BASE or QUOTE side.
@@ -332,6 +337,7 @@ Read current LP balances across pools.
 ```
 
 `get_my_lp_holdings` is an inventory view. Results are now stably ordered by symbol / pool id instead of summing BASE LP raw units with QUOTE LP raw units into a misleading mixed-unit ranking.
+If market detail exposes stale LP token addresses, MCP now re-checks live pool token addresses from pool info before reporting balances.
 
 ---
 
@@ -362,6 +368,8 @@ Pre-check whether collateral is available before trading.
 }
 ```
 
+`check_account_ready` now uses SDK `getAvailableMarginBalance` as its primary trading-account source. If the SDK read degrades, the response includes `summary.degraded=true` plus diagnostics such as `sdkAvailableMarginBalance`, `accountInfoFreeMargin`, and `availableMarginError`.
+
 ### `get_orders`
 Read open orders, history, or both.
 

package/dist/auth/resolveClient.js

@@ -2,6 +2,10 @@ import { MyxClient } from "@myx-trade/sdk";
 import { JsonRpcProvider, Wallet } from "ethers";
 import { normalizeAddress } from "../utils/address.js";
 let cached = null;
+const BETA_BROKERS_BY_CHAIN = {
+    421614: ["0x895c4ae2a22bb26851011d733a9355f663a1f939"],
+    59141: ["0x634efdc9dc76d7abf6e49279875a31b02e9891e2"],
+};
 function getDefaultBrokerByChainId(chainId) {
     // Testnet mappings
     if (chainId === 421614)
@@ -18,6 +22,14 @@ function getDefaultQuoteTokenByChainId(chainId) {
         return "0xD984fd34f91F92DA0586e1bE82E262fF27DC431b"; // Linea Sepolia
     return "0xD984fd34f91F92DA0586e1bE82E262fF27DC431b";
 }
+function resolveIsBetaMode(chainId, brokerAddressRaw) {
+    const explicit = String(process.env.IS_BETA_MODE ?? "").trim().toLowerCase();
+    if (explicit === "true")
+        return true;
+    if (explicit === "false")
+        return false;
+    return Boolean(BETA_BROKERS_BY_CHAIN[chainId]?.includes(String(brokerAddressRaw ?? "").trim().toLowerCase()));
+}
 export async function resolveClient() {
     if (cached)
         return cached;
@@ -25,7 +37,6 @@ export async function resolveClient() {
     const privateKey = process.env.PRIVATE_KEY;
     const chainId = Number(process.env.CHAIN_ID) || 59141;
     const isTestnet = process.env.IS_TESTNET !== "false";
-    const isBetaMode = String(process.env.IS_BETA_MODE ?? "").trim().toLowerCase() === "true";
     const brokerAddressRaw = process.env.BROKER_ADDRESS || getDefaultBrokerByChainId(chainId);
     const quoteTokenRaw = process.env.QUOTE_TOKEN_ADDRESS || getDefaultQuoteTokenByChainId(chainId);
     const quoteDecimals = Number(process.env.QUOTE_TOKEN_DECIMALS) || 6;
@@ -39,6 +50,7 @@ export async function resolveClient() {
         throw new Error("QUOTE_TOKEN_ADDRESS env var is required.");
     const brokerAddress = normalizeAddress(brokerAddressRaw, "BROKER_ADDRESS");
     const quoteToken = normalizeAddress(quoteTokenRaw, "QUOTE_TOKEN_ADDRESS");
+    const isBetaMode = resolveIsBetaMode(chainId, brokerAddress);
     const provider = new JsonRpcProvider(rpcUrl);
     const signer = new Wallet(privateKey, provider);
     // Inject the EIP-1193 mock so SDK can sign transactions seamlessly

package/dist/prompts/tradingGuide.js

@@ -12,14 +12,14 @@ export const tradingGuidePrompt = {
                     content: {
                         type: "text",
                         text: `
-# MYX Trading MCP Best Practices (v3.0.24)
+# MYX Trading MCP Best Practices (v3.0.27)
 
 You are an expert crypto trader using the MYX Protocol. To ensure successful execution and safe handling of user funds, follow these patterns:
 
 ## 1. The Standard Workflow
 1. **Discovery**: Use \`search_tools\` if the intent is unclear, then use \`find_pool\` with a keyword (e.g. "BTC") to get the \`poolId\`. 
 2. **Context**: Use \`get_account_snapshot\` (with \`poolId\`) to check balances, trading metrics, and VIP tier. Use \`get_price\` for real-time market/oracle prices.
-3. **Pre-check**: Use \`check_account_ready\` to ensure the trading account has enough collateral.
+3. **Pre-check**: Use \`check_account_ready\` to inspect SDK-aligned \`availableMarginBalance\` before trading.
 4. **Execution**: Prefer \`open_position_simple\` for entry. It supports Stop-Loss (\`slPrice\`) and Take-Profit (\`tpPrice\`) in one call.
 5. **Monitoring**: Use \`get_positions_all\` to track active trades and \`get_orders\` for pending/filled history.
 6. **Unified Operations**: Use \`cancel_orders\` for targeted or global撤单, and \`manage_tp_sl\` to update protection orders.
@@ -33,17 +33,23 @@ You are an expert crypto trader using the MYX Protocol. To ensure successful exe
 - **Liquidity Metadata**: When calling \`get_pool_metadata(includeLiquidity=true)\`, MCP uses a fresh Oracle price automatically and ignores caller-supplied \`marketPrice\`.
 - **LP Strategy**: Use \`get_my_lp_holdings\` to monitor liquidity positions. Naming follows \`mBASE.QUOTE\` (e.g., \`mBTC.USDC\`).
 - **Enum Tolerance**: The server tolerates common lowercase or alias inputs such as \`open\`, \`base\`, \`buy\`, and \`add\`, but canonical forms are still preferred in documentation.
-- **Oracle Safety**: Execution flows now require a fresh Oracle price. Do not fall back to stale ticker or user-supplied execution prices when the Oracle is unavailable.
+- **Execution Price**: \`open_position_simple\` no longer auto-fills a fresh Oracle price for \`MARKET\`; provide \`price\` explicitly when you want MCP to compute size / fee previews.
+- **Funding Delta Ownership**: MCP no longer performs its own increase-order margin/deposit reconciliation. SDK \`createIncreaseOrder\` owns deposit-delta handling for new increase orders.
+- **Pre-check Diagnostics**: \`check_account_ready\` now reports SDK \`availableMarginBalance\` first. If that read degrades, inspect \`summary.degraded\` and \`diagnostics.availableMarginError\` before trusting fallback account fields.
+- **Beta Broker Mode**: Current Arbitrum Sepolia / Linea Sepolia test brokers auto-enable beta mode when \`IS_BETA_MODE\` is omitted.
 - **Approval Safety**: Local fallback flows prefer exact approval sizing. Do not assume unlimited approvals are necessary.
 - **Position Semantics**: \`size\` is BASE quantity, not USD notional. If a \`positionId\` is supplied, \`direction\` must match the live position.
 - **TP/SL Semantics**: LONG should use \`tpPrice > entryPrice\` and \`slPrice < entryPrice\`; SHORT uses the inverse. Plain integer strings like \`"65000"\` are treated as human prices, not implicit raw 30-decimal values.
 - **LP Safety**: LP execution requires a fresh price snapshot and preview success; do not continue after preview failure.
 - **LP Read Semantics**: Treat \`get_my_lp_holdings\` as an inventory listing, not a portfolio ranking by economic value.
+- **LP Token Resolution**: If LP balances look empty but pool supply changed, re-check live pool token addresses from pool info instead of trusting market-detail LP token addresses blindly.
+- **LP Approval Fallback**: Some test tokens revert on \`allowance()\`; MCP should treat that as a recoverable LP write-path issue and try the direct router approval/execution path.
 
 ## 3. Testnet Broker Reference
 - Arbitrum test: \`0x895C4ae2A22bB26851011d733A9355f663a1F939\`
 - Linea test: \`0x634EfDC9dC76D7AbF6E49279875a31B02E9891e2\`
 - Always keep \`RPC_URL\`, \`CHAIN_ID\`, and \`BROKER_ADDRESS\` on the same network.
+- If \`IS_BETA_MODE\` is unset, MCP auto-detects beta mode for those two testnet brokers.
 
 Current Session:
 - Wallet: ${address}

package/dist/server.js

@@ -461,7 +461,7 @@ function zodSchemaToJsonSchema(zodSchema) {
     };
 }
 // ─── MCP Server ───
-const server = new Server({ name: "myx-mcp-trading-server", version: "3.0.24" }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
+const server = new Server({ name: "myx-mcp-trading-server", version: "3.0.27" }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
 // List tools
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {

package/dist/services/poolService.js

@@ -110,6 +110,14 @@ function isAbiLengthMismatchError(message) {
 function isSdkWaitNotFunctionError(message) {
     return message.toLowerCase().includes("wait is not a function");
 }
+function isAllowanceReadError(message) {
+    const lower = message.toLowerCase();
+    return (lower.includes("function \"allowance\" reverted") ||
+        lower.includes("function 'allowance' reverted") ||
+        lower.includes("allowance(address owner, address spender)") ||
+        lower.includes("allowance(address,address)") ||
+        lower.includes("allowance reverted"));
+}
 function readLastMockTxHash() {
     const hash = String(globalThis?.__MCP_LAST_TX_HASH ?? "").trim();
     if (!hash.startsWith("0x") || hash.length !== 66)
@@ -198,12 +206,6 @@ function applyMinOutBySlippage(amountOut, slippage) {
     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;
@@ -212,14 +214,14 @@ async function getMarketDetailOrThrow(client, chainId, poolId) {
     }
     return detail;
 }
-async function buildOraclePricePayload(client, chainId, poolId, fallbackOracleType) {
+async function buildOraclePricePayload(client, chainId, poolId) {
     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 = assertOracleFreshness(oracle?.publishTime, poolId);
-    const oracleType = Number.isFinite(Number(oracle?.oracleType)) ? Number(oracle.oracleType) : fallbackOracleType;
+    const oracleType = Number.isFinite(Number(oracle?.oracleType)) ? Number(oracle.oracleType) : 1;
     const value = toPositiveBigint(oracle?.value) ?? 0n;
     const referencePrice30 = BigInt(ensureUnits(String(oracle?.price ?? "0"), 30, "oracle price"));
     if (referencePrice30 <= 0n) {
@@ -267,28 +269,52 @@ async function executeLiquidityTxViaRouter(params) {
         throw new Error(`Liquidity ${poolType.toLowerCase()} ${action} amount must be > 0.`);
     }
     let approvalTxHash = null;
+    let approvalMode = "not_required";
+    let allowanceReadError = null;
     if (action === "deposit") {
         const tokenAddress = normalizeAddress(poolType === "QUOTE" ? marketDetail.quoteToken : marketDetail.baseToken, poolType === "QUOTE" ? "quoteToken" : "baseToken");
+        const approvalSpender = poolType === "QUOTE" ? addresses.quotePool : addresses.basePool;
         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, amountIn);
+        let needsApproval = true;
+        try {
+            const allowance = toPositiveBigint(await tokenContract.allowance(address, approvalSpender)) ?? 0n;
+            needsApproval = allowance < amountIn;
+            approvalMode = needsApproval ? "checked_allowance_then_approve" : "existing_allowance";
+            if (!needsApproval) {
+                logger.info(`[LP fallback] allowance already sufficient for ${poolType} deposit. spender=${approvalSpender}, current=${allowance.toString()}, required=${amountIn.toString()}`);
+            }
+        }
+        catch (error) {
+            allowanceReadError = extractErrorMessage(error);
+            approvalMode = "optimistic_approve_after_allowance_revert";
+            logger.warn(`[LP fallback] allowance read failed for ${poolType} deposit; trying direct approve on spender=${approvalSpender}. error=${allowanceReadError}`);
+        }
+        if (needsApproval) {
+            logger.info(`[LP fallback] approving spender=${approvalSpender} for ${poolType} deposit. required=${amountIn.toString()}, mode=${approvalMode}`);
+            const approveTx = await tokenContract.approve(approvalSpender, amountIn);
             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.`);
+                throw new Error(`Approval transaction reverted for ${poolType} deposit (spender=${approvalSpender}).`);
             }
         }
     }
-    const needOraclePrice = shouldUseOraclePriceByState(marketDetail.state);
     let oraclePayload = {
         prices: [],
         value: 0n,
         referencePrice30: 0n,
     };
-    if (needOraclePrice) {
-        oraclePayload = await buildOraclePricePayload(client, chainId, poolId, Number(marketDetail.oracleType ?? 1));
+    try {
+        oraclePayload = await buildOraclePricePayload(client, chainId, poolId);
+    }
+    catch {
+        const fallbackPrice = await resolvePositiveMarketPrice30(client, poolId, chainId);
+        if (fallbackPrice && fallbackPrice > 0n) {
+            oraclePayload.referencePrice30 = fallbackPrice;
+        }
+    }
+    if (oraclePayload.referencePrice30 <= 0n) {
+        throw new Error(`Oracle price unavailable for LP preview on pool ${poolId}.`);
     }
     const amountOut = await previewAmountOutForLiquidity(signer, chainId, poolId, poolType, action, amountIn, oraclePayload.referencePrice30);
     const minAmountOut = applyMinOutBySlippage(amountOut, slippage);
@@ -361,9 +387,51 @@ async function executeLiquidityTxViaRouter(params) {
             usedOraclePrice: oraclePayload.prices.length > 0,
             oracleValue: oraclePayload.value.toString(),
             approvalTxHash,
+            approvalMode,
+            allowanceReadError,
+            approvalSpender: action === "deposit" ? (poolType === "QUOTE" ? addresses.quotePool : addresses.basePool) : null,
         },
     };
 }
+async function executeLiquidityTx(params) {
+    const { chainId, poolId, poolType, action, amount, slippage } = params;
+    const sdkAmount = Number(String(amount ?? "").trim());
+    const beforeHash = readLastMockTxHash();
+    if (!Number.isFinite(sdkAmount) || sdkAmount <= 0) {
+        logger.warn(`[LP SDK] amount=${String(amount)} is not a finite positive human number; using explicit router path for ${poolType} ${action}.`);
+        return executeLiquidityTxViaRouter(params);
+    }
+    try {
+        return await withMutedSdkAbiMismatchLogs(async () => {
+            if (poolType === "QUOTE" && action === "deposit") {
+                return await quote.deposit({ chainId, poolId, amount: sdkAmount, slippage });
+            }
+            if (poolType === "QUOTE" && action === "withdraw") {
+                return await quote.withdraw({ chainId, poolId, amount: sdkAmount, slippage });
+            }
+            if (poolType === "BASE" && action === "deposit") {
+                return await base.deposit({ chainId, poolId, amount: sdkAmount, slippage });
+            }
+            return await base.withdraw({ chainId, poolId, amount: sdkAmount, slippage });
+        });
+    }
+    catch (error) {
+        const message = extractErrorMessage(error);
+        const recovered = recoverSdkSubmittedTxHash(beforeHash, message, { poolType, action });
+        if (recovered) {
+            return recovered;
+        }
+        if (isAbiLengthMismatchError(message)) {
+            logger.warn(`[LP SDK] ABI overload mismatch for ${poolType} ${action}; falling back to explicit router path.`);
+            return executeLiquidityTxViaRouter(params);
+        }
+        if (isAllowanceReadError(message)) {
+            logger.warn(`[LP SDK] allowance read failed for ${poolType} ${action}; falling back to explicit router path.`);
+            return executeLiquidityTxViaRouter(params);
+        }
+        throw error;
+    }
+}
 async function resolvePositiveMarketPrice30(client, poolId, chainId) {
     if (!client)
         return null;
@@ -494,28 +562,28 @@ export async function getLiquidityInfo(client, poolId, chainIdOverride) {
  */
 export async function quoteDeposit(poolId, amount, slippage, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    return executeLiquidityTxViaRouter({ chainId, poolId, poolType: "QUOTE", action: "deposit", amount, slippage });
+    return executeLiquidityTx({ chainId, poolId, poolType: "QUOTE", action: "deposit", amount, slippage });
 }
 /**
  * Quote 池 withdraw
  */
 export async function quoteWithdraw(poolId, amount, slippage, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    return executeLiquidityTxViaRouter({ chainId, poolId, poolType: "QUOTE", action: "withdraw", amount, slippage });
+    return executeLiquidityTx({ chainId, poolId, poolType: "QUOTE", action: "withdraw", amount, slippage });
 }
 /**
  * Base 池 deposit
  */
 export async function baseDeposit(poolId, amount, slippage, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    return executeLiquidityTxViaRouter({ chainId, poolId, poolType: "BASE", action: "deposit", amount, slippage });
+    return executeLiquidityTx({ chainId, poolId, poolType: "BASE", action: "deposit", amount, slippage });
 }
 /**
  * Base 池 withdraw
  */
 export async function baseWithdraw(poolId, amount, slippage, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    return executeLiquidityTxViaRouter({ chainId, poolId, poolType: "BASE", action: "withdraw", amount, slippage });
+    return executeLiquidityTx({ chainId, poolId, poolType: "BASE", action: "withdraw", amount, slippage });
 }
 /**
  * 获取 LP 价格

package/dist/services/tradeService.js

@@ -4,7 +4,6 @@ import { getChainId, getQuoteToken, getQuoteDecimals } from "../auth/resolveClie
 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";
 import { mapTimeInForce } from "../utils/mappings.js";
 import { getFreshOraclePrice } from "./marketService.js";
@@ -96,17 +95,6 @@ function parseDecimals(value, fallback) {
 function normalizeIdentifier(value) {
     return String(value ?? "").trim().toLowerCase();
 }
-function toBigIntOrZero(value) {
-    try {
-        const text = String(value ?? "").trim();
-        if (!text)
-            return 0n;
-        return BigInt(text);
-    }
-    catch {
-        return 0n;
-    }
-}
 const ORDER_VALUE_SCALE = 1000000n;
 const DECIMAL_INPUT_RE = /^\d+(\.\d+)?$/;
 function parseScaledDecimal(value, scale, label) {
@@ -155,37 +143,6 @@ function validateIncreaseOrderEconomics(args) {
     const priceHuman = formatUnits(priceRawBig, 30);
     throw new Error(`Invalid size semantics: size is BASE quantity, not USD notional. collateralAmount*leverage implies ≈${targetHuman} quote, but size*price implies ≈${actualHuman} quote. At price ${priceHuman}, recommended size is ≈${recommendedSizeHuman}.`);
 }
-function countAdditionalExecutionOrders(args) {
-    let count = 1;
-    if (String(args.tpPrice ?? "").trim()) {
-        count += 1;
-    }
-    if (String(args.slPrice ?? "").trim()) {
-        count += 1;
-    }
-    return count;
-}
-async function getRequiredIncreaseSpendRaw(client, marketId, args, chainId) {
-    const collateralRaw = BigInt(args.collateralRaw);
-    const tradingFeeRaw = BigInt(args.tradingFeeRaw);
-    const executionOrderCount = countAdditionalExecutionOrders(args);
-    const networkFeeText = String(await client.utils.getNetworkFee(marketId, chainId) ?? "").trim();
-    if (!/^\d+$/.test(networkFeeText)) {
-        throw new Error(`Failed to resolve networkFee for marketId=${marketId}.`);
-    }
-    const baseNetworkFeeRaw = BigInt(networkFeeText);
-    if (baseNetworkFeeRaw <= 0n) {
-        throw new Error(`networkFee must be > 0 for marketId=${marketId}.`);
-    }
-    const networkFeeRaw = baseNetworkFeeRaw * BigInt(executionOrderCount);
-    return {
-        collateralRaw,
-        tradingFeeRaw,
-        networkFeeRaw,
-        executionOrderCount,
-        totalSpendRaw: collateralRaw + tradingFeeRaw + networkFeeRaw,
-    };
-}
 async function resolveDecimalsForUpdateOrder(client, chainId, marketId, poolIdHint) {
     let baseDecimals = 18;
     let quoteDecimals = getQuoteDecimals();
@@ -283,16 +240,8 @@ export async function openPosition(client, address, args) {
     const tradingFeeRaw = ensureUnits(args.tradingFee, quoteDecimals, "tradingFee", { allowImplicitRaw: false });
     const resolvedMarketId = String(args.marketId ?? poolData.marketId ?? "").trim();
     if (!resolvedMarketId) {
-        throw new Error(`marketId is required to compute networkFee for poolId=${args.poolId}.`);
+        throw new Error(`marketId is required for poolId=${args.poolId}.`);
     }
-    const spend = await getRequiredIncreaseSpendRaw(client, resolvedMarketId, {
-        collateralRaw,
-        tradingFeeRaw,
-        tpPrice: args.tpPrice,
-        tpSize: args.tpSize,
-        slPrice: args.slPrice,
-        slSize: args.slSize,
-    }, chainId);
     validateIncreaseOrderEconomics({
         collateralRaw,
         sizeRaw,
@@ -302,43 +251,6 @@ export async function openPosition(client, address, args) {
         quoteDecimals,
     });
     const timeInForce = mapTimeInForce(args.timeInForce);
-    // --- Auto-Deposit Logic (Strict) ---
-    const allowAutoDeposit = args.autoDeposit !== false;
-    console.log(`[tradeService] Checking marginBalance for ${address} in pool ${args.poolId}...`);
-    const marginInfo = await client.account.getAccountInfo(chainId, address, args.poolId);
-    let marginBalanceRaw = BigInt(0);
-    let walletBalanceRaw = BigInt(0);
-    if (marginInfo?.code === 0 && marginInfo?.data) {
-        marginBalanceRaw = toBigIntOrZero(marginInfo.data.freeMargin);
-        walletBalanceRaw = toBigIntOrZero(marginInfo.data.walletBalance);
-    }
-    const requiredRaw = spend.totalSpendRaw;
-    if (marginBalanceRaw < requiredRaw) {
-        if (!allowAutoDeposit) {
-            throw new Error(`Insufficient marginBalance (${marginBalanceRaw.toString()}) for required collateral (${requiredRaw.toString()}). ` +
-                `Deposit to trading account first (account_deposit) or retry with autoDeposit=true.`);
-        }
-        const neededRaw = requiredRaw - marginBalanceRaw;
-        console.log(`[tradeService] marginBalance (${marginBalanceRaw.toString()}) < Required (${requiredRaw.toString()}). Need to deposit: ${neededRaw.toString()}`);
-        if (walletBalanceRaw < neededRaw) {
-            // Also check real wallet balance just in case account info wallet field is stale.
-            const realWalletRes = await client.account.getWalletQuoteTokenBalance(chainId, address);
-            const realWalletRaw = BigInt(realWalletRes?.data || "0");
-            if (realWalletRaw < neededRaw) {
-                throw new Error(`Insufficient funds: marginBalance (${marginBalanceRaw.toString()}) + walletBalance (${walletBalanceRaw.toString()}) + realWallet (${realWalletRaw.toString()}) is less than required collateral (${requiredRaw.toString()}).`);
-            }
-            walletBalanceRaw = realWalletRaw;
-        }
-        console.log(`[tradeService] Depositing ${neededRaw.toString()} ${poolData.quoteSymbol} from wallet...`);
-        const depositRaw = await client.account.deposit({
-            amount: neededRaw.toString(),
-            tokenAddress: poolData.quoteToken,
-            chainId
-        });
-        const depositResult = await finalizeMutationResult(depositRaw, client.signer || (client.provider ? { provider: client.provider } : null), "auto_deposit");
-        console.log(`[tradeService] Auto-deposit confirmed in tx: ${depositResult.confirmation?.txHash}`);
-    }
-    // --- End Auto-Deposit Logic ---
     const orderParams = {
         chainId,
         address,
@@ -364,7 +276,7 @@ export async function openPosition(client, address, args) {
         orderParams.slSize = ensureUnits(args.slSize, baseDecimals, "slSize", { allowImplicitRaw: false });
     if (args.slPrice)
         orderParams.slPrice = ensureUnits(args.slPrice, 30, "slPrice", { allowImplicitRaw: false });
-    return client.order.createIncreaseOrder(orderParams, tradingFeeRaw, args.marketId);
+    return client.order.createIncreaseOrder(orderParams, tradingFeeRaw, resolvedMarketId);
 }
 /**
  * 平仓 / 减仓

package/dist/tools/checkAccountReady.js

@@ -31,20 +31,32 @@ export const checkAccountReadyTool = {
             const detail = detailRes?.data || detailRes;
             const quoteDecimals = Number(detail?.quoteDecimals ?? 6);
             const quoteSymbol = detail?.quoteSymbol || "USDC";
-            const marginInfo = await client.account.getAccountInfo(chainId, address, poolId);
-            let marginBalanceRaw = 0n;
+            const availableMarginRes = await client.account.getAvailableMarginBalance({ chainId, address, poolId }).catch((error) => ({
+                code: -1,
+                message: error?.message || String(error),
+            }));
+            const availableMarginBalanceRaw = availableMarginRes?.code === 0
+                ? toBigIntOrZero(availableMarginRes.data)
+                : 0n;
+            const marginInfo = await client.account.getAccountInfo(chainId, address, poolId).catch(() => null);
             let accountWalletBalanceRaw = 0n;
+            let freeMarginRaw = 0n;
+            let quoteProfitRaw = 0n;
+            let lockedMarginRaw = 0n;
             if (marginInfo?.code === 0 && marginInfo?.data) {
-                marginBalanceRaw = toBigIntOrZero(marginInfo.data.freeMargin);
+                freeMarginRaw = toBigIntOrZero(marginInfo.data.freeMargin);
+                quoteProfitRaw = toBigIntOrZero(marginInfo.data.quoteProfit);
+                lockedMarginRaw = toBigIntOrZero(marginInfo.data.lockedMargin);
                 accountWalletBalanceRaw = toBigIntOrZero(marginInfo.data.walletBalance);
             }
             const walletRes = await client.account.getWalletQuoteTokenBalance(chainId, address);
             const walletBalanceRaw = BigInt(walletRes?.data || "0");
             const requiredRaw = BigInt(parseUserUnits(args.collateralAmount, quoteDecimals, "required"));
-            const isReady = (marginBalanceRaw >= requiredRaw) || (marginBalanceRaw + walletBalanceRaw >= requiredRaw);
-            const deficitRaw = requiredRaw > marginBalanceRaw ? requiredRaw - marginBalanceRaw : 0n;
+            const isReady = (availableMarginBalanceRaw >= requiredRaw) || (availableMarginBalanceRaw + walletBalanceRaw >= requiredRaw);
+            const deficitRaw = requiredRaw > availableMarginBalanceRaw ? requiredRaw - availableMarginBalanceRaw : 0n;
             const needDepositFromWallet = deficitRaw > 0n;
             const walletSufficient = walletBalanceRaw >= deficitRaw;
+            const degraded = availableMarginRes?.code !== 0;
             const format = (v) => ethers.formatUnits(v, quoteDecimals);
             return {
                 content: [{
@@ -54,14 +66,22 @@ export const checkAccountReadyTool = {
                             data: {
                                 isReady,
                                 neededTotal: format(requiredRaw),
-                                currentMarginBalance: format(marginBalanceRaw),
+                                currentAvailableMarginBalance: format(availableMarginBalanceRaw),
                                 currentWalletBalance: format(walletBalanceRaw),
                                 summary: {
-                                    hasEnoughInMargin: marginBalanceRaw >= requiredRaw,
+                                    hasEnoughInMargin: availableMarginBalanceRaw >= requiredRaw,
                                     needDepositFromWallet,
                                     walletSufficientForDeposit: walletSufficient,
                                     accountInfoWalletBalance: format(accountWalletBalanceRaw),
+                                    degraded,
                                     quoteSymbol
+                                },
+                                diagnostics: {
+                                    sdkAvailableMarginBalance: format(availableMarginBalanceRaw),
+                                    accountInfoFreeMargin: format(freeMarginRaw),
+                                    accountInfoQuoteProfit: format(quoteProfitRaw),
+                                    accountInfoLockedMargin: format(lockedMarginRaw),
+                                    availableMarginError: degraded ? String(availableMarginRes?.message || "Failed to get available margin balance") : null,
                                 }
                             }
                         }, null, 2)

package/dist/tools/getMyLpHoldings.js

@@ -4,6 +4,7 @@ import { COMMON_LP_AMOUNT_DECIMALS } from "@myx-trade/sdk";
 import { Contract, formatUnits } from "ethers";
 import { extractErrorMessage } from "../utils/errorMessage.js";
 import { getPoolList } from "../services/marketService.js";
+import { getPoolInfo } from "../services/poolService.js";
 const ADDRESS_RE = /^0x[a-fA-F0-9]{40}$/;
 const ERC20_BALANCE_ABI = ["function balanceOf(address owner) view returns (uint256)"];
 function collectRows(input) {
@@ -126,22 +127,61 @@ async function readErc20Balance(provider, tokenAddress, holder) {
     const balance = await contract.balanceOf(holder);
     return BigInt(balance).toString();
 }
+function collectAddressCandidates(...values) {
+    const unique = new Set();
+    for (const value of values) {
+        const normalized = readAddress(value);
+        if (normalized)
+            unique.add(normalized.toLowerCase());
+    }
+    return Array.from(unique.values());
+}
+async function resolveLpBalanceFromCandidates(provider, holder, candidateAddresses) {
+    let selectedAddress = null;
+    let selectedBalanceRaw = "0";
+    const warnings = [];
+    for (const candidate of candidateAddresses) {
+        try {
+            const balanceRaw = await readErc20Balance(provider, candidate, holder);
+            if (!selectedAddress) {
+                selectedAddress = candidate;
+                selectedBalanceRaw = balanceRaw;
+            }
+            if (BigInt(balanceRaw) > 0n) {
+                return { tokenAddress: candidate, balanceRaw, warnings };
+            }
+        }
+        catch (error) {
+            warnings.push(`${candidate}: ${extractErrorMessage(error)}`);
+        }
+    }
+    return {
+        tokenAddress: selectedAddress,
+        balanceRaw: selectedBalanceRaw,
+        warnings,
+    };
+}
 export const getMyLpHoldingsTool = {
     name: "get_my_lp_holdings",
-    description: "[ACCOUNT] List your LP holdings across pools on the current chain by reading base/quote LP token balances. Includes standardized LP asset names: base LP `mBASE.QUOTE`, quote LP `mQUOTE.BASE`.",
+    description: "[ACCOUNT] List your LP holdings across pools on the current wallet chain by reading base/quote LP token balances. Includes standardized LP asset names: base LP `mBASE.QUOTE`, quote LP `mQUOTE.BASE`.",
     schema: {
         includeZero: z.coerce.boolean().optional().describe("If true, include pools with zero LP balances (default false)."),
         poolIds: z.union([z.array(z.string()).min(1), z.string().min(1)]).optional().describe("Optional poolId filter. Supports array, JSON-array string, comma string, or single poolId."),
         maxPools: z.coerce.number().int().positive().max(2000).optional().describe("Optional cap for scanned pools (default all)."),
+        chainId: z.coerce.number().int().positive().optional().describe("Optional chainId hint. Must match the active wallet/provider chain for LP balance reads."),
     },
     handler: async (args) => {
         try {
             const { client, address, signer } = await resolveClient();
-            const chainId = getChainId();
+            const activeChainId = getChainId();
+            const chainId = args.chainId ?? activeChainId;
             const provider = signer?.provider;
             if (!provider) {
                 throw new Error("Provider is unavailable for LP balance reads.");
             }
+            if (chainId !== activeChainId) {
+                throw new Error(`get_my_lp_holdings reads balances from the active wallet/provider chain only. Requested chainId=${chainId}, active chainId=${activeChainId}. Switch MCP network config first, then retry.`);
+            }
             const includeZero = !!args.includeZero;
             const poolIdsFilter = normalizePoolIdsInput(args.poolIds);
             const filterSet = new Set(poolIdsFilter.map((item) => item.toLowerCase()));
@@ -170,6 +210,7 @@ export const getMyLpHoldingsTool = {
                 let basePoolToken = readAddress(row?.basePoolToken ?? row?.base_pool_token);
                 let quotePoolToken = readAddress(row?.quotePoolToken ?? row?.quote_pool_token);
                 let detail = null;
+                let poolInfo = null;
                 if (!basePoolToken || !quotePoolToken) {
                     try {
                         const detailRes = await client.markets.getMarketDetail({ chainId, poolId });
@@ -183,23 +224,34 @@ export const getMyLpHoldingsTool = {
                 }
                 const { baseSymbol, quoteSymbol } = resolveBaseQuoteSymbols(row, detail);
                 const { baseLpAssetName, quoteLpAssetName } = buildLpAssetNames(baseSymbol, quoteSymbol);
-                let baseLpRaw = "0";
-                let quoteLpRaw = "0";
-                if (basePoolToken) {
+                let baseCandidates = collectAddressCandidates(basePoolToken);
+                let quoteCandidates = collectAddressCandidates(quotePoolToken);
+                let baseResolved = await resolveLpBalanceFromCandidates(provider, address, baseCandidates);
+                let quoteResolved = await resolveLpBalanceFromCandidates(provider, address, quoteCandidates);
+                const needPoolInfoEnrichment = (BigInt(baseResolved.balanceRaw) === 0n && BigInt(quoteResolved.balanceRaw) === 0n) ||
+                    !baseResolved.tokenAddress ||
+                    !quoteResolved.tokenAddress;
+                if (needPoolInfoEnrichment) {
                     try {
-                        baseLpRaw = await readErc20Balance(provider, basePoolToken, address);
+                        poolInfo = await getPoolInfo(poolId, chainId, client);
+                        baseCandidates = collectAddressCandidates(...baseCandidates, poolInfo?.basePool?.poolToken, poolInfo?.basePool?.pool_token);
+                        quoteCandidates = collectAddressCandidates(...quoteCandidates, poolInfo?.quotePool?.poolToken, poolInfo?.quotePool?.pool_token);
+                        baseResolved = await resolveLpBalanceFromCandidates(provider, address, baseCandidates);
+                        quoteResolved = await resolveLpBalanceFromCandidates(provider, address, quoteCandidates);
                     }
                     catch (error) {
-                        warnings.push(`pool ${poolId}: failed to read base LP balance (${extractErrorMessage(error)})`);
+                        warnings.push(`pool ${poolId}: failed to enrich pool info (${extractErrorMessage(error)})`);
                     }
                 }
-                if (quotePoolToken) {
-                    try {
-                        quoteLpRaw = await readErc20Balance(provider, quotePoolToken, address);
-                    }
-                    catch (error) {
-                        warnings.push(`pool ${poolId}: failed to read quote LP balance (${extractErrorMessage(error)})`);
-                    }
+                const baseLpRaw = baseResolved.balanceRaw;
+                const quoteLpRaw = quoteResolved.balanceRaw;
+                basePoolToken = baseResolved.tokenAddress ?? basePoolToken;
+                quotePoolToken = quoteResolved.tokenAddress ?? quotePoolToken;
+                for (const warning of baseResolved.warnings) {
+                    warnings.push(`pool ${poolId}: failed to read base LP balance (${warning})`);
+                }
+                for (const warning of quoteResolved.warnings) {
+                    warnings.push(`pool ${poolId}: failed to read quote LP balance (${warning})`);
                 }
                 const hasAnyLp = BigInt(baseLpRaw) > 0n || BigInt(quoteLpRaw) > 0n;
                 if (!includeZero && !hasAnyLp)

package/dist/tools/manageLiquidity.js

@@ -113,7 +113,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 get_pool_metadata.`);
+                throw new Error(`SDK returned an empty result for liquidity ${action}. This usually indicates a contract-level restriction or an unavailable LP execution path. Please check get_pool_metadata and retry.`);
             }
             if (raw && typeof raw === "object" && "code" in raw && Number(raw.code) !== 0) {
                 throw new Error(`Liquidity ${action} failed: ${extractErrorMessage(raw)}`);

package/dist/tools/manageTpSl.js

@@ -73,9 +73,11 @@ 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);
+    if (isExplicitZeroValue(args.tpPrice) && isExplicitZeroValue(args.slPrice))
+        return true;
+    if (isExplicitZeroValue(args.price))
+        return true;
+    return false;
 }
 function isInvalidParameterRevert(error) {
     const message = String(error?.message ?? error ?? "").toLowerCase();

package/dist/tools/openPositionSimple.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { OrderType } from "@myx-trade/sdk";
 import { formatUnits } from "ethers";
 import { resolveClient, getChainId } from "../auth/resolveClient.js";
-import { resolvePool, getFreshOraclePrice } from "../services/marketService.js";
+import { resolvePool } from "../services/marketService.js";
 import { openPosition } from "../services/tradeService.js";
 import { isZeroAddress, normalizeAddress } from "../utils/address.js";
 import { finalizeMutationResult } from "../utils/mutationResult.js";
@@ -10,6 +10,7 @@ import { mapDirection, mapOrderType } from "../utils/mappings.js";
 import { normalizeSlippagePct4dp, SLIPPAGE_PCT_4DP_DESC } from "../utils/slippage.js";
 import { parseUserPrice30, parseUserUnits } from "../utils/units.js";
 import { verifyTradeOutcome } from "../utils/verification.js";
+import { extractErrorMessage } from "../utils/errorMessage.js";
 const MAX_UINT256 = "115792089237316195423570985008687907853269984665640564039457584007913129639935";
 function pow10(decimals) {
     if (!Number.isInteger(decimals) || decimals < 0) {
@@ -100,7 +101,7 @@ export const openPositionSimpleTool = {
         autoDeposit: z.coerce
             .boolean()
             .optional()
-            .describe("If true, auto-deposit to margin account if marginBalance < needed (default false)."),
+            .describe("Deprecated compatibility flag. SDK now handles deposit deltas during order creation."),
         dryRun: z.coerce.boolean().optional().describe("If true, only compute params; do not send a transaction."),
     },
     handler: async (args) => {
@@ -150,18 +151,15 @@ export const openPositionSimpleTool = {
             // 4) Determine reference price (30 decimals)
             let price30;
             let priceMeta = { source: "user", publishTime: null, oracleType: null, human: null };
-            if (orderType === OrderType.MARKET) {
-                const oracle = await getFreshOraclePrice(client, poolId, chainId);
-                price30 = parseUserPrice30(oracle.price, "oraclePrice");
-                priceMeta = { source: "oracle", publishTime: oracle.publishTime, oracleType: oracle.oracleType, human: oracle.price };
-            }
-            else {
-                const userPrice = String(args.price ?? "").trim();
-                if (!userPrice)
-                    throw new Error("price is required for LIMIT/STOP.");
-                price30 = parseUserPrice30(userPrice, "price");
-                priceMeta = { source: "user", publishTime: null, oracleType: null, human: userPrice };
+            const userPrice = String(args.price ?? "").trim();
+            if (!userPrice) {
+                if (orderType === OrderType.MARKET) {
+                    throw new Error("price is required for MARKET orders. MCP no longer auto-fills a fresh Oracle price for MARKET.");
+                }
+                throw new Error("price is required for LIMIT/STOP.");
             }
+            price30 = parseUserPrice30(userPrice, "price");
+            priceMeta = { source: "user", publishTime: null, oracleType: null, human: userPrice };
             const price30Big = asBigint(price30, "price");
             if (price30Big <= 0n)
                 throw new Error("price must be > 0.");
@@ -352,7 +350,7 @@ export const openPositionSimpleTool = {
             };
         }
         catch (error) {
-            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+            return { content: [{ type: "text", text: `Error: ${extractErrorMessage(error)}` }], isError: true };
         }
     },
 };

package/dist/tools/searchTools.js

@@ -82,6 +82,7 @@ const TOOL_DISCOVERY_META = {
         category: "liquidity",
         aliases: ["my lp", "lp balances"],
         intents: ["list my liquidity", "portfolio lp"],
+        commonArgs: ["includeZero", "poolIds", "maxPools", "chainId"],
     },
     get_account_snapshot: {
         category: "account",

package/dist/utils/errorMessage.js

@@ -1,3 +1,4 @@
+import { extractContractErrorFromText } from "./errors.js";
 const USELESS_MESSAGE_SET = new Set([
     "",
     "undefined",
@@ -26,6 +27,39 @@ function safeStringify(value) {
         return cleanMessage(String(value ?? ""));
     }
 }
+function extractContractError(value) {
+    const visited = new Set();
+    const scan = (input, depth) => {
+        if (depth > 6 || input === null || input === undefined)
+            return null;
+        if (typeof input === "string") {
+            return extractContractErrorFromText(input);
+        }
+        if (typeof input === "number" || typeof input === "boolean" || typeof input === "bigint") {
+            return null;
+        }
+        if (input instanceof Error) {
+            return scan(input.message, depth + 1) ?? scan(input.cause, depth + 1);
+        }
+        if (!isRecord(input))
+            return null;
+        if (visited.has(input))
+            return null;
+        visited.add(input);
+        for (const key of ["data", "message", "reason", "shortMessage", "error", "cause", "info", "details"]) {
+            const decoded = scan(input[key], depth + 1);
+            if (decoded)
+                return decoded;
+        }
+        for (const nested of Object.values(input)) {
+            const decoded = scan(nested, depth + 1);
+            if (decoded)
+                return decoded;
+        }
+        return null;
+    };
+    return scan(value, 0);
+}
 export function isMeaningfulErrorMessage(message) {
     return cleanMessage(message) !== null;
 }
@@ -65,5 +99,10 @@ export function extractErrorMessage(error, fallback = "Unknown error") {
         }
         return safeStringify(value);
     };
-    return read(error, 0) ?? fallback;
+    const base = read(error, 0) ?? fallback;
+    const decodedContractError = extractContractError(error);
+    if (decodedContractError && !base.includes(decodedContractError)) {
+        return `${base} (Decoded: ${decodedContractError})`;
+    }
+    return base;
 }

package/dist/utils/errors.js

@@ -254,3 +254,64 @@ export function decodeErrorSelector(errorData) {
     const selector = hex.slice(0, 8);
     return CONTRACT_ERRORS[selector] || null;
 }
+function normalizeErrorHex(errorData) {
+    if (!errorData || typeof errorData !== "string")
+        return null;
+    let hex = errorData.trim().toLowerCase();
+    if (!hex)
+        return null;
+    if (hex.startsWith("0x"))
+        hex = hex.slice(2);
+    if (!/^[0-9a-f]+$/i.test(hex) || hex.length < 8)
+        return null;
+    return hex;
+}
+function readUint256Arg(hex, argIndex) {
+    const start = 8 + (argIndex * 64);
+    const end = start + 64;
+    if (hex.length < end)
+        return null;
+    try {
+        return BigInt(`0x${hex.slice(start, end)}`);
+    }
+    catch {
+        return null;
+    }
+}
+export function describeContractError(errorData) {
+    const hex = normalizeErrorHex(errorData);
+    if (!hex)
+        return null;
+    const selector = hex.slice(0, 8);
+    const name = CONTRACT_ERRORS[selector];
+    if (!name)
+        return null;
+    if (selector === "ffd10028") {
+        const current = readUint256Arg(hex, 0);
+        const required = readUint256Arg(hex, 1);
+        if (current !== null && required !== null) {
+            return `${name} [current=${current.toString()}, required=${required.toString()}]`;
+        }
+    }
+    if (selector === "71c4efed") {
+        const expected = readUint256Arg(hex, 0);
+        const actual = readUint256Arg(hex, 1);
+        if (expected !== null && actual !== null) {
+            return `${name} [expected=${expected.toString()}, actual=${actual.toString()}]`;
+        }
+    }
+    return name;
+}
+export function extractContractErrorFromText(text) {
+    if (!text || typeof text !== "string")
+        return null;
+    const matches = text.match(/0x[0-9a-fA-F]{8,}/g);
+    if (!matches)
+        return null;
+    for (const match of matches) {
+        const decoded = describeContractError(match);
+        if (decoded)
+            return decoded;
+    }
+    return null;
+}

package/dist/utils/slippage.js

@@ -3,7 +3,6 @@ export const SLIPPAGE_PCT_4DP_MAX = 10000n;
 export const BUSINESS_SLIPPAGE_PCT_4DP_MAX = BigInt(process.env.BUSINESS_MAX_SLIPPAGE_PCT_4DP ?? "500");
 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 const BUSINESS_LP_SLIPPAGE_MAX_RATIO = Number(process.env.BUSINESS_MAX_LP_SLIPPAGE_RATIO ?? 0.05);
 export function isValidSlippagePct4dp(value) {
     if (!SLIPPAGE_PCT_4DP_RE.test(value))
         return false;
@@ -50,9 +49,5 @@ export function normalizeLpSlippageRatio(value, label = "slippage") {
     if (!Number.isFinite(numeric) || numeric < 0) {
         throw new Error(`${label} must be a finite number >= 0.`);
     }
-    const ratio = numeric > 1 && numeric <= 100 ? numeric / 100 : numeric;
-    if (ratio > BUSINESS_LP_SLIPPAGE_MAX_RATIO) {
-        throw new Error(`${label} exceeds business safety cap ${BUSINESS_LP_SLIPPAGE_MAX_RATIO * 100}%.`);
-    }
-    return ratio;
+    return numeric > 1 && numeric <= 100 ? numeric / 100 : numeric;
 }

package/package.json

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