@rhea-finance/cross-chain-aggregation-dex 0.2.1 → 0.2.2

package/dist/index.js

@@ -49,14 +49,51 @@ function processErrorMessage(errorMessage) {
   }
   return TRANSACTION_EXECUTION_ERROR_MESSAGE;
 }
-function normalizeError(error) {
-  if (!error) return ErrorMessages.EXECUTE_FAILED;
+function normalizeErrorForIntents(error) {
+  if (!error) return ErrorMessages.QUOTE_FAILED;
   const errorLower = error.toLowerCase();
-  if (errorLower.includes("quote") || errorLower.includes("route") || errorLower.includes("missing") || errorLower.includes("required") || errorLower.includes("invalid") || errorLower.includes("balance") || errorLower.includes("liquidity") || errorLower.includes("slippage") || errorLower.includes("gas") || errorLower.includes("network")) {
+  if (errorLower.includes("quote") || errorLower.includes("route") || errorLower.includes("missing") || errorLower.includes("required") || errorLower.includes("invalid") || errorLower.includes("balance") || errorLower.includes("liquidity") || errorLower.includes("gas") || errorLower.includes("network")) {
     return ErrorMessages.QUOTE_FAILED;
   }
   return processErrorMessage(error);
 }
+function normalizeError(error) {
+  if (!error) return ErrorMessages.EXECUTE_FAILED;
+  return error;
+}
+function formatErrorMessage({
+  error,
+  fallbackMessage,
+  originAsset,
+  friendly
+}) {
+  let messageStr = "";
+  if (error) {
+    if (typeof error === "string") {
+      messageStr = error;
+    } else if (typeof error === "object") {
+      messageStr = error?.message || error?.error || JSON.stringify(error);
+    } else {
+      messageStr = String(error);
+    }
+  }
+  if (!messageStr || messageStr === "null" || messageStr === "undefined") {
+    messageStr = fallbackMessage || "Transaction execution error occurred. Please contact support";
+  }
+  if (messageStr?.includes("low") && originAsset) {
+    return "Amount is too low for bridge.";
+  } else if (messageStr?.includes("(")) {
+    const index = messageStr.indexOf("(");
+    return friendly ? processErrorMessage(messageStr.slice(0, index)) : messageStr.slice(0, index);
+  } else if (messageStr?.includes("timed out") || messageStr?.includes("not allowed")) {
+    return "transaction has been cancelled";
+  } else if ((messageStr?.toLowerCase().includes("tokenin") || messageStr?.toLowerCase().includes("tokenout")) && messageStr?.toLowerCase().includes("not valid")) {
+    return "Failed to get quote";
+  } else if (messageStr?.toLowerCase().includes("liquidity") && messageStr?.toLowerCase().includes("available")) {
+    return "Failed to get quote";
+  }
+  return friendly ? processErrorMessage(messageStr) : messageStr;
+}
 
 // src/utils/logger.ts
 var LOG_LEVELS = {
@@ -420,7 +457,7 @@ var NearSmartRouter = class {
           amountOut: "0",
           minAmountOut: "0",
           routes: [],
-          error: normalizeError(response?.result_msg || response?.result_message) || ErrorMessages.QUOTE_FAILED
+          error: response?.result_msg || response?.result_message || ErrorMessages.QUOTE_FAILED
         };
       }
       const { routes: serverRoutes, amount_out } = response.result_data;
@@ -459,7 +496,7 @@ var NearSmartRouter = class {
         amountOut: "0",
         minAmountOut: "0",
         routes: [],
-        error: normalizeError(error?.message) || ErrorMessages.QUOTE_FAILED
+        error: error?.message || ErrorMessages.QUOTE_FAILED
       };
     }
   }
@@ -521,7 +558,6 @@ var NearSmartRouter = class {
             },
             gas: "50000000000000",
             expandDeposit: "1250000000000000000000"
-            // 0.00125 NEAR
           });
         }
         transactions.push({
@@ -577,7 +613,6 @@ var NearSmartRouter = class {
           msg: JSON.stringify(swapMsg)
         },
         gas: "250",
-        // NEP-141 requires attaching 1 yoctoNEAR for certain calls.
         expandDeposit: "1"
       });
       const result = await this.nearChainAdapter.call({
@@ -764,7 +799,7 @@ var AggregateDexRouter = class {
         amountOut: "0",
         minAmountOut: "0",
         routes: [],
-        error: normalizeError(error?.message) || ErrorMessages.QUOTE_FAILED
+        error: error?.message || ErrorMessages.QUOTE_FAILED
       };
     }
   }
@@ -896,7 +931,7 @@ var AggregateDexRouter = class {
       } catch (error) {
         return {
           success: false,
-          error: normalizeError(error?.message) || ErrorMessages.QUOTE_FAILED
+          error: error?.message || ErrorMessages.QUOTE_FAILED
         };
       }
       const routerMsg = finalQuote.routerMsg;
@@ -1099,7 +1134,8 @@ var AggregateDexRouter = class {
       } catch (error) {
         return {
           success: false,
-          error: normalizeError(error?.message) || ErrorMessages.QUOTE_FAILED
+          // ✅ 预交易阶段：保留原始错误信息，不简化
+          error: error?.message || ErrorMessages.QUOTE_FAILED
         };
       }
       const finalAmountToTransfer = finalQuoteForExecution.amountIn;
@@ -1267,17 +1303,9 @@ async function estimateGasLimit(gas, to, transactionData, value, sender, chainId
           reason: estimateError?.reason,
           message: estimateError?.message || String(estimateError)
         };
-        console.warn("RPC gas estimate failed:", {
-          error: estimateError?.message || String(estimateError),
-          code: estimateError?.code,
-          reason: estimateError?.reason
-        });
       }
     }
   } catch (error) {
-    console.warn("Gas estimation error:", {
-      error: error?.message || String(error)
-    });
   }
   if (estimatedGasLimit && estimatedGasLimit.gt(0) && hasReliableEstimate) {
     return [estimatedGasLimit, true, rpcEstimateError];
@@ -1363,7 +1391,7 @@ var BitgetRouter = class {
           amountOut: "0",
           minAmountOut: "0",
           routes: [],
-          error: ErrorMessages.QUOTE_FAILED
+          error: "Bitget quote failed: Router requires recipient address"
         };
       }
       const { tokenIn, tokenOut, amountIn, slippage, sender, recipient } = params;
@@ -1376,7 +1404,7 @@ var BitgetRouter = class {
           amountOut: "0",
           minAmountOut: "0",
           routes: [],
-          error: ErrorMessages.QUOTE_FAILED
+          error: "Bitget quote failed: Sender and recipient addresses are required"
         };
       }
       if (tokenIn?.address === void 0 || tokenOut?.address === void 0) {
@@ -1388,7 +1416,7 @@ var BitgetRouter = class {
           amountOut: "0",
           minAmountOut: "0",
           routes: [],
-          error: ErrorMessages.QUOTE_FAILED
+          error: "Bitget quote failed: Token addresses are required"
         };
       }
       const normalizedTokenIn = tokenIn.address === "" ? "" : this.normalizeEvmAddress(tokenIn.address);
@@ -1410,7 +1438,7 @@ var BitgetRouter = class {
       if (!isBitgetResponseSuccess(response) || !response.data) {
         return createQuoteError(
           params,
-          normalizeError(response.msg) || ErrorMessages.QUOTE_FAILED
+          response.msg || "Bitget API error: Failed to get quote"
         );
       }
       const {
@@ -1476,21 +1504,23 @@ var BitgetRouter = class {
     } catch (error) {
       return createQuoteError(
         params,
-        normalizeError(error?.message) || ErrorMessages.QUOTE_FAILED
+        error?.message || "Bitget quote failed: Unknown error"
       );
     }
   }
   async executeSwap(params) {
     try {
       if (!requiresRecipientInExecute(params)) {
-        return createExecuteError(ErrorMessages.QUOTE_FAILED);
+        return createExecuteError("Bitget swap failed: Router requires recipient address");
       }
       const { quote, sender, receiveUser } = params;
       if (!quote.success) {
-        return createExecuteError(ErrorMessages.QUOTE_FAILED);
+        return createExecuteError(
+          quote.error || "Bitget swap failed: Invalid quote"
+        );
       }
       if (!receiveUser || receiveUser.trim() === "") {
-        return createExecuteError(ErrorMessages.QUOTE_FAILED);
+        return createExecuteError("Bitget swap failed: Recipient address is required");
       }
       let market;
       try {
@@ -1498,13 +1528,13 @@ var BitgetRouter = class {
           const routerMsg = JSON.parse(quote.routerMsg);
           market = routerMsg.market || "";
         } else {
-          return createExecuteError(ErrorMessages.QUOTE_FAILED);
+          return createExecuteError("Bitget swap failed: Missing router message data");
         }
       } catch (error) {
-        return createExecuteError(ErrorMessages.QUOTE_FAILED);
+        return createExecuteError("Bitget swap failed: Invalid router message format");
       }
       if (!market) {
-        return createExecuteError(ErrorMessages.QUOTE_FAILED);
+        return createExecuteError("Bitget swap failed: Market information is required");
       }
       const normalizedTokenIn = this.normalizeEvmAddress(
         quote.tokenIn.address
@@ -1527,9 +1557,8 @@ var BitgetRouter = class {
         tokenOutDecimals: quote.tokenOut.decimals
       });
       if (!isBitgetResponseSuccess(reQuoteResponse) || !reQuoteResponse.data) {
-        return createExecuteError(
-          normalizeError(reQuoteResponse.msg) || ErrorMessages.QUOTE_FAILED
-        );
+        const errorMsg = reQuoteResponse.msg || "Bitget re-quote failed: No data returned";
+        return createExecuteError(errorMsg);
       }
       market = reQuoteResponse.data?.market || market;
       const swapResponse = await this.bitgetAdapter.swap({
@@ -1548,11 +1577,13 @@ var BitgetRouter = class {
       });
       if (!isBitgetResponseSuccess(swapResponse) || !swapResponse.data) {
         return createExecuteError(
-          normalizeError(swapResponse.msg) || ErrorMessages.QUOTE_FAILED
+          swapResponse.msg || "Bitget swap failed: No transaction data"
         );
       }
       if (swapResponse.data?.estimateRevert === true) {
-        return createExecuteError(ErrorMessages.QUOTE_FAILED);
+        return createExecuteError(
+          swapResponse.msg || "Bitget swap failed: Transaction would revert (slippage or price impact too high)"
+        );
       }
       let transactionData = swapResponse.data?.calldata || swapResponse.data?.data;
       const to = swapResponse.data?.contract || swapResponse.data?.to;
@@ -1566,14 +1597,18 @@ var BitgetRouter = class {
       }
       const gas = swapResponse.data?.gas || (swapResponse.data?.computeUnits !== void 0 ? String(swapResponse.data.computeUnits) : void 0);
       if (!to || !transactionData) {
-        return createExecuteError(ErrorMessages.QUOTE_FAILED);
+        return createExecuteError(
+          swapResponse.msg || "Bitget swap failed: Missing transaction data or recipient address"
+        );
       }
       if (transactionData.length < 10 || !/^0x[0-9a-fA-F]+$/.test(transactionData)) {
-        return createExecuteError(ErrorMessages.QUOTE_FAILED);
+        return createExecuteError(
+          swapResponse.msg || "Bitget swap failed: Invalid transaction data format"
+        );
       }
       if (normalizedTokenIn && normalizedTokenIn !== "") {
         if (!this.evmChainAdapter.getBalance) {
-          return createExecuteError(ErrorMessages.QUOTE_FAILED);
+          return createExecuteError("Bitget swap failed: Balance check not supported");
         }
         const tokenBalanceFormatted = await this.evmChainAdapter.getBalance({
           address: sender,
@@ -1583,7 +1618,7 @@ var BitgetRouter = class {
         const balanceBN = ethers.ethers.utils.parseUnits(tokenBalanceFormatted || "0", tokenDecimals);
         const amountInBN = ethers.ethers.BigNumber.from(quote.amountIn);
         if (balanceBN.lt(amountInBN)) {
-          return createExecuteError(ErrorMessages.QUOTE_FAILED);
+          return createExecuteError("Bitget swap failed: Insufficient token balance");
         }
         const currentAllowance = await this.evmChainAdapter.getAllowance({
           tokenAddress: normalizedTokenIn,
@@ -1616,17 +1651,17 @@ var BitgetRouter = class {
               retryCount++;
             }
             if (newAllowanceBN.lt(amountInBN)) {
-              return createExecuteError(ErrorMessages.QUOTE_FAILED);
+              return createExecuteError("Bitget swap failed: Token approval failed or insufficient");
             }
           } catch (error) {
             return createExecuteError(
-              normalizeError(error?.message) || ErrorMessages.QUOTE_FAILED
+              error?.message || "Bitget approval check failed"
             );
           }
         }
       } else {
         if (!this.evmChainAdapter.getBalance) {
-          return createExecuteError(ErrorMessages.QUOTE_FAILED);
+          return createExecuteError("Bitget swap failed: Balance check not supported");
         }
         const nativeBalanceFormatted = await this.evmChainAdapter.getBalance({
           address: sender,
@@ -1650,7 +1685,7 @@ var BitgetRouter = class {
         const gasCostEstimate = estimatedGasLimitForBalance.mul(gasPriceEstimate2);
         const totalRequired = amountInBN.add(gasCostEstimate);
         if (balanceBN.lt(totalRequired)) {
-          return createExecuteError(ErrorMessages.QUOTE_FAILED);
+          return createExecuteError("Bitget swap failed: Insufficient balance (including gas fee)");
         }
       }
       if (normalizedTokenIn && normalizedTokenIn !== "") {
@@ -1662,7 +1697,7 @@ var BitgetRouter = class {
         const finalAllowanceBN = ethers.ethers.BigNumber.from(finalAllowanceCheck);
         const amountInBN = ethers.ethers.BigNumber.from(quote.amountIn);
         if (finalAllowanceBN.lt(amountInBN)) {
-          return createExecuteError(ErrorMessages.QUOTE_FAILED);
+          return createExecuteError("Bitget swap failed: Insufficient token allowance");
         }
       }
       const [estimatedGasLimit, hasReliableEstimate, rpcEstimateError] = await estimateGasLimit(
@@ -1683,10 +1718,13 @@ var BitgetRouter = class {
             tokenOut: quote.tokenOut.symbol,
             rpcError: rpcEstimateError
           });
-          return createExecuteError(ErrorMessages.QUOTE_FAILED);
+          const errorMsg = rpcEstimateError?.message || rpcEstimateError?.reason || "";
+          return createExecuteError(
+            errorMsg || "Bitget swap failed: Transaction would revert (slippage or price impact too high)"
+          );
         }
         if (!gas || gas === "0") {
-          return createExecuteError(ErrorMessages.QUOTE_FAILED);
+          return createExecuteError("Bitget swap failed: Invalid gas estimate from Bitget");
         }
         logger.warn("RPC gas estimation failed, using Bitget estimate", {
           chainId: this.chainId,
@@ -1719,7 +1757,7 @@ var BitgetRouter = class {
         if (!feeData.maxFeePerGas || !feeData.maxPriorityFeePerGas || feeData.maxFeePerGas.lte(0) || feeData.maxPriorityFeePerGas.lte(0)) {
           const cachedGasPrice = await getCachedGasPrice();
           if (!cachedGasPrice || cachedGasPrice.lte(0)) {
-            return createExecuteError(ErrorMessages.QUOTE_FAILED);
+            return createExecuteError("Bitget swap failed: Unable to get valid gas price");
           }
           feeData.maxFeePerGas = cachedGasPrice;
           feeData.maxPriorityFeePerGas = cachedGasPrice.div(10);
@@ -1752,27 +1790,27 @@ var BitgetRouter = class {
         } catch (error) {
           const cachedGasPrice = await getCachedGasPrice();
           if (!cachedGasPrice || cachedGasPrice.lte(0)) {
-            return createExecuteError(ErrorMessages.QUOTE_FAILED);
+            return createExecuteError("Bitget swap failed: Unable to get valid gas price");
           }
           feeData.gasPrice = cachedGasPrice;
         }
       }
       if (!to || !ethers.ethers.utils.isAddress(to)) {
-        return createExecuteError(ErrorMessages.QUOTE_FAILED);
+        return createExecuteError("Bitget swap failed: Invalid recipient address");
       }
       if (!transactionData || transactionData.length < 10) {
-        return createExecuteError(ErrorMessages.QUOTE_FAILED);
+        return createExecuteError("Bitget swap failed: Invalid transaction data");
       }
       if (!estimatedGasLimit || estimatedGasLimit.lte(0)) {
-        return createExecuteError(ErrorMessages.QUOTE_FAILED);
+        return createExecuteError("Bitget swap failed: Invalid gas limit");
       }
       if (supportsEip1559) {
         if (!feeData.maxFeePerGas || !feeData.maxPriorityFeePerGas || feeData.maxFeePerGas.lte(0) || feeData.maxPriorityFeePerGas.lte(0)) {
-          return createExecuteError(ErrorMessages.QUOTE_FAILED);
+          return createExecuteError("Bitget swap failed: Invalid gas fee data (EIP-1559)");
         }
       } else {
         if (!feeData.gasPrice || feeData.gasPrice.lte(0)) {
-          return createExecuteError(ErrorMessages.QUOTE_FAILED);
+          return createExecuteError("Bitget swap failed: Invalid gas price");
         }
       }
       const txParams = {
@@ -1812,118 +1850,949 @@ var BitgetRouter = class {
     }
   }
 };
-async function completeQuote(params, config) {
-  const {
-    sourceToken,
-    targetToken,
-    sourceChain,
-    targetChain: _targetChain,
-    // Reserved for future use
-    amountIn,
-    slippage,
-    recipient,
-    refundTo,
-    customRecipientMsg,
-    appFees,
-    evmChainId
-  } = params;
-  const {
-    intentsQuotationAdapter,
-    dexRouters,
-    dexRouter,
-    bluechipTokens,
-    configAdapter,
-    currentUserAddress,
-    isIntentsSupportedToken: customIsIntentsSupportedToken
-  } = config;
-  const wrapNearContractId = configAdapter.getWrapNearContractId();
-  const routers = dexRouters || (dexRouter ? [dexRouter] : []);
-  const userAddress = currentUserAddress || recipient;
-  if (!userAddress) {
-    throw new Error(ErrorMessages.QUOTE_FAILED);
+var OkxRouter = class {
+  constructor(config) {
+    this.okxAdapter = config.okxAdapter;
+    this.evmChainAdapter = config.evmChainAdapter;
+    this.chainId = config.chainId;
   }
-  if (sourceToken?.address === void 0) {
-    throw new Error(ErrorMessages.QUOTE_FAILED);
+  getCapabilities() {
+    return {
+      requiresRecipient: true,
+      requiresFinalizeQuote: false,
+      requiresComplexRegistration: false,
+      supportedChain: "evm"
+    };
   }
-  if (targetToken?.address === void 0) {
-    throw new Error(ErrorMessages.QUOTE_FAILED);
+  getSupportedChain() {
+    return "evm";
   }
-  const isEvmChain = evmChainId !== void 0 || sourceChain === "evm" || sourceChain === "ethereum" || sourceChain === "bsc" || sourceChain === "polygon" || sourceChain === "base" || sourceChain === "monad" || sourceToken.chain === "evm";
-  const isTokenIntentsSupported = customIsIntentsSupportedToken ? customIsIntentsSupportedToken(sourceToken) : isEvmChain ? isEvmIntentsSupportedToken(sourceToken, bluechipTokens) : isNearIntentsSupportedToken(sourceToken, bluechipTokens);
-  const bluechipToken = isEvmChain ? findBestEvmBluechipToken(
-    bluechipTokens,
-    configAdapter.getEvmNativeWrappedTokenAddress?.()
-  ) : findBestBluechipToken(bluechipTokens, wrapNearContractId);
-  if (!bluechipToken?.address) {
-    throw new Error(ErrorMessages.QUOTE_FAILED);
+  getChainId() {
+    return this.chainId;
   }
-  const quotePaths = [];
-  routers.forEach((router, index) => {
-    const supportedChain = router.getSupportedChain();
-    const isEvmRouter = supportedChain === "evm";
-    let routeType;
-    if (isEvmRouter) {
-      routeType = "evm";
-    } else {
-      routeType = index === 0 ? "v1" : "v2";
+  async quote(params) {
+    try {
+      if (!requiresRecipient(params)) {
+        return createQuoteError(params, "OKX quote failed: Router requires recipient address");
+      }
+      const { tokenIn, tokenOut, amountIn, slippage, sender, recipient } = params;
+      if (!sender || !recipient) {
+        return createQuoteError(params, "OKX quote failed: Sender and recipient addresses are required");
+      }
+      if (tokenIn?.address === void 0 || tokenOut?.address === void 0) {
+        return createQuoteError(params, "OKX quote failed: Token addresses are required");
+      }
+      const normalizedTokenIn = tokenIn.address === "" ? "" : this.normalizeEvmAddress(tokenIn.address);
+      const normalizedTokenOut = tokenOut.address === "" ? "" : this.normalizeEvmAddress(tokenOut.address);
+      const slippageBps = convertSlippageToBasisPoints(slippage);
+      const slippageDecimal = slippageBps / 1e4;
+      const response = await this.okxAdapter.quote({
+        chainId: this.chainId,
+        tokenIn: normalizedTokenIn,
+        tokenOut: normalizedTokenOut,
+        amountIn: String(amountIn),
+        slippage: slippageDecimal,
+        userAddress: sender,
+        tokenInSymbol: tokenIn.symbol,
+        tokenInDecimals: tokenIn.decimals,
+        tokenOutSymbol: tokenOut.symbol,
+        tokenOutDecimals: tokenOut.decimals
+      });
+      const is429Error = response.code === "429" || response.code === 429 || response.msg && response.msg.toLowerCase().includes("rate limit");
+      if (is429Error) {
+        return {
+          success: false,
+          tokenIn: params.tokenIn,
+          tokenOut: params.tokenOut,
+          amountIn: params.amountIn,
+          amountOut: "0",
+          minAmountOut: "0",
+          routes: [],
+          error: "Rate limit exceeded"
+        };
+      }
+      if (response.code !== "0" && response.code !== 0 && response.code !== void 0) {
+        const errorCode = response.code;
+        const errorMsg = response.msg || "Unknown error";
+        logger.error("OKX quote API error", {
+          code: errorCode,
+          msg: errorMsg,
+          tokenIn: params.tokenIn.symbol,
+          tokenOut: params.tokenOut.symbol,
+          amountIn: params.amountIn,
+          fullResponse: response
+        });
+        return createQuoteError(params, `OKX API error (${errorCode}): ${errorMsg}`);
+      }
+      if (!response.data || response.data.length === 0) {
+        logger.error("OKX quote empty data", {
+          code: response.code,
+          msg: response.msg,
+          hasData: !!response.data,
+          dataLength: response.data?.length || 0,
+          tokenIn: params.tokenIn.symbol,
+          tokenOut: params.tokenOut.symbol,
+          fullResponse: response
+        });
+        return createQuoteError(
+          params,
+          response.msg || "OKX API returned empty data"
+        );
+      }
+      const quoteData = response.data[0];
+      const fromTokenAmount = quoteData.fromTokenAmount || quoteData.fromAmount;
+      const toTokenAmount = quoteData.toTokenAmount || quoteData.toAmount;
+      const estimateGasFee = quoteData.estimateGasFee || quoteData.estimatedGas;
+      let minToAmount;
+      if (toTokenAmount) {
+        const toAmountBN = ethers.ethers.BigNumber.from(toTokenAmount);
+        const slippageAmount = toAmountBN.mul(Math.floor(slippageDecimal * 1e4)).div(1e4);
+        minToAmount = toAmountBN.sub(slippageAmount).toString();
+      } else {
+        minToAmount = "0";
+      }
+      const formattedAmountOut = toTokenAmount ? ethers.ethers.BigNumber.from(toTokenAmount).toString() : "0";
+      const formattedMinAmountOut = minToAmount || formattedAmountOut;
+      return {
+        success: true,
+        tokenIn,
+        tokenOut,
+        amountIn: fromTokenAmount || String(amountIn),
+        amountOut: formattedAmountOut,
+        minAmountOut: formattedMinAmountOut,
+        routes: [],
+        gasEstimate: estimateGasFee,
+        routerMsg: JSON.stringify({
+          chainId: this.chainId,
+          adapter: "okx"
+        }),
+        recipient,
+        slippage
+      };
+    } catch (error) {
+      const errorMessage = error?.message || String(error);
+      const isRateLimit = errorMessage?.includes("429") || errorMessage?.toLowerCase().includes("rate limit") || errorMessage?.toLowerCase().includes("too many requests");
+      logger.error("OKX quote exception", {
+        error: errorMessage,
+        isRateLimit,
+        tokenIn: params.tokenIn.symbol,
+        tokenOut: params.tokenOut.symbol,
+        amountIn: params.amountIn,
+        errorStack: error?.stack,
+        fullError: error
+      });
+      const detailedError = isRateLimit ? `OKX API rate limit error: ${errorMessage}. Please try again later.` : `OKX quote failed: ${errorMessage}`;
+      return createQuoteError(params, detailedError);
     }
-    const capabilities = router.getCapabilities();
-    const quoteParams = capabilities.requiresRecipient ? {
-      tokenIn: sourceToken,
-      tokenOut: bluechipToken,
-      amountIn,
-      slippage,
-      swapType: "EXACT_INPUT",
-      sender: userAddress,
-      recipient: userAddress
-    } : {
-      tokenIn: sourceToken,
-      tokenOut: bluechipToken,
-      amountIn,
-      slippage,
-      swapType: "EXACT_INPUT"
-    };
-    quotePaths.push({
-      type: routeType,
-      router,
-      promise: (async () => {
-        const preSwapQuote = await router.quote(quoteParams);
-        if (!preSwapQuote.success) {
-          throw new Error(ErrorMessages.QUOTE_FAILED);
+  }
+  async executeSwap(params) {
+    try {
+      if (!requiresRecipientInExecute(params)) {
+        return createExecuteError("OKX swap failed: Router requires recipient address");
+      }
+      const { quote, sender, receiveUser } = params;
+      if (!quote.success) {
+        return createExecuteError(
+          quote.error || "OKX swap failed: Invalid quote"
+        );
+      }
+      if (!receiveUser || receiveUser.trim() === "") {
+        return createExecuteError("OKX swap failed: Recipient address is required");
+      }
+      const normalizedTokenIn = this.normalizeEvmAddress(quote.tokenIn.address);
+      const normalizedTokenOut = this.normalizeEvmAddress(
+        quote.tokenOut.address
+      );
+      const slippageBps = convertSlippageToBasisPoints(quote.slippage || 5e-3);
+      const executionSlippage = slippageBps / 1e4;
+      const reQuoteResponse = await this.okxAdapter.quote({
+        chainId: this.chainId,
+        tokenIn: normalizedTokenIn,
+        tokenOut: normalizedTokenOut,
+        amountIn: quote.amountIn,
+        slippage: executionSlippage,
+        userAddress: receiveUser,
+        tokenInSymbol: quote.tokenIn.symbol,
+        tokenInDecimals: quote.tokenIn.decimals,
+        tokenOutSymbol: quote.tokenOut.symbol,
+        tokenOutDecimals: quote.tokenOut.decimals
+      });
+      if (reQuoteResponse.code !== "0" && reQuoteResponse.code !== 0 && reQuoteResponse.code !== void 0) {
+        const errorMsg = reQuoteResponse.msg || `OKX re-quote failed: Error code ${reQuoteResponse.code}`;
+        return createExecuteError(errorMsg);
+      }
+      if (!reQuoteResponse.data || reQuoteResponse.data.length === 0) {
+        const errorMsg = reQuoteResponse.msg || "OKX re-quote failed: No data returned";
+        return createExecuteError(errorMsg);
+      }
+      const reQuoteData = reQuoteResponse.data[0];
+      const toTokenAmount = reQuoteData.toTokenAmount || reQuoteData.toAmount;
+      const okxEstimateGasFee = reQuoteData.estimateGasFee || reQuoteData.estimatedGas;
+      const isCrossChain = receiveUser.toLowerCase() !== sender.toLowerCase();
+      let minAmountOut;
+      if (reQuoteData.minToAmount && reQuoteData.minToAmount !== "0") {
+        minAmountOut = reQuoteData.minToAmount;
+        if (isCrossChain) {
+          logger.info("OKX swap: Using API minToAmount for cross-chain swap", {
+            minToAmount: minAmountOut,
+            toTokenAmount
+          });
         }
-        let normalizedSourceAsset;
-        if (isEvmChain) {
-          const bluechipKey = bluechipToken.symbol?.toUpperCase();
-          const bluechipTokenConfig = bluechipKey && bluechipTokens[bluechipKey] || void 0;
-          normalizedSourceAsset = bluechipTokenConfig?.assetId ? bluechipTokenConfig.assetId : `evm:${normalizeEvmAddress(bluechipToken.address)}`;
-        } else {
-          const bluechipKey = bluechipToken.symbol?.toUpperCase() === "WNEAR" ? "NEAR" : bluechipToken.symbol?.toUpperCase();
-          const bluechipTokenConfig = bluechipKey && bluechipTokens[bluechipKey] || void 0;
-          normalizedSourceAsset = bluechipTokenConfig?.assetId ? bluechipTokenConfig.assetId : `nep141:${bluechipToken.address}`;
+      } else if (toTokenAmount) {
+        const toAmountBN = ethers.ethers.BigNumber.from(toTokenAmount);
+        const effectiveSlippage = isCrossChain ? executionSlippage + 0.02 : executionSlippage;
+        const slippageBps2 = ethers.ethers.BigNumber.from(Math.floor(effectiveSlippage * 1e4));
+        const slippageAmount = toAmountBN.mul(slippageBps2).div(1e4);
+        minAmountOut = toAmountBN.sub(slippageAmount).toString();
+        if (isCrossChain) {
+          logger.info("OKX swap: Calculated minAmountOut for cross-chain swap", {
+            toTokenAmount,
+            executionSlippage,
+            effectiveSlippage,
+            slippageBps: slippageBps2.toString(),
+            slippageAmount: slippageAmount.toString(),
+            minAmountOut
+          });
         }
-        let normalizedTargetAsset = targetToken.address;
-        if (normalizedTargetAsset?.startsWith("1cs_v1:")) ; else if (normalizedTargetAsset && !normalizedTargetAsset.startsWith("nep141:") && !normalizedTargetAsset.startsWith("nep245:") && normalizedTargetAsset.includes(".")) {
-          normalizedTargetAsset = `nep141:${normalizeTokenId(
-            normalizedTargetAsset,
-            wrapNearContractId
-          )}`;
+      } else {
+        minAmountOut = "0";
+      }
+      logger.info("OKX swap: calling swap API", {
+        chainId: this.chainId,
+        tokenIn: normalizedTokenIn,
+        tokenOut: normalizedTokenOut,
+        amountIn: quote.amountIn,
+        minAmountOut,
+        fromAddress: sender,
+        toAddress: receiveUser,
+        receiveUser,
+        tokenInSymbol: quote.tokenIn.symbol,
+        tokenInDecimals: quote.tokenIn.decimals,
+        tokenOutSymbol: quote.tokenOut.symbol,
+        tokenOutDecimals: quote.tokenOut.decimals
+      });
+      const swapResponse = await this.okxAdapter.swap({
+        chainId: this.chainId,
+        tokenIn: normalizedTokenIn,
+        tokenOut: normalizedTokenOut,
+        amountIn: quote.amountIn,
+        minAmountOut,
+        slippage: executionSlippage,
+        fromAddress: sender,
+        toAddress: receiveUser,
+        tokenInSymbol: quote.tokenIn.symbol,
+        tokenInDecimals: quote.tokenIn.decimals,
+        tokenOutSymbol: quote.tokenOut.symbol,
+        tokenOutDecimals: quote.tokenOut.decimals
+      });
+      if (swapResponse.code !== "0" && swapResponse.code !== 0 && swapResponse.code !== void 0) {
+        return createExecuteError(
+          swapResponse.msg || `OKX swap failed: Error code ${swapResponse.code}`
+        );
+      }
+      if (!swapResponse.data) {
+        return createExecuteError(
+          swapResponse.msg || "OKX swap failed: No transaction data"
+        );
+      }
+      let txData = null;
+      if (Array.isArray(swapResponse.data) && swapResponse.data.length > 0) {
+        const firstItem = swapResponse.data[0];
+        txData = firstItem?.tx || firstItem;
+      } else if (swapResponse.data && !Array.isArray(swapResponse.data)) {
+        const data = swapResponse.data;
+        if (data.tx) {
+          txData = data.tx;
+        } else if (data.transaction) {
+          txData = data.transaction;
+        } else {
+          txData = data;
         }
-        if (!normalizedTargetAsset?.startsWith("1cs_v1:")) {
-          normalizedTargetAsset = normalizeDestinationAsset(normalizedTargetAsset, wrapNearContractId) || normalizedTargetAsset;
+      }
+      if (!txData) {
+        logger.error("OKX swap response: no txData found", {
+          swapResponse
+        });
+        return createExecuteError(
+          swapResponse.msg || "OKX swap failed: No transaction data in response"
+        );
+      }
+      const dataObj = Array.isArray(swapResponse.data) ? swapResponse.data[0] : swapResponse.data;
+      if (dataObj?.estimateRevert === true || txData?.estimateRevert === true) {
+        logger.error("OKX swap: estimateRevert is true, transaction would fail", {
+          swapResponse,
+          txData
+        });
+        return createExecuteError(
+          swapResponse.msg || "OKX swap failed: Transaction would revert (slippage or price impact too high)"
+        );
+      }
+      let transactionData = txData.data || "";
+      const to = txData.to || "";
+      let value = txData.value || "0";
+      if (transactionData && !transactionData.startsWith("0x")) {
+        transactionData = "0x" + transactionData;
+      }
+      const isNativeTokenIn = !normalizedTokenIn || normalizedTokenIn === "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+      if (isNativeTokenIn) {
+        value = quote.amountIn;
+      }
+      const gas = txData.gas || txData.gasPrice || okxEstimateGasFee || void 0;
+      if (!to || !transactionData) {
+        logger.error("OKX swap response: missing to or transactionData", {
+          to,
+          hasTransactionData: !!transactionData,
+          txData
+        });
+        return createExecuteError(
+          swapResponse.msg || "OKX swap failed: Missing transaction data or recipient address"
+        );
+      }
+      if (transactionData.length < 10 || !/^0x[0-9a-fA-F]+$/.test(transactionData)) {
+        logger.error("OKX swap: invalid transaction data format", {
+          transactionDataLength: transactionData.length,
+          transactionDataPrefix: transactionData.substring(0, 20)
+        });
+        return createExecuteError(
+          swapResponse.msg || "OKX swap failed: Invalid transaction data format"
+        );
+      }
+      logger.info("OKX swap: starting balance and allowance checks");
+      let dexContractAddress;
+      if (normalizedTokenIn && normalizedTokenIn !== "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE") {
+        logger.info("OKX swap: checking ERC20 token balance and allowance", {
+          tokenIn: normalizedTokenIn,
+          sender,
+          to
+        });
+        if (!this.evmChainAdapter.getBalance) {
+          return createExecuteError("OKX swap failed: Balance check not supported");
         }
-        const slippageBps = convertSlippageToBasisPoints(slippage);
-        let formattedAmountOut = preSwapQuote.amountOut;
-        if (isEvmChain && bluechipToken.decimals !== void 0) {
+        const tokenBalanceFormatted = await this.evmChainAdapter.getBalance({
+          address: sender,
+          tokenAddress: normalizedTokenIn
+        });
+        const tokenDecimals = quote.tokenIn.decimals || 18;
+        const balanceBN = ethers.ethers.utils.parseUnits(
+          tokenBalanceFormatted || "0",
+          tokenDecimals
+        );
+        const amountInBN = ethers.ethers.BigNumber.from(quote.amountIn);
+        logger.info("OKX swap: token balance check", {
+          balance: balanceBN.toString(),
+          amountIn: amountInBN.toString(),
+          hasEnoughBalance: balanceBN.gte(amountInBN)
+        });
+        if (balanceBN.lt(amountInBN)) {
+          logger.error("OKX swap: insufficient token balance", {
+            balance: balanceBN.toString(),
+            amountIn: amountInBN.toString()
+          });
+          return createExecuteError("OKX swap failed: Insufficient token balance");
+        }
+        logger.info("OKX swap: getting approve transaction to find dexContractAddress", {
+          tokenIn: normalizedTokenIn,
+          amountIn: quote.amountIn
+        });
+        const approveResponse = await this.okxAdapter.getApproveTransaction({
+          chainId: this.chainId,
+          tokenAddress: normalizedTokenIn,
+          approveAmount: quote.amountIn
+        });
+        if (approveResponse.code !== "0" && approveResponse.code !== 0) {
+          logger.error("OKX swap: failed to get approve transaction", {
+            code: approveResponse.code,
+            msg: approveResponse.msg
+          });
+          return createExecuteError(
+            approveResponse.msg || "Failed to get OKX approve transaction"
+          );
+        }
+        dexContractAddress = approveResponse.data?.dexContractAddress;
+        if (!dexContractAddress) {
+          logger.error("OKX swap: no dexContractAddress in approve response");
+          return createExecuteError("Failed to get OKX DEX contract address");
+        }
+        logger.info("OKX swap: checking token allowance", {
+          tokenIn: normalizedTokenIn,
+          owner: sender,
+          spender: dexContractAddress
+        });
+        const currentAllowance = await this.evmChainAdapter.getAllowance({
+          tokenAddress: normalizedTokenIn,
+          owner: sender,
+          spender: dexContractAddress
+        });
+        const allowanceBN = ethers.ethers.BigNumber.from(currentAllowance);
+        logger.info("OKX swap: token allowance check", {
+          allowance: allowanceBN.toString(),
+          amountIn: amountInBN.toString(),
+          hasEnoughAllowance: allowanceBN.gte(amountInBN),
+          dexContractAddress,
+          sender,
+          tokenIn: normalizedTokenIn
+        });
+        if (allowanceBN.lt(amountInBN)) {
+          logger.warn("OKX swap: insufficient token allowance, need to approve", {
+            allowance: allowanceBN.toString(),
+            amountIn: amountInBN.toString(),
+            dexContractAddress,
+            sender,
+            tokenIn: normalizedTokenIn
+          });
+          if (!approveResponse.data?.data) {
+            logger.error("OKX swap: no approve transaction data");
+            return createExecuteError("Failed to get OKX approve transaction data");
+          }
           try {
-            const amountBN = new Big3__default.default(preSwapQuote.amountOut);
-            if (amountBN.lte(0)) {
-              throw new Error(ErrorMessages.QUOTE_FAILED);
+            const [estimatedGasLimit, hasReliableEstimate] = await estimateGasLimit(
+              approveResponse.data.gasLimit,
+              normalizedTokenIn,
+              approveResponse.data.data,
+              "0",
+              sender,
+              this.chainId,
+              this.evmChainAdapter
+            );
+            const approveTxParams = {
+              to: normalizedTokenIn,
+              data: approveResponse.data.data,
+              value: "0",
+              gasLimit: estimatedGasLimit.toString()
+            };
+            if (isEip1559Chain(this.chainId)) {
+              const feeData2 = await getEip1559FeeData(this.chainId, this.evmChainAdapter);
+              if (feeData2.maxFeePerGas && feeData2.maxPriorityFeePerGas) {
+                approveTxParams.type = 2;
+                approveTxParams.maxFeePerGas = feeData2.maxFeePerGas.toString();
+                approveTxParams.maxPriorityFeePerGas = feeData2.maxPriorityFeePerGas.toString();
+              } else {
+                if (approveResponse.data.gasPrice) {
+                  approveTxParams.gasPrice = approveResponse.data.gasPrice;
+                }
+              }
+            } else {
+              if (approveResponse.data.gasPrice) {
+                approveTxParams.gasPrice = approveResponse.data.gasPrice;
+              } else {
+                const estimatedGasPrice = await getGasPriceEstimate(
+                  this.chainId,
+                  this.evmChainAdapter
+                );
+                approveTxParams.gasPrice = estimatedGasPrice.toString();
+              }
+            }
+            logger.info("OKX swap: sending approve transaction", {
+              to: normalizedTokenIn,
+              tokenIn: normalizedTokenIn,
+              dexContractAddress,
+              hasData: !!approveResponse.data.data,
+              gasLimit: estimatedGasLimit.toString(),
+              okxGasLimit: approveResponse.data.gasLimit,
+              hasReliableEstimate
+            });
+            const approveResult = await this.evmChainAdapter.sendTransaction(approveTxParams);
+            if (approveResult.status !== "success") {
+              logger.error("OKX swap: approve transaction failed", {
+                status: approveResult.status,
+                message: approveResult.message
+              });
+              return createExecuteError(
+                approveResult.message || "Approve transaction failed"
+              );
+            }
+            logger.info("OKX swap: approve transaction successful", {
+              txHash: approveResult.txHash
+            });
+            let retryCount = 0;
+            while (retryCount < MAX_APPROVAL_RETRIES) {
+              await new Promise(
+                (resolve) => setTimeout(resolve, APPROVAL_RETRY_DELAY_MS * (retryCount + 1))
+              );
+              const newAllowance = await this.evmChainAdapter.getAllowance({
+                tokenAddress: normalizedTokenIn,
+                owner: sender,
+                spender: dexContractAddress
+              });
+              const newAllowanceBN = ethers.ethers.BigNumber.from(newAllowance);
+              logger.info("OKX swap: checking approval status", {
+                retryCount,
+                allowance: newAllowanceBN.toString(),
+                amountIn: amountInBN.toString(),
+                hasEnoughAllowance: newAllowanceBN.gte(amountInBN)
+              });
+              if (newAllowanceBN.gte(amountInBN)) {
+                logger.info("OKX swap: approval confirmed");
+                break;
+              }
+              retryCount++;
+            }
+            const finalAllowance = await this.evmChainAdapter.getAllowance({
+              tokenAddress: normalizedTokenIn,
+              owner: sender,
+              spender: dexContractAddress
+            });
+            const finalAllowanceBN = ethers.ethers.BigNumber.from(finalAllowance);
+            if (finalAllowanceBN.lt(amountInBN)) {
+              logger.error("OKX swap: approval still insufficient after retries", {
+                allowance: finalAllowanceBN.toString(),
+                amountIn: amountInBN.toString()
+              });
+              return createExecuteError("Token approval failed or insufficient");
             }
-            formattedAmountOut = amountBN.toFixed(0, Big3__default.default.roundDown);
           } catch (error) {
-            throw new Error(ErrorMessages.QUOTE_FAILED);
+            logger.error("OKX swap: approve transaction error", {
+              error: error?.message
+            });
+            return createExecuteError(
+              normalizeError(error?.message) || "Approve transaction failed"
+            );
+          }
+        }
+      } else {
+        if (!this.evmChainAdapter.getBalance) {
+          return createExecuteError("OKX swap failed: Balance check not supported");
+        }
+        const nativeBalanceFormatted = await this.evmChainAdapter.getBalance({
+          address: sender,
+          tokenAddress: void 0
+        });
+        const balanceBN = ethers.ethers.utils.parseEther(nativeBalanceFormatted || "0");
+        const amountInBN = ethers.ethers.BigNumber.from(quote.amountIn);
+        const gasPriceEstimate2 = await getGasPriceEstimate(
+          this.chainId,
+          this.evmChainAdapter
+        );
+        const [estimatedGasLimitForBalance] = await estimateGasLimit(
+          gas,
+          to,
+          transactionData,
+          value,
+          sender,
+          this.chainId,
+          this.evmChainAdapter
+        );
+        const gasCostEstimate = estimatedGasLimitForBalance.mul(gasPriceEstimate2);
+        const totalRequired = amountInBN.add(gasCostEstimate);
+        if (balanceBN.lt(totalRequired)) {
+          return createExecuteError("OKX swap failed: Insufficient balance (including gas fee)");
+        }
+      }
+      if (normalizedTokenIn && normalizedTokenIn !== "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE" && dexContractAddress) {
+        const finalAllowanceCheck = await this.evmChainAdapter.getAllowance({
+          tokenAddress: normalizedTokenIn,
+          owner: sender,
+          spender: dexContractAddress
+        });
+        const finalAllowanceBN = ethers.ethers.BigNumber.from(finalAllowanceCheck);
+        const amountInBN = ethers.ethers.BigNumber.from(quote.amountIn);
+        if (finalAllowanceBN.lt(amountInBN)) {
+          logger.error("OKX swap: final allowance check failed", {
+            allowance: finalAllowanceBN.toString(),
+            amountIn: amountInBN.toString(),
+            dexContractAddress
+          });
+          return createExecuteError("OKX swap failed: Insufficient token allowance");
+        }
+      }
+      const [rpcEstimatedGasLimit, hasReliableRpcEstimate, rpcEstimateError] = await estimateGasLimit(
+        void 0,
+        to,
+        transactionData,
+        value,
+        sender,
+        this.chainId,
+        this.evmChainAdapter
+      );
+      let finalGasLimit;
+      const MAX_REASONABLE_GAS_LIMIT = ethers.ethers.BigNumber.from("500000");
+      const okxGasBN = gas ? ethers.ethers.BigNumber.from(gas) : null;
+      const okxEstimateGasFeeBN = okxEstimateGasFee ? ethers.ethers.BigNumber.from(okxEstimateGasFee) : null;
+      if (rpcEstimateError) {
+        const isUnpredictableGasLimit = rpcEstimateError.code === "UNPREDICTABLE_GAS_LIMIT" || rpcEstimateError.message && rpcEstimateError.message.includes("UNPREDICTABLE_GAS_LIMIT") || rpcEstimateError.reason && rpcEstimateError.reason.includes("execution reverted");
+        if (isUnpredictableGasLimit) {
+          logger.warn("Blocking transaction due to RPC gas estimation failure", {
+            chainId: this.chainId,
+            tokenIn: quote.tokenIn.symbol,
+            tokenOut: quote.tokenOut.symbol,
+            rpcError: rpcEstimateError
+          });
+          const errorMsg = rpcEstimateError?.message || rpcEstimateError?.reason || "";
+          return createExecuteError(
+            errorMsg || "OKX swap failed: Transaction would revert (slippage or price impact too high)"
+          );
+        }
+        if (okxEstimateGasFeeBN && okxEstimateGasFeeBN.gt(0)) {
+          finalGasLimit = okxEstimateGasFeeBN.gt(MAX_REASONABLE_GAS_LIMIT) ? MAX_REASONABLE_GAS_LIMIT : okxEstimateGasFeeBN;
+          logger.warn("RPC gas estimation failed, using OKX estimateGasFee (capped)", {
+            chainId: this.chainId,
+            tokenIn: quote.tokenIn.symbol,
+            tokenOut: quote.tokenOut.symbol,
+            okxEstimateGasFee: okxEstimateGasFeeBN.toString(),
+            finalGasLimit: finalGasLimit.toString(),
+            rpcError: rpcEstimateError
+          });
+        } else if (okxGasBN && okxGasBN.gt(0)) {
+          finalGasLimit = okxGasBN.gt(MAX_REASONABLE_GAS_LIMIT) ? MAX_REASONABLE_GAS_LIMIT : okxGasBN;
+          logger.warn("RPC gas estimation failed, using OKX gas from swap (capped)", {
+            chainId: this.chainId,
+            tokenIn: quote.tokenIn.symbol,
+            tokenOut: quote.tokenOut.symbol,
+            okxGas: okxGasBN.toString(),
+            finalGasLimit: finalGasLimit.toString(),
+            rpcError: rpcEstimateError
+          });
+        } else {
+          return createExecuteError("OKX swap failed: Unable to determine gas limit");
+        }
+      } else if (hasReliableRpcEstimate && rpcEstimatedGasLimit.gt(0)) {
+        finalGasLimit = rpcEstimatedGasLimit;
+        if (okxGasBN && okxGasBN.gt(rpcEstimatedGasLimit.mul(2))) {
+          logger.warn("OKX gas estimate is much higher than RPC estimate, using RPC estimate", {
+            chainId: this.chainId,
+            tokenIn: quote.tokenIn.symbol,
+            tokenOut: quote.tokenOut.symbol,
+            rpcEstimate: rpcEstimatedGasLimit.toString(),
+            okxGas: okxGasBN.toString(),
+            finalGasLimit: finalGasLimit.toString()
+          });
+        } else {
+          logger.info("Using RPC gas estimate for swap transaction", {
+            chainId: this.chainId,
+            tokenIn: quote.tokenIn.symbol,
+            tokenOut: quote.tokenOut.symbol,
+            rpcEstimate: rpcEstimatedGasLimit.toString(),
+            okxGas: okxGasBN?.toString() || "not provided",
+            finalGasLimit: finalGasLimit.toString()
+          });
+        }
+      } else {
+        if (okxEstimateGasFeeBN && okxEstimateGasFeeBN.gt(0)) {
+          finalGasLimit = okxEstimateGasFeeBN.gt(MAX_REASONABLE_GAS_LIMIT) ? MAX_REASONABLE_GAS_LIMIT : okxEstimateGasFeeBN;
+        } else if (okxGasBN && okxGasBN.gt(0)) {
+          finalGasLimit = okxGasBN.gt(MAX_REASONABLE_GAS_LIMIT) ? MAX_REASONABLE_GAS_LIMIT : okxGasBN;
+        } else if (rpcEstimatedGasLimit.gt(0)) {
+          finalGasLimit = rpcEstimatedGasLimit;
+        } else {
+          return createExecuteError("OKX swap failed: Unable to determine gas limit");
+        }
+        logger.warn("Gas estimation unreliable, using fallback (capped)", {
+          chainId: this.chainId,
+          tokenIn: quote.tokenIn.symbol,
+          tokenOut: quote.tokenOut.symbol,
+          finalGasLimit: finalGasLimit.toString(),
+          okxGas: okxGasBN?.toString() || "not provided",
+          okxEstimateGasFee: okxEstimateGasFeeBN?.toString() || "not provided"
+        });
+      }
+      const supportsEip1559 = isEip1559Chain(this.chainId);
+      let gasPriceEstimate;
+      const getCachedGasPrice = async () => {
+        if (!gasPriceEstimate) {
+          gasPriceEstimate = await getGasPriceEstimate(
+            this.chainId,
+            this.evmChainAdapter
+          );
+        }
+        return gasPriceEstimate;
+      };
+      let feeData = {};
+      if (supportsEip1559) {
+        feeData = await getEip1559FeeData(this.chainId, this.evmChainAdapter);
+        if (!feeData.maxFeePerGas || !feeData.maxPriorityFeePerGas || feeData.maxFeePerGas.lte(0) || feeData.maxPriorityFeePerGas.lte(0)) {
+          const cachedGasPrice = await getCachedGasPrice();
+          if (!cachedGasPrice || cachedGasPrice.lte(0)) {
+            return createExecuteError("OKX swap failed: Unable to get valid gas price");
+          }
+          feeData.maxFeePerGas = cachedGasPrice;
+          feeData.maxPriorityFeePerGas = cachedGasPrice.div(10);
+          const minPriorityFee = ethers.ethers.utils.parseUnits("1", "gwei");
+          if (feeData.maxPriorityFeePerGas.lt(minPriorityFee)) {
+            feeData.maxPriorityFeePerGas = minPriorityFee;
+          }
+        }
+      } else {
+        try {
+          const signer = await this.evmChainAdapter.getSigner?.();
+          if (signer?.provider) {
+            const providerFeeData = await signer.provider.getFeeData();
+            if (providerFeeData.gasPrice && providerFeeData.gasPrice.gt(0)) {
+              feeData.gasPrice = providerFeeData.gasPrice;
+            } else {
+              const cachedGasPrice = await getCachedGasPrice();
+              if (!cachedGasPrice || cachedGasPrice.lte(0)) {
+                return createExecuteError("Failed to get valid gas price. Please try again.");
+              }
+              feeData.gasPrice = cachedGasPrice;
+            }
+          } else {
+            const cachedGasPrice = await getCachedGasPrice();
+            if (!cachedGasPrice || cachedGasPrice.lte(0)) {
+              return createExecuteError("Failed to get valid gas price. Please try again.");
+            }
+            feeData.gasPrice = cachedGasPrice;
           }
+        } catch (error) {
+          const cachedGasPrice = await getCachedGasPrice();
+          if (!cachedGasPrice || cachedGasPrice.lte(0)) {
+            return createExecuteError("OKX swap failed: Unable to get valid gas price");
+          }
+          feeData.gasPrice = cachedGasPrice;
+        }
+      }
+      if (!to || !ethers.ethers.utils.isAddress(to)) {
+        return createExecuteError("OKX swap failed: Invalid recipient address");
+      }
+      if (!transactionData || transactionData.length < 10) {
+        return createExecuteError("OKX swap failed: Invalid transaction data");
+      }
+      if (!finalGasLimit || finalGasLimit.lte(0)) {
+        return createExecuteError("OKX swap failed: Invalid gas limit");
+      }
+      if (supportsEip1559) {
+        if (!feeData.maxFeePerGas || !feeData.maxPriorityFeePerGas || feeData.maxFeePerGas.lte(0) || feeData.maxPriorityFeePerGas.lte(0)) {
+          return createExecuteError("OKX swap failed: Invalid gas fee data (EIP-1559)");
+        }
+      } else {
+        if (!feeData.gasPrice || feeData.gasPrice.lte(0)) {
+          return createExecuteError("OKX swap failed: Invalid gas price");
+        }
+      }
+      const txParams = {
+        to,
+        data: transactionData,
+        value: value || "0",
+        gasLimit: finalGasLimit.toString()
+      };
+      if (supportsEip1559 && feeData.maxFeePerGas && feeData.maxPriorityFeePerGas) {
+        txParams.type = 2;
+        txParams.maxFeePerGas = feeData.maxFeePerGas.toString();
+        txParams.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas.toString();
+      } else if (feeData.gasPrice) {
+        txParams.gasPrice = feeData.gasPrice.toString();
+      }
+      logger.info("OKX sending transaction to wallet", {
+        to,
+        hasData: !!transactionData,
+        dataLength: transactionData?.length,
+        value,
+        gasLimit: finalGasLimit.toString(),
+        supportsEip1559,
+        feeData: supportsEip1559 ? {
+          maxFeePerGas: feeData.maxFeePerGas?.toString(),
+          maxPriorityFeePerGas: feeData.maxPriorityFeePerGas?.toString()
+        } : { gasPrice: feeData.gasPrice?.toString() }
+      });
+      const result = await this.evmChainAdapter.sendTransaction(txParams);
+      logger.info("OKX transaction result", {
+        status: result.status,
+        txHash: result.txHash,
+        message: result.message
+      });
+      if (result.status === "success") {
+        return {
+          success: true,
+          txHash: result.txHash,
+          txHashArray: result.txHash ? [result.txHash] : []
+        };
+      } else {
+        logger.error("OKX transaction failed", {
+          status: result.status,
+          txHash: result.txHash,
+          message: result.message
+        });
+        return createExecuteError(
+          normalizeError(result.message) || ErrorMessages.EXECUTE_FAILED
+        );
+      }
+    } catch (error) {
+      logger.error("OKX execute swap error:", error);
+      return createExecuteError(
+        normalizeError(error?.message) || ErrorMessages.EXECUTE_FAILED
+      );
+    }
+  }
+  normalizeEvmAddress(address) {
+    if (!address) return address;
+    try {
+      return ethers.ethers.utils.getAddress(address);
+    } catch (e) {
+      const addr = address.startsWith("0x") ? address.slice(2) : address;
+      return "0x" + addr.toLowerCase();
+    }
+  }
+};
+async function completeQuote(params, config) {
+  const {
+    sourceToken,
+    targetToken,
+    sourceChain,
+    targetChain: _targetChain,
+    // Reserved for future use
+    amountIn,
+    slippage,
+    recipient,
+    refundTo,
+    customRecipientMsg,
+    appFees,
+    evmChainId
+  } = params;
+  const {
+    intentsQuotationAdapter,
+    dexRouters,
+    dexRouter,
+    bluechipTokens,
+    configAdapter,
+    currentUserAddress,
+    isIntentsSupportedToken: customIsIntentsSupportedToken
+  } = config;
+  const wrapNearContractId = configAdapter.getWrapNearContractId();
+  const routers = dexRouters || (dexRouter ? [dexRouter] : []);
+  const userAddress = currentUserAddress || recipient;
+  if (!userAddress) {
+    throw new Error(ErrorMessages.QUOTE_FAILED);
+  }
+  if (sourceToken?.address === void 0) {
+    throw new Error(ErrorMessages.QUOTE_FAILED);
+  }
+  if (targetToken?.address === void 0) {
+    throw new Error(ErrorMessages.QUOTE_FAILED);
+  }
+  const isEvmChain = evmChainId !== void 0 || sourceToken.chain === "evm" || sourceChain === "evm";
+  const isTokenIntentsSupported = isEvmChain && sourceToken.platform === "nearIntents" || (customIsIntentsSupportedToken ? customIsIntentsSupportedToken(sourceToken) : isEvmChain ? isEvmIntentsSupportedToken(sourceToken, bluechipTokens) : isNearIntentsSupportedToken(sourceToken, bluechipTokens));
+  const bluechipToken = isEvmChain ? findBestEvmBluechipToken(
+    bluechipTokens,
+    configAdapter.getEvmNativeWrappedTokenAddress?.()
+  ) : findBestBluechipToken(bluechipTokens, wrapNearContractId);
+  if (!bluechipToken?.address) {
+    throw new Error(ErrorMessages.QUOTE_FAILED);
+  }
+  async function quoteWithRetry(router, quoteParams, _routerType, _routerName, maxRetries = 2, initialDelay = 1e3) {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const quote = await router.quote(quoteParams);
+        if (quote.success) {
+          return quote;
+        }
+        const isRateLimit = quote.error?.includes("429") || quote.error?.toLowerCase().includes("rate limit") || quote.error?.toLowerCase().includes("too many requests");
+        if (!isRateLimit || attempt === maxRetries) {
+          return quote;
+        }
+        const baseDelay = isRateLimit ? 2e3 : initialDelay;
+        const delay = baseDelay * Math.pow(2, attempt);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      } catch (error) {
+        const errorMessage = error?.message || String(error);
+        const isRateLimit = errorMessage?.includes("429") || errorMessage?.toLowerCase().includes("rate limit") || errorMessage?.toLowerCase().includes("too many requests");
+        if (!isRateLimit || attempt === maxRetries) {
+          throw error;
         }
+        const baseDelay = isRateLimit ? 2e3 : initialDelay;
+        const delay = baseDelay * Math.pow(2, attempt);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    return null;
+  }
+  const preSwapQuotePromises = routers.map(async (router, index) => {
+    const supportedChain = router.getSupportedChain();
+    const isEvmRouter = supportedChain === "evm";
+    let routeType;
+    if (isEvmRouter) {
+      routeType = "evm";
+    } else {
+      routeType = index === 0 ? "v1" : "v2";
+    }
+    const capabilities = router.getCapabilities();
+    const quoteParams = capabilities.requiresRecipient ? {
+      tokenIn: sourceToken,
+      tokenOut: bluechipToken,
+      amountIn,
+      slippage,
+      swapType: "EXACT_INPUT",
+      sender: userAddress,
+      recipient: userAddress
+    } : {
+      tokenIn: sourceToken,
+      tokenOut: bluechipToken,
+      amountIn,
+      slippage,
+      swapType: "EXACT_INPUT"
+    };
+    const routerName = router.getSupportedChain() === "evm" ? `EVM-${router.getChainId?.() || "unknown"}` : "NEAR";
+    const routerType = router.okxAdapter ? "OKX" : router.bitgetAdapter ? "Bitget" : routerName;
+    try {
+      const preSwapQuote = await quoteWithRetry(
+        router,
+        quoteParams,
+        routerType,
+        routerName,
+        2,
+        1e3
+      );
+      if (!preSwapQuote || !preSwapQuote.success) {
+        return null;
+      }
+      return {
+        type: routeType,
+        router,
+        preSwapQuote
+      };
+    } catch (error) {
+      return null;
+    }
+  });
+  const preSwapQuoteResults = await Promise.allSettled(preSwapQuotePromises);
+  const validPreSwapQuotes = [];
+  preSwapQuoteResults.forEach((result) => {
+    if (result.status === "fulfilled" && result.value !== null) {
+      validPreSwapQuotes.push(result.value);
+    }
+  });
+  let bestPreSwapQuote = null;
+  if (validPreSwapQuotes.length > 0) {
+    bestPreSwapQuote = validPreSwapQuotes.reduce((best, current) => {
+      const bestAmount = new Big3__default.default(best.preSwapQuote.amountOut);
+      const currentAmount = new Big3__default.default(current.preSwapQuote.amountOut);
+      return currentAmount.gt(bestAmount) ? current : best;
+    });
+  }
+  const quotePaths = [];
+  if (bestPreSwapQuote) {
+    const { router, preSwapQuote, type: routeType } = bestPreSwapQuote;
+    let normalizedSourceAsset;
+    if (bluechipToken.assetId && (bluechipToken.assetId.startsWith("nep245:") || bluechipToken.assetId.startsWith("nep141:") || bluechipToken.assetId.startsWith("1cs_v1:"))) {
+      normalizedSourceAsset = bluechipToken.assetId;
+    } else if (isEvmChain) {
+      const bluechipKey = bluechipToken.symbol?.toUpperCase();
+      const bluechipTokenConfig = bluechipKey && bluechipTokens[bluechipKey] || void 0;
+      normalizedSourceAsset = bluechipTokenConfig?.assetId ? bluechipTokenConfig.assetId : `evm:${normalizeEvmAddress(bluechipToken.address)}`;
+    } else {
+      const bluechipKey = bluechipToken.symbol?.toUpperCase() === "WNEAR" ? "NEAR" : bluechipToken.symbol?.toUpperCase();
+      const bluechipTokenConfig = bluechipKey && bluechipTokens[bluechipKey] || void 0;
+      normalizedSourceAsset = bluechipTokenConfig?.assetId ? bluechipTokenConfig.assetId : `nep141:${bluechipToken.address}`;
+    }
+    let normalizedTargetAsset;
+    if (targetToken.assetId && (targetToken.assetId.startsWith("nep245:") || targetToken.assetId.startsWith("nep141:") || targetToken.assetId.startsWith("1cs_v1:"))) {
+      normalizedTargetAsset = targetToken.assetId;
+    } else {
+      normalizedTargetAsset = targetToken.address;
+      if (normalizedTargetAsset?.startsWith("1cs_v1:")) ; else if (normalizedTargetAsset && !normalizedTargetAsset.startsWith("nep141:") && !normalizedTargetAsset.startsWith("nep245:") && normalizedTargetAsset.includes(".")) {
+        normalizedTargetAsset = `nep141:${normalizeTokenId(
+          normalizedTargetAsset,
+          wrapNearContractId
+        )}`;
+      }
+      if (!normalizedTargetAsset?.startsWith("1cs_v1:")) {
+        normalizedTargetAsset = normalizeDestinationAsset(normalizedTargetAsset, wrapNearContractId) || normalizedTargetAsset;
+      }
+    }
+    const slippageBps = convertSlippageToBasisPoints(slippage);
+    const formattedAmountOut = preSwapQuote.amountOut;
+    quotePaths.push({
+      type: routeType,
+      router,
+      promise: (async () => {
         try {
           const intentsQuote = await intentsQuotationAdapter.quote({
             originAsset: normalizedSourceAsset,
@@ -1937,7 +2806,13 @@ async function completeQuote(params, config) {
             ...appFees ? { appFees } : {}
           });
           if (intentsQuote.quoteStatus !== "success") {
-            throw new Error(ErrorMessages.QUOTE_FAILED);
+            const formatError = config.formatErrorMessage || formatErrorMessage;
+            const errorMessage = formatError({
+              error: intentsQuote.messageOriginal || intentsQuote.message,
+              originAsset: normalizedSourceAsset,
+              fallbackMessage: ErrorMessages.QUOTE_FAILED
+            });
+            throw new Error(errorMessage);
           }
           return {
             intentsQuote,
@@ -1950,13 +2825,17 @@ async function completeQuote(params, config) {
         }
       })()
     });
-  });
+  }
   if (isTokenIntentsSupported) {
     quotePaths.push({
       type: "intents",
       promise: (async () => {
         let normalizedSourceAsset;
-        if (isEvmChain) {
+        if (isEvmChain && sourceToken.platform === "nearIntents" && sourceToken.assetId) {
+          normalizedSourceAsset = sourceToken.assetId;
+        } else if (sourceToken.assetId && (sourceToken.assetId.startsWith("nep245:") || sourceToken.assetId.startsWith("nep141:") || sourceToken.assetId.startsWith("1cs_v1:"))) {
+          normalizedSourceAsset = sourceToken.assetId;
+        } else if (isEvmChain) {
           const sourceKey = sourceToken.symbol?.toUpperCase();
           const sourceTokenConfig = sourceKey ? bluechipTokens[sourceKey] : void 0;
           if (sourceTokenConfig?.assetId) {
@@ -1978,15 +2857,22 @@ async function completeQuote(params, config) {
             }
           }
         }
-        let normalizedTargetAsset = targetToken.address;
-        if (normalizedTargetAsset?.startsWith("1cs_v1:")) ; else if (normalizedTargetAsset && !normalizedTargetAsset.startsWith("nep141:") && !normalizedTargetAsset.startsWith("nep245:") && normalizedTargetAsset.includes(".")) {
-          normalizedTargetAsset = `nep141:${normalizeTokenId(
-            normalizedTargetAsset,
-            wrapNearContractId
-          )}`;
-        }
-        if (!normalizedTargetAsset?.startsWith("1cs_v1:")) {
-          normalizedTargetAsset = normalizeDestinationAsset(normalizedTargetAsset, wrapNearContractId) || normalizedTargetAsset;
+        let normalizedTargetAsset;
+        if (isEvmChain && targetToken.platform === "nearIntents" && targetToken.assetId) {
+          normalizedTargetAsset = targetToken.assetId;
+        } else if (targetToken.assetId && (targetToken.assetId.startsWith("nep245:") || targetToken.assetId.startsWith("nep141:") || targetToken.assetId.startsWith("1cs_v1:"))) {
+          normalizedTargetAsset = targetToken.assetId;
+        } else {
+          normalizedTargetAsset = targetToken.address;
+          if (normalizedTargetAsset?.startsWith("1cs_v1:")) ; else if (normalizedTargetAsset && !normalizedTargetAsset.startsWith("nep141:") && !normalizedTargetAsset.startsWith("nep245:") && normalizedTargetAsset.includes(".")) {
+            normalizedTargetAsset = `nep141:${normalizeTokenId(
+              normalizedTargetAsset,
+              wrapNearContractId
+            )}`;
+          }
+          if (!normalizedTargetAsset?.startsWith("1cs_v1:")) {
+            normalizedTargetAsset = normalizeDestinationAsset(normalizedTargetAsset, wrapNearContractId) || normalizedTargetAsset;
+          }
         }
         const slippageBps = convertSlippageToBasisPoints(slippage);
         const intentsQuote = await intentsQuotationAdapter.quote({
@@ -2000,7 +2886,13 @@ async function completeQuote(params, config) {
           ...customRecipientMsg ? { customRecipientMsg } : {}
         });
         if (intentsQuote.quoteStatus !== "success") {
-          throw new Error(ErrorMessages.QUOTE_FAILED);
+          const formatError = config.formatErrorMessage || formatErrorMessage;
+          const errorMessage = formatError({
+            error: intentsQuote.messageOriginal || intentsQuote.message,
+            originAsset: normalizedSourceAsset,
+            fallbackMessage: ErrorMessages.QUOTE_FAILED
+          });
+          throw new Error(errorMessage);
         }
         return {
           intentsQuote,
@@ -2013,6 +2905,7 @@ async function completeQuote(params, config) {
     quotePaths.map((p) => p.promise)
   );
   const validPaths = [];
+  const errorMessages = [];
   pathResults.forEach((result, index) => {
     const pathType = quotePaths[index].type;
     if (result.status === "fulfilled") {
@@ -2020,10 +2913,28 @@ async function completeQuote(params, config) {
         type: pathType,
         ...result.value
       });
+    } else if (result.status === "rejected") {
+      const error = result.reason;
+      if (error instanceof Error) {
+        errorMessages.push(error.message);
+      } else if (typeof error === "string") {
+        errorMessages.push(error);
+      } else {
+        errorMessages.push(String(error));
+      }
     }
   });
   if (validPaths.length === 0) {
-    throw new Error(ErrorMessages.QUOTE_FAILED);
+    const intentsError = errorMessages.find(
+      (msg) => msg && msg !== ErrorMessages.QUOTE_FAILED && (msg.toLowerCase().includes("bridge") || msg.toLowerCase().includes("amount") || msg.toLowerCase().includes("low") || msg.toLowerCase().includes("minimum"))
+    );
+    const bestError = intentsError || errorMessages[0] || ErrorMessages.QUOTE_FAILED;
+    const formatError = config.formatErrorMessage || formatErrorMessage;
+    const formattedError = formatError({
+      error: bestError,
+      fallbackMessage: ErrorMessages.QUOTE_FAILED
+    });
+    throw new Error(formattedError);
   }
   const bestPath = validPaths.reduce((best, current) => {
     const bestAmount = new Big3__default.default(best.finalAmountOut);
@@ -2083,37 +2994,43 @@ async function quoteSameChainSwap(params, dexRouters) {
       return router.quote(quoteParams);
     })
   );
-  const validQuotes = quoteResults.filter(
-    (r) => r.status === "fulfilled" && r.value.success
+  const fulfilledResults = quoteResults.filter(
+    (r) => r.status === "fulfilled"
   ).map((r, index) => ({
-    quote: r.value,
-    router: dexRouters[index]
+    result: r.value,
+    router: dexRouters[index],
+    index
   }));
-  if (validQuotes.length === 0) {
-    const errors = quoteResults.map((r, index) => {
-      if (r.status === "rejected") {
-        return `Router ${index}: ${r.reason}`;
-      }
-      if (r.status === "fulfilled" && !r.value.success) {
-        return `Router ${index}: ${r.value.error}`;
-      }
-      return null;
-    }).filter(Boolean);
-    const errorMessage = errors.length > 0 ? `${ErrorMessages.QUOTE_FAILED}: ${errors.join("; ")}` : ErrorMessages.QUOTE_FAILED;
-    throw new Error(errorMessage);
-  }
-  return selectBestQuote(validQuotes);
+  const validQuotes = fulfilledResults.filter((r) => r.result.success).map((r) => ({
+    quote: r.result,
+    router: r.router
+  }));
+  if (validQuotes.length > 0) {
+    return selectBestQuote(validQuotes);
+  }
+  const errors = fulfilledResults.filter((r) => !r.result.success).map((r) => {
+    const error = r.result.error || "";
+    const is429 = error.includes("429") || error.toLowerCase().includes("rate limit") || error.toLowerCase().includes("too many requests");
+    return is429 ? null : `Router ${r.index}: ${error}`;
+  }).filter(Boolean);
+  if (errors.length === 0) {
+    throw new Error("All liquidity providers are busy. Please try again later.");
+  }
+  const errorMessage = errors.length > 0 ? `${ErrorMessages.QUOTE_FAILED}: ${errors.join("; ")}` : ErrorMessages.QUOTE_FAILED;
+  throw new Error(errorMessage);
 }
 
 exports.AggregateDexRouter = AggregateDexRouter;
 exports.BitgetRouter = BitgetRouter;
 exports.ErrorMessages = ErrorMessages;
 exports.NearSmartRouter = NearSmartRouter;
+exports.OkxRouter = OkxRouter;
 exports.TRANSACTION_EXECUTION_ERROR_MESSAGE = TRANSACTION_EXECUTION_ERROR_MESSAGE;
 exports.completeQuote = completeQuote;
 exports.convertSlippageToBasisPoints = convertSlippageToBasisPoints;
 exports.findBestBluechipToken = findBestBluechipToken;
 exports.findBestEvmBluechipToken = findBestEvmBluechipToken;
+exports.formatErrorMessage = formatErrorMessage;
 exports.formatGasString = formatGasString;
 exports.formatGasToTgas = formatGasToTgas;
 exports.getBluechipTokensConfig = getBluechipTokensConfig;
@@ -2123,6 +3040,7 @@ exports.isNearIntentsSupportedToken = isNearIntentsSupportedToken;
 exports.logger = logger;
 exports.normalizeDestinationAsset = normalizeDestinationAsset;
 exports.normalizeError = normalizeError;
+exports.normalizeErrorForIntents = normalizeErrorForIntents;
 exports.normalizeEvmAddress = normalizeEvmAddress;
 exports.normalizeTokenId = normalizeTokenId;
 exports.processErrorMessage = processErrorMessage;