@michaleffffff/mcp-trading-server 3.0.5 → 3.0.10

package/dist/services/poolService.js

@@ -2,6 +2,75 @@ 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 { normalizeAddress } from "../utils/address.js";
+import { Contract, parseUnits, MaxUint256 } from "ethers";
+import { logger } from "../utils/logger.js";
+const LP_DECIMALS = 18;
+const POOL_MANAGER_BY_CHAIN = {
+    421614: "0xf268D9FeD3Bd56fd9aBdb4FeEb993338613678A8",
+};
+const POOL_MANAGER_ABI = [
+    "function deployPool((bytes32 marketId,address baseToken))",
+    "function getMarketPool(bytes32 marketId,address asset) view returns ((bytes32 marketId,bytes32 poolId,address baseToken,address quoteToken,uint8 riskTier,uint8 state,address basePoolToken,address quotePoolToken,uint16 maxPriceDeviation,bool compoundEnabled,uint64 windowCapUsd,address poolVault,address tradingVault))",
+];
+const LP_ROUTER_BY_CHAIN = {
+    421614: {
+        router: "0x5E16C0699de2Ee5D69a620AB38AE2c81A29a58df",
+        basePool: "0xDb41D850e9b30fc0417F488D1aB64fdc1d0DdFdc",
+        quotePool: "0xF0784c1023C051Bf1D5b8470A896c536039B06B9",
+    },
+    59141: {
+        router: "0xf1395643D77DD839E4b8d3Bb122fd0275Cf07631",
+        basePool: "0x31b093BBADbb2A3Bcd7E433E8Ed5bcdD76fFAFFe",
+        quotePool: "0xFF8A6797E2063A7a4cd1468eB7cC0db9798C753f",
+    },
+    97: {
+        router: "0xe9F2E58562aD1D50AfB1eD92EAa6D367A6D0e552",
+        basePool: "0x39506f97D1c1A91EAfD59368697E20dC1fE5eEDB",
+        quotePool: "0x80DAa474e7e2C9c86708e434B80636b92fb4e9EE",
+    },
+    56: {
+        router: "0x06d76c78B56D361de01A8903deA8aCEFFe6251d6",
+        basePool: "0x59E365A627C5A1CE459e8e3489C97Ab2BEd56FEa",
+        quotePool: "0xB1E6df749A602892FafB27bb39Fd4F044527121E",
+    },
+};
+const LP_ROUTER_BY_CHAIN_BETA = {
+    421614: {
+        router: "0xfb790ECE13Cd9e296b4a06ABF38D10431360c236",
+        basePool: "0x1F767BEa83EDe5E0C18904f439C579f52c2c0F1b",
+        quotePool: "0x50ad7da312c58c6689bEF028954a366cb5b8ee13",
+    },
+    59141: {
+        router: "0x0AE31989318565620c03d35889a0B2536b8fba5C",
+        basePool: "0xc9e3826c42183207B418116A16827C1605132c51",
+        quotePool: "0x9A9934D3b22103dE822d94A22A3177d728FE0e5a",
+    },
+    97: {
+        router: "0x0F4C6f18Fb136DD1eBd6Da3C5d86a86597CF79a3",
+        basePool: "0x51B62554a76197d5DF2D5dC4D57FF54d40775938",
+        quotePool: "0x783Ed065a12e1C1D33c2a8d6408385C1843D3084",
+    },
+};
+const PREVIEW_POOL_ABI = [
+    "function previewLpAmountOut(bytes32,uint256,uint256) view returns (uint256)",
+    "function previewQuoteAmountOut(bytes32,uint256,uint256) view returns (uint256)",
+    "function previewBaseAmountOut(bytes32,uint256,uint256) view returns (uint256)",
+];
+const ROUTER_ABI = [
+    "function depositQuote((bytes32,uint256,uint256,address,(uint256,uint256,uint8,uint256)[]))",
+    "function depositQuote((bytes32,uint8,uint64,bytes)[],(bytes32,uint256,uint256,address,(uint256,uint256,uint8,uint256)[])) payable",
+    "function withdrawQuote((bytes32,uint256,uint256,address))",
+    "function withdrawQuote((bytes32,uint8,uint64,bytes)[],(bytes32,uint256,uint256,address)) payable",
+    "function depositBase((bytes32,uint256,uint256,address,(uint256,uint256,uint8,uint256)[]))",
+    "function depositBase((bytes32,uint8,uint64,bytes)[],(bytes32,uint256,uint256,address,(uint256,uint256,uint8,uint256)[])) payable",
+    "function withdrawBase((bytes32,uint256,uint256,address))",
+    "function withdrawBase((bytes32,uint8,uint64,bytes)[],(bytes32,uint256,uint256,address)) payable",
+];
+const ERC20_ABI = [
+    "function allowance(address,address) view returns (uint256)",
+    "function approve(address,uint256) returns (bool)",
+];
 function isDivideByZeroError(message) {
     const lower = message.toLowerCase();
     return (lower.includes("divide_by_zero") ||
@@ -19,74 +88,378 @@ function toPositiveBigint(input) {
         return null;
     }
 }
+function isAbiLengthMismatchError(message) {
+    const lower = message.toLowerCase();
+    return lower.includes("abi encoding params/values length mismatch");
+}
+function isSdkWaitNotFunctionError(message) {
+    return message.toLowerCase().includes("wait is not a function");
+}
+function readLastMockTxHash() {
+    const hash = String(globalThis?.__MCP_LAST_TX_HASH ?? "").trim();
+    if (!hash.startsWith("0x") || hash.length !== 66)
+        return null;
+    return hash;
+}
+function recoverSdkSubmittedTxHash(beforeHash, message, context) {
+    if (!isSdkWaitNotFunctionError(message))
+        return null;
+    const recovered = readLastMockTxHash();
+    if (!recovered || recovered === beforeHash)
+        return null;
+    logger.warn(`Recovered SDK-submitted tx hash for ${context.poolType} ${context.action} after wait() incompatibility: ${recovered}`);
+    return {
+        transactionHash: recovered,
+        fallback: {
+            mode: "sdk_submitted_txhash_recovery",
+            reason: "sdk_wait_not_function",
+            poolType: context.poolType,
+            action: context.action,
+        },
+    };
+}
+async function withMutedSdkAbiMismatchLogs(runner) {
+    const original = console.error;
+    console.error = (...args) => {
+        const first = args?.[0];
+        const firstText = typeof first === "string"
+            ? first
+            : first instanceof Error
+                ? first.message
+                : (first && typeof first === "object"
+                    ? JSON.stringify(first)
+                    : String(first ?? ""));
+        const lower = firstText.toLowerCase();
+        if (isAbiLengthMismatchError(firstText) || lower.includes("abiencodinglengthmismatcherror")) {
+            return;
+        }
+        original(...args);
+    };
+    try {
+        return await runner();
+    }
+    finally {
+        console.error = original;
+    }
+}
+function isBetaModeEnabled() {
+    return String(process.env.IS_BETA_MODE ?? "").trim().toLowerCase() === "true";
+}
+function getPoolManagerAddress(chainId) {
+    const envAddress = String(process.env.POOL_MANAGER_ADDRESS ?? "").trim();
+    if (envAddress) {
+        return normalizeAddress(envAddress, "POOL_MANAGER_ADDRESS");
+    }
+    const mapped = POOL_MANAGER_BY_CHAIN[chainId];
+    if (!mapped) {
+        throw new Error(`Pool manager address is not configured for chainId=${chainId}. Set POOL_MANAGER_ADDRESS env var.`);
+    }
+    return mapped;
+}
+function getLpAddresses(chainId) {
+    const source = isBetaModeEnabled() ? LP_ROUTER_BY_CHAIN_BETA : LP_ROUTER_BY_CHAIN;
+    const matched = source[chainId];
+    if (!matched) {
+        throw new Error(`Liquidity router config not found for chainId=${chainId}.`);
+    }
+    return matched;
+}
+function normalizeSlippageRatio(slippage) {
+    if (!Number.isFinite(slippage) || slippage < 0)
+        return 0;
+    if (slippage > 1 && slippage <= 100)
+        return slippage / 100;
+    if (slippage > 1)
+        return 1;
+    return slippage;
+}
+function applyMinOutBySlippage(amountOut, slippage) {
+    if (amountOut <= 0n)
+        return 0n;
+    const ratio = normalizeSlippageRatio(slippage);
+    const scale = 1000000n;
+    const ratioScaled = BigInt(Math.round(ratio * 1_000_000));
+    const effective = ratioScaled >= scale ? 0n : (scale - ratioScaled);
+    return (amountOut * effective) / scale;
+}
+function shouldUseOraclePriceByState(state) {
+    const numeric = Number(state);
+    if (!Number.isFinite(numeric))
+        return true;
+    return numeric !== 0 && numeric !== 1;
+}
+async function getMarketDetailOrThrow(client, chainId, poolId) {
+    const raw = await client.markets.getMarketDetail({ chainId, poolId });
+    const detail = raw?.data ?? raw;
+    if (!detail || !detail.poolId) {
+        throw new Error(`Failed to fetch market detail for poolId=${poolId}.`);
+    }
+    return detail;
+}
+async function buildOraclePricePayload(client, chainId, poolId, fallbackOracleType) {
+    const oracle = await client.utils.getOraclePrice(poolId, chainId);
+    const vaa = String(oracle?.vaa ?? "").trim();
+    if (!vaa || !vaa.startsWith("0x")) {
+        throw new Error(`Oracle VAA unavailable for pool ${poolId}.`);
+    }
+    const publishTime = toPositiveBigint(oracle?.publishTime) ?? BigInt(Math.floor(Date.now() / 1000));
+    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"));
+    return {
+        prices: [[poolId, oracleType, publishTime, vaa]],
+        value,
+        referencePrice30,
+    };
+}
+async function previewAmountOutForLiquidity(signer, chainId, poolId, poolType, action, amountIn, referencePrice30) {
+    try {
+        const addresses = getLpAddresses(chainId);
+        const poolAddress = poolType === "QUOTE" ? addresses.quotePool : addresses.basePool;
+        const previewContract = new Contract(poolAddress, PREVIEW_POOL_ABI, signer);
+        if (action === "deposit") {
+            const out = await previewContract.previewLpAmountOut(poolId, amountIn, referencePrice30);
+            return toPositiveBigint(out) ?? 0n;
+        }
+        if (poolType === "QUOTE") {
+            const out = await previewContract.previewQuoteAmountOut(poolId, amountIn, referencePrice30);
+            return toPositiveBigint(out) ?? 0n;
+        }
+        const out = await previewContract.previewBaseAmountOut(poolId, amountIn, referencePrice30);
+        return toPositiveBigint(out) ?? 0n;
+    }
+    catch (error) {
+        logger.warn("LP preview call failed; fallback to minAmountOut=0.", extractErrorMessage(error));
+        return 0n;
+    }
+}
+async function executeLiquidityTxViaRouter(params) {
+    const { chainId, poolId, poolType, action, amount, slippage } = params;
+    const { client, signer, address } = await resolveClient();
+    const marketDetail = await getMarketDetailOrThrow(client, chainId, poolId);
+    const addresses = getLpAddresses(chainId);
+    const decimals = action === "deposit"
+        ? Number(poolType === "QUOTE" ? marketDetail.quoteDecimals : marketDetail.baseDecimals)
+        : LP_DECIMALS;
+    if (!Number.isFinite(decimals) || decimals < 0) {
+        throw new Error(`Invalid decimals while preparing ${poolType} ${action} transaction.`);
+    }
+    const amountIn = parseUnits(String(amount), decimals);
+    if (amountIn <= 0n) {
+        throw new Error(`Liquidity ${poolType.toLowerCase()} ${action} amount must be > 0.`);
+    }
+    let approvalTxHash = null;
+    if (action === "deposit") {
+        const tokenAddress = normalizeAddress(poolType === "QUOTE" ? marketDetail.quoteToken : marketDetail.baseToken, poolType === "QUOTE" ? "quoteToken" : "baseToken");
+        const tokenContract = new Contract(tokenAddress, ERC20_ABI, signer);
+        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);
+            approvalTxHash = String(approveTx?.hash ?? "").trim() || null;
+            const approveReceipt = await approveTx?.wait?.();
+            if (approveReceipt && approveReceipt.status !== 1) {
+                throw new Error(`Router approval transaction reverted for ${poolType} deposit.`);
+            }
+        }
+    }
+    const needOraclePrice = shouldUseOraclePriceByState(marketDetail.state);
+    let oraclePayload = {
+        prices: [],
+        value: 0n,
+        referencePrice30: 0n,
+    };
+    if (needOraclePrice) {
+        oraclePayload = await buildOraclePricePayload(client, chainId, poolId, Number(marketDetail.oracleType ?? 1));
+    }
+    const amountOut = await previewAmountOutForLiquidity(signer, chainId, poolId, poolType, action, amountIn, oraclePayload.referencePrice30);
+    const minAmountOut = applyMinOutBySlippage(amountOut, slippage);
+    const routerContract = new Contract(addresses.router, ROUTER_ABI, signer);
+    const txOverrides = {};
+    if (oraclePayload.value > 0n) {
+        txOverrides.value = oraclePayload.value;
+    }
+    let tx;
+    if (poolType === "QUOTE" && action === "deposit") {
+        const paramsTuple = [
+            poolId,
+            amountIn,
+            minAmountOut,
+            address,
+            [],
+        ];
+        if (oraclePayload.prices.length > 0) {
+            tx = await routerContract["depositQuote((bytes32,uint8,uint64,bytes)[],(bytes32,uint256,uint256,address,(uint256,uint256,uint8,uint256)[]))"](oraclePayload.prices, paramsTuple, txOverrides);
+        }
+        else {
+            tx = await routerContract["depositQuote((bytes32,uint256,uint256,address,(uint256,uint256,uint8,uint256)[]))"](paramsTuple, txOverrides);
+        }
+    }
+    else if (poolType === "QUOTE" && action === "withdraw") {
+        const paramsTuple = [poolId, amountIn, minAmountOut, address];
+        if (oraclePayload.prices.length > 0) {
+            tx = await routerContract["withdrawQuote((bytes32,uint8,uint64,bytes)[],(bytes32,uint256,uint256,address))"](oraclePayload.prices, paramsTuple, txOverrides);
+        }
+        else {
+            tx = await routerContract["withdrawQuote((bytes32,uint256,uint256,address))"](paramsTuple, txOverrides);
+        }
+    }
+    else if (poolType === "BASE" && action === "deposit") {
+        const paramsTuple = [
+            poolId,
+            amountIn,
+            minAmountOut,
+            address,
+            [],
+        ];
+        if (oraclePayload.prices.length > 0) {
+            tx = await routerContract["depositBase((bytes32,uint8,uint64,bytes)[],(bytes32,uint256,uint256,address,(uint256,uint256,uint8,uint256)[]))"](oraclePayload.prices, paramsTuple, txOverrides);
+        }
+        else {
+            tx = await routerContract["depositBase((bytes32,uint256,uint256,address,(uint256,uint256,uint8,uint256)[]))"](paramsTuple, txOverrides);
+        }
+    }
+    else {
+        const paramsTuple = [poolId, amountIn, minAmountOut, address];
+        if (oraclePayload.prices.length > 0) {
+            tx = await routerContract["withdrawBase((bytes32,uint8,uint64,bytes)[],(bytes32,uint256,uint256,address))"](oraclePayload.prices, paramsTuple, txOverrides);
+        }
+        else {
+            tx = await routerContract["withdrawBase((bytes32,uint256,uint256,address))"](paramsTuple, txOverrides);
+        }
+    }
+    const txHash = String(tx?.hash ?? "").trim();
+    if (!txHash || !txHash.startsWith("0x")) {
+        throw new Error(`${poolType} ${action} fallback sent transaction but no hash was returned.`);
+    }
+    return {
+        transactionHash: txHash,
+        fallback: {
+            mode: "router_explicit_signature",
+            action,
+            poolType,
+            amountIn: amountIn.toString(),
+            minAmountOut: minAmountOut.toString(),
+            usedOraclePrice: oraclePayload.prices.length > 0,
+            oracleValue: oraclePayload.value.toString(),
+            approvalTxHash,
+        },
+    };
+}
+async function resolvePositiveMarketPrice30(client, poolId, chainId) {
+    if (!client)
+        return null;
+    try {
+        const oracle = await client.utils?.getOraclePrice?.(poolId, chainId);
+        const byValue = toPositiveBigint(oracle?.value);
+        const byPrice = toPositiveBigint(oracle?.price);
+        if (byValue)
+            return byValue;
+        if (byPrice)
+            return byPrice;
+    }
+    catch {
+    }
+    try {
+        const tickerRes = await client.markets?.getTickerList?.({ chainId, poolIds: [poolId] });
+        const row = Array.isArray(tickerRes) ? tickerRes[0] : tickerRes?.data?.[0];
+        if (row?.price) {
+            const tickerRaw = ensureUnits(row.price, 30, "ticker price");
+            const byTicker = toPositiveBigint(tickerRaw);
+            if (byTicker)
+                return byTicker;
+        }
+    }
+    catch {
+    }
+    return null;
+}
 /**
  * 创建合约市场池子
  */
 export async function createPool(baseToken, marketId) {
-    await resolveClient();
+    const { signer } = await resolveClient();
     const chainId = getChainId();
-    return pool.createPool({ chainId, baseToken, marketId });
+    const normalizedBaseToken = normalizeAddress(baseToken, "baseToken");
+    const normalizedMarketId = String(marketId ?? "").trim();
+    try {
+        return await pool.createPool({ chainId, baseToken: normalizedBaseToken, marketId: normalizedMarketId });
+    }
+    catch (error) {
+        const message = extractErrorMessage(error).toLowerCase();
+        if (!message.includes("deploypool is not a function")) {
+            throw error;
+        }
+        logger.warn("SDK pool.createPool write path unavailable; falling back to direct PoolManager.deployPool.");
+        const poolManagerAddress = getPoolManagerAddress(chainId);
+        const contract = new Contract(poolManagerAddress, POOL_MANAGER_ABI, signer);
+        const tx = await contract.deployPool([normalizedMarketId, normalizedBaseToken]);
+        const txHash = String(tx?.hash ?? "").trim();
+        if (!txHash.startsWith("0x")) {
+            throw new Error("Direct deployPool fallback submitted transaction but no hash was returned.");
+        }
+        return {
+            transactionHash: txHash,
+            fallback: {
+                mode: "pool_manager_direct_deploy",
+                chainId,
+                poolManagerAddress,
+            },
+        };
+    }
+}
+export async function getMarketPoolByBaseToken(marketId, baseToken, chainIdOverride) {
+    const { signer } = await resolveClient();
+    const chainId = chainIdOverride ?? getChainId();
+    const normalizedBaseToken = normalizeAddress(baseToken, "baseToken");
+    const normalizedMarketId = String(marketId ?? "").trim();
+    const poolManagerAddress = getPoolManagerAddress(chainId);
+    const contract = new Contract(poolManagerAddress, POOL_MANAGER_ABI, signer);
+    const record = await contract.getMarketPool(normalizedMarketId, normalizedBaseToken);
+    return {
+        poolManagerAddress,
+        chainId,
+        marketId: String(record?.marketId ?? normalizedMarketId),
+        poolId: String(record?.poolId ?? ""),
+        baseToken: String(record?.baseToken ?? normalizedBaseToken),
+        quoteToken: String(record?.quoteToken ?? ""),
+        state: Number(record?.state ?? -1),
+        basePoolToken: String(record?.basePoolToken ?? ""),
+        quotePoolToken: String(record?.quotePoolToken ?? ""),
+    };
 }
 /**
  * 获取池子信息
  */
 export async function getPoolInfo(poolId, chainIdOverride, clientOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    let needOracleFallback = false;
+    const client = clientOverride ?? (await resolveClient()).client;
     try {
-        const direct = await pool.getPoolInfo(chainId, poolId);
-        if (direct)
-            return direct;
-        needOracleFallback = true;
+        const marketPrice30 = await resolvePositiveMarketPrice30(client, poolId, chainId);
+        if (marketPrice30 && marketPrice30 > 0n) {
+            const withPrice = await pool.getPoolInfo(chainId, poolId, marketPrice30);
+            if (withPrice)
+                return withPrice;
+        }
     }
     catch (error) {
         const message = extractErrorMessage(error);
         if (!isDivideByZeroError(message)) {
             throw new Error(`get_pool_info failed: ${message}`);
         }
-        needOracleFallback = true;
     }
-    if (!needOracleFallback)
-        return undefined;
-    const client = clientOverride ?? (await resolveClient()).client;
-    if (!client?.utils?.getOraclePrice) {
-        throw new Error("get_pool_info failed and oracle fallback is unavailable (client.utils.getOraclePrice missing).");
-    }
-    let oracleRaw = 0n;
     try {
-        const oracle = await client.utils.getOraclePrice(poolId, chainId);
-        const byValue = toPositiveBigint(oracle?.value);
-        const byPrice = toPositiveBigint(oracle?.price);
-        oracleRaw = byValue ?? byPrice ?? 0n;
+        const direct = await pool.getPoolInfo(chainId, poolId);
+        if (direct)
+            return direct;
+        throw new Error(`Pool info for ${poolId} returned undefined.`);
     }
     catch (error) {
-        throw new Error(`get_pool_info fallback failed to fetch oracle price: ${extractErrorMessage(error)}`);
-    }
-    if (oracleRaw <= 0n) {
-        try {
-            const tickerRes = await client.markets.getTickerList({ chainId, poolIds: [poolId] });
-            const row = Array.isArray(tickerRes) ? tickerRes[0] : tickerRes?.data?.[0];
-            if (row?.price) {
-                const tickerRaw = ensureUnits(row.price, 30, "ticker price");
-                const byTicker = toPositiveBigint(tickerRaw);
-                oracleRaw = byTicker ?? 0n;
-            }
-        }
-        catch {
-        }
-    }
-    if (oracleRaw <= 0n) {
-        throw new Error("get_pool_info fallback requires a positive oracle/ticker price, but both resolved to 0.");
-    }
-    try {
-        const retried = await pool.getPoolInfo(chainId, poolId, oracleRaw);
-        if (!retried) {
-            throw new Error(`Pool info for ${poolId} returned undefined after oracle-price retry.`);
+        const message = extractErrorMessage(error);
+        if (isDivideByZeroError(message)) {
+            throw new Error("get_pool_info unavailable: pool reserves are currently empty or market price context is unresolved.");
         }
-        return retried;
-    }
-    catch (error) {
-        throw new Error(`get_pool_info failed after oracle-price retry: ${extractErrorMessage(error)}`);
+        throw new Error(`get_pool_info failed: ${message}`);
     }
 }
 /**
@@ -108,28 +481,80 @@ export async function getLiquidityInfo(client, poolId, marketPrice, chainIdOverr
  */
 export async function quoteDeposit(poolId, amount, slippage, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    return quote.deposit({ chainId, poolId, amount, slippage });
+    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 });
+    }
 }
 /**
  * Quote 池 withdraw
  */
 export async function quoteWithdraw(poolId, amount, slippage, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    return quote.withdraw({ chainId, poolId, amount, slippage });
+    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 });
+    }
 }
 /**
  * Base 池 deposit
  */
 export async function baseDeposit(poolId, amount, slippage, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    return base.deposit({ chainId, poolId, amount, slippage });
+    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 });
+    }
 }
 /**
  * Base 池 withdraw
  */
 export async function baseWithdraw(poolId, amount, slippage, chainIdOverride) {
     const chainId = chainIdOverride ?? getChainId();
-    return base.withdraw({ chainId, poolId, amount, slippage });
+    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 });
+    }
 }
 /**
  * 获取 LP 价格

package/dist/services/tradeService.js

@@ -93,6 +93,17 @@ function parseDecimals(value, fallback) {
 function normalizeIdentifier(value) {
     return String(value ?? "").trim().toLowerCase();
 }
+function toBigIntOrZero(value) {
+    try {
+        const text = String(value ?? "").trim();
+        if (!text)
+            return 0n;
+        return BigInt(text);
+    }
+    catch {
+        return 0n;
+    }
+}
 async function resolveDecimalsForUpdateOrder(client, chainId, marketId, poolIdHint) {
     let baseDecimals = 18;
     let quoteDecimals = getQuoteDecimals();
@@ -193,16 +204,10 @@ export async function openPosition(client, address, args) {
     console.log(`[tradeService] Checking marginBalance for ${address} in pool ${args.poolId}...`);
     const marginInfo = await client.account.getAccountInfo(chainId, address, args.poolId);
     let marginBalanceRaw = BigInt(0);
-    let walletBalanceRaw = BigInt(0); // Using availableMargin as wallet balance per user
-    if (marginInfo?.code === 0) {
-        if (Array.isArray(marginInfo.data)) {
-            marginBalanceRaw = BigInt(marginInfo.data[0] || "0");
-            walletBalanceRaw = BigInt(marginInfo.data[1] || "0");
-        }
-        else {
-            marginBalanceRaw = BigInt(marginInfo.data?.marginBalance || "0");
-            walletBalanceRaw = BigInt(marginInfo.data?.availableMargin || "0");
-        }
+    let walletBalanceRaw = BigInt(0);
+    if (marginInfo?.code === 0 && marginInfo?.data) {
+        marginBalanceRaw = toBigIntOrZero(marginInfo.data.freeMargin);
+        walletBalanceRaw = toBigIntOrZero(marginInfo.data.walletBalance);
     }
     const requiredRaw = BigInt(collateralRaw);
     if (marginBalanceRaw < requiredRaw) {
@@ -213,15 +218,15 @@ export async function openPosition(client, address, args) {
         const neededRaw = requiredRaw - marginBalanceRaw;
         console.log(`[tradeService] marginBalance (${marginBalanceRaw.toString()}) < Required (${requiredRaw.toString()}). Need to deposit: ${neededRaw.toString()}`);
         if (walletBalanceRaw < neededRaw) {
-            // Also check real wallet balance just in case user's availableMargin is truly empty
+            // Also check real wallet balance just in case account info wallet field is stale.
             const realWalletRes = await client.account.getWalletQuoteTokenBalance(chainId, address);
             const realWalletRaw = BigInt(realWalletRes?.data || "0");
             if (realWalletRaw < neededRaw) {
-                throw new Error(`Insufficient funds: marginBalance (${marginBalanceRaw.toString()}) + availableMargin (as wallet: ${walletBalanceRaw.toString()}) + real wallet (${realWalletRaw.toString()}) is less than required collateral (${requiredRaw.toString()}).`);
+                throw new Error(`Insufficient funds: marginBalance (${marginBalanceRaw.toString()}) + walletBalance (${walletBalanceRaw.toString()}) + realWallet (${realWalletRaw.toString()}) is less than required collateral (${requiredRaw.toString()}).`);
             }
             walletBalanceRaw = realWalletRaw;
         }
-        console.log(`[tradeService] Depositing ${neededRaw.toString()} ${poolData.quoteSymbol} from wallet (availableMargin)...`);
+        console.log(`[tradeService] Depositing ${neededRaw.toString()} ${poolData.quoteSymbol} from wallet...`);
         const depositRaw = await client.account.deposit({
             amount: neededRaw.toString(),
             tokenAddress: poolData.quoteToken,