@michaleffffff/mcp-trading-server 3.0.20 → 3.0.21

package/CHANGELOG.md

@@ -1,12 +1,19 @@
 # Changelog
 
-## 3.0.20 - 2026-03-19
+## 3.0.21 - 2026-03-19
 
 ### Fixed
 - Hardened `get_pool_metadata` funding-rate formatting:
   - `fundingInfo.nextFundingRate` now preserves readable `%/秒` and `%/天` output for negative rates too.
   - Regression coverage now asserts both numeric funding-rate views and display strings.
 
+### Changed
+- Refreshed operator-facing docs and prompts to match the latest trading safety behavior:
+  - `README.md` now documents Oracle-only execution, exact-approval defaults, base-size semantics, TP/SL semantic checks, and LP preview fail-close.
+  - `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.
+
 ## 3.0.19 - 2026-03-19
 
 ### Fixed

package/README.md

@@ -10,6 +10,7 @@ A production-ready MCP (Model Context Protocol) server for deep integration with
 - **SDK baseline**: `@myx-trade/sdk@^1.0.2` compatibility completed.
 - **Refinement**: Consolidated 40+ specialized tools into ~26 high-level unified tools.
 - **Improved UX**: Enhanced AI parameter parsing, automated unit conversion, and structured error reporting.
+- **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.
 - **Breaking changes**: Many low-level tools (e.g., `get_market_price`, `get_oracle_price`, `get_open_orders`) have been merged into unified counterparts.
 
 ---
@@ -31,13 +32,20 @@ Copy `.env.example` to `.env` and configure your trading wallet:
 
 ```bash
 PRIVATE_KEY=0x...
-RPC_URL=https://bsc-dataseed.bnbchain.org
-CHAIN_ID=56
+RPC_URL=https://your-testnet-or-mainnet-rpc
+CHAIN_ID=...
 BROKER_ADDRESS=0x...
 QUOTE_TOKEN_ADDRESS=0x...
-QUOTE_TOKEN_DECIMALS=18
+QUOTE_TOKEN_DECIMALS=...
 ```
 
+## Testnet `MYXBroker` Reference
+
+- Arbitrum test: `0x895C4ae2A22bB26851011d733A9355f663a1F939`
+- Linea test: `0x634EfDC9dC76D7AbF6E49279875a31B02E9891e2`
+
+Use the broker that matches your active RPC and chain configuration.
+
 ---
 
 # Core Tools Reference
@@ -77,6 +85,17 @@ QUOTE_TOKEN_DECIMALS=18
 
 ---
 
+# Safety Defaults
+
+- **Oracle-only execution**: trading paths now require a fresh Oracle price and reject stale / missing execution prices.
+- **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.
+- **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`.
+
+---
+
 # Tool Discovery
 
 When a client or LLM is unsure which tool to call:
@@ -111,6 +130,7 @@ Use these conventions when generating tool arguments:
 - `timeInForce`: SDK `v1.0.2` 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%`
 - Human units: `"100"` means 100 USDC or 100 token units depending on field
 - Raw units: `"raw:1000000"` means exact on-chain integer units
 

package/TOOL_EXAMPLES.md

@@ -7,6 +7,13 @@ All examples use the MCP format:
 { "name": "tool_name", "arguments": { "...": "..." } }
 ```
 
+## Environment Notes
+
+- Common testnet brokers:
+  - Arbitrum test: `0x895C4ae2A22bB26851011d733A9355f663a1F939`
+  - Linea test: `0x634EfDC9dC76D7AbF6E49279875a31B02E9891e2`
+- Keep `RPC_URL`, `CHAIN_ID`, and `BROKER_ADDRESS` on the same network.
+
 ---
 
 ## Discovery First
@@ -75,6 +82,8 @@ 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.
+Auto-computed `tradingFee` follows notional semantics rather than raw collateral-only estimation.
 
 Raw-units example:
 
@@ -113,6 +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`.
 `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.
 
 ### `close_position`
 Close or reduce a position. Use `ALL` for a full close.
@@ -137,6 +147,8 @@ Close or reduce a position. Use `ALL` for a full close.
 }
 ```
 
+`direction` must match the live position. MCP now validates live direction before sending the close request.
+
 ### `manage_tp_sl`
 Create or update TP/SL on an open position.
 
@@ -154,6 +166,9 @@ Create or update TP/SL on an open position.
 }
 ```
 
+Plain integer prices such as `"2800"` are treated as human prices, not implicit raw 30-decimal values.
+For LONG positions, use `tpPrice > entryPrice` and `slPrice < entryPrice`. For SHORT positions, use the inverse.
+
 Delete both TP/SL orders:
 
 ```json
@@ -284,6 +299,9 @@ Alias-friendly form also works:
 }
 ```
 
+LP preview failures now fail closed; the server no longer downgrades to `minAmountOut=0`.
+Oracle-backed LP pricing requires a fresh price snapshot before execution.
+
 ### `get_lp_price`
 Read LP NAV price for BASE or QUOTE side.
 
@@ -391,3 +409,5 @@ Read open positions, history, or both.
 4. Canonical enums are still preferred:
    `OPEN|HISTORY|ALL`, `BASE|QUOTE`, `LONG|SHORT`, `MARKET|LIMIT|STOP`.
 5. The server tolerates common lowercase and alias forms for better AI compatibility.
+6. Trading `slippagePct` uses 4-decimal raw units, so `100 = 1.00%` and `50 = 0.50%`.
+7. High-risk execution paths prefer fresh Oracle pricing, exact approval sizing, and fail-close behavior on missing previews or invalid units.

package/dist/prompts/tradingGuide.js

@@ -12,7 +12,7 @@ export const tradingGuidePrompt = {
                     content: {
                         type: "text",
                         text: `
-# MYX Trading MCP Best Practices (v3.0.12)
+# MYX Trading MCP Best Practices (v3.0.21)
 
 You are an expert crypto trader using the MYX Protocol. To ensure successful execution and safe handling of user funds, follow these patterns:
 
@@ -28,21 +28,27 @@ You are an expert crypto trader using the MYX Protocol. To ensure successful exe
 - **Consolidated Tools**: Many legacy tools have been merged. Always use the high-level versions (e.g., \`get_price\` instead of \`get_market_price\`).
 - **Discovery**: \`search_tools\` understands legacy names like \`get_open_orders\` and intent phrases like \`add base lp\`.
 - **Unit Prefixes**: Prefer \`human:\` for readable amounts (e.g., "100" USDC) and \`raw:\` for exact on-chain units.
-- **Slippage**: Default is 100 (1%). For volatile tokens, consider 200-300 (2-3%).
+- **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.
 - **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.
+- **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.
+
+## 3. Testnet Broker Reference
+- Arbitrum test: \`0x895C4ae2A22bB26851011d733A9355f663a1F939\`
+- Linea test: \`0x634EfDC9dC76D7AbF6E49279875a31B02E9891e2\`
+- Always keep \`RPC_URL\`, \`CHAIN_ID\`, and \`BROKER_ADDRESS\` on the same network.
 
 Current Session:
 - Wallet: ${address}
 - Chain ID: ${chainId}
 
-## 3. Self-Healing
+## 4. Self-Healing
 If a transaction reverts with a hex code, the server will attempt to decode it (e.g., "AccountInsufficientFreeAmount"). Error payloads now include structured \`code/hint/action\` fields; use them to provide concrete next steps.
-
-Current Session:
-- Wallet: ${address}
-- Chain ID: ${chainId}
 `
                     }
                 }

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.20" }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
+const server = new Server({ name: "myx-mcp-trading-server", version: "3.0.21" }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
 // List tools
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {

package/dist/services/marketService.js

@@ -1,5 +1,6 @@
 import { getChainId } from "../auth/resolveClient.js";
 import { getMarketStateDesc } from "../utils/mappings.js";
+export const DEFAULT_ORACLE_MAX_AGE_SEC = Number(process.env.ORACLE_MAX_AGE_SEC ?? 90);
 function collectRows(input) {
     if (Array.isArray(input))
         return input.flatMap(collectRows);
@@ -92,6 +93,46 @@ export async function getOraclePrice(client, poolId, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
     return client.utils.getOraclePrice(poolId, chainId);
 }
+function parseOraclePublishTime(value, poolId) {
+    const text = String(value ?? "").trim();
+    if (!/^\d+$/.test(text)) {
+        throw new Error(`Oracle publishTime missing or invalid for poolId=${poolId}.`);
+    }
+    const parsed = BigInt(text);
+    if (parsed <= 0n) {
+        throw new Error(`Oracle publishTime must be positive for poolId=${poolId}.`);
+    }
+    return parsed;
+}
+export function assertOracleFreshness(publishTimeValue, poolId, maxAgeSec = DEFAULT_ORACLE_MAX_AGE_SEC) {
+    if (!Number.isFinite(maxAgeSec) || maxAgeSec <= 0) {
+        throw new Error(`Invalid oracle max age configuration: ${maxAgeSec}`);
+    }
+    const publishTime = parseOraclePublishTime(publishTimeValue, poolId);
+    const nowSec = BigInt(Math.floor(Date.now() / 1000));
+    const maxAge = BigInt(Math.floor(maxAgeSec));
+    if (publishTime > nowSec + 5n) {
+        throw new Error(`Oracle publishTime is in the future for poolId=${poolId}.`);
+    }
+    const age = nowSec - publishTime;
+    if (age > maxAge) {
+        throw new Error(`Oracle price expired for poolId=${poolId}: age=${age.toString()}s exceeds maxAge=${maxAge.toString()}s.`);
+    }
+    return publishTime;
+}
+export async function getFreshOraclePrice(client, poolId, chainIdOverride, maxAgeSec = DEFAULT_ORACLE_MAX_AGE_SEC) {
+    const oracle = await getOraclePrice(client, poolId, chainIdOverride);
+    const price = String(oracle?.price ?? "").trim();
+    if (!price) {
+        throw new Error(`Oracle price missing for poolId=${poolId}.`);
+    }
+    const publishTime = assertOracleFreshness(oracle?.publishTime, poolId, maxAgeSec);
+    return {
+        ...oracle,
+        price,
+        publishTime: publishTime.toString(),
+    };
+}
 export async function searchMarket(client, keyword, limit = 1000, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
     const normalizedKeyword = String(keyword ?? "").trim();

package/dist/services/poolService.js

@@ -1,10 +1,11 @@
 import { pool, quote, base } from "@myx-trade/sdk";
 import { getChainId, resolveClient } from "../auth/resolveClient.js";
 import { extractErrorMessage } from "../utils/errorMessage.js";
-import { ensureUnits } from "../utils/units.js";
+import { ensureUnits, parseUserUnits } from "../utils/units.js";
 import { normalizeAddress } from "../utils/address.js";
-import { Contract, parseUnits, MaxUint256 } from "ethers";
+import { Contract } from "ethers";
 import { logger } from "../utils/logger.js";
+import { assertOracleFreshness } from "./marketService.js";
 const LP_DECIMALS = 18;
 const POOL_MANAGER_BY_CHAIN = {
     421614: "0xf268D9FeD3Bd56fd9aBdb4FeEb993338613678A8",
@@ -202,10 +203,13 @@ async function buildOraclePricePayload(client, chainId, poolId, fallbackOracleTy
     if (!vaa || !vaa.startsWith("0x")) {
         throw new Error(`Oracle VAA unavailable for pool ${poolId}.`);
     }
-    const publishTime = toPositiveBigint(oracle?.publishTime) ?? BigInt(Math.floor(Date.now() / 1000));
+    const publishTime = assertOracleFreshness(oracle?.publishTime, poolId);
     const oracleType = Number.isFinite(Number(oracle?.oracleType)) ? Number(oracle.oracleType) : fallbackOracleType;
     const value = toPositiveBigint(oracle?.value) ?? 0n;
     const referencePrice30 = BigInt(ensureUnits(String(oracle?.price ?? "0"), 30, "oracle price"));
+    if (referencePrice30 <= 0n) {
+        throw new Error(`Oracle price must be positive for pool ${poolId}.`);
+    }
     return {
         prices: [[poolId, oracleType, publishTime, vaa]],
         value,
@@ -229,8 +233,7 @@ async function previewAmountOutForLiquidity(signer, chainId, poolId, poolType, a
         return toPositiveBigint(out) ?? 0n;
     }
     catch (error) {
-        logger.warn("LP preview call failed; fallback to minAmountOut=0.", extractErrorMessage(error));
-        return 0n;
+        throw new Error(`LP preview failed: ${extractErrorMessage(error)}`);
     }
 }
 async function executeLiquidityTxViaRouter(params) {
@@ -244,7 +247,7 @@ async function executeLiquidityTxViaRouter(params) {
     if (!Number.isFinite(decimals) || decimals < 0) {
         throw new Error(`Invalid decimals while preparing ${poolType} ${action} transaction.`);
     }
-    const amountIn = parseUnits(String(amount), decimals);
+    const amountIn = BigInt(parseUserUnits(String(amount), decimals, "amount"));
     if (amountIn <= 0n) {
         throw new Error(`Liquidity ${poolType.toLowerCase()} ${action} amount must be > 0.`);
     }
@@ -255,7 +258,7 @@ async function executeLiquidityTxViaRouter(params) {
         const allowance = toPositiveBigint(await tokenContract.allowance(address, addresses.router)) ?? 0n;
         if (allowance < amountIn) {
             logger.info(`[LP fallback] allowance insufficient for ${poolType} deposit, approving router. required=${amountIn.toString()}, current=${allowance.toString()}`);
-            const approveTx = await tokenContract.approve(addresses.router, MaxUint256);
+            const approveTx = await tokenContract.approve(addresses.router, amountIn);
             approvalTxHash = String(approveTx?.hash ?? "").trim() || null;
             const approveReceipt = await approveTx?.wait?.();
             if (approveReceipt && approveReceipt.status !== 1) {
@@ -351,10 +354,8 @@ async function resolvePositiveMarketPrice30(client, poolId, chainId) {
         return null;
     try {
         const oracle = await client.utils?.getOraclePrice?.(poolId, chainId);
-        const byValue = toPositiveBigint(oracle?.value);
+        assertOracleFreshness(oracle?.publishTime, poolId);
         const byPrice = toPositiveBigint(oracle?.price);
-        if (byValue)
-            return byValue;
         if (byPrice)
             return byPrice;
     }
@@ -481,80 +482,28 @@ export async function getLiquidityInfo(client, poolId, marketPrice, chainIdOverr
  */
 export async function quoteDeposit(poolId, amount, slippage, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    const txHashBefore = readLastMockTxHash();
-    try {
-        return await withMutedSdkAbiMismatchLogs(() => quote.deposit({ chainId, poolId, amount, slippage }));
-    }
-    catch (error) {
-        const message = extractErrorMessage(error);
-        const recovered = recoverSdkSubmittedTxHash(txHashBefore, message, { poolType: "QUOTE", action: "deposit" });
-        if (recovered)
-            return recovered;
-        if (!isAbiLengthMismatchError(message))
-            throw error;
-        logger.warn("quote.deposit hit SDK ABI mismatch; switching to explicit router path.");
-        return executeLiquidityTxViaRouter({ chainId, poolId, poolType: "QUOTE", action: "deposit", amount, slippage });
-    }
+    return executeLiquidityTxViaRouter({ chainId, poolId, poolType: "QUOTE", action: "deposit", amount, slippage });
 }
 /**
  * Quote 池 withdraw
  */
 export async function quoteWithdraw(poolId, amount, slippage, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    const txHashBefore = readLastMockTxHash();
-    try {
-        return await withMutedSdkAbiMismatchLogs(() => quote.withdraw({ chainId, poolId, amount, slippage }));
-    }
-    catch (error) {
-        const message = extractErrorMessage(error);
-        const recovered = recoverSdkSubmittedTxHash(txHashBefore, message, { poolType: "QUOTE", action: "withdraw" });
-        if (recovered)
-            return recovered;
-        if (!isAbiLengthMismatchError(message))
-            throw error;
-        logger.warn("quote.withdraw hit SDK ABI mismatch; switching to explicit router path.");
-        return executeLiquidityTxViaRouter({ chainId, poolId, poolType: "QUOTE", action: "withdraw", amount, slippage });
-    }
+    return executeLiquidityTxViaRouter({ chainId, poolId, poolType: "QUOTE", action: "withdraw", amount, slippage });
 }
 /**
  * Base 池 deposit
  */
 export async function baseDeposit(poolId, amount, slippage, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    const txHashBefore = readLastMockTxHash();
-    try {
-        return await withMutedSdkAbiMismatchLogs(() => base.deposit({ chainId, poolId, amount, slippage }));
-    }
-    catch (error) {
-        const message = extractErrorMessage(error);
-        const recovered = recoverSdkSubmittedTxHash(txHashBefore, message, { poolType: "BASE", action: "deposit" });
-        if (recovered)
-            return recovered;
-        if (!isAbiLengthMismatchError(message))
-            throw error;
-        logger.warn("base.deposit hit SDK ABI mismatch; switching to explicit router path.");
-        return executeLiquidityTxViaRouter({ chainId, poolId, poolType: "BASE", action: "deposit", amount, slippage });
-    }
+    return executeLiquidityTxViaRouter({ chainId, poolId, poolType: "BASE", action: "deposit", amount, slippage });
 }
 /**
  * Base 池 withdraw
  */
 export async function baseWithdraw(poolId, amount, slippage, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    const txHashBefore = readLastMockTxHash();
-    try {
-        return await withMutedSdkAbiMismatchLogs(() => base.withdraw({ chainId, poolId, amount, slippage }));
-    }
-    catch (error) {
-        const message = extractErrorMessage(error);
-        const recovered = recoverSdkSubmittedTxHash(txHashBefore, message, { poolType: "BASE", action: "withdraw" });
-        if (recovered)
-            return recovered;
-        if (!isAbiLengthMismatchError(message))
-            throw error;
-        logger.warn("base.withdraw hit SDK ABI mismatch; switching to explicit router path.");
-        return executeLiquidityTxViaRouter({ chainId, poolId, poolType: "BASE", action: "withdraw", amount, slippage });
-    }
+    return executeLiquidityTxViaRouter({ chainId, poolId, poolType: "BASE", action: "withdraw", amount, slippage });
 }
 /**
  * 获取 LP 价格

package/dist/services/tradeService.js

@@ -7,6 +7,7 @@ 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";
 function resolveDirection(direction) {
     if (typeof direction === "string") {
         const text = direction.trim().toUpperCase();
@@ -154,6 +155,37 @@ 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();
@@ -249,6 +281,18 @@ export async function openPosition(client, address, args) {
     const sizeRaw = ensureUnits(args.size, baseDecimals, "size", { allowImplicitRaw: false });
     const priceRaw = ensureUnits(args.price, 30, "price", { allowImplicitRaw: false });
     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}.`);
+    }
+    const spend = await getRequiredIncreaseSpendRaw(client, resolvedMarketId, {
+        collateralRaw,
+        tradingFeeRaw,
+        tpPrice: args.tpPrice,
+        tpSize: args.tpSize,
+        slPrice: args.slPrice,
+        slSize: args.slSize,
+    }, chainId);
     validateIncreaseOrderEconomics({
         collateralRaw,
         sizeRaw,
@@ -268,7 +312,7 @@ export async function openPosition(client, address, args) {
         marginBalanceRaw = toBigIntOrZero(marginInfo.data.freeMargin);
         walletBalanceRaw = toBigIntOrZero(marginInfo.data.walletBalance);
     }
-    const requiredRaw = BigInt(collateralRaw);
+    const requiredRaw = spend.totalSpendRaw;
     if (marginBalanceRaw < requiredRaw) {
         if (!allowAutoDeposit) {
             throw new Error(`Insufficient marginBalance (${marginBalanceRaw.toString()}) for required collateral (${requiredRaw.toString()}). ` +
@@ -459,9 +503,14 @@ export async function closeAllPositions(client, address) {
     const results = [];
     for (const pos of positions) {
         const dir = pos.direction === 0 ? Direction.LONG : Direction.SHORT;
-        // Get current price for slippage protection
-        const oracleData = await client.utils.getOraclePrice(pos.poolId, chainId);
-        const currentPrice30 = ensureUnits(oracleData.price, 30, "oracle price");
+        const marketDetailRes = await client.markets.getMarketDetail({ chainId, poolId: pos.poolId });
+        const marketDetail = marketDetailRes?.data || (marketDetailRes?.marketId ? marketDetailRes : null);
+        if (!marketDetail?.marketId) {
+            throw new Error(`Could not resolve market metadata for poolId=${pos.poolId}.`);
+        }
+        const baseDecimals = Number(marketDetail.baseDecimals ?? 18);
+        const oracleData = await getFreshOraclePrice(client, pos.poolId, chainId);
+        const currentPrice30 = ensureUnits(oracleData.price, 30, "oracle price", { allowImplicitRaw: false });
         // For LONG close (Decrease LONG): Price should be lower (e.g. 90% of current)
         // For SHORT close (Decrease SHORT): Price should be higher (e.g. 110% of current)
         // Here we use a safe 10% slippage price
@@ -472,7 +521,13 @@ export async function closeAllPositions(client, address) {
         else {
             slippagePrice30 = (BigInt(currentPrice30) * 110n) / 100n;
         }
-        const sizeWei = ensureUnits(pos.size, 18, "size");
+        const sizeInput = /^\d+$/.test(String(pos.sizeRaw ?? pos.positionSizeRaw ?? "").trim())
+            ? `raw:${String(pos.sizeRaw ?? pos.positionSizeRaw).trim()}`
+            : String(pos.size ?? pos.positionSize ?? "").trim();
+        if (!sizeInput) {
+            throw new Error(`Position size missing for positionId=${String(pos.positionId ?? "").trim()}.`);
+        }
+        const sizeWei = ensureUnits(sizeInput, baseDecimals, "size", { allowImplicitRaw: false });
         const res = await client.order.createDecreaseOrder({
             chainId,
             address,
@@ -485,7 +540,7 @@ export async function closeAllPositions(client, address) {
             size: sizeWei,
             price: slippagePrice30.toString(),
             postOnly: false,
-            slippagePct: "1000", // 10%
+            slippagePct: "100", // 1%
             executionFeeToken: getQuoteToken(),
             leverage: pos.userLeverage,
         });

package/dist/tools/accountTransfer.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { resolveClient, getChainId, getQuoteToken } from "../auth/resolveClient.js";
 import { normalizeAddress } from "../utils/address.js";
 import { finalizeMutationResult } from "../utils/mutationResult.js";
+import { fetchErc20Decimals } from "../utils/token.js";
 const MAX_UINT256 = "115792089237316195423570985008687907853269984665640564039457584007913129639935";
 function asBigintOrNull(value) {
     try {
@@ -52,11 +53,9 @@ export const accountDepositTool = {
             const chainId = getChainId();
             const tokenAddressInput = String(args.tokenAddress ?? "").trim() || getQuoteToken();
             const tokenAddress = normalizeAddress(tokenAddressInput, "tokenAddress");
-            // For deposit, we default to quote decimals (6) as it's the most common use case.
-            // ensureUnits handles 'raw:' prefix if absolute precision is needed.
             const { ensureUnits } = await import("../utils/units.js");
-            const { getQuoteDecimals } = await import("../auth/resolveClient.js");
-            const amount = ensureUnits(args.amount, getQuoteDecimals(), "amount", { allowImplicitRaw: false });
+            const tokenDecimals = await fetchErc20Decimals(signer.provider ?? signer, tokenAddress, "deposit token");
+            const amount = ensureUnits(args.amount, tokenDecimals, "amount", { allowImplicitRaw: false });
             let approval = null;
             const needApproval = await client.utils.needsApproval(address, chainId, tokenAddress, amount);
             if (needApproval) {
@@ -102,9 +101,17 @@ export const accountWithdrawTool = {
             const { client, address, signer } = await resolveClient();
             const chainId = getChainId();
             const { ensureUnits } = await import("../utils/units.js");
-            const { getQuoteDecimals } = await import("../auth/resolveClient.js");
-            // Assuming 18 decimals for base and quoteDecimals for quote
-            const decimals = args.isQuoteToken ? getQuoteDecimals() : 18;
+            const marketDetailRes = await client.markets.getMarketDetail({ chainId, poolId: args.poolId });
+            const marketDetail = marketDetailRes?.data || (marketDetailRes?.marketId ? marketDetailRes : null);
+            if (!marketDetail?.marketId) {
+                throw new Error(`Could not resolve market metadata for poolId=${args.poolId}.`);
+            }
+            const decimals = Number(Boolean(args.isQuoteToken)
+                ? marketDetail.quoteDecimals
+                : marketDetail.baseDecimals);
+            if (!Number.isFinite(decimals) || decimals < 0) {
+                throw new Error(`Invalid token decimals for withdraw on poolId=${args.poolId}.`);
+            }
             const amount = ensureUnits(args.amount, decimals, "amount", { allowImplicitRaw: false });
             const amountRaw = asBigintOrNull(amount);
             if (amountRaw === null || amountRaw <= 0n) {

package/dist/tools/closeAllPositions.js

@@ -1,9 +1,25 @@
 import { z } from "zod";
 import { resolveClient, getChainId, getQuoteToken } from "../auth/resolveClient.js";
-import { getOraclePrice, resolvePool } from "../services/marketService.js";
+import { getFreshOraclePrice, resolvePool } from "../services/marketService.js";
 import { ensureUnits } from "../utils/units.js";
 import { finalizeMutationResult } from "../utils/mutationResult.js";
 import { normalizeSlippagePct4dpFlexible, SLIPPAGE_PCT_4DP_DESC } from "../utils/slippage.js";
+const INTEGER_RE = /^\d+$/;
+function resolvePositionSizeInput(position) {
+    const rawCandidates = [position?.sizeRaw, position?.positionSizeRaw];
+    for (const candidate of rawCandidates) {
+        const text = String(candidate ?? "").trim();
+        if (INTEGER_RE.test(text))
+            return `raw:${text}`;
+    }
+    const humanCandidates = [position?.size, position?.positionSize];
+    for (const candidate of humanCandidates) {
+        const text = String(candidate ?? "").trim();
+        if (text)
+            return text;
+    }
+    throw new Error(`Position size missing for positionId=${String(position?.positionId ?? position?.position_id ?? "").trim()}.`);
+}
 export const closeAllPositionsTool = {
     name: "close_all_positions",
     description: "[TRADE] Emergency: close ALL open positions in a pool at once. Use for risk management.",
@@ -28,27 +44,18 @@ export const closeAllPositionsTool = {
                 return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: { message: "No open positions in this pool.", closed: 0 } }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
             }
             // 2) 为每个仓位构建平仓参数
-            const slippagePct = normalizeSlippagePct4dpFlexible(args.slippagePct ?? "200");
-            // 3) We need actual oracle prices to avoid Revert 0x613970e0 (InvalidParameter)
-            const oraclePriceReq = await getOraclePrice(client, poolId).catch(() => null);
-            let fallbackPrice = "0";
-            if (oraclePriceReq && oraclePriceReq.price) {
-                fallbackPrice = oraclePriceReq.price.toString();
-            }
-            else {
-                const { getMarketPrice } = await import("../services/marketService.js");
-                const marketData = await getMarketPrice(client, poolId).catch(() => null);
-                if (marketData && marketData.price) {
-                    fallbackPrice = marketData.price.toString();
-                }
-                else {
-                    // Extreme fallback - but this may still revert
-                    fallbackPrice = poolPositions[0]?.entryPrice || "0";
-                }
+            const slippagePct = normalizeSlippagePct4dpFlexible(args.slippagePct ?? "100");
+            const marketDetailRes = await client.markets.getMarketDetail({ chainId, poolId });
+            const marketDetail = marketDetailRes?.data || (marketDetailRes?.marketId ? marketDetailRes : null);
+            if (!marketDetail?.marketId) {
+                throw new Error(`Could not resolve market metadata for poolId=${poolId}.`);
             }
+            const baseDecimals = Number(marketDetail.baseDecimals ?? 18);
+            const quoteToken = String(marketDetail.quoteToken ?? "").trim() || getQuoteToken();
+            const oracle = await getFreshOraclePrice(client, poolId, chainId);
+            const freshOraclePrice = oracle.price.toString();
             const closeParams = poolPositions.map((pos) => {
-                const rawSize = pos.size || pos.positionSize || "0";
-                const rawPrice = pos.markPrice || pos.mark_price || fallbackPrice;
+                const sizeInput = resolvePositionSizeInput(pos);
                 return {
                     chainId,
                     address,
@@ -59,11 +66,11 @@ export const closeAllPositionsTool = {
                     timeInForce: 0, // IOC
                     direction: pos.direction ?? 0,
                     collateralAmount: "0",
-                    size: ensureUnits(rawSize, 18, "size"),
-                    price: ensureUnits(rawPrice, 30, "price"),
+                    size: ensureUnits(sizeInput, baseDecimals, "size", { allowImplicitRaw: false }),
+                    price: ensureUnits(freshOraclePrice, 30, "price", { allowImplicitRaw: false }),
                     postOnly: false,
                     slippagePct,
-                    executionFeeToken: pos.quoteToken || pos.quote_token || getQuoteToken(),
+                    executionFeeToken: quoteToken,
                     leverage: pos.userLeverage ?? pos.leverage ?? 1,
                 };
             });

package/dist/tools/closePosition.js

@@ -95,6 +95,20 @@ export const closePositionTool = {
                 triggerType: preparedArgs.triggerType !== undefined ? mapTriggerType(preparedArgs.triggerType) : undefined,
                 executionFeeToken: poolData.quoteToken || preparedArgs.executionFeeToken
             };
+            const positionsRes = await client.position.listPositions(address);
+            const positions = Array.isArray(positionsRes?.data) ? positionsRes.data : [];
+            const target = positions.find((position) => {
+                const pid = String(position?.positionId ?? position?.position_id ?? "").trim().toLowerCase();
+                const pool = String(position?.poolId ?? position?.pool_id ?? "").trim().toLowerCase();
+                return pid === String(preparedArgs.positionId ?? "").trim().toLowerCase() && pool === String(poolId).toLowerCase();
+            });
+            if (!target) {
+                throw new Error(`Could not find live position snapshot for positionId=${preparedArgs.positionId} in poolId=${poolId}.`);
+            }
+            const liveDirection = Number(target?.direction);
+            if (!Number.isFinite(liveDirection) || liveDirection !== mappedArgs.direction) {
+                throw new Error(`direction mismatch for positionId=${preparedArgs.positionId}: input=${mappedArgs.direction}, live=${String(target?.direction ?? "unknown")}.`);
+            }
             const raw = await closePos(client, address, mappedArgs);
             const data = await finalizeMutationResult(raw, signer, "close_position");
             const txHash = data.confirmation?.txHash;

package/dist/tools/executeTrade.js

@@ -10,6 +10,14 @@ import { parseUserUnits } from "../utils/units.js";
 import { isZeroAddress } 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) {
+    return 10n ** BigInt(decimals);
+}
+function computeQuoteNotionalRaw(sizeRaw, priceRaw30, baseDecimals, quoteDecimals) {
+    const numerator = sizeRaw * priceRaw30 * pow10(quoteDecimals);
+    const denominator = pow10(baseDecimals + 30);
+    return numerator / denominator;
+}
 export const executeTradeTool = {
     name: "execute_trade",
     description: "[TRADE] Create an increase order (open or add to position) using SDK-native parameters.",
@@ -76,6 +84,22 @@ export const executeTradeTool = {
                 throw new Error("size must be > 0.");
             if (BigInt(priceRaw) <= 0n)
                 throw new Error("price must be > 0.");
+            if (normalizedPositionId) {
+                const positionsRes = await client.position.listPositions(address);
+                const positions = Array.isArray(positionsRes?.data) ? positionsRes.data : [];
+                const target = positions.find((position) => {
+                    const positionId = String(position?.positionId ?? position?.position_id ?? "").trim().toLowerCase();
+                    const positionPoolId = String(position?.poolId ?? position?.pool_id ?? "").trim().toLowerCase();
+                    return positionId === normalizedPositionId.toLowerCase() && positionPoolId === String(poolId).toLowerCase();
+                });
+                if (!target) {
+                    throw new Error(`Could not find live position for positionId=${normalizedPositionId} in poolId=${poolId}.`);
+                }
+                const liveDirection = Number(target?.direction);
+                if (!Number.isFinite(liveDirection) || liveDirection !== mappedDirection) {
+                    throw new Error(`direction mismatch for positionId=${normalizedPositionId}: input=${mappedDirection}, live=${String(target?.direction ?? "unknown")}.`);
+                }
+            }
             let tradingFeeRaw = "";
             let tradingFeeMeta = { source: "user" };
             const tradingFeeInput = String(args.tradingFee ?? "").trim();
@@ -107,7 +131,8 @@ export const executeTradeTool = {
                 }
                 const rateRaw = args.postOnly ? feeRes.data.makerFeeRate : feeRes.data.takerFeeRate;
                 const rateBig = BigInt(String(rateRaw ?? "0"));
-                tradingFeeRaw = ((BigInt(collateralRaw) * rateBig) / 1000000n).toString();
+                const notionalQuoteRaw = computeQuoteNotionalRaw(BigInt(sizeRaw), BigInt(priceRaw), baseDecimals, quoteDecimals);
+                tradingFeeRaw = ((notionalQuoteRaw * rateBig) / 1000000n).toString();
                 tradingFeeMeta = { source: "computed", assetClass, riskTier, feeRate: String(rateRaw ?? "0") };
             }
             const mappedArgs = {

package/dist/tools/manageLiquidity.js

@@ -5,6 +5,7 @@ import { resolveClient, getChainId } from "../auth/resolveClient.js";
 import { resolvePool } from "../services/marketService.js";
 import { finalizeMutationResult } from "../utils/mutationResult.js";
 import { extractErrorMessage } from "../utils/errorMessage.js";
+import { normalizeLpSlippageRatio } from "../utils/slippage.js";
 function normalizeAssetSymbol(value) {
     const text = String(value ?? "").trim();
     if (!text)
@@ -67,7 +68,7 @@ export const manageLiquidityTool = {
         action: z.coerce.string().describe("'deposit' or 'withdraw' (aliases: add/remove/increase/decrease; case-insensitive)"),
         poolType: z.enum(["BASE", "QUOTE"]).describe("'BASE' or 'QUOTE'"),
         poolId: z.string().describe("Pool ID or Base Token Address"),
-        amount: z.coerce.number().positive().describe("Amount in human-readable units"),
+        amount: z.coerce.string().describe("Amount in human-readable units string"),
         slippage: z.coerce.number().min(0).describe("LP slippage ratio (e.g. 0.01 = 1%)"),
         chainId: z.coerce.number().int().positive().optional().describe("Optional chainId override"),
     },
@@ -75,9 +76,13 @@ export const manageLiquidityTool = {
         try {
             const { client, signer } = await resolveClient();
             let { action, poolType, poolId } = args;
-            const { amount, slippage } = args;
+            const amount = String(args.amount ?? "").trim();
+            const slippage = normalizeLpSlippageRatio(args.slippage);
             const chainId = args.chainId ?? getChainId();
             action = String(action ?? "").trim().toLowerCase();
+            if (!amount) {
+                throw new Error("amount is required.");
+            }
             const validActions = new Set(["deposit", "withdraw", "add", "remove", "increase", "decrease"]);
             if (!validActions.has(action)) {
                 throw new Error(`Invalid action: ${args.action}. Use deposit/withdraw or aliases add/remove/increase/decrease.`);

package/dist/tools/manageTpSl.js

@@ -29,7 +29,7 @@ function readSnapshotText(snapshot, keys) {
     }
     return "";
 }
-function normalizeUnitsInput(text) {
+function normalizeSizeInput(text) {
     const raw = String(text ?? "").trim();
     if (!raw)
         return "";
@@ -39,6 +39,17 @@ function normalizeUnitsInput(text) {
         return `raw:${raw}`;
     return raw;
 }
+function normalizePriceInput(text, source = "user") {
+    const raw = String(text ?? "").trim();
+    if (!raw)
+        return "";
+    if (/^(raw|human):/i.test(raw))
+        return raw;
+    if (source === "snapshot" && /^\d+$/.test(raw) && raw.length > 12) {
+        return `raw:${raw}`;
+    }
+    return raw;
+}
 function isExplicitZeroValue(value) {
     if (value === undefined || value === null)
         return false;
@@ -160,6 +171,58 @@ function resolvePositionSizeRaw(positionSnapshot, baseDecimals) {
     }
     return "";
 }
+function resolveEntryPriceInput(positionSnapshot) {
+    const rawCandidates = [
+        positionSnapshot?.entryPriceRaw,
+        positionSnapshot?.openPriceRaw,
+        positionSnapshot?.avgPriceRaw,
+        positionSnapshot?.averageOpenPriceRaw,
+    ];
+    for (const value of rawCandidates) {
+        const text = String(value ?? "").trim();
+        if (INTEGER_RE.test(text))
+            return `raw:${text}`;
+    }
+    const humanCandidates = [
+        positionSnapshot?.entryPrice,
+        positionSnapshot?.openPrice,
+        positionSnapshot?.avgPrice,
+        positionSnapshot?.averageOpenPrice,
+    ];
+    for (const value of humanCandidates) {
+        const text = String(value ?? "").trim();
+        if (text)
+            return text;
+    }
+    return "";
+}
+function validateTpSlPriceSemantics(direction, entryPriceInput, tpPriceInput, slPriceInput) {
+    if (!entryPriceInput) {
+        throw new Error("Unable to resolve entryPrice for TP/SL validation.");
+    }
+    const entryPriceRaw = BigInt(parseUserUnits(entryPriceInput, 30, "entryPrice"));
+    if (entryPriceRaw <= 0n) {
+        throw new Error("entryPrice must be > 0 for TP/SL validation.");
+    }
+    if (tpPriceInput) {
+        const tpPriceRaw = BigInt(parseUserUnits(tpPriceInput, 30, "tpPrice"));
+        if (direction === 0 && tpPriceRaw <= entryPriceRaw) {
+            throw new Error("LONG TP must be greater than entryPrice.");
+        }
+        if (direction === 1 && tpPriceRaw >= entryPriceRaw) {
+            throw new Error("SHORT TP must be less than entryPrice.");
+        }
+    }
+    if (slPriceInput) {
+        const slPriceRaw = BigInt(parseUserUnits(slPriceInput, 30, "slPrice"));
+        if (direction === 0 && slPriceRaw >= entryPriceRaw) {
+            throw new Error("LONG SL must be less than entryPrice.");
+        }
+        if (direction === 1 && slPriceRaw <= entryPriceRaw) {
+            throw new Error("SHORT SL must be greater than entryPrice.");
+        }
+    }
+}
 async function cancelTpSlByIntent(client, address, signer, chainId, args) {
     if (args.orderId) {
         const raw = await client.order.cancelAllOrders([String(args.orderId)], chainId);
@@ -265,12 +328,21 @@ export const manageTpSlTool = {
                 const snapshotTpSize = readSnapshotText(orderSnapshot, ["tpSize", "takeProfitSize"]);
                 const snapshotSlPrice = readSnapshotText(orderSnapshot, ["slPrice", "stopLossPrice", "slTriggerPrice"]);
                 const snapshotSlSize = readSnapshotText(orderSnapshot, ["slSize", "stopLossSize"]);
+                const orderPositionId = readSnapshotText(orderSnapshot, ["positionId", "position_id"]);
                 const size = isNonEmpty(args.size) ? String(args.size) : snapshotSize;
                 const price = isNonEmpty(args.price) ? String(args.price) : snapshotPrice;
                 const tpPrice = isNonEmpty(args.tpPrice) ? String(args.tpPrice) : snapshotTpPrice;
                 const tpSize = isNonEmpty(args.tpSize) ? String(args.tpSize) : snapshotTpSize;
                 const slPrice = isNonEmpty(args.slPrice) ? String(args.slPrice) : snapshotSlPrice;
                 const slSize = isNonEmpty(args.slSize) ? String(args.slSize) : snapshotSlSize;
+                const updateDirection = normalizeDirectionInput(args.direction ?? orderSnapshot?.direction);
+                const positionSnapshot = orderPositionId
+                    ? await findPositionSnapshot(client, address, args.poolId, orderPositionId)
+                    : null;
+                if (updateDirection !== undefined) {
+                    const entryPriceInput = resolveEntryPriceInput(positionSnapshot);
+                    validateTpSlPriceSemantics(updateDirection, entryPriceInput, tpPrice || undefined, slPrice || undefined);
+                }
                 if (!size || !price) {
                     throw new Error("size and price are required for update. Provide them explicitly, or ensure orderId can be found via get_orders so they can be auto-resolved.");
                 }
@@ -288,12 +360,12 @@ export const manageTpSlTool = {
                         orderId: args.orderId,
                         marketId: market.marketId,
                         poolId: args.poolId,
-                        size: normalizeUnitsInput(size),
-                        price: normalizeUnitsInput(price),
-                        tpPrice: tpPrice ? normalizeUnitsInput(tpPrice) : "0",
-                        tpSize: tpSize ? normalizeUnitsInput(tpSize) : "0",
-                        slPrice: slPrice ? normalizeUnitsInput(slPrice) : "0",
-                        slSize: slSize ? normalizeUnitsInput(slSize) : "0",
+                        size: normalizeSizeInput(size),
+                        price: normalizePriceInput(price, isNonEmpty(args.price) ? "user" : "snapshot"),
+                        tpPrice: tpPrice ? normalizePriceInput(tpPrice, isNonEmpty(args.tpPrice) ? "user" : "snapshot") : "0",
+                        tpSize: tpSize ? normalizeSizeInput(tpSize) : "0",
+                        slPrice: slPrice ? normalizePriceInput(slPrice, isNonEmpty(args.slPrice) ? "user" : "snapshot") : "0",
+                        slSize: slSize ? normalizeSizeInput(slSize) : "0",
                         quoteToken: market.quoteToken,
                         useOrderCollateral: args.useOrderCollateral ?? true
                     }, chainId);
@@ -326,6 +398,8 @@ export const manageTpSlTool = {
                 if (resolvedDirection === undefined || !resolvedLeverage || Number(resolvedLeverage) <= 0) {
                     throw new Error("direction and leverage are required when creating new TP/SL.");
                 }
+                const entryPriceInput = resolveEntryPriceInput(positionSnapshot);
+                validateTpSlPriceSemantics(resolvedDirection, entryPriceInput, isNonEmpty(args.tpPrice) ? String(args.tpPrice) : undefined, isNonEmpty(args.slPrice) ? String(args.slPrice) : undefined);
                 let tpSizeInput = isNonEmpty(args.tpSize) ? String(args.tpSize) : "";
                 let slSizeInput = isNonEmpty(args.slSize) ? String(args.slSize) : "";
                 const needsTpSize = isNonEmpty(args.tpPrice) && !tpSizeInput;

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 } from "../services/marketService.js";
+import { resolvePool, getFreshOraclePrice } from "../services/marketService.js";
 import { openPosition } from "../services/tradeService.js";
 import { isZeroAddress, normalizeAddress } from "../utils/address.js";
 import { finalizeMutationResult } from "../utils/mutationResult.js";
@@ -25,6 +25,29 @@ function asBigint(raw, label) {
         throw new Error(`${label} must be an integer string.`);
     }
 }
+function computeQuoteNotionalRaw(sizeRaw, priceRaw30, baseDecimals, quoteDecimals) {
+    const numerator = sizeRaw * priceRaw30 * pow10(quoteDecimals);
+    const denominator = pow10(baseDecimals + 30);
+    return numerator / denominator;
+}
+async function getRequiredApprovalSpendRaw(client, marketId, args, chainId) {
+    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}.`);
+    }
+    let executionOrderCount = 1n;
+    if (args.tpPrice && BigInt(String(args.tpSize ?? "0")) > 0n)
+        executionOrderCount += 1n;
+    if (args.slPrice && BigInt(String(args.slSize ?? "0")) > 0n)
+        executionOrderCount += 1n;
+    return (args.collateralRaw +
+        BigInt(args.tradingFeeRaw) +
+        (baseNetworkFeeRaw * executionOrderCount)).toString();
+}
 function pickMarketDetail(res) {
     if (!res)
         return null;
@@ -128,19 +151,9 @@ export const openPositionSimpleTool = {
             let price30;
             let priceMeta = { source: "user", publishTime: null, oracleType: null, human: null };
             if (orderType === OrderType.MARKET) {
-                try {
-                    const oracle = await client.utils.getOraclePrice(poolId, chainId);
-                    price30 = parseUserPrice30(oracle.price, "oraclePrice");
-                    priceMeta = { source: "oracle", publishTime: oracle.publishTime, oracleType: oracle.oracleType, human: oracle.price };
-                }
-                catch (e) {
-                    const tickers = await client.markets.getTickerList({ chainId, poolIds: [poolId] });
-                    const row = Array.isArray(tickers) ? tickers[0] : tickers?.data?.[0];
-                    if (!row?.price)
-                        throw new Error(`Failed to fetch oracle and ticker price for poolId=${poolId}: ${e?.message || e}`);
-                    price30 = parseUserPrice30(row.price, "marketPrice");
-                    priceMeta = { source: "ticker", publishTime: null, oracleType: null, human: row.price };
-                }
+                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();
@@ -219,7 +232,8 @@ export const openPositionSimpleTool = {
                         const rateRaw = postOnly ? feeData.makerFeeRate : feeData.takerFeeRate;
                         tradingFeeMeta.feeRate = rateRaw;
                         const rate = asBigint(String(rateRaw), "feeRate");
-                        const fee = (collateralRawBig * rate) / 1000000n;
+                        const notionalQuoteRaw = computeQuoteNotionalRaw(sizeRawBig, price30Big, baseDecimals, quoteDecimals);
+                        const fee = (notionalQuoteRaw * rate) / 1000000n;
                         tradingFeeRaw = fee.toString();
                     }
                     else {
@@ -274,9 +288,14 @@ export const openPositionSimpleTool = {
             // 7) Optional approval
             let approval = null;
             if (args.autoApprove) {
-                const requiredApprovalRaw = tradingFeeRaw && /^\d+$/.test(String(tradingFeeRaw))
-                    ? (collateralRawBig + asBigint(String(tradingFeeRaw), "tradingFee")).toString()
-                    : collateralRaw;
+                const requiredApprovalRaw = await getRequiredApprovalSpendRaw(client, marketId, {
+                    collateralRaw: collateralRawBig,
+                    tradingFeeRaw: String(tradingFeeRaw),
+                    tpPrice: prep.tpPrice,
+                    tpSize: prep.tpSize,
+                    slPrice: prep.slPrice,
+                    slSize: prep.slSize,
+                }, chainId);
                 const needApproval = await client.utils.needsApproval(address, chainId, quoteToken, requiredApprovalRaw);
                 if (needApproval) {
                     const approveAmount = args.approveMax ? MAX_UINT256 : requiredApprovalRaw;

package/dist/utils/slippage.js

@@ -1,7 +1,9 @@
 const SLIPPAGE_PCT_4DP_RE = /^\d+$/;
 export const SLIPPAGE_PCT_4DP_MAX = 10000n;
+export const BUSINESS_SLIPPAGE_PCT_4DP_MAX = BigInt(process.env.BUSINESS_MAX_SLIPPAGE_PCT_4DP ?? "500");
 export const SLIPPAGE_PCT_4DP_DESC = "Slippage in 4-decimal precision raw units (1 = 0.01%, 10000 = 100%)";
 const SLIPPAGE_PERCENT_HUMAN_RE = /^\d+(\.\d{1,2})?$/;
+export const BUSINESS_LP_SLIPPAGE_MAX_RATIO = Number(process.env.BUSINESS_MAX_LP_SLIPPAGE_RATIO ?? 0.05);
 export function isValidSlippagePct4dp(value) {
     if (!SLIPPAGE_PCT_4DP_RE.test(value))
         return false;
@@ -12,6 +14,10 @@ export function normalizeSlippagePct4dp(value, label = "slippagePct") {
     if (!isValidSlippagePct4dp(raw)) {
         throw new Error(`${label} must be an integer in [0, 10000] with 4-decimal precision (1 = 0.01%).`);
     }
+    const parsed = BigInt(raw);
+    if (parsed > BUSINESS_SLIPPAGE_PCT_4DP_MAX) {
+        throw new Error(`${label} exceeds business safety cap ${BUSINESS_SLIPPAGE_PCT_4DP_MAX.toString()} (${Number(BUSINESS_SLIPPAGE_PCT_4DP_MAX) / 100}%).`);
+    }
     return raw;
 }
 export function normalizeSlippagePct4dpFlexible(value, label = "slippagePct") {
@@ -34,5 +40,19 @@ export function normalizeSlippagePct4dpFlexible(value, label = "slippagePct") {
     if (converted > SLIPPAGE_PCT_4DP_MAX) {
         throw new Error(`${label} must be <= 100% (raw <= 10000).`);
     }
+    if (converted > BUSINESS_SLIPPAGE_PCT_4DP_MAX) {
+        throw new Error(`${label} exceeds business safety cap ${BUSINESS_SLIPPAGE_PCT_4DP_MAX.toString()} (${Number(BUSINESS_SLIPPAGE_PCT_4DP_MAX) / 100}%).`);
+    }
     return converted.toString();
 }
+export function normalizeLpSlippageRatio(value, label = "slippage") {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || numeric < 0) {
+        throw new Error(`${label} must be a finite number >= 0.`);
+    }
+    const ratio = numeric > 1 && numeric <= 100 ? numeric / 100 : numeric;
+    if (ratio > BUSINESS_LP_SLIPPAGE_MAX_RATIO) {
+        throw new Error(`${label} exceeds business safety cap ${BUSINESS_LP_SLIPPAGE_MAX_RATIO * 100}%.`);
+    }
+    return ratio;
+}

package/dist/utils/token.js

@@ -0,0 +1,15 @@
+import { Contract } from "ethers";
+const ERC20_DECIMALS_ABI = [
+    "function decimals() view returns (uint8)",
+];
+export async function fetchErc20Decimals(providerOrSigner, tokenAddress, label = "token") {
+    if (!providerOrSigner) {
+        throw new Error(`Provider unavailable while resolving decimals for ${label}.`);
+    }
+    const contract = new Contract(tokenAddress, ERC20_DECIMALS_ABI, providerOrSigner);
+    const decimals = Number(await contract.decimals());
+    if (!Number.isFinite(decimals) || decimals < 0) {
+        throw new Error(`Invalid decimals returned for ${label}: ${decimals}`);
+    }
+    return Math.floor(decimals);
+}

package/dist/utils/units.js

@@ -36,25 +36,17 @@ export function ensureUnits(value, decimals, label = "value", options = {}) {
     }
     if (!DECIMAL_RE.test(str))
         throw new Error(`${label} must be a numeric string.`);
-    // Truncate decimals if they exceed the allowed precision to prevent parseUnits throwing
     if (str.includes(".")) {
-        const parts = str.split(".");
-        if (parts[1].length > decimals) {
-            console.warn(`[ensureUnits] Truncating ${label} precision: ${str} -> ${parts[0]}.${parts[1].slice(0, decimals)}`);
-            str = `${parts[0]}.${parts[1].slice(0, decimals)}`;
+        const [, fracPart = ""] = str.split(".");
+        if (fracPart.length > decimals) {
+            throw new Error(`${label} exceeds supported precision: got ${fracPart.length} decimals, max is ${decimals}.`);
         }
     }
     // Legacy compatibility: optionally treat very large integers as already raw.
     if (allowImplicitRaw && !str.includes(".") && (str.length > 12 || str.length > decimals)) {
         return str;
     }
-    try {
-        return parseUnits(str, decimals).toString();
-    }
-    catch (e) {
-        console.warn(`[ensureUnits] parseUnits failed for ${label}: ${str}. Returning raw.`);
-        return str;
-    }
+    return parseUnits(str, decimals).toString();
 }
 export function parseUserUnits(value, decimals, label = "value") {
     let str = String(value).trim();

package/dist/utils/verification.js

@@ -1,5 +1,28 @@
 import { getChainId } from "../auth/resolveClient.js";
 import { decodeErrorSelector } from "./errors.js";
+import { getHistoryOrderStatusDesc } from "./mappings.js";
+const FINAL_HISTORY_STATUSES = new Set([1, 2, 9]);
+function collectHistoryRows(historyRes) {
+    if (Array.isArray(historyRes?.data))
+        return historyRes.data;
+    if (Array.isArray(historyRes?.data?.data))
+        return historyRes.data.data;
+    if (Array.isArray(historyRes))
+        return historyRes;
+    return [];
+}
+function normalizeHash(value) {
+    return String(value ?? "").trim().toLowerCase();
+}
+function enrichCancelReason(order) {
+    let cancelReason = order?.cancelReason || (Number(order?.status) === 1 ? "Unknown cancellation" : null);
+    if (cancelReason && cancelReason.startsWith("0x")) {
+        const decoded = decodeErrorSelector(cancelReason);
+        if (decoded)
+            cancelReason = `${cancelReason} (${decoded})`;
+    }
+    return cancelReason;
+}
 /**
  * 等待后端索引并验证交易结果 (增强版)
  */
@@ -9,22 +32,26 @@ export async function verifyTradeOutcome(client, address, poolId, txHash) {
     const maxAttempts = 6;
     let currentDelay = 1000;
     let matchedOrder = null;
+    let matchedBy = null;
     for (let i = 0; i < maxAttempts; i++) {
         try {
             // 查询历史订单
             const historyRes = await client.order.getOrderHistory({
                 chainId,
                 poolId,
-                limit: 10
+                limit: 50,
+                page: 1,
             }, address);
-            const history = historyRes?.data || historyRes?.data?.data || [];
-            matchedOrder = history.find((o) => String(o.orderHash).toLowerCase() === txHash.toLowerCase() ||
-                String(o.txHash).toLowerCase() === txHash.toLowerCase());
+            const history = collectHistoryRows(historyRes);
+            const targetHash = normalizeHash(txHash);
+            const txHashMatch = history.find((o) => normalizeHash(o.txHash) === targetHash);
+            const orderHashMatch = history.find((o) => normalizeHash(o.orderHash) === targetHash);
+            matchedOrder = txHashMatch ?? orderHashMatch ?? null;
+            matchedBy = txHashMatch ? "txHash" : orderHashMatch ? "orderHash" : null;
             // 如果找到了订单且已经有最终状态，则退出轮询
             if (matchedOrder) {
                 const status = Number(matchedOrder.status);
-                if (status === 1 || status === 9 || status === 2) {
-                    // 1: Cancelled, 9: Successful, 2: Expired
+                if (FINAL_HISTORY_STATUSES.has(status)) {
                     break;
                 }
             }
@@ -46,16 +73,20 @@ export async function verifyTradeOutcome(client, address, poolId, txHash) {
     catch (e) {
         console.warn(`[verifyTradeOutcome] Failed to fetch positions:`, e);
     }
-    let cancelReason = matchedOrder?.cancelReason || (matchedOrder?.status === 1 ? "Unknown cancellation" : null);
-    if (cancelReason && cancelReason.startsWith("0x")) {
-        const decoded = decodeErrorSelector(cancelReason);
-        if (decoded)
-            cancelReason = `${cancelReason} (${decoded})`;
-    }
+    const statusCode = matchedOrder ? Number(matchedOrder.status) : null;
+    const statusText = statusCode === null || !Number.isFinite(statusCode)
+        ? null
+        : getHistoryOrderStatusDesc(statusCode);
+    const final = statusCode !== null && FINAL_HISTORY_STATUSES.has(statusCode);
+    const cancelReason = matchedOrder ? enrichCancelReason(matchedOrder) : null;
     return {
         order: matchedOrder,
         positions: positions,
         verified: !!matchedOrder,
+        matchedBy,
+        statusCode,
+        statusText,
+        final,
         cancelReason
     };
 }

package/package.json

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