@michaleffffff/mcp-trading-server 3.0.16 → 3.0.21

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

@@ -1,10 +1,12 @@
 import { z } from "zod";
+import { formatUnits } from "ethers";
 import { resolveClient, getChainId } from "../auth/resolveClient.js";
 import { getMarketDetail, resolvePool } from "../services/marketService.js";
 import { getPoolInfo, getLiquidityInfo } from "../services/poolService.js";
 import { extractErrorMessage } from "../utils/errorMessage.js";
 import { parseUserPrice30 } from "../utils/units.js";
 const INTEGER_RE = /^\d+$/;
+const SIGNED_INTEGER_RE = /^-?\d+$/;
 const DECIMAL_RE = /^\d+(\.\d+)?$/;
 function normalizeMarketPrice30Input(value) {
     const text = String(value ?? "").trim();
@@ -29,6 +31,180 @@ function compactWarning(scope, err) {
     }
     return `${scope}: ${flat}`;
 }
+function formatRawValue(value, decimals) {
+    const text = String(value ?? "").trim();
+    if (!INTEGER_RE.test(text))
+        return null;
+    try {
+        return formatUnits(text, decimals);
+    }
+    catch {
+        return null;
+    }
+}
+function buildFormattedAmount(value, decimals, symbol) {
+    const raw = String(value ?? "");
+    const formatted = formatRawValue(value, decimals);
+    return {
+        raw,
+        decimals,
+        formatted,
+        display: formatted && symbol ? `${formatted} ${symbol}` : formatted,
+        symbol: symbol ?? null,
+    };
+}
+function buildFormattedPrice30(value, quoteSymbol) {
+    const raw = String(value ?? "");
+    const formatted = formatRawValue(value, 30);
+    return {
+        raw,
+        decimals: 30,
+        formatted,
+        display: formatted && quoteSymbol ? `${formatted} ${quoteSymbol}` : formatted,
+        symbol: quoteSymbol ?? null,
+    };
+}
+function buildFormattedRatio18(value) {
+    const raw = String(value ?? "");
+    const formatted = formatRawValue(value, 18);
+    return {
+        raw,
+        decimals: 18,
+        formatted,
+        display: formatted,
+    };
+}
+function buildRawScalar(value) {
+    const raw = String(value ?? "").trim();
+    if (!SIGNED_INTEGER_RE.test(raw)) {
+        return { raw, withCommas: raw || null };
+    }
+    try {
+        return {
+            raw,
+            withCommas: BigInt(raw).toLocaleString("en-US"),
+        };
+    }
+    catch {
+        return { raw, withCommas: raw };
+    }
+}
+function formatScaledIntegerString(raw, decimals) {
+    if (!SIGNED_INTEGER_RE.test(raw))
+        return null;
+    const negative = raw.startsWith("-");
+    const digits = negative ? raw.slice(1) : raw;
+    const padded = digits.padStart(decimals + 1, "0");
+    const intPart = padded.slice(0, -decimals) || "0";
+    const fracPart = padded.slice(-decimals).replace(/0+$/, "");
+    const normalized = fracPart ? `${intPart}.${fracPart}` : intPart;
+    return negative ? `-${normalized}` : normalized;
+}
+function buildFundingRateInfo(value) {
+    const base = buildRawScalar(value);
+    const raw = String(value ?? "").trim();
+    if (!SIGNED_INTEGER_RE.test(raw))
+        return base;
+    try {
+        const rawBig = BigInt(raw);
+        const perDayRaw = rawBig * 86400n;
+        const percentPerSecond = formatScaledIntegerString(raw, 12);
+        const percentPerDay = formatScaledIntegerString(perDayRaw.toString(), 12);
+        return {
+            ...base,
+            scale: "1e12 => percent",
+            percentPerSecond,
+            displayPerSecond: percentPerSecond ? `${percentPerSecond}%/秒` : null,
+            percentPerDay,
+            displayPerDay: percentPerDay ? `${percentPerDay}%/天` : null,
+        };
+    }
+    catch {
+        return base;
+    }
+}
+function buildTimestampInfo(value) {
+    const raw = String(value ?? "").trim();
+    const base = buildRawScalar(value);
+    if (!INTEGER_RE.test(raw)) {
+        return base;
+    }
+    const seconds = Number(raw);
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        return base;
+    }
+    const isoUtc = new Date(seconds * 1000).toISOString();
+    const secondsUntil = seconds - Math.floor(Date.now() / 1000);
+    return {
+        ...base,
+        isoUtc,
+        secondsUntil,
+    };
+}
+function computeQuoteNotionalDisplay(baseRaw, price30Raw, baseDecimals, quoteDecimals, quoteSymbol) {
+    const baseText = String(baseRaw ?? "").trim();
+    const priceText = String(price30Raw ?? "").trim();
+    if (!INTEGER_RE.test(baseText) || !INTEGER_RE.test(priceText))
+        return null;
+    try {
+        const notionalRaw = (BigInt(baseText) * BigInt(priceText) * (10n ** BigInt(quoteDecimals))) /
+            (10n ** BigInt(baseDecimals + 30));
+        return buildFormattedAmount(notionalRaw.toString(), quoteDecimals, quoteSymbol);
+    }
+    catch {
+        return null;
+    }
+}
+function formatPoolInfoSnapshot(poolInfo, marketDetail) {
+    if (!poolInfo || typeof poolInfo !== "object")
+        return null;
+    const baseSymbol = String(marketDetail?.baseSymbol ?? "BASE");
+    const quoteSymbol = String(marketDetail?.quoteSymbol ?? "QUOTE");
+    const baseDecimals = Number(marketDetail?.baseDecimals ?? 18);
+    const quoteDecimals = Number(marketDetail?.quoteDecimals ?? 6);
+    return {
+        quotePool: poolInfo.quotePool ? {
+            poolToken: poolInfo.quotePool.poolToken ?? null,
+            exchangeRate: buildFormattedRatio18(poolInfo.quotePool.exchangeRate),
+            poolTokenPrice: buildFormattedPrice30(poolInfo.quotePool.poolTokenPrice, quoteSymbol),
+            poolTokenSupply: buildFormattedAmount(poolInfo.quotePool.poolTokenSupply, 18, `m${quoteSymbol}.${baseSymbol}`),
+            totalDebt: buildFormattedAmount(poolInfo.quotePool.totalDebt, quoteDecimals, quoteSymbol),
+            baseCollateral: buildFormattedAmount(poolInfo.quotePool.baseCollateral, baseDecimals, baseSymbol),
+        } : null,
+        basePool: poolInfo.basePool ? {
+            poolToken: poolInfo.basePool.poolToken ?? null,
+            exchangeRate: buildFormattedRatio18(poolInfo.basePool.exchangeRate),
+            poolTokenPrice: buildFormattedPrice30(poolInfo.basePool.poolTokenPrice, quoteSymbol),
+            poolTokenSupply: buildFormattedAmount(poolInfo.basePool.poolTokenSupply, 18, `m${baseSymbol}.${quoteSymbol}`),
+            totalDebt: buildFormattedAmount(poolInfo.basePool.totalDebt, quoteDecimals, quoteSymbol),
+            baseCollateral: buildFormattedAmount(poolInfo.basePool.baseCollateral, baseDecimals, baseSymbol),
+        } : null,
+        reserveInfo: poolInfo.reserveInfo ? {
+            baseTotalAmount: buildFormattedAmount(poolInfo.reserveInfo.baseTotalAmount, baseDecimals, baseSymbol),
+            baseReservedAmount: buildFormattedAmount(poolInfo.reserveInfo.baseReservedAmount, baseDecimals, baseSymbol),
+            quoteTotalAmount: buildFormattedAmount(poolInfo.reserveInfo.quoteTotalAmount, quoteDecimals, quoteSymbol),
+            quoteReservedAmount: buildFormattedAmount(poolInfo.reserveInfo.quoteReservedAmount, quoteDecimals, quoteSymbol),
+        } : null,
+        fundingInfo: poolInfo.fundingInfo ? {
+            nextFundingRate: buildFundingRateInfo(poolInfo.fundingInfo.nextFundingRate),
+            lastFundingFeeTracker: buildRawScalar(poolInfo.fundingInfo.lastFundingFeeTracker),
+            nextEpochTime: buildTimestampInfo(poolInfo.fundingInfo.nextEpochTime),
+        } : null,
+        ioTracker: poolInfo.ioTracker ? {
+            tracker: buildFormattedAmount(poolInfo.ioTracker.tracker, baseDecimals, baseSymbol),
+            longSize: buildFormattedAmount(poolInfo.ioTracker.longSize, baseDecimals, baseSymbol),
+            shortSize: buildFormattedAmount(poolInfo.ioTracker.shortSize, baseDecimals, baseSymbol),
+            poolEntryPrice: buildFormattedPrice30(poolInfo.ioTracker.poolEntryPrice, quoteSymbol),
+            trackerNotionalAtEntry: computeQuoteNotionalDisplay(poolInfo.ioTracker.tracker, poolInfo.ioTracker.poolEntryPrice, baseDecimals, quoteDecimals, quoteSymbol),
+            longNotionalAtEntry: computeQuoteNotionalDisplay(poolInfo.ioTracker.longSize, poolInfo.ioTracker.poolEntryPrice, baseDecimals, quoteDecimals, quoteSymbol),
+            shortNotionalAtEntry: computeQuoteNotionalDisplay(poolInfo.ioTracker.shortSize, poolInfo.ioTracker.poolEntryPrice, baseDecimals, quoteDecimals, quoteSymbol),
+        } : null,
+        liquidityInfo: poolInfo.liquidityInfo ? {
+            windowCaps: buildFormattedAmount(poolInfo.liquidityInfo.windowCaps, quoteDecimals, quoteSymbol),
+            openInterest: buildFormattedAmount(poolInfo.liquidityInfo.openInterest, 18, quoteSymbol),
+        } : null,
+    };
+}
 export const getPoolMetadataTool = {
     name: "get_pool_metadata",
     description: "[MARKET] Get comprehensive metadata for a pool (market detail, on-chain info, liquidity, and limits).",
@@ -57,6 +233,11 @@ export const getPoolMetadataTool = {
             // 2. Pool Info (Reserves, Utilization)
             try {
                 results.poolInfo = await getPoolInfo(poolId, chainId, client);
+                const rawMarketDetail = results.marketDetail?.data ?? results.marketDetail;
+                const formatted = formatPoolInfoSnapshot(results.poolInfo, rawMarketDetail);
+                if (formatted) {
+                    results.poolInfoFormatted = formatted;
+                }
             }
             catch (err) {
                 errors.push(compactWarning("poolInfo", err));

package/dist/tools/manageLiquidity.js

@@ -1,9 +1,11 @@
 import { z } from "zod";
+import { formatUnits } from "ethers";
 import { quoteDeposit, quoteWithdraw, baseDeposit, baseWithdraw, getLpPrice, } from "../services/poolService.js";
 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)
@@ -45,6 +47,20 @@ function resolveLpAssetNames(detail) {
         quoteLpAssetName,
     };
 }
+function formatLpPricePayload(value, quoteSymbol) {
+    const raw = String(value ?? "").trim();
+    if (!/^\d+$/.test(raw)) {
+        return { raw, formatted: null, decimals: 30, symbol: quoteSymbol ?? null };
+    }
+    const formatted = formatUnits(raw, 30);
+    return {
+        raw,
+        formatted,
+        decimals: 30,
+        symbol: quoteSymbol ?? null,
+        display: quoteSymbol ? `${formatted} ${quoteSymbol}` : formatted,
+    };
+}
 export const manageLiquidityTool = {
     name: "manage_liquidity",
     description: "[LIQUIDITY] Add or withdraw liquidity from a BASE or QUOTE pool. Success response includes LP naming metadata: base `mBASE.QUOTE`, quote `mQUOTE.BASE`, plus `operatedLpAssetName` based on poolType.",
@@ -52,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"),
     },
@@ -60,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.`);
@@ -135,8 +155,20 @@ export const getLpPriceTool = {
     },
     handler: async (args) => {
         try {
-            const data = await getLpPrice(args.poolType, args.poolId, args.chainId);
-            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data }, (k, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
+            const { client } = await resolveClient();
+            const chainId = args.chainId ?? getChainId();
+            const poolId = await resolvePool(client, args.poolId, undefined, chainId);
+            const detailRes = await client.markets.getMarketDetail({ chainId, poolId }).catch(() => null);
+            const detail = detailRes?.data || (detailRes?.marketId ? detailRes : null);
+            const quoteSymbol = String(detail?.quoteSymbol ?? "").trim() || null;
+            const rawPrice = await getLpPrice(args.poolType, poolId, chainId);
+            const payload = {
+                raw: String(rawPrice ?? ""),
+                formatted: formatLpPricePayload(rawPrice, quoteSymbol ?? undefined),
+                poolType: args.poolType,
+                poolId,
+            };
+            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: payload }, (k, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
         }
         catch (error) {
             return { content: [{ type: "text", text: `Error: ${extractErrorMessage(error)}` }], isError: true };

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;