@michaleffffff/mcp-trading-server 3.0.24 → 3.0.26

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 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` and that increase-order funding reconciliation lives in the SDK.
+- 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 +36,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,16 +82,19 @@ 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`.
@@ -168,7 +173,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"
   }
 }
 ```
@@ -362,6 +364,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.26)
 
 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,7 +33,10 @@ 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.
@@ -44,6 +47,7 @@ You are an expert crypto trader using the MYX Protocol. To ensure successful exe
 - 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.26" }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
 // List tools
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {

package/dist/services/poolService.js

@@ -198,12 +198,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 +206,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) {
@@ -281,14 +275,22 @@ async function executeLiquidityTxViaRouter(params) {
             }
         }
     }
-    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);
@@ -364,6 +366,41 @@ async function executeLiquidityTxViaRouter(params) {
         },
     };
 }
+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);
+        }
+        throw error;
+    }
+}
 async function resolvePositiveMarketPrice30(client, poolId, chainId) {
     if (!client)
         return null;
@@ -494,28 +531,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

@@ -128,20 +128,25 @@ async function readErc20Balance(provider, tokenAddress, holder) {
 }
 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()));

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/package.json

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