@michaleffffff/mcp-trading-server 3.0.21 → 3.0.26

package/CHANGELOG.md

@@ -1,5 +1,74 @@
 # 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
+- Hardened LP MCP behavior:
+  - `get_pool_metadata(includeLiquidity=true)` now ignores caller-supplied `marketPrice` and derives liquidity depth from a fresh Oracle price only.
+  - `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`:
+  - Updated `README.md`, `TOOL_EXAMPLES.md`, and `trading_best_practices` prompt version strings.
+  - Refreshed LP safety docs to reflect Oracle-only liquidity metadata and inventory-only LP holdings semantics.
+
+## 3.0.23 - 2026-03-19
+
+### Changed
+- Upgraded SDK dependency to `@myx-trade/sdk@^1.0.4-beta.4`.
+- Refreshed operator-facing docs and runtime hints to match the new SDK baseline:
+  - `README.md` now references `@myx-trade/sdk@^1.0.4-beta.4`.
+  - `TOOL_EXAMPLES.md`, `execute_trade`, `close_position`, and `mapTimeInForce` now document the current IOC-only `timeInForce` behavior using `v1.0.4-beta.4`.
+  - `trading_best_practices` prompt now aligns with release `v3.0.23`.
+
+### Fixed
+- Hardened LP MCP behavior and synchronized docs:
+  - `get_pool_metadata(includeLiquidity=true)` now ignores caller-supplied `marketPrice` and derives liquidity depth from a fresh Oracle price only.
+  - `get_pool_info` MCP-side price resolution no longer falls back from fresh Oracle to ticker-derived market price.
+  - Beta LP router / `PoolManager` chain mappings were completed for the MCP fallback path.
+  - `get_my_lp_holdings` no longer ranks rows by mixed BASE/QUOTE LP raw balances.
+  - `README.md`, `TOOL_EXAMPLES.md`, and `mcp_config_guide.md` now document these LP-specific MCP semantics.
+
+## 3.0.22 - 2026-03-19
+
+### Changed
+- Upgraded SDK dependency to `@myx-trade/sdk@^1.0.4-beta.1`.
+- Refreshed operator-facing docs and runtime hints to match the new SDK baseline:
+  - `README.md` now references `@myx-trade/sdk@^1.0.4-beta.1`.
+  - `TOOL_EXAMPLES.md`, `execute_trade`, `close_position`, and `mapTimeInForce` now document the current IOC-only `timeInForce` behavior using the new SDK version.
+  - `trading_best_practices` prompt now aligns with release `v3.0.22`.
+
 ## 3.0.21 - 2026-03-19
 
 ### Fixed
@@ -13,6 +82,9 @@
   - `mcp_config_guide.md` now includes required `BROKER_ADDRESS` configuration and testnet `MYXBroker` references.
   - `TOOL_EXAMPLES.md` now reflects fresh-Oracle execution, live-direction validation, human-price TP/SL parsing, and trading `slippagePct` conventions.
   - `trading_best_practices` prompt now aligns with the current MCP safety constraints and testnet broker references.
+- Updated testnet broker defaults:
+  - Arbitrum Sepolia `BROKER_ADDRESS` -> `0x895C4ae2A22bB26851011d733A9355f663a1F939`
+  - Linea Sepolia `BROKER_ADDRESS` -> `0x634EfDC9dC76D7AbF6E49279875a31B02E9891e2`
 
 ## 3.0.19 - 2026-03-19
 

package/README.md

@@ -6,11 +6,11 @@ A production-ready MCP (Model Context Protocol) server for deep integration with
 
 # Release Notes
 
-- **Current release: 3.0.20**
-- **SDK baseline**: `@myx-trade/sdk@^1.0.2` compatibility completed.
+- **Current release: 3.0.24**
+- **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.
 
 ---
 
@@ -55,7 +57,7 @@ Use the broker that matches your active RPC and chain configuration.
 * **`list_pools`**: List all tradable assets on the current chain.
 * **`search_tools`**: Discover the right MCP tool by keyword, legacy tool name, or intent phrase.
 * **`get_price`**: Fetch real-time prices (Impact Market Price or Oracle Price).
-* **`get_pool_metadata`**: Comprehensive metrics (Fees, Open Interest, Liquidity Depth).
+* **`get_pool_metadata`**: Comprehensive metrics (Fees, Open Interest, Liquidity Depth via fresh Oracle price).
 * **`get_kline`**: Fetch candlestick data for technical analysis.
 
 ### ⚔️ Trading Operations
@@ -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,19 +82,24 @@ 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 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.
 
 ---
 
@@ -127,7 +134,7 @@ Use these conventions when generating tool arguments:
 - `status`: `OPEN` / `HISTORY` / `ALL` are canonical; lowercase is tolerated
 - `poolType`: `BASE` / `QUOTE` are canonical; lowercase is tolerated
 - `orderType`: `MARKET` / `LIMIT` / `STOP` / `CONDITIONAL`
-- `timeInForce`: SDK `v1.0.2` currently supports `IOC` only, so use `0` or `"IOC"`
+- `timeInForce`: SDK `v1.0.4-beta.4` currently supports `IOC` only, so use `0` or `"IOC"`
 - `size`: base token quantity, not USD notional; expected order value is usually `collateralAmount * leverage`
 - `executionFeeToken`: must be a real token address; zero address is rejected. Use the pool `quoteToken`
 - `slippagePct`: trading tools use 4-decimal raw units where `100 = 1.00%` and `50 = 0.50%`
@@ -156,6 +163,8 @@ Examples:
 }
 ```
 
+For `get_pool_metadata(includeLiquidity=true)`, do not rely on a custom `marketPrice` override. MCP now ignores that field and uses a fresh Oracle price automatically.
+
 ```json
 {
   "name": "open_position_simple",
@@ -164,7 +173,7 @@ Examples:
     "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.20)
+# 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"
   }
 }
 ```
@@ -120,7 +122,7 @@ Low-level increase-order tool when you want full control.
 }
 ```
 
-`timeInForce` should be `0` (or `"IOC"` in string form) for SDK `v1.0.2`.
+`timeInForce` should be `0` (or `"IOC"` in string form) for SDK `v1.0.4-beta.4`.
 `executionFeeToken` must be a real token address; do not pass the zero address. Use the pool `quoteToken`.
 If `positionId` is supplied on increase flows, `direction` must remain consistent with the live position.
 
@@ -249,6 +251,7 @@ Unified pool detail, config, and liquidity info.
 ```
 
 `get_pool_metadata` returns raw values in `poolInfo` and precision-safe human-readable values in `poolInfoFormatted`, including readable funding epoch timestamps, funding-rate `%/秒` and `%/天`, and IO notional-at-entry views.
+When `includeLiquidity=true`, MCP derives liquidity depth from a fresh Oracle price automatically. Any caller-supplied `marketPrice` is now treated as deprecated and ignored.
 
 ### `get_kline`
 Read chart data. Use `limit: 1` for the latest bar.
@@ -330,6 +333,8 @@ 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.
+
 ---
 
 ## Account And Monitoring
@@ -359,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,13 +2,17 @@ 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)
-        return "0x8f3153C18f698166f5D6124d8ba5B567F5f120f9"; // Arbitrum Sepolia
+        return "0x895C4ae2A22bB26851011d733A9355f663a1F939"; // Arbitrum Sepolia
     if (chainId === 59141)
-        return "0x0FB08D3A1Ea6bE515fe78D3e0CaEb6990b468Cf3"; // Linea Sepolia
-    return "0x8f3153C18f698166f5D6124d8ba5B567F5f120f9";
+        return "0x634EfDC9dC76D7AbF6E49279875a31B02E9891e2"; // Linea Sepolia
+    return "0x895C4ae2A22bB26851011d733A9355f663a1F939";
 }
 function getDefaultQuoteTokenByChainId(chainId) {
     // Testnet mappings
@@ -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.21)
+# 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.
@@ -30,18 +30,24 @@ You are an expert crypto trader using the MYX Protocol. To ensure successful exe
 - **Unit Prefixes**: Prefer \`human:\` for readable amounts (e.g., "100" USDC) and \`raw:\` for exact on-chain units.
 - **Slippage**: Trading tools use 4-decimal raw units where \`100 = 1.00%\` and \`50 = 0.50%\`. Keep it tight unless the market is genuinely illiquid.
 - **Fees**: Use \`get_pool_metadata\` to view current fee tiers and pool configuration.
+- **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.
 
 ## 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.21" }, { 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 {
@@ -582,7 +582,7 @@ server.setRequestHandler(GetPromptRequestSchema, async (request) => {
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    logger.info("🚀 MYX Trading MCP Server v3.0.20 running (stdio, pure on-chain, prod ready)");
+    logger.info("🚀 MYX Trading MCP Server v3.0.24 running (stdio, pure on-chain, prod ready)");
 }
 main().catch((err) => {
     logger.error("Fatal Server Startup Error", err);

package/dist/services/poolService.js

@@ -5,10 +5,19 @@ import { ensureUnits, parseUserUnits } from "../utils/units.js";
 import { normalizeAddress } from "../utils/address.js";
 import { Contract } from "ethers";
 import { logger } from "../utils/logger.js";
-import { assertOracleFreshness } from "./marketService.js";
+import { assertOracleFreshness, getFreshOraclePrice } from "./marketService.js";
 const LP_DECIMALS = 18;
 const POOL_MANAGER_BY_CHAIN = {
     421614: "0xf268D9FeD3Bd56fd9aBdb4FeEb993338613678A8",
+    59141: "0x85e869d98216221807A06636541Ec93C9c0a4B0c",
+    97: "0x4F917ef137b573D9790b87e3cF6dfb698cF00c9c",
+    56: "0x13F2130c2F3bfd612BBCBF35FB9E467dd32bAF3A",
+};
+const POOL_MANAGER_BY_CHAIN_BETA = {
+    421614: "0x05314a21Fc97B74f168730153b2B63A870D25dE5",
+    59141: "0xcf51a6895864c6D8E507fC31EF16b9011287c5f4",
+    97: "0x9E84a999e15CCdb2F64a5AF10939c25769dF6b07",
+    56: "0x9E84a999e15CCdb2F64a5AF10939c25769dF6b07",
 };
 const POOL_MANAGER_ABI = [
     "function deployPool((bytes32 marketId,address baseToken))",
@@ -52,6 +61,11 @@ const LP_ROUTER_BY_CHAIN_BETA = {
         basePool: "0x51B62554a76197d5DF2D5dC4D57FF54d40775938",
         quotePool: "0x783Ed065a12e1C1D33c2a8d6408385C1843D3084",
     },
+    56: {
+        router: "0x0F4C6f18Fb136DD1eBd6Da3C5d86a86597CF79a3",
+        basePool: "0x51B62554a76197d5DF2D5dC4D57FF54d40775938",
+        quotePool: "0x783Ed065a12e1C1D33c2a8d6408385C1843D3084",
+    },
 };
 const PREVIEW_POOL_ABI = [
     "function previewLpAmountOut(bytes32,uint256,uint256) view returns (uint256)",
@@ -151,9 +165,10 @@ function getPoolManagerAddress(chainId) {
     if (envAddress) {
         return normalizeAddress(envAddress, "POOL_MANAGER_ADDRESS");
     }
-    const mapped = POOL_MANAGER_BY_CHAIN[chainId];
+    const source = isBetaModeEnabled() ? POOL_MANAGER_BY_CHAIN_BETA : POOL_MANAGER_BY_CHAIN;
+    const mapped = source[chainId];
     if (!mapped) {
-        throw new Error(`Pool manager address is not configured for chainId=${chainId}. Set POOL_MANAGER_ADDRESS env var.`);
+        throw new Error(`Pool manager address is not configured for chainId=${chainId} (beta=${isBetaModeEnabled()}). Set POOL_MANAGER_ADDRESS env var.`);
     }
     return mapped;
 }
@@ -183,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;
@@ -197,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) {
@@ -266,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);
@@ -349,30 +366,53 @@ 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;
     try {
-        const oracle = await client.utils?.getOraclePrice?.(poolId, chainId);
-        assertOracleFreshness(oracle?.publishTime, poolId);
-        const byPrice = toPositiveBigint(oracle?.price);
+        const oracle = await getFreshOraclePrice(client, poolId, chainId);
+        const oraclePrice30 = ensureUnits(String(oracle?.price ?? "").trim(), 30, "oracle price");
+        const byPrice = toPositiveBigint(oraclePrice30);
         if (byPrice)
             return byPrice;
     }
     catch {
     }
-    try {
-        const tickerRes = await client.markets?.getTickerList?.({ chainId, poolIds: [poolId] });
-        const row = Array.isArray(tickerRes) ? tickerRes[0] : tickerRes?.data?.[0];
-        if (row?.price) {
-            const tickerRaw = ensureUnits(row.price, 30, "ticker price");
-            const byTicker = toPositiveBigint(tickerRaw);
-            if (byTicker)
-                return byTicker;
-        }
-    }
-    catch {
-    }
     return null;
 }
 /**
@@ -473,37 +513,46 @@ export async function getPoolDetail(poolId, chainIdOverride) {
 /**
  * 获取流动性信息
  */
-export async function getLiquidityInfo(client, poolId, marketPrice, chainIdOverride) {
+export async function getLiquidityInfo(client, poolId, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    return client.utils.getLiquidityInfo({ chainId, poolId, marketPrice });
+    const oracle = await getFreshOraclePrice(client, poolId, chainId);
+    const marketPrice = ensureUnits(String(oracle?.price ?? "").trim(), 30, "oracle price");
+    const liquidityInfo = await client.utils.getLiquidityInfo({ chainId, poolId, marketPrice });
+    return {
+        liquidityInfo,
+        marketPrice,
+        marketPriceSource: "oracle",
+        oraclePublishTime: String(oracle?.publishTime ?? ""),
+        oracleType: oracle?.oracleType ?? null,
+    };
 }
 /**
  * Quote 池 deposit
  */
 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/closePosition.js

@@ -41,7 +41,7 @@ export const closePositionTool = {
         collateralAmount: z.union([z.string(), z.number()]).describe("Collateral amount (human/raw). Also supports ALL/FULL/MAX to use live position collateral raw."),
         size: z.union([z.string(), z.number()]).describe("Position size (human/raw). Also supports ALL/FULL/MAX for exact full-close raw size."),
         price: z.union([z.string(), z.number()]).describe("Price (human or 30-dec raw units)"),
-        timeInForce: z.union([z.number(), z.string()]).describe("SDK v1.0.2 supports IOC only. Use 0 or 'IOC'."),
+        timeInForce: z.union([z.number(), z.string()]).describe("SDK v1.0.4-beta.4 supports IOC only. Use 0 or 'IOC'."),
         postOnly: z.coerce.boolean().describe("Post-only flag"),
         slippagePct: z.coerce.string().default("50").describe(SLIPPAGE_PCT_4DP_DESC),
         executionFeeToken: z.string().describe("Execution fee token address"),

package/dist/tools/executeTrade.js

@@ -32,7 +32,7 @@ export const executeTradeTool = {
         collateralAmount: z.union([z.string(), z.number()]).describe("Collateral. e.g. '100' or 'raw:100000000' (6 decimals for USDC)."),
         size: z.union([z.string(), z.number()]).describe("Notional size in base tokens. e.g. '0.5' BTC or 'raw:50000000'."),
         price: z.union([z.string(), z.number()]).describe("Execution or Limit price. e.g. '65000' or 'raw:...'"),
-        timeInForce: z.union([z.number(), z.string()]).describe("SDK v1.0.2 supports IOC only. Use 0 or 'IOC'."),
+        timeInForce: z.union([z.number(), z.string()]).describe("SDK v1.0.4-beta.4 supports IOC only. Use 0 or 'IOC'."),
         postOnly: z.coerce.boolean().describe("If true, order only executes as Maker."),
         slippagePct: z.coerce.string().default("50").describe(`${SLIPPAGE_PCT_4DP_DESC}. Default is 50 (0.5%).`),
         executionFeeToken: z.string().optional().describe("Address of token to pay gas/execution fees (typically USDC). Default is pool quoteToken."),

package/dist/tools/getMyLpHoldings.js

@@ -121,9 +121,6 @@ function toSymbol(row) {
         return base;
     return normalizePoolId(row?.poolId ?? row?.pool_id);
 }
-function sumRaw(baseRaw, quoteRaw) {
-    return BigInt(baseRaw || "0") + BigInt(quoteRaw || "0");
-}
 async function readErc20Balance(provider, tokenAddress, holder) {
     const contract = new Contract(tokenAddress, ERC20_BALANCE_ABI, provider);
     const balance = await contract.balanceOf(holder);
@@ -131,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()));
@@ -227,11 +229,10 @@ export const getMyLpHoldingsTool = {
                 });
             }
             items.sort((left, right) => {
-                const leftSum = sumRaw(left.baseLpBalanceRaw, left.quoteLpBalanceRaw);
-                const rightSum = sumRaw(right.baseLpBalanceRaw, right.quoteLpBalanceRaw);
-                if (leftSum === rightSum)
-                    return 0;
-                return rightSum > leftSum ? 1 : -1;
+                const symbolCompare = String(left.symbol ?? "").localeCompare(String(right.symbol ?? ""));
+                if (symbolCompare !== 0)
+                    return symbolCompare;
+                return String(left.poolId ?? "").localeCompare(String(right.poolId ?? ""));
             });
             const payload = {
                 meta: {

package/dist/tools/getPoolMetadata.js

@@ -4,21 +4,8 @@ import { resolveClient, getChainId } from "../auth/resolveClient.js";
 import { getMarketDetail, resolvePool } from "../services/marketService.js";
 import { getPoolInfo, getLiquidityInfo } from "../services/poolService.js";
 import { extractErrorMessage } from "../utils/errorMessage.js";
-import { parseUserPrice30 } from "../utils/units.js";
 const INTEGER_RE = /^\d+$/;
 const SIGNED_INTEGER_RE = /^-?\d+$/;
-const DECIMAL_RE = /^\d+(\.\d+)?$/;
-function normalizeMarketPrice30Input(value) {
-    const text = String(value ?? "").trim();
-    if (!text)
-        return "";
-    if (INTEGER_RE.test(text))
-        return text;
-    if (!DECIMAL_RE.test(text) && !/^raw:/i.test(text) && !/^human:/i.test(text)) {
-        throw new Error("marketPrice must be numeric, or prefixed with raw:/human:.");
-    }
-    return parseUserPrice30(text, "marketPrice");
-}
 function compactWarning(scope, err) {
     const raw = extractErrorMessage(err);
     const flat = raw.replace(/\s+/g, " ").trim();
@@ -211,8 +198,8 @@ export const getPoolMetadataTool = {
     schema: {
         poolId: z.string().optional().describe("Pool ID, Token Address, or Keyword"),
         keyword: z.string().optional().describe("Market keyword (e.g. 'BTC')"),
-        includeLiquidity: z.boolean().default(false).describe("Whether to include liquidity depth (requires marketPrice)"),
-        marketPrice: z.union([z.string(), z.number()]).optional().describe("Current price (required if includeLiquidity is true)"),
+        includeLiquidity: z.boolean().default(false).describe("Whether to include liquidity depth (uses fresh oracle price automatically)"),
+        marketPrice: z.union([z.string(), z.number()]).optional().describe("Deprecated and ignored. MCP now uses fresh oracle price for liquidity depth."),
         includeConfig: z.boolean().default(false).describe("Whether to include pool level configuration/limits"),
         chainId: z.number().int().positive().optional().describe("Optional chainId override"),
     },
@@ -245,10 +232,15 @@ export const getPoolMetadataTool = {
             // 3. Optional: Liquidity Info
             if (args.includeLiquidity) {
                 try {
-                    const price = normalizeMarketPrice30Input(args.marketPrice);
-                    if (!price)
-                        throw new Error("marketPrice is required for liquidity info.");
-                    results.liquidityInfo = await getLiquidityInfo(client, poolId, price, chainId);
+                    const liquidityResult = await getLiquidityInfo(client, poolId, chainId);
+                    results.liquidityInfo = liquidityResult.liquidityInfo;
+                    results.liquidityInfoMeta = {
+                        marketPriceSource: liquidityResult.marketPriceSource,
+                        marketPrice: liquidityResult.marketPrice,
+                        oraclePublishTime: liquidityResult.oraclePublishTime,
+                        oracleType: liquidityResult.oracleType,
+                        ignoredUserMarketPrice: args.marketPrice !== undefined ? String(args.marketPrice) : null,
+                    };
                 }
                 catch (err) {
                     errors.push(compactWarning("liquidityInfo", err));

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/mappings.js

@@ -171,7 +171,7 @@ export const mapTriggerType = (input) => {
     throw new Error(`Invalid triggerType: ${input}. Use 0/NONE, 1/GTE or 2/LTE.`);
 };
 /**
- * SDK v1.0.2 currently exposes IOC only.
+ * SDK v1.0.4-beta.4 currently exposes IOC only.
  */
 export const mapTimeInForce = (input) => {
     if (input === 0)
@@ -179,5 +179,5 @@ export const mapTimeInForce = (input) => {
     const s = String(input ?? "").trim().toUpperCase();
     if (s === "0" || s === "IOC")
         return 0;
-    throw new Error(`Invalid timeInForce: ${input}. SDK v1.0.2 currently supports IOC only, use 0/IOC.`);
+    throw new Error(`Invalid timeInForce: ${input}. SDK v1.0.4-beta.4 currently supports IOC only, use 0/IOC.`);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@michaleffffff/mcp-trading-server",
-  "version": "3.0.21",
+  "version": "3.0.26",
   "type": "module",
   "bin": {
     "myx-mcp": "dist/server.js"
@@ -21,7 +21,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
-    "@myx-trade/sdk": "^1.0.2",
+    "@myx-trade/sdk": "^1.0.4-beta.4",
     "dotenv": "^17.3.1",
     "ethers": "^6.13.1",
     "zod": "^4.3.6"