@michaleffffff/mcp-trading-server 3.1.0 → 3.1.2

package/CHANGELOG.md

@@ -1,10 +1,27 @@
 # Changelog
 
+## 3.1.2 - 2026-03-23
+### Changed
+- Added local preflight validation for opening `LIMIT` / `STOP` orders so `open_position_simple` and `execute_trade` now fail fast with clear guidance when:
+  - `triggerType` conflicts with the selected open-order semantics
+  - the target price is on the wrong side of the current oracle price for the chosen `LONG` / `SHORT` + `LIMIT` / `STOP` combination
+
+## 3.1.1 - 2026-03-23
+### Changed
+- Upgraded the active SDK baseline to `@myx-trade/sdk@^1.0.4`.
+- Synced operator-facing docs to the current baseline:
+  - `README.md` now references `@myx-trade/sdk@^1.0.4`.
+  - `mcp_config_guide.md` no longer refers to a separate Beta environment for LP / create-market flows.
+  - Current testnet live regression notes now align with the post-upgrade trade/account behavior.
+- Deduplicated SDK compatibility helpers used by market lookup / `get_base_detail` without changing runtime behavior.
+
 ## 3.1.0 - 2026-03-20
 ### Changed
 - 发布 `3.1.0`，统一版本元数据到新的主次版本号。
 - 运行环境现在只区分测试环境与正式环境，不再走 beta host / beta 地址分支。
 - 修复测试环境下的市场发现链路，`list_pools` 恢复返回当前链池列表，`get_all_tickers` 在主接口不可用时继续走 fallback。
+- `open_position_simple` 在用户提供 `size + price + leverage` 但未提供 `collateralAmount` 时，改为自动反推保证金；若用户传入的 `collateralAmount` 明显不足，则提前返回清晰错误。
+- `execute_trade` / `close_position` 不再对外暴露 `timeInForce`；MCP 内部固定使用 `IOC (0)`，避免把一个不可配置字段误导成可配置参数。
 
 ## 3.0.31 - 2026-03-20
 ### Fixed

package/README.md

@@ -7,10 +7,11 @@ A production-ready MCP (Model Context Protocol) server for deep integration with
 # Release Notes
 
 - **Current release: 3.1.0**
-- **SDK baseline**: `@myx-trade/sdk@^1.0.4-beta.4` compatibility completed.
+- **SDK baseline**: `@myx-trade/sdk@^1.0.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 explicit-price execution for `open_position_simple`, exact-approval defaults, notional-based fee checks, TP/SL semantic validation, and LP preview fail-close behavior.
+- **Regression status**: Current trade/account compatibility was verified against the `1.0.4` baseline, including testnet live checks for `get_trade_flow`, `get_base_detail`, `account_deposit`, `account_withdraw`, `cancel_orders`, `manage_tp_sl`, and `close_position`.
 - **Breaking changes**: Many low-level tools (e.g., `get_market_price`, `get_oracle_price`, `get_open_orders`) have been merged into unified counterparts.
 
 ---
@@ -134,8 +135,9 @@ 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.4-beta.4` currently supports `IOC` only, so use `0` or `"IOC"`
+- Trading MCP tools now fix `timeInForce` internally to `IOC (0)`; do not pass this field
 - `size`: base token quantity, not USD notional; expected order value is usually `collateralAmount * leverage`
+- `open_position_simple`: if `size + price + leverage` are provided, MCP can auto-compute `collateralAmount`; if `collateralAmount` is also provided, MCP validates it against the requested notional
 - `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%`
 - Human units: `"100"` means 100 USDC or 100 token units depending on field

package/TOOL_EXAMPLES.md

@@ -81,7 +81,7 @@ 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 `size + price + leverage` are provided on `open_position_simple`, MCP can now auto-compute `collateralAmount`. If you also provide `collateralAmount`, MCP validates that it is sufficient for the requested position.
 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`.
@@ -116,13 +116,12 @@ Low-level increase-order tool when you want full control.
     "price": "2500",
     "size": "0.2",
     "collateralAmount": "100",
-    "timeInForce": 0,
     "leverage": 5
   }
 }
 ```
 
-`timeInForce` should be `0` (or `"IOC"` in string form) for SDK `v1.0.4-beta.4`.
+`timeInForce` is fixed internally to `IOC (0)` in MCP trading tools; do not pass this field.
 `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.
 
@@ -140,7 +139,6 @@ Close or reduce a position. Use `ALL` for a full close.
     "collateralAmount": "ALL",
     "size": "ALL",
     "price": "2200",
-    "timeInForce": 0,
     "postOnly": false,
     "slippagePct": "50",
     "executionFeeToken": "0x...",

package/dist/prompts/tradingGuide.js

@@ -34,6 +34,7 @@ You are an expert crypto trader using the MYX Protocol. To ensure successful exe
 - **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.
 - **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.
+- **Collateral Auto-Compute**: If you provide \`size + price + leverage\` to \`open_position_simple\`, MCP can infer \`collateralAmount\` automatically. If you provide \`collateralAmount\` too, MCP validates that it is sufficient for the intended notional.
 - **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.
 - **Approval Safety**: Local fallback flows prefer exact approval sizing. Do not assume unlimited approvals are necessary.

package/dist/services/balanceService.js

@@ -1,7 +1,7 @@
-import { getChainId } from "../auth/resolveClient.js";
+import { getChainId, getQuoteToken } from "../auth/resolveClient.js";
 export async function getBalances(client, address, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    return client.account.getWalletQuoteTokenBalance(chainId, address);
+    return client.account.getWalletQuoteTokenBalance({ chainId, address, tokenAddress: getQuoteToken() });
 }
 export async function getMarginBalance(client, address, poolId, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();

package/dist/services/marketService.js

@@ -69,10 +69,27 @@ function matchesKeyword(row, keywordUpper) {
         .join("|");
     return haystack.includes(keywordUpper);
 }
+export async function searchMarketCompat(client, params) {
+    const normalizedKeyword = String(params.keyword ?? "").trim();
+    const attempts = [
+        { chainId: params.chainId, keyword: normalizedKeyword, limit: params.limit },
+        { chainId: params.chainId, searchKey: normalizedKeyword },
+    ];
+    let lastError = null;
+    for (const attempt of attempts) {
+        try {
+            return await client.markets.searchMarket(attempt);
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw lastError ?? new Error("searchMarket failed");
+}
 async function fetchApiMarketRows(client, chainId) {
     // Preferred path: documented markets.searchMarket
     try {
-        const searchRes = await client.markets.searchMarket({ chainId, keyword: "", limit: 2000 });
+        const searchRes = await searchMarketCompat(client, { chainId, keyword: "", limit: 2000 });
         const searchRows = extractMarketRows(searchRes, chainId).filter((row) => normalizePoolId(row) && matchesChainId(row, chainId));
         if (searchRows.length > 0)
             return searchRows;
@@ -156,7 +173,11 @@ export async function searchMarket(client, keyword, limit = 1000, chainIdOverrid
     const requestedLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 1000;
     let dataList = [];
     try {
-        const searchRes = await client.markets.searchMarket({ chainId, keyword: normalizedKeyword, limit: requestedLimit });
+        const searchRes = await searchMarketCompat(client, {
+            chainId,
+            keyword: normalizedKeyword,
+            limit: requestedLimit,
+        });
         dataList = extractMarketRows(searchRes, chainId);
     }
     catch {
@@ -235,7 +256,7 @@ export async function getMarketDetail(client, poolId, chainIdOverride) {
 export async function getPoolList(client, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
     try {
-        const searchRes = await client.markets.searchMarket({ chainId, keyword: "", limit: 2000 });
+        const searchRes = await searchMarketCompat(client, { chainId, keyword: "", limit: 2000 });
         const rows = extractMarketRows(searchRes, chainId).filter((row) => normalizePoolId(row) && matchesChainId(row, chainId));
         if (rows.length > 0)
             return rows;

package/dist/services/tradeService.js

@@ -121,6 +121,68 @@ function computeRecommendedSizeRaw(targetQuoteRaw, priceRaw30, baseDecimals, quo
     const denominator = priceRaw30 * (10n ** BigInt(quoteDecimals));
     return numerator / denominator;
 }
+function getOrderTypeLabel(orderType) {
+    if (orderType === OrderType.MARKET)
+        return "MARKET";
+    if (orderType === OrderType.LIMIT)
+        return "LIMIT";
+    if (orderType === OrderType.STOP)
+        return "STOP";
+    return `ORDER_TYPE_${String(orderType)}`;
+}
+function getDirectionLabel(direction) {
+    return direction === 0 ? "LONG" : "SHORT";
+}
+function getTriggerTypeLabel(triggerType) {
+    if (triggerType === TriggerType.NONE)
+        return "NONE";
+    if (triggerType === TriggerType.GTE)
+        return "GTE";
+    if (triggerType === TriggerType.LTE)
+        return "LTE";
+    return `TRIGGER_TYPE_${String(triggerType)}`;
+}
+async function validateIncreaseOrderTriggerSemantics(client, args, chainId) {
+    const directionIndex = resolveDirectionIndex(args.direction);
+    const orderType = Number(args.orderType);
+    const explicitTriggerType = args.triggerType;
+    if (orderType === OrderType.MARKET) {
+        if (explicitTriggerType !== undefined && explicitTriggerType !== null && Number(explicitTriggerType) !== TriggerType.NONE) {
+            throw new Error("Invalid triggerType for MARKET open order: MARKET orders must use triggerType=0/NONE.");
+        }
+        return;
+    }
+    if (orderType !== OrderType.LIMIT && orderType !== OrderType.STOP) {
+        return;
+    }
+    const expectedTriggerType = resolveTriggerType(orderType, directionIndex, false);
+    const effectiveTriggerType = explicitTriggerType === undefined || explicitTriggerType === null
+        ? expectedTriggerType
+        : Number(explicitTriggerType);
+    if (effectiveTriggerType !== expectedTriggerType) {
+        throw new Error(`Invalid triggerType for opening ${getDirectionLabel(directionIndex)} ${getOrderTypeLabel(orderType)} order: ` +
+            `expected ${getTriggerTypeLabel(expectedTriggerType)}, got ${getTriggerTypeLabel(effectiveTriggerType)}.`);
+    }
+    const oracleData = await getFreshOraclePrice(client, args.poolId, chainId);
+    const currentPriceRaw = ensureUnits(oracleData.price, 30, "oracle price", { allowImplicitRaw: false });
+    const targetPriceRaw = BigInt(args.priceRaw30);
+    const currentPriceRawBig = BigInt(currentPriceRaw);
+    const currentPriceHuman = formatUnits(currentPriceRawBig, 30);
+    const targetPriceHuman = formatUnits(targetPriceRaw, 30);
+    const orderLabel = `${getDirectionLabel(directionIndex)} ${getOrderTypeLabel(orderType)}`;
+    const shouldBeBelowCurrent = (orderType === OrderType.LIMIT && directionIndex === 0) ||
+        (orderType === OrderType.STOP && directionIndex === 1);
+    const shouldBeAboveCurrent = (orderType === OrderType.STOP && directionIndex === 0) ||
+        (orderType === OrderType.LIMIT && directionIndex === 1);
+    if (shouldBeBelowCurrent && targetPriceRaw >= currentPriceRawBig) {
+        throw new Error(`Invalid ${orderLabel} price: target price ${targetPriceHuman} must be below current oracle price ${currentPriceHuman}. ` +
+            `If you want to trade above current price, use ${directionIndex === 0 ? "STOP LONG" : "LIMIT SHORT"} instead.`);
+    }
+    if (shouldBeAboveCurrent && targetPriceRaw <= currentPriceRawBig) {
+        throw new Error(`Invalid ${orderLabel} price: target price ${targetPriceHuman} must be above current oracle price ${currentPriceHuman}. ` +
+            `If you want to trade below current price, use ${directionIndex === 0 ? "LIMIT LONG" : "STOP SHORT"} instead.`);
+    }
+}
 function validateIncreaseOrderEconomics(args) {
     const collateralRawBig = BigInt(args.collateralRaw);
     const sizeRawBig = BigInt(args.sizeRaw);
@@ -250,6 +312,13 @@ export async function openPosition(client, address, args) {
         baseDecimals,
         quoteDecimals,
     });
+    await validateIncreaseOrderTriggerSemantics(client, {
+        poolId: args.poolId,
+        orderType: Number(args.orderType),
+        direction: args.direction,
+        triggerType: args.triggerType,
+        priceRaw30: priceRaw,
+    }, chainId);
     const timeInForce = mapTimeInForce(args.timeInForce);
     const orderParams = {
         chainId,

package/dist/tools/accountInfo.js

@@ -13,10 +13,7 @@ export const getTradeFlowTool = {
             const { client, address } = await resolveClient();
             const chainId = getChainId();
             const query = { chainId, poolId: args.poolId, limit: args.limit ?? 20 };
-            const accessToken = typeof client?.getAccessToken === "function"
-                ? (await client.getAccessToken()) || ""
-                : "";
-            const result = await client.api.getTradeFlow({ ...query, address, accessToken });
+            const result = await client.account.getTradeFlow(query, address);
             const enhancedData = (result?.data || []).map((flow) => ({
                 ...flow,
                 typeDesc: getTradeFlowTypeDesc(flow.type)

package/dist/tools/accountTransfer.js

@@ -38,6 +38,12 @@ function formatUnixTimestamp(timestamp) {
         return String(timestamp);
     return `${timestamp.toString()} (${new Date(numeric * 1000).toISOString()})`;
 }
+async function withdrawCompat(client, params) {
+    if (typeof client?.account?.withdraw === "function") {
+        return client.account.withdraw(params);
+    }
+    return client.account.updateAndWithdraw(params.receiver, params.poolId, params.isQuoteToken, params.amount, params.chainId);
+}
 export const accountDepositTool = {
     name: "account_deposit",
     description: "[ACCOUNT] Deposit funds from wallet into the MYX trading account.",
@@ -136,7 +142,13 @@ export const accountWithdrawTool = {
                 throw new Error(`Account has locked funds until releaseTime=${formatUnixTimestamp(releaseTime)}. ` +
                     `Retry after unlock or reduce withdraw amount.`);
             }
-            const raw = await client.account.updateAndWithdraw(address, args.poolId, Boolean(args.isQuoteToken), amount, chainId);
+            const raw = await withdrawCompat(client, {
+                receiver: address,
+                poolId: args.poolId,
+                isQuoteToken: Boolean(args.isQuoteToken),
+                amount,
+                chainId,
+            });
             const data = await finalizeMutationResult(raw, signer, "account_withdraw");
             const preflight = {
                 requestedAmountRaw: amountRaw.toString(),

package/dist/tools/cancelOrders.js

@@ -52,7 +52,11 @@ export const cancelOrdersTool = {
             if (targetOrderIds.length === 0) {
                 return { content: [{ type: "text", text: JSON.stringify({ status: "success", message: "No matching open orders found to cancel." }) }] };
             }
-            const raw = await client.order.cancelAllOrders(targetOrderIds, chainId);
+            const raw = args.cancelAll
+                ? await client.order.cancelAllOrders(targetOrderIds, chainId)
+                : targetOrderIds.length === 1
+                    ? await client.order.cancelOrder(targetOrderIds[0], chainId)
+                    : await client.order.cancelOrders(targetOrderIds, chainId);
             const result = await finalizeMutationResult(raw, signer, "cancel_orders");
             return {
                 content: [{

package/dist/tools/checkAccountReady.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { resolveClient, getChainId } from "../auth/resolveClient.js";
+import { resolveClient, getChainId, getQuoteToken } from "../auth/resolveClient.js";
 import { resolvePool } from "../services/marketService.js";
 import { parseUserUnits } from "../utils/units.js";
 import { ethers } from "ethers";
@@ -49,7 +49,11 @@ export const checkAccountReadyTool = {
                 lockedMarginRaw = toBigIntOrZero(marginInfo.data.lockedMargin);
                 accountWalletBalanceRaw = toBigIntOrZero(marginInfo.data.walletBalance);
             }
-            const walletRes = await client.account.getWalletQuoteTokenBalance(chainId, address);
+            const walletRes = await client.account.getWalletQuoteTokenBalance({
+                chainId,
+                address,
+                tokenAddress: getQuoteToken(),
+            });
             const walletBalanceRaw = BigInt(walletRes?.data || "0");
             const requiredRaw = BigInt(parseUserUnits(args.collateralAmount, quoteDecimals, "required"));
             const isReady = (availableMarginBalanceRaw >= requiredRaw) || (availableMarginBalanceRaw + walletBalanceRaw >= requiredRaw);

package/dist/tools/closePosition.js

@@ -6,6 +6,7 @@ import { SLIPPAGE_PCT_4DP_DESC } from "../utils/slippage.js";
 import { verifyTradeOutcome } from "../utils/verification.js";
 import { mapDirection, mapOrderType, mapTriggerType } from "../utils/mappings.js";
 import { parseUserUnits } from "../utils/units.js";
+import { isZeroAddress, normalizeAddress } from "../utils/address.js";
 const FULL_CLOSE_MARKERS = new Set(["ALL", "FULL", "MAX"]);
 const INTEGER_RE = /^\d+$/;
 function wantsFullCloseMarker(input) {
@@ -29,6 +30,20 @@ function resolvePositionRaw(position, rawFields, humanFields, decimals, label) {
         return "";
     return parseUserUnits(human, decimals, label);
 }
+function resolveQuoteExecutionFeeToken(input, quoteToken) {
+    const quoteTokenNormalized = normalizeAddress(quoteToken, "quoteToken");
+    const raw = String(input ?? "").trim();
+    if (!raw)
+        return quoteTokenNormalized;
+    if (isZeroAddress(raw)) {
+        throw new Error(`executionFeeToken cannot be zero address. Use the pool quoteToken address ${quoteTokenNormalized}.`);
+    }
+    const normalized = normalizeAddress(raw, "executionFeeToken");
+    if (normalized.toLowerCase() !== quoteTokenNormalized.toLowerCase()) {
+        throw new Error(`executionFeeToken must equal the pool quoteToken ${quoteTokenNormalized}. Native token and non-quote tokens are not supported in MCP trade flows.`);
+    }
+    return quoteTokenNormalized;
+}
 export const closePositionTool = {
     name: "close_position",
     description: "[TRADE] Create a decrease order (close or reduce position) using SDK-native parameters.",
@@ -39,13 +54,13 @@ export const closePositionTool = {
         triggerType: z.union([z.number(), z.string()]).optional().describe("Trigger type: 0/NONE, 1/GTE, 2/LTE"),
         direction: z.union([z.number(), z.string()]).describe("Position direction: 0/LONG or 1/SHORT"),
         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."),
+        size: z.union([z.string(), z.number()]).describe("Position size as base asset quantity (human/raw), NOT USD notional. 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.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"),
+        executionFeeToken: z.string().optional().describe("Optional. Must equal the pool quoteToken address. Defaults to the pool quoteToken."),
         leverage: z.coerce.number().describe("Leverage"),
+        verify: z.coerce.boolean().optional().describe("If true, wait for backend order-index verification after chain confirmation. Default false for faster responses."),
     },
     handler: async (args) => {
         try {
@@ -93,7 +108,8 @@ export const closePositionTool = {
                 direction: mapDirection(preparedArgs.direction),
                 orderType: mapOrderType(preparedArgs.orderType),
                 triggerType: preparedArgs.triggerType !== undefined ? mapTriggerType(preparedArgs.triggerType) : undefined,
-                executionFeeToken: poolData.quoteToken || preparedArgs.executionFeeToken
+                executionFeeToken: resolveQuoteExecutionFeeToken(preparedArgs.executionFeeToken, String(poolData.quoteToken ?? "")),
+                timeInForce: 0,
             };
             const positionsRes = await client.position.listPositions(address);
             const positions = Array.isArray(positionsRes?.data) ? positionsRes.data : [];
@@ -113,10 +129,11 @@ export const closePositionTool = {
             const data = await finalizeMutationResult(raw, signer, "close_position");
             const txHash = data.confirmation?.txHash;
             let verification = null;
-            if (txHash) {
+            const shouldVerify = Boolean(preparedArgs.verify ?? false);
+            if (txHash && shouldVerify) {
                 verification = await verifyTradeOutcome(client, address, preparedArgs.poolId, txHash);
             }
-            const payload = { ...data, verification };
+            const payload = { ...data, verification, verificationSkipped: !!txHash && !shouldVerify };
             return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: payload }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
         }
         catch (error) {

package/dist/tools/executeTrade.js

@@ -7,7 +7,7 @@ import { verifyTradeOutcome } from "../utils/verification.js";
 import { mapDirection, mapOrderType, mapTriggerType } from "../utils/mappings.js";
 import { extractErrorMessage } from "../utils/errorMessage.js";
 import { parseUserUnits } from "../utils/units.js";
-import { isZeroAddress } from "../utils/address.js";
+import { isZeroAddress, normalizeAddress } from "../utils/address.js";
 const POSITION_ID_RE = /^$|^0x[0-9a-fA-F]{64}$/;
 const ZERO_POSITION_ID_RE = /^0x0{64}$/i;
 function pow10(decimals) {
@@ -18,6 +18,20 @@ function computeQuoteNotionalRaw(sizeRaw, priceRaw30, baseDecimals, quoteDecimal
     const denominator = pow10(baseDecimals + 30);
     return numerator / denominator;
 }
+function resolveQuoteExecutionFeeToken(input, quoteToken) {
+    const quoteTokenNormalized = normalizeAddress(quoteToken, "quoteToken");
+    const raw = String(input ?? "").trim();
+    if (!raw)
+        return quoteTokenNormalized;
+    if (isZeroAddress(raw)) {
+        throw new Error(`executionFeeToken cannot be zero address. Use the pool quoteToken address ${quoteTokenNormalized}.`);
+    }
+    const normalized = normalizeAddress(raw, "executionFeeToken");
+    if (normalized.toLowerCase() !== quoteTokenNormalized.toLowerCase()) {
+        throw new Error(`executionFeeToken must equal the pool quoteToken ${quoteTokenNormalized}. Native token and non-quote tokens are not supported in MCP trade flows.`);
+    }
+    return quoteTokenNormalized;
+}
 export const executeTradeTool = {
     name: "execute_trade",
     description: "[TRADE] Create an increase order (open or add to position) using SDK-native parameters.",
@@ -30,12 +44,11 @@ export const executeTradeTool = {
         triggerType: z.union([z.number(), z.string()]).optional().describe("0=None (Market), 1=GTE, 2=LTE. e.g. 'GTE'."),
         direction: z.union([z.number(), z.string()]).describe("0/LONG/BUY or 1/SHORT/SELL."),
         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'."),
+        size: z.union([z.string(), z.number()]).describe("Base asset quantity, NOT USD notional. 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.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."),
+        executionFeeToken: z.string().optional().describe("Optional. Must equal the pool quoteToken address. Defaults to the pool quoteToken."),
         leverage: z.coerce.number().positive().describe("Leverage multiplier, e.g., 10 for 10x."),
         tpSize: z.union([z.string(), z.number()]).optional().describe("Take Profit size. Use '0' to disable."),
         tpPrice: z.union([z.string(), z.number()]).optional().describe("Take Profit trigger price."),
@@ -45,6 +58,7 @@ export const executeTradeTool = {
         assetClass: z.coerce.number().int().nonnegative().optional().describe("Optional fee lookup assetClass (default from pool config or 1)."),
         riskTier: z.coerce.number().int().nonnegative().optional().describe("Optional fee lookup riskTier (default from pool config or 1)."),
         marketId: z.string().describe("Specific Market Config Hash. Fetch via get_pool_metadata (resolve poolId first with find_pool/list_pools)."),
+        verify: z.coerce.boolean().optional().describe("If true, wait for backend order-index verification after chain confirmation. Default false for faster responses."),
     },
     handler: async (args) => {
         try {
@@ -70,11 +84,7 @@ export const executeTradeTool = {
             const mappedOrderType = mapOrderType(args.orderType);
             const mappedTriggerType = args.triggerType !== undefined ? mapTriggerType(args.triggerType) : undefined;
             const slippagePctNormalized = normalizeSlippagePct4dp(args.slippagePct);
-            if (args.executionFeeToken !== undefined && args.executionFeeToken !== null && String(args.executionFeeToken).trim() !== "") {
-                if (isZeroAddress(args.executionFeeToken)) {
-                    throw new Error(`executionFeeToken cannot be zero address. Use the pool quoteToken address ${poolData.quoteToken}.`);
-                }
-            }
+            const executionFeeToken = resolveQuoteExecutionFeeToken(args.executionFeeToken, String(poolData.quoteToken ?? ""));
             const collateralRaw = parseUserUnits(args.collateralAmount, quoteDecimals, "collateralAmount");
             const sizeRaw = parseUserUnits(args.size, baseDecimals, "size");
             const priceRaw = parseUserUnits(args.price, 30, "price");
@@ -142,13 +152,13 @@ export const executeTradeTool = {
                 triggerType: mappedTriggerType,
                 // Normalize positionId
                 positionId: normalizedPositionId,
-                // Enforce executionFeeToken as quoteToken
-                executionFeeToken: poolData.quoteToken || args.executionFeeToken,
+                executionFeeToken,
                 collateralAmount: `raw:${collateralRaw}`,
                 size: `raw:${sizeRaw}`,
                 price: `raw:${priceRaw}`,
                 tradingFee: `raw:${tradingFeeRaw}`,
                 slippagePct: slippagePctNormalized,
+                timeInForce: 0,
             };
             if (args.tpSize !== undefined) {
                 mappedArgs.tpSize = `raw:${parseUserUnits(args.tpSize, baseDecimals, "tpSize")}`;
@@ -166,17 +176,23 @@ export const executeTradeTool = {
             const data = await finalizeMutationResult(raw, signer, "execute_trade");
             const txHash = data.confirmation?.txHash;
             let verification = null;
-            if (txHash) {
+            const shouldVerify = Boolean(args.verify ?? false);
+            if (txHash && shouldVerify) {
                 verification = await verifyTradeOutcome(client, address, args.poolId, txHash);
             }
             const payload = {
                 ...data,
                 verification,
+                verificationSkipped: !!txHash && !shouldVerify,
                 preflight: {
                     normalized: {
                         collateralAmountRaw: collateralRaw,
                         sizeRaw,
                         priceRaw30: priceRaw,
+                        sizeSemantics: "base_quantity",
+                        impliedNotionalQuoteRaw: computeQuoteNotionalRaw(BigInt(sizeRaw), BigInt(priceRaw), baseDecimals, quoteDecimals).toString(),
+                        executionFeeToken,
+                        timeInForce: mappedArgs.timeInForce,
                         tradingFeeRaw,
                         tpSizeRaw: mappedArgs.tpSize?.replace(/^raw:/i, "") ?? null,
                         tpPriceRaw30: mappedArgs.tpPrice?.replace(/^raw:/i, "") ?? null,

package/dist/tools/getBaseDetail.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { resolveClient, getChainId } from "../auth/resolveClient.js";
+import { searchMarketCompat } from "../services/marketService.js";
 import { normalizeAddress } from "../utils/address.js";
 import { extractErrorMessage } from "../utils/errorMessage.js";
 function collectRows(input) {
@@ -14,10 +15,10 @@ function collectRows(input) {
 function isNonEmptyObject(value) {
     return !!value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0;
 }
-async function findBaseDetailFromMarkets(client, chainId, baseAddress) {
+async function loadMarketRows(client, chainId) {
     let rows = [];
     try {
-        const searchRes = await client.markets.searchMarket({ chainId, keyword: "", limit: 2000 });
+        const searchRes = await searchMarketCompat(client, { chainId, keyword: "", limit: 2000 });
         rows = collectRows(searchRes?.data ?? searchRes);
     }
     catch {
@@ -32,8 +33,15 @@ async function findBaseDetailFromMarkets(client, chainId, baseAddress) {
             rows = [];
         }
     }
-    const normalized = baseAddress.toLowerCase();
-    const matched = rows.find((row) => String(row?.baseToken ?? row?.baseAddress ?? "").trim().toLowerCase() === normalized);
+    return rows;
+}
+function findMarketRowByBaseAddress(rows, baseAddress) {
+    const normalizedBaseAddress = baseAddress.toLowerCase();
+    return rows.find((row) => String(row?.baseToken ?? row?.baseAddress ?? "").trim().toLowerCase() === normalizedBaseAddress);
+}
+async function findBaseDetailFromMarkets(client, chainId, baseAddress) {
+    const rows = await loadMarketRows(client, chainId);
+    const matched = findMarketRowByBaseAddress(rows, baseAddress);
     if (!matched)
         return null;
     const poolId = String(matched?.poolId ?? matched?.pool_id ?? "").trim();
@@ -83,6 +91,12 @@ async function findBaseDetailFromMarkets(client, chainId, baseAddress) {
         source: "market_search_fallback",
     };
 }
+async function resolvePoolIdByBaseAddress(client, chainId, baseAddress) {
+    const rows = await loadMarketRows(client, chainId);
+    const matched = findMarketRowByBaseAddress(rows, baseAddress);
+    const poolId = String(matched?.poolId ?? matched?.pool_id ?? "").trim();
+    return poolId || null;
+}
 function buildReadErrorPayload(args, messageLike, code = "SDK_READ_ERROR") {
     const chainId = args.chainId ?? getChainId();
     const message = extractErrorMessage(messageLike, "Failed to read base token detail.");
@@ -113,7 +127,16 @@ export const getBaseDetailTool = {
             const { client } = await resolveClient();
             const chainId = args.chainId ?? getChainId();
             const baseAddress = normalizeAddress(args.baseAddress, "baseAddress");
-            const result = await client.markets.getBaseDetail({ chainId, baseAddress });
+            const poolId = await resolvePoolIdByBaseAddress(client, chainId, baseAddress);
+            if (!poolId) {
+                const fallback = await findBaseDetailFromMarkets(client, chainId, baseAddress);
+                if (fallback) {
+                    return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: fallback }, null, 2) }] };
+                }
+                const body = buildReadErrorPayload({ ...args, baseAddress }, "Could not resolve poolId from baseAddress.", "NOT_FOUND");
+                return { content: [{ type: "text", text: JSON.stringify(body, null, 2) }], isError: true };
+            }
+            const result = await client.markets.getBaseDetail({ chainId, poolId });
             const hasCode = !!result && typeof result === "object" && !Array.isArray(result) && Object.prototype.hasOwnProperty.call(result, "code");
             const code = hasCode ? Number(result.code) : 0;
             const payload = hasCode ? result.data : result;

package/dist/tools/getMyLpHoldings.js

@@ -3,9 +3,10 @@ import { resolveClient, getChainId } from "../auth/resolveClient.js";
 import { COMMON_LP_AMOUNT_DECIMALS } from "@myx-trade/sdk";
 import { Contract, formatUnits } from "ethers";
 import { extractErrorMessage } from "../utils/errorMessage.js";
-import { getPoolList } from "../services/marketService.js";
-import { getPoolInfo } from "../services/poolService.js";
+import { getFreshOraclePrice, getPoolList } from "../services/marketService.js";
+import { getLpPrice, getPoolInfo } from "../services/poolService.js";
 const ADDRESS_RE = /^0x[a-fA-F0-9]{40}$/;
+const INTEGER_RE = /^\d+$/;
 const ERC20_BALANCE_ABI = ["function balanceOf(address owner) view returns (uint256)"];
 function collectRows(input) {
     if (Array.isArray(input))
@@ -127,6 +128,71 @@ async function readErc20Balance(provider, tokenAddress, holder) {
     const balance = await contract.balanceOf(holder);
     return BigInt(balance).toString();
 }
+function pow10(decimals) {
+    if (!Number.isInteger(decimals) || decimals < 0) {
+        throw new Error(`Invalid decimals: ${decimals}`);
+    }
+    return 10n ** BigInt(decimals);
+}
+function parseIntegerRaw(value) {
+    const text = String(value ?? "").trim();
+    if (!INTEGER_RE.test(text))
+        return null;
+    try {
+        return BigInt(text);
+    }
+    catch {
+        return null;
+    }
+}
+function formatRawValue(value, decimals) {
+    if (!value || !INTEGER_RE.test(value))
+        return null;
+    try {
+        return formatUnits(value, decimals);
+    }
+    catch {
+        return null;
+    }
+}
+function computeLpValueQuoteRaw(lpBalanceRaw, lpPriceQuoteRaw30, quoteDecimals) {
+    const balance = parseIntegerRaw(lpBalanceRaw);
+    const price = parseIntegerRaw(lpPriceQuoteRaw30);
+    if (balance === null || price === null)
+        return null;
+    const valueRaw = (balance * price * pow10(quoteDecimals)) /
+        pow10(COMMON_LP_AMOUNT_DECIMALS + 30);
+    return valueRaw.toString();
+}
+function computeUnderlyingTokenRawFromExchangeRate(lpBalanceRaw, exchangeRateRaw18, tokenDecimals) {
+    const balance = parseIntegerRaw(lpBalanceRaw);
+    const exchangeRate = parseIntegerRaw(exchangeRateRaw18);
+    if (balance === null || exchangeRate === null)
+        return null;
+    const underlyingRaw = (balance * exchangeRate * pow10(tokenDecimals)) /
+        pow10(COMMON_LP_AMOUNT_DECIMALS + 18);
+    return underlyingRaw.toString();
+}
+function computeQuoteValueFromBaseAmountRaw(baseAmountRaw, basePriceRaw30, baseDecimals, quoteDecimals) {
+    const baseAmount = parseIntegerRaw(baseAmountRaw);
+    const basePrice = parseIntegerRaw(basePriceRaw30);
+    if (baseAmount === null || basePrice === null)
+        return null;
+    const quoteValueRaw = (baseAmount * basePrice * pow10(quoteDecimals)) /
+        pow10(baseDecimals + 30);
+    return quoteValueRaw.toString();
+}
+function sumRawValues(...values) {
+    let total = 0n;
+    let found = false;
+    for (const value of values) {
+        if (!value || !INTEGER_RE.test(value))
+            continue;
+        total += BigInt(value);
+        found = true;
+    }
+    return found ? total.toString() : null;
+}
 function collectAddressCandidates(...values) {
     const unique = new Set();
     for (const value of values) {
@@ -205,6 +271,9 @@ export const getMyLpHoldingsTool = {
             const warnings = [];
             let totalBaseLpRaw = 0n;
             let totalQuoteLpRaw = 0n;
+            let totalBaseEstimatedValueQuoteRaw = 0n;
+            let totalQuoteEstimatedValueQuoteRaw = 0n;
+            const valuationBuckets = new Map();
             for (const row of scannedRows) {
                 const poolId = normalizePoolId(row?.poolId ?? row?.pool_id);
                 let basePoolToken = readAddress(row?.basePoolToken ?? row?.base_pool_token);
@@ -259,6 +328,140 @@ export const getMyLpHoldingsTool = {
                     continue;
                 totalBaseLpRaw += BigInt(baseLpRaw);
                 totalQuoteLpRaw += BigInt(quoteLpRaw);
+                const baseDecimals = Number(detail?.baseDecimals ?? row?.baseDecimals ?? row?.base_decimals ?? 18);
+                const quoteDecimals = Number(detail?.quoteDecimals ?? row?.quoteDecimals ?? row?.quote_decimals ?? 6);
+                async function ensurePoolInfoLoaded() {
+                    if (poolInfo)
+                        return poolInfo;
+                    poolInfo = await getPoolInfo(poolId, chainId, client);
+                    return poolInfo;
+                }
+                let baseLpPriceQuoteRaw = null;
+                let quoteLpPriceQuoteRaw = null;
+                let baseEstimatedUnderlyingRaw = null;
+                let quoteEstimatedUnderlyingRaw = null;
+                let baseEstimatedValueQuoteRaw = null;
+                let quoteEstimatedValueQuoteRaw = null;
+                let baseValueSource = null;
+                let quoteValueSource = null;
+                let baseOraclePriceRaw30 = null;
+                const baseValuationNotes = [];
+                const quoteValuationNotes = [];
+                if (BigInt(baseLpRaw) > 0n) {
+                    try {
+                        const raw = String(await getLpPrice("BASE", poolId, chainId) ?? "").trim();
+                        if (INTEGER_RE.test(raw) && BigInt(raw) > 0n) {
+                            baseLpPriceQuoteRaw = raw;
+                            baseEstimatedValueQuoteRaw = computeLpValueQuoteRaw(baseLpRaw, raw, quoteDecimals);
+                            baseValueSource = "sdk.getLpPrice(BASE)";
+                        }
+                    }
+                    catch (error) {
+                        baseValuationNotes.push(`failed to fetch BASE LP price (${extractErrorMessage(error)})`);
+                    }
+                    if (!baseEstimatedValueQuoteRaw) {
+                        try {
+                            const info = await ensurePoolInfoLoaded();
+                            const raw = String(info?.basePool?.poolTokenPrice ?? "").trim();
+                            if (INTEGER_RE.test(raw) && BigInt(raw) > 0n) {
+                                baseLpPriceQuoteRaw = raw;
+                                baseEstimatedValueQuoteRaw = computeLpValueQuoteRaw(baseLpRaw, raw, quoteDecimals);
+                                baseValueSource = "poolInfo.basePool.poolTokenPrice";
+                            }
+                        }
+                        catch (error) {
+                            baseValuationNotes.push(`failed to load pool info for BASE valuation (${extractErrorMessage(error)})`);
+                        }
+                    }
+                    if (!baseEstimatedValueQuoteRaw) {
+                        try {
+                            const info = await ensurePoolInfoLoaded();
+                            const exchangeRateRaw = String(info?.basePool?.exchangeRate ?? "").trim();
+                            baseEstimatedUnderlyingRaw = computeUnderlyingTokenRawFromExchangeRate(baseLpRaw, exchangeRateRaw, baseDecimals);
+                            if (baseEstimatedUnderlyingRaw && BigInt(baseEstimatedUnderlyingRaw) > 0n) {
+                                const oracle = await getFreshOraclePrice(client, poolId, chainId);
+                                baseOraclePriceRaw30 = String(oracle?.price ?? "").trim();
+                                baseEstimatedValueQuoteRaw = computeQuoteValueFromBaseAmountRaw(baseEstimatedUnderlyingRaw, baseOraclePriceRaw30, baseDecimals, quoteDecimals);
+                                if (baseEstimatedValueQuoteRaw) {
+                                    baseValueSource = "poolInfo.basePool.exchangeRate * oraclePrice";
+                                }
+                            }
+                        }
+                        catch (error) {
+                            baseValuationNotes.push(`failed to estimate BASE LP value from exchangeRate/oracle (${extractErrorMessage(error)})`);
+                        }
+                    }
+                    if (!baseEstimatedValueQuoteRaw) {
+                        warnings.push(`pool ${poolId}: BASE LP value unavailable (${baseValuationNotes.join("; ") || "no valuation source"})`);
+                    }
+                }
+                if (BigInt(quoteLpRaw) > 0n) {
+                    try {
+                        const raw = String(await getLpPrice("QUOTE", poolId, chainId) ?? "").trim();
+                        if (INTEGER_RE.test(raw) && BigInt(raw) > 0n) {
+                            quoteLpPriceQuoteRaw = raw;
+                            quoteEstimatedValueQuoteRaw = computeLpValueQuoteRaw(quoteLpRaw, raw, quoteDecimals);
+                            quoteValueSource = "sdk.getLpPrice(QUOTE)";
+                        }
+                    }
+                    catch (error) {
+                        quoteValuationNotes.push(`failed to fetch QUOTE LP price (${extractErrorMessage(error)})`);
+                    }
+                    if (!quoteEstimatedValueQuoteRaw) {
+                        try {
+                            const info = await ensurePoolInfoLoaded();
+                            const raw = String(info?.quotePool?.poolTokenPrice ?? "").trim();
+                            if (INTEGER_RE.test(raw) && BigInt(raw) > 0n) {
+                                quoteLpPriceQuoteRaw = raw;
+                                quoteEstimatedValueQuoteRaw = computeLpValueQuoteRaw(quoteLpRaw, raw, quoteDecimals);
+                                quoteValueSource = "poolInfo.quotePool.poolTokenPrice";
+                            }
+                        }
+                        catch (error) {
+                            quoteValuationNotes.push(`failed to load pool info for QUOTE valuation (${extractErrorMessage(error)})`);
+                        }
+                    }
+                    if (!quoteEstimatedValueQuoteRaw) {
+                        try {
+                            const info = await ensurePoolInfoLoaded();
+                            const exchangeRateRaw = String(info?.quotePool?.exchangeRate ?? "").trim();
+                            quoteEstimatedUnderlyingRaw = computeUnderlyingTokenRawFromExchangeRate(quoteLpRaw, exchangeRateRaw, quoteDecimals);
+                            if (quoteEstimatedUnderlyingRaw && BigInt(quoteEstimatedUnderlyingRaw) > 0n) {
+                                quoteEstimatedValueQuoteRaw = quoteEstimatedUnderlyingRaw;
+                                quoteValueSource = "poolInfo.quotePool.exchangeRate";
+                            }
+                        }
+                        catch (error) {
+                            quoteValuationNotes.push(`failed to estimate QUOTE LP value from exchangeRate (${extractErrorMessage(error)})`);
+                        }
+                    }
+                    if (!quoteEstimatedValueQuoteRaw) {
+                        warnings.push(`pool ${poolId}: QUOTE LP value unavailable (${quoteValuationNotes.join("; ") || "no valuation source"})`);
+                    }
+                }
+                const estimatedValueQuoteRaw = sumRawValues(baseEstimatedValueQuoteRaw, quoteEstimatedValueQuoteRaw);
+                if (baseEstimatedValueQuoteRaw) {
+                    totalBaseEstimatedValueQuoteRaw += BigInt(baseEstimatedValueQuoteRaw);
+                }
+                if (quoteEstimatedValueQuoteRaw) {
+                    totalQuoteEstimatedValueQuoteRaw += BigInt(quoteEstimatedValueQuoteRaw);
+                }
+                if (baseEstimatedValueQuoteRaw || quoteEstimatedValueQuoteRaw) {
+                    const bucketKey = `${quoteSymbol ?? "QUOTE"}:${quoteDecimals}`;
+                    const bucket = valuationBuckets.get(bucketKey) ?? {
+                        quoteSymbol,
+                        quoteDecimals,
+                        totalBaseEstimatedValueQuoteRaw: 0n,
+                        totalQuoteEstimatedValueQuoteRaw: 0n,
+                    };
+                    if (baseEstimatedValueQuoteRaw) {
+                        bucket.totalBaseEstimatedValueQuoteRaw += BigInt(baseEstimatedValueQuoteRaw);
+                    }
+                    if (quoteEstimatedValueQuoteRaw) {
+                        bucket.totalQuoteEstimatedValueQuoteRaw += BigInt(quoteEstimatedValueQuoteRaw);
+                    }
+                    valuationBuckets.set(bucketKey, bucket);
+                }
                 items.push({
                     poolId,
                     symbol: toSymbol(row),
@@ -271,8 +474,26 @@ export const getMyLpHoldingsTool = {
                     quotePoolToken: quotePoolToken ?? null,
                     baseLpBalanceRaw: baseLpRaw,
                     baseLpBalance: formatUnits(baseLpRaw, COMMON_LP_AMOUNT_DECIMALS),
+                    baseLpPriceQuoteRaw,
+                    baseLpPriceQuote: formatRawValue(baseLpPriceQuoteRaw, 30),
+                    baseEstimatedUnderlyingRaw,
+                    baseEstimatedUnderlying: formatRawValue(baseEstimatedUnderlyingRaw, baseDecimals),
+                    baseOraclePriceRaw30,
+                    baseOraclePrice: formatRawValue(baseOraclePriceRaw30, 30),
+                    baseEstimatedValueQuoteRaw,
+                    baseEstimatedValueQuote: formatRawValue(baseEstimatedValueQuoteRaw, quoteDecimals),
+                    baseValueSource,
                     quoteLpBalanceRaw: quoteLpRaw,
                     quoteLpBalance: formatUnits(quoteLpRaw, COMMON_LP_AMOUNT_DECIMALS),
+                    quoteLpPriceQuoteRaw,
+                    quoteLpPriceQuote: formatRawValue(quoteLpPriceQuoteRaw, 30),
+                    quoteEstimatedUnderlyingRaw,
+                    quoteEstimatedUnderlying: formatRawValue(quoteEstimatedUnderlyingRaw, quoteDecimals),
+                    quoteEstimatedValueQuoteRaw,
+                    quoteEstimatedValueQuote: formatRawValue(quoteEstimatedValueQuoteRaw, quoteDecimals),
+                    quoteValueSource,
+                    estimatedValueQuoteRaw,
+                    estimatedValueQuote: formatRawValue(estimatedValueQuoteRaw, quoteDecimals),
                     hasAnyLp,
                 });
             }
@@ -282,6 +503,20 @@ export const getMyLpHoldingsTool = {
                     return symbolCompare;
                 return String(left.poolId ?? "").localeCompare(String(right.poolId ?? ""));
             });
+            const valuationSummaryByQuote = Array.from(valuationBuckets.values()).map((bucket) => {
+                const totalEstimatedValueQuoteRaw = bucket.totalBaseEstimatedValueQuoteRaw + bucket.totalQuoteEstimatedValueQuoteRaw;
+                return {
+                    quoteSymbol: bucket.quoteSymbol,
+                    quoteDecimals: bucket.quoteDecimals,
+                    totalBaseEstimatedValueQuoteRaw: bucket.totalBaseEstimatedValueQuoteRaw.toString(),
+                    totalBaseEstimatedValueQuote: formatUnits(bucket.totalBaseEstimatedValueQuoteRaw, bucket.quoteDecimals),
+                    totalQuoteEstimatedValueQuoteRaw: bucket.totalQuoteEstimatedValueQuoteRaw.toString(),
+                    totalQuoteEstimatedValueQuote: formatUnits(bucket.totalQuoteEstimatedValueQuoteRaw, bucket.quoteDecimals),
+                    totalEstimatedValueQuoteRaw: totalEstimatedValueQuoteRaw.toString(),
+                    totalEstimatedValueQuote: formatUnits(totalEstimatedValueQuoteRaw, bucket.quoteDecimals),
+                };
+            });
+            const singleQuoteSummary = valuationSummaryByQuote.length === 1 ? valuationSummaryByQuote[0] : null;
             const payload = {
                 meta: {
                     address,
@@ -298,6 +533,13 @@ export const getMyLpHoldingsTool = {
                     totalBaseLp: formatUnits(totalBaseLpRaw, COMMON_LP_AMOUNT_DECIMALS),
                     totalQuoteLpRaw: totalQuoteLpRaw.toString(),
                     totalQuoteLp: formatUnits(totalQuoteLpRaw, COMMON_LP_AMOUNT_DECIMALS),
+                    totalBaseEstimatedValueQuoteRaw: totalBaseEstimatedValueQuoteRaw.toString(),
+                    totalBaseEstimatedValueQuote: singleQuoteSummary?.totalBaseEstimatedValueQuote ?? null,
+                    totalQuoteEstimatedValueQuoteRaw: totalQuoteEstimatedValueQuoteRaw.toString(),
+                    totalQuoteEstimatedValueQuote: singleQuoteSummary?.totalQuoteEstimatedValueQuote ?? null,
+                    totalEstimatedValueQuoteRaw: (totalBaseEstimatedValueQuoteRaw + totalQuoteEstimatedValueQuoteRaw).toString(),
+                    totalEstimatedValueQuote: singleQuoteSummary?.totalEstimatedValueQuote ?? null,
+                    valuationSummaryByQuote,
                 },
                 items,
             };

package/dist/tools/manageTpSl.js

@@ -227,7 +227,7 @@ function validateTpSlPriceSemantics(direction, entryPriceInput, tpPriceInput, sl
 }
 async function cancelTpSlByIntent(client, address, signer, chainId, args) {
     if (args.orderId) {
-        const raw = await client.order.cancelAllOrders([String(args.orderId)], chainId);
+        const raw = await client.order.cancelOrder(String(args.orderId), chainId);
         const data = await finalizeMutationResult(raw, signer, "manage_tp_sl_delete");
         return {
             content: [{
@@ -264,7 +264,9 @@ async function cancelTpSlByIntent(client, address, signer, chainId, args) {
                 }]
         };
     }
-    const raw = await client.order.cancelAllOrders(orderIds, chainId);
+    const raw = orderIds.length === 1
+        ? await client.order.cancelOrder(orderIds[0], chainId)
+        : await client.order.cancelOrders(orderIds, chainId);
     const data = await finalizeMutationResult(raw, signer, "manage_tp_sl_delete");
     return {
         content: [{

package/dist/tools/openPositionSimple.js

@@ -31,6 +31,14 @@ function computeQuoteNotionalRaw(sizeRaw, priceRaw30, baseDecimals, quoteDecimal
     const denominator = pow10(baseDecimals + 30);
     return numerator / denominator;
 }
+function divRoundUp(numerator, denominator) {
+    if (denominator <= 0n) {
+        throw new Error("denominator must be > 0.");
+    }
+    if (numerator <= 0n)
+        return 0n;
+    return (numerator + denominator - 1n) / denominator;
+}
 async function getRequiredApprovalSpendRaw(client, marketId, args, chainId) {
     const networkFeeText = String(await client.utils.getNetworkFee(marketId, chainId) ?? "").trim();
     if (!/^\d+$/.test(networkFeeText)) {
@@ -58,6 +66,20 @@ function pickMarketDetail(res) {
         return res;
     return null;
 }
+function resolveQuoteExecutionFeeToken(input, quoteToken) {
+    const quoteTokenNormalized = normalizeAddress(quoteToken, "quoteToken");
+    const raw = String(input ?? "").trim();
+    if (!raw)
+        return quoteTokenNormalized;
+    if (isZeroAddress(raw)) {
+        throw new Error(`executionFeeToken cannot be zero address. Use the pool quoteToken address ${quoteTokenNormalized}.`);
+    }
+    const normalized = normalizeAddress(raw, "executionFeeToken");
+    if (normalized.toLowerCase() !== quoteTokenNormalized.toLowerCase()) {
+        throw new Error(`executionFeeToken must equal the pool quoteToken ${quoteTokenNormalized}. Native token and non-quote tokens are not supported in MCP trade flows.`);
+    }
+    return quoteTokenNormalized;
+}
 export const openPositionSimpleTool = {
     name: "open_position_simple",
     description: "[TRADE] High-level open position helper. Computes size/price/tradingFee and submits an increase order. Human units by default; use 'raw:' prefix for raw units.",
@@ -79,13 +101,13 @@ export const openPositionSimpleTool = {
         size: z.coerce
             .string()
             .optional()
-            .describe("Position size. e.g. '0.5' BTC. If omitted, computed from collateral*leverage/price."),
+            .describe("Position size as base asset quantity, NOT USD notional. e.g. '0.5' BTC. If omitted, computed from collateral*leverage/price."),
         slippagePct: z.coerce
             .string()
             .optional()
             .describe(`${SLIPPAGE_PCT_4DP_DESC} Default 50 (=0.5%).`),
         postOnly: z.coerce.boolean().optional().describe("Post-only (default false)."),
-        executionFeeToken: z.string().optional().describe("Execution fee token address (default quoteToken)."),
+        executionFeeToken: z.string().optional().describe("Optional. Must equal the pool quoteToken address. Defaults to the pool quoteToken."),
         assetClass: z.coerce.number().int().nonnegative().optional().describe("Fee query assetClass (default 1)."),
         riskTier: z.coerce.number().int().nonnegative().optional().describe("Fee query riskTier (default 1)."),
         tradingFee: z.coerce
@@ -103,6 +125,7 @@ export const openPositionSimpleTool = {
             .optional()
             .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."),
+        verify: z.coerce.boolean().optional().describe("If true, wait for backend order-index verification after chain confirmation. Default false for faster responses."),
     },
     handler: async (args) => {
         try {
@@ -142,12 +165,7 @@ export const openPositionSimpleTool = {
             const orderType = mapOrderType(args.orderType ?? 0);
             const postOnly = Boolean(args.postOnly ?? false);
             const slippagePct = normalizeSlippagePct4dp(args.slippagePct ?? "50");
-            if (args.executionFeeToken !== undefined && args.executionFeeToken !== null && String(args.executionFeeToken).trim() !== "") {
-                if (isZeroAddress(args.executionFeeToken)) {
-                    throw new Error(`executionFeeToken cannot be zero address. Use the pool quoteToken address ${quoteToken}.`);
-                }
-            }
-            const executionFeeToken = normalizeAddress(args.executionFeeToken || quoteToken, "executionFeeToken");
+            const executionFeeToken = resolveQuoteExecutionFeeToken(args.executionFeeToken, quoteToken);
             // 4) Determine reference price (30 decimals)
             let price30;
             let priceMeta = { source: "user", publishTime: null, oracleType: null, human: null };
@@ -166,6 +184,7 @@ export const openPositionSimpleTool = {
             const collateralInput = String(args.collateralAmount ?? "").trim();
             let collateralRaw = "";
             let collateralRawBig = 0n;
+            let collateralMeta = { source: collateralInput ? "user" : "computed" };
             if (collateralInput) {
                 collateralRaw = parseUserUnits(collateralInput, quoteDecimals, "collateralAmount");
                 collateralRawBig = asBigint(collateralRaw, "collateralAmount");
@@ -195,12 +214,25 @@ export const openPositionSimpleTool = {
                 sizeMeta = { source: "computed", notionalQuoteRaw: notionalQuoteRaw.toString() };
             }
             const sizeRawBig = asBigint(sizeRaw, "size");
+            const leverageBig = BigInt(args.leverage);
+            const impliedNotionalQuoteRaw = computeQuoteNotionalRaw(sizeRawBig, price30Big, baseDecimals, quoteDecimals);
             if (!collateralInput) {
-                const notionalQuoteRaw = (sizeRawBig * price30Big * pow10(quoteDecimals)) / pow10(baseDecimals + 30);
-                const suggestedCollateralRaw = notionalQuoteRaw / BigInt(args.leverage);
-                const suggestedCollateralHuman = formatUnits(suggestedCollateralRaw, quoteDecimals);
-                const notionalHuman = formatUnits(notionalQuoteRaw, quoteDecimals);
-                throw new Error(`collateralAmount is required for open_position_simple. Based on size=${userSize || formatUnits(sizeRawBig, baseDecimals)}, price=${priceMeta.human ?? formatUnits(price30Big, 30)}, leverage=${args.leverage}, implied order value is ≈${notionalHuman} quote and suggested collateralAmount is ≈${suggestedCollateralHuman}.`);
+                collateralRawBig = divRoundUp(impliedNotionalQuoteRaw, leverageBig);
+                if (collateralRawBig <= 0n) {
+                    throw new Error("Computed collateralAmount is 0. Reduce size, reduce leverage, or check price precision.");
+                }
+                collateralRaw = collateralRawBig.toString();
+                collateralMeta = {
+                    source: "computed",
+                    impliedNotionalQuoteRaw: impliedNotionalQuoteRaw.toString(),
+                };
+            }
+            else {
+                const maxNotionalFromCollateralRaw = collateralRawBig * leverageBig;
+                if (maxNotionalFromCollateralRaw < impliedNotionalQuoteRaw) {
+                    const requiredCollateralRaw = divRoundUp(impliedNotionalQuoteRaw, leverageBig);
+                    throw new Error(`collateralAmount is insufficient for open_position_simple. Based on size=${userSize || formatUnits(sizeRawBig, baseDecimals)}, price=${priceMeta.human ?? formatUnits(price30Big, 30)}, leverage=${args.leverage}, implied order value is ≈${formatUnits(impliedNotionalQuoteRaw, quoteDecimals)} quote, provided collateralAmount is ${formatUnits(collateralRawBig, quoteDecimals)}, and required collateralAmount is at least ≈${formatUnits(requiredCollateralRaw, quoteDecimals)}.`);
+                }
             }
             const maxTradeAmountHuman = String(process.env.MAX_TRADE_AMOUNT ?? "").trim();
             if (maxTradeAmountHuman) {
@@ -267,6 +299,7 @@ export const openPositionSimpleTool = {
                 tradingFeeMeta,
                 autoDeposit: Boolean(args.autoDeposit ?? false),
                 priceMeta,
+                collateralMeta,
                 sizeMeta,
                 tpPrice: args.tpPrice ? parseUserPrice30(args.tpPrice, "tpPrice") : null,
                 tpSize: args.tpSize ? parseUserUnits(args.tpSize, baseDecimals, "tpSize") : (args.tpPrice ? sizeRaw : null),
@@ -338,8 +371,32 @@ export const openPositionSimpleTool = {
             const raw = await openPosition(client, address, openArgs);
             const data = await finalizeMutationResult(raw, signer, "open_position_simple");
             const txHash = data.confirmation?.txHash;
-            const verification = txHash ? await verifyTradeOutcome(client, address, poolId, txHash) : null;
-            const payload = { prepared: prep, approval, ...data, verification };
+            const shouldVerify = Boolean(args.verify ?? false);
+            const verification = txHash && shouldVerify ? await verifyTradeOutcome(client, address, poolId, txHash) : null;
+            const payload = {
+                prepared: prep,
+                approval,
+                ...data,
+                verification,
+                verificationSkipped: !!txHash && !shouldVerify,
+                preflight: {
+                    normalized: {
+                        collateralAmountRaw: collateralRaw,
+                        sizeRaw,
+                        priceRaw30: price30,
+                        sizeSemantics: "base_quantity",
+                        impliedNotionalQuoteRaw: impliedNotionalQuoteRaw.toString(),
+                        executionFeeToken,
+                        timeInForce: openArgs.timeInForce,
+                        tradingFeeRaw: String(tradingFeeRaw),
+                        tpSizeRaw: openArgs.tpSize?.replace(/^raw:/i, "") ?? null,
+                        tpPriceRaw30: openArgs.tpPrice?.replace(/^raw:/i, "") ?? null,
+                        slSizeRaw: openArgs.slSize?.replace(/^raw:/i, "") ?? null,
+                        slPriceRaw30: openArgs.slPrice?.replace(/^raw:/i, "") ?? null,
+                    },
+                    tradingFeeMeta,
+                },
+            };
             return {
                 content: [
                     {

package/package.json

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