@rhea-finance/cross-chain-aggregation-dex 0.1.2 → 0.1.4

package/dist/index.js

@@ -1,10 +1,10 @@
 'use strict';
 
-var Big2 = require('big.js');
+var Big3 = require('big.js');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var Big2__default = /*#__PURE__*/_interopDefault(Big2);
+var Big3__default = /*#__PURE__*/_interopDefault(Big3);
 
 // src/types/index.ts
 function requiresRecipient(params) {
@@ -66,28 +66,18 @@ function setBluechipTokensConfig(config) {
 }
 function getBluechipTokensConfig() {
   if (!bluechipTokensConfig) {
-    logger.warn(
-      "getBluechipTokensConfig - Bluechip tokens config not set, returning empty config"
-    );
     return {};
   }
   return bluechipTokensConfig;
 }
 function normalizeTokenId(tokenId, wrapNearContractId = "wrap.near") {
   if (!tokenId) {
-    logger.error("normalizeTokenId - Empty tokenId:", tokenId);
     return "";
   }
   let normalized = tokenId.replace(/^nep141:/, "");
   if (normalized === "near") {
     normalized = wrapNearContractId;
   }
-  if (!normalized) {
-    logger.error("normalizeTokenId - Result is empty:", {
-      tokenId,
-      normalized
-    });
-  }
   return normalized;
 }
 function isNearIntentsSupportedToken(token, bluechipTokens) {
@@ -134,9 +124,6 @@ function findBestBluechipToken(bluechipTokens, wrapNearContractId = "wrap.near")
     });
   }
   if (preferredTokens.length === 0) {
-    logger.warn(
-      "findBestBluechipToken - No preferred tokens found, using wrap.near"
-    );
     return {
       address: wrapNearContractId,
       symbol: "wNEAR",
@@ -144,7 +131,6 @@ function findBestBluechipToken(bluechipTokens, wrapNearContractId = "wrap.near")
       chain: "near"
     };
   }
-  logger.debug("findBestBluechipToken - Selected token:", preferredTokens[0]);
   return preferredTokens[0];
 }
 function convertSlippageToBasisPoints(slippage) {
@@ -198,10 +184,6 @@ function formatGasToTgas(gasInYoctoNEAR) {
     const tgasBigInt = gasBigInt / BigInt("1000000000000");
     return tgasBigInt.toString();
   } catch (error) {
-    logger.error("formatGasToTgas - Error formatting gas:", {
-      gasInYoctoNEAR,
-      error
-    });
     return "0";
   }
 }
@@ -247,6 +229,13 @@ function formatGasString(gas) {
   }
   return gasStr;
 }
+function selectBestQuote(quotes) {
+  return quotes.reduce((best, current) => {
+    const bestAmount = new Big3__default.default(best.quote.amountOut);
+    const currentAmount = new Big3__default.default(current.quote.amountOut);
+    return currentAmount.gt(bestAmount) ? current : best;
+  });
+}
 var NearSmartRouter = class {
   constructor(config) {
     this.findPathAdapter = config.findPathAdapter;
@@ -290,16 +279,6 @@ var NearSmartRouter = class {
         this.wrapNearContractId
       );
       if (!normalizedTokenIn || !normalizedTokenOut) {
-        logger.error("SmartRouter quote - Invalid token addresses:", {
-          tokenIn: {
-            original: tokenIn.address,
-            normalized: normalizedTokenIn
-          },
-          tokenOut: {
-            original: tokenOut.address,
-            normalized: normalizedTokenOut
-          }
-        });
         return {
           success: false,
           tokenIn: params.tokenIn,
@@ -308,18 +287,11 @@ var NearSmartRouter = class {
           amountOut: "0",
           minAmountOut: "0",
           routes: [],
-          error: `Invalid token address: tokenIn=${normalizedTokenIn || "empty"}, tokenOut=${normalizedTokenOut || "empty"}`
+          error: "Invalid token address"
         };
       }
       const slippageBps = convertSlippageToBasisPoints(slippage);
       const slippageDecimalForApi = slippageBps / 1e4;
-      logger.debug("SmartRouter quote - Calling findPath:", {
-        tokenIn: normalizedTokenIn,
-        tokenOut: normalizedTokenOut,
-        amountIn,
-        slippage: slippageDecimalForApi,
-        slippageBps
-      });
       const response = await this.findPathAdapter.findPath({
         tokenIn: normalizedTokenIn,
         tokenOut: normalizedTokenOut,
@@ -327,11 +299,6 @@ var NearSmartRouter = class {
         slippage: slippageDecimalForApi,
         supportLedger: false
       });
-      logger.debug("SmartRouter quote - findPath response:", {
-        result_code: response?.result_code,
-        result_msg: response?.result_msg || response?.result_message,
-        hasRoutes: !!response?.result_data?.routes?.length
-      });
       if (response?.result_code !== 0 || !response?.result_data?.routes?.length) {
         return {
           success: false,
@@ -345,7 +312,7 @@ var NearSmartRouter = class {
         };
       }
       const { routes: serverRoutes, amount_out } = response.result_data;
-      const slippageDecimal = new Big2__default.default(slippageBps).div(1e4);
+      const slippageDecimal = new Big3__default.default(slippageBps).div(1e4);
       const routes = serverRoutes.map((route) => ({
         pools: route.pools.map((pool) => ({
           pool_id: Number(pool.pool_id),
@@ -358,8 +325,8 @@ var NearSmartRouter = class {
         amountIn,
         amountOut: route.amount_out || amount_out || "0"
       }));
-      const amountOut = new Big2__default.default(amount_out || 0);
-      const minAmountOut = amountOut.mul(new Big2__default.default(1).minus(slippageDecimal)).toFixed(0, Big2__default.default.roundDown);
+      const amountOut = new Big3__default.default(amount_out || 0);
+      const minAmountOut = amountOut.mul(new Big3__default.default(1).minus(slippageDecimal)).toFixed(0, Big3__default.default.roundDown);
       return {
         success: true,
         tokenIn,
@@ -432,10 +399,6 @@ var NearSmartRouter = class {
           isRegistered = false;
         }
         if (!isRegistered) {
-          logger.debug("SmartRouter - Registering recipient account:", {
-            contractId: quote.tokenOut.address,
-            accountId: finalRecipient
-          });
           transactions.push({
             contractId: quote.tokenOut.address,
             methodName: "storage_deposit",
@@ -456,15 +419,6 @@ var NearSmartRouter = class {
       if (finalRecipient) {
         swapMsg.swap_out_recipient = finalRecipient;
       }
-      logger.debug("SmartRouter - Executing swap:", {
-        contractId: quote.tokenIn.address,
-        receiver_id: this.refExchangeId,
-        amount: quote.amountIn,
-        swapMsg,
-        swapActionsCount: swapActions.length,
-        recipient: finalRecipient,
-        tokenOut: quote.tokenOut?.address
-      });
       transactions.push({
         contractId: quote.tokenIn.address,
         methodName: "ft_transfer_call",
@@ -527,11 +481,7 @@ var AggregateDexRouter = class {
     this.configAdapter = config.configAdapter;
     this.aggregateDexContractId = this.configAdapter.getAggregateDexContractId?.() || "";
     this.wrapNearContractId = this.configAdapter.getWrapNearContractId();
-    if (!this.aggregateDexContractId) {
-      logger.error(
-        "AggregateDexRouter - AGGREGATE_DEX_CONTRACT_ID not configured"
-      );
-    }
+    if (!this.aggregateDexContractId) ;
   }
   /**
    * Get Router capabilities
@@ -561,15 +511,11 @@ var AggregateDexRouter = class {
           amountOut: "0",
           minAmountOut: "0",
           routes: [],
-          error: "V2 Router requires sender and recipient parameters"
+          error: "Missing sender or recipient"
         };
       }
       const { tokenIn, tokenOut, amountIn, slippage, sender, recipient } = params;
       if (!sender || !recipient) {
-        logger.error("AggregateDexRouter quote - Missing sender or recipient:", {
-          sender,
-          recipient
-        });
         return {
           success: false,
           tokenIn: params.tokenIn,
@@ -578,7 +524,7 @@ var AggregateDexRouter = class {
           amountOut: "0",
           minAmountOut: "0",
           routes: [],
-          error: `V2 Router requires non-empty sender and recipient. Got sender="${sender}", recipient="${recipient}"`
+          error: "Missing sender or recipient"
         };
       }
       if (!tokenIn?.address || !tokenOut?.address) {
@@ -602,16 +548,6 @@ var AggregateDexRouter = class {
         this.wrapNearContractId
       );
       if (!normalizedTokenIn || !normalizedTokenOut) {
-        logger.error("AggregateDexRouter quote - Invalid token addresses:", {
-          tokenIn: {
-            original: tokenIn.address,
-            normalized: normalizedTokenIn
-          },
-          tokenOut: {
-            original: tokenOut.address,
-            normalized: normalizedTokenOut
-          }
-        });
         return {
           success: false,
           tokenIn: params.tokenIn,
@@ -620,7 +556,7 @@ var AggregateDexRouter = class {
           amountOut: "0",
           minAmountOut: "0",
           routes: [],
-          error: `Invalid token address: tokenIn=${normalizedTokenIn || "empty"}, tokenOut=${normalizedTokenOut || "empty"}`
+          error: "Invalid token address"
         };
       }
       const slippageBps = convertSlippageToBasisPoints(slippage);
@@ -643,7 +579,7 @@ var AggregateDexRouter = class {
           amountOut: "0",
           minAmountOut: "0",
           routes: [],
-          error: response.result_message || "V2 Router API call failed"
+          error: "Failed to get quote"
         };
       }
       const {
@@ -671,7 +607,6 @@ var AggregateDexRouter = class {
         slippage
       };
     } catch (error) {
-      logger.error("AggregateDexRouter quote - Error:", error);
       return {
         success: false,
         tokenIn: params.tokenIn,
@@ -680,7 +615,7 @@ var AggregateDexRouter = class {
         amountOut: "0",
         minAmountOut: "0",
         routes: [],
-        error: error?.message || "Quote failed"
+        error: "Failed to get quote"
       };
     }
   }
@@ -696,65 +631,61 @@ var AggregateDexRouter = class {
       recipient: depositAddress
     });
   }
-  async reFetchQuoteWithBalance(quoteParams, actualBalance, context) {
-    const balanceBig = new Big2__default.default(actualBalance);
+  async reFetchQuoteWithBalance(quoteParams, actualBalance, _context) {
+    const balanceBig = new Big3__default.default(actualBalance);
     const adjustedParams = {
       ...quoteParams,
       amountIn: balanceBig.toFixed(0)
     };
-    logger.warn(`AggregateDexRouter - ${context}: re-fetching quote with actual balance:`, {
-      requestedAmount: quoteParams.amountIn,
-      actualBalance
-    });
     const adjustedQuote = await this.quote(adjustedParams);
     if (adjustedQuote.success && adjustedQuote.routerMsg && adjustedQuote.signature) {
       return adjustedQuote;
     } else {
-      throw new Error(`Failed to re-fetch quote with actual balance: ${adjustedQuote.error || "Unknown error"}`);
+      throw new Error("Failed to get quote");
     }
   }
   async ensureQuoteAmountWithinBalance(quoteParams, actualBalance, context) {
-    const requestedAmountBig = new Big2__default.default(quoteParams.amountIn);
-    const balanceBig = new Big2__default.default(actualBalance);
+    const requestedAmountBig = new Big3__default.default(quoteParams.amountIn);
+    const balanceBig = new Big3__default.default(actualBalance);
     const isNativeNear = (quoteParams.tokenIn.symbol === "NEAR" || quoteParams.tokenIn.address === "near" || !quoteParams.tokenIn.address && quoteParams.tokenIn.symbol === "NEAR") && quoteParams.tokenIn.address !== this.wrapNearContractId;
     let effectiveBalanceBig = balanceBig;
     let effectiveBalanceStr = actualBalance;
     if (isNativeNear) {
-      const reserveAmount = new Big2__default.default("50000000000000000000000");
+      const reserveAmount = new Big3__default.default("50000000000000000000000");
       if (balanceBig.gt(reserveAmount)) {
         effectiveBalanceBig = balanceBig.minus(reserveAmount);
         effectiveBalanceStr = effectiveBalanceBig.toFixed(0);
       } else {
-        effectiveBalanceBig = new Big2__default.default(0);
+        effectiveBalanceBig = new Big3__default.default(0);
         effectiveBalanceStr = "0";
       }
     }
     if (requestedAmountBig.gt(effectiveBalanceBig) && balanceBig.gt(0)) {
-      return await this.reFetchQuoteWithBalance(quoteParams, effectiveBalanceStr, `${context} (requested amount exceeds available balance${isNativeNear ? " minus gas reserve" : ""})`);
+      return await this.reFetchQuoteWithBalance(quoteParams, effectiveBalanceStr, context);
     }
     if (balanceBig.gt(0) && requestedAmountBig.lt(balanceBig)) {
       const diff = balanceBig.minus(requestedAmountBig);
       const diffPercent = diff.div(balanceBig).times(100);
       const isMaxSwap = diffPercent.lt(0.1) || diff.lt(1e3);
       if (isMaxSwap) {
-        return await this.reFetchQuoteWithBalance(quoteParams, effectiveBalanceStr, `${context} (MAX swap detected, using ${isNativeNear ? "balance minus gas reserve" : "actual balance"})`);
+        return await this.reFetchQuoteWithBalance(quoteParams, effectiveBalanceStr, context);
       }
     }
     const quote = await this.quote(quoteParams);
     if (!quote.success) {
-      throw new Error(`Failed to fetch quote: ${quote.error || "Unknown error"}`);
+      throw new Error("Failed to get quote");
     }
     if (quote.amountIn !== quoteParams.amountIn) {
-      const apiAmountBig = new Big2__default.default(quote.amountIn);
+      const apiAmountBig = new Big3__default.default(quote.amountIn);
       if (apiAmountBig.gt(effectiveBalanceBig) && balanceBig.gt(0)) {
-        return await this.reFetchQuoteWithBalance(quoteParams, effectiveBalanceStr, `${context} (API returned amount_in exceeds available balance)`);
+        return await this.reFetchQuoteWithBalance(quoteParams, effectiveBalanceStr, context);
       }
       if (apiAmountBig.lt(balanceBig) && balanceBig.gt(0)) {
         const diff = balanceBig.minus(apiAmountBig);
         const diffPercent = diff.div(balanceBig).times(100);
         const isMaxSwap = diffPercent.lt(0.1) || diff.lt(1e3);
         if (isMaxSwap) {
-          return await this.reFetchQuoteWithBalance(quoteParams, effectiveBalanceStr, `${context} (API returned amount_in close to balance, MAX swap detected)`);
+          return await this.reFetchQuoteWithBalance(quoteParams, effectiveBalanceStr, context);
         }
       }
     }
@@ -765,7 +696,7 @@ var AggregateDexRouter = class {
       if (!requiresRecipientInExecute(params)) {
         return {
           success: false,
-          error: "V2 Router requires sender and receiveUser parameters"
+          error: "Missing sender or receiveUser"
         };
       }
       const { quote, sender, receiveUser } = params;
@@ -778,13 +709,13 @@ var AggregateDexRouter = class {
       if (!receiveUser || receiveUser.trim() === "") {
         return {
           success: false,
-          error: "receiveUser (depositAddress) is required"
+          error: "Missing receiveUser"
         };
       }
       if (receiveUser.startsWith("0x") && receiveUser.length === 42) {
         return {
           success: false,
-          error: `receiveUser appears to be an EVM address (${receiveUser}). For NEAR chain swaps, depositAddress must be a NEAR account (64 hex chars or .near format)`
+          error: "Invalid receiveUser address"
         };
       }
       const slippage = quote.slippage || 5e-3;
@@ -814,10 +745,9 @@ var AggregateDexRouter = class {
           "Re-fetching quote with receiveUser"
         );
       } catch (error) {
-        logger.error("AggregateDexRouter - Failed to fetch quote with receiveUser:", error);
         return {
           success: false,
-          error: `Failed to fetch quote with receiveUser="${receiveUser}": ${error?.message || "Unknown error"}`
+          error: "Failed to get quote"
         };
       }
       const routerMsg = finalQuote.routerMsg;
@@ -825,7 +755,7 @@ var AggregateDexRouter = class {
       if (!routerMsg || !signature) {
         return {
           success: false,
-          error: `Quote fetched with receiveUser="${receiveUser}" is missing routerMsg or signature.`
+          error: "Failed to get quote"
         };
       }
       const tokens = finalQuote.tokens || [];
@@ -892,14 +822,7 @@ var AggregateDexRouter = class {
         const receiveUserStorageBalance = await getStorageBalance(
           finalQuote.tokenOut.address,
           receiveUser
-        ).catch((error) => {
-          logger.warn("AggregateDexRouter - Failed to check receiveUser storage balance:", {
-            receiveUser,
-            tokenOut: finalQuote.tokenOut.address,
-            error: error?.message
-          });
-          return null;
-        });
+        ).catch(() => null);
         if (!receiveUserStorageBalance) {
           transactions.push({
             contractId: finalQuote.tokenOut.address,
@@ -943,8 +866,8 @@ var AggregateDexRouter = class {
           (_, index) => !registeredStatus[index]
         );
         if (unregisteredTokens.length > 0) {
-          const depositPerToken = new Big2__default.default("0.005").mul(
-            new Big2__default.default("1000000000000000000000000")
+          const depositPerToken = new Big3__default.default("0.005").mul(
+            new Big3__default.default("1000000000000000000000000")
           );
           const totalDeposit = depositPerToken.mul(unregisteredTokens.length);
           transactions.push({
@@ -984,10 +907,9 @@ var AggregateDexRouter = class {
           "Final balance check before execution"
         );
       } catch (error) {
-        logger.error("AggregateDexRouter - Failed final balance check:", error);
         return {
           success: false,
-          error: `Failed final balance check: ${error?.message || "Unknown error"}`
+          error: "Failed to get quote"
         };
       }
       const finalAmountToTransfer = finalQuoteForExecution.amountIn;
@@ -1018,14 +940,13 @@ var AggregateDexRouter = class {
       } else {
         return {
           success: false,
-          error: result.message || "Execute swap failed"
+          error: "Execute swap failed"
         };
       }
     } catch (error) {
-      logger.error("AggregateDexRouter executeSwap - Error:", error);
       return {
         success: false,
-        error: error?.message || "Execute swap failed"
+        error: "Execute swap failed"
       };
     }
   }
@@ -1043,10 +964,6 @@ var AggregateDexRouter = class {
         }
       });
     } catch (error) {
-      logger.error(
-        "AggregateDexRouter - Failed to query user tokens registered:",
-        error
-      );
       return tokens.map(() => false);
     }
   }
@@ -1055,13 +972,15 @@ async function completeQuote(params, config) {
   const {
     sourceToken,
     targetToken,
-    sourceChain,
+    sourceChain: _sourceChain,
+    // Reserved for future use
     targetChain: _targetChain,
     // Reserved for future use
     amountIn,
     slippage,
     recipient,
-    refundTo
+    refundTo,
+    customRecipientMsg
   } = params;
   const {
     intentsQuotationAdapter,
@@ -1069,7 +988,8 @@ async function completeQuote(params, config) {
     dexRouter,
     bluechipTokens,
     configAdapter,
-    currentUserAddress
+    currentUserAddress,
+    isIntentsSupportedToken: customIsIntentsSupportedToken
   } = config;
   const wrapNearContractId = configAdapter.getWrapNearContractId();
   const routers = dexRouters || (dexRouter ? [dexRouter] : []);
@@ -1086,226 +1006,227 @@ async function completeQuote(params, config) {
   if (!targetToken?.address) {
     throw new Error("Target token address is required");
   }
-  const needsPreSwap = sourceChain === "near" && !isNearIntentsSupportedToken(sourceToken, bluechipTokens);
+  const isTokenIntentsSupported = customIsIntentsSupportedToken ? customIsIntentsSupportedToken(sourceToken) : isNearIntentsSupportedToken(sourceToken, bluechipTokens);
   const bluechipToken = findBestBluechipToken(
     bluechipTokens,
     wrapNearContractId
   );
   if (!bluechipToken?.address) {
-    logger.error("DEX Aggregator - Failed to find bluechip token:", {
-      bluechipToken,
-      bluechipTokens
-    });
     throw new Error("Failed to find bluechip token address");
   }
-  logger.debug("DEX Aggregator - Using bluechip token:", {
-    address: bluechipToken.address,
-    symbol: bluechipToken.symbol,
-    decimals: bluechipToken.decimals
-  });
-  let preSwapQuote = null;
-  let bestRouter = null;
-  if (needsPreSwap) {
-    if (!sourceToken?.address) {
-      throw new Error("Source token address is required");
-    }
-    logger.debug("DEX Aggregator - Pre-swap quote params:", {
-      tokenIn: {
-        address: sourceToken.address,
-        symbol: sourceToken.symbol
-      },
-      tokenOut: {
-        address: bluechipToken.address,
-        symbol: bluechipToken.symbol
-      },
+  const quotePaths = [];
+  routers.forEach((router, index) => {
+    const routeType = index === 0 ? "v1" : "v2";
+    const capabilities = router.getCapabilities();
+    const quoteParams = capabilities.requiresRecipient ? {
+      tokenIn: sourceToken,
+      tokenOut: bluechipToken,
       amountIn,
       slippage,
-      routersCount: routers.length,
-      userAddress
-    });
-    const quotes = await Promise.allSettled(
-      routers.map((router) => {
-        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"
-        };
-        return router.quote(quoteParams);
-      })
-    );
-    const validQuotes = quotes.filter(
-      (r) => r.status === "fulfilled" && r.value.success
-    ).map((r) => r.value);
-    if (validQuotes.length === 0) {
-      const errors = quotes.map((r, index) => {
-        if (r.status === "rejected") {
-          return `Router ${index}: ${r.reason}`;
+      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("Failed to get quote");
         }
-        if (r.status === "fulfilled" && !r.value.success) {
-          return `Router ${index}: ${r.value.error}`;
+        const bluechipKey = bluechipToken.symbol?.toUpperCase() === "WNEAR" ? "NEAR" : bluechipToken.symbol?.toUpperCase();
+        const bluechipTokenConfig = bluechipKey && bluechipTokens[bluechipKey] || void 0;
+        const normalizedSourceAsset = bluechipTokenConfig?.assetId ? bluechipTokenConfig.assetId : `nep141:${bluechipToken.address}`;
+        let normalizedTargetAsset = targetToken.address;
+        if (normalizedTargetAsset && !normalizedTargetAsset.startsWith("nep141:") && !normalizedTargetAsset.startsWith("nep245:") && normalizedTargetAsset.includes(".")) {
+          normalizedTargetAsset = `nep141:${normalizeTokenId(
+            normalizedTargetAsset,
+            wrapNearContractId
+          )}`;
         }
-        return null;
-      }).filter(Boolean);
-      logger.error("DEX Aggregator - All router quotes failed:", errors);
-      throw new Error(
-        `All router quotes failed: ${errors.join("; ")}`
-      );
-    }
-    const bestQuote = validQuotes.reduce((best, current) => {
-      const bestAmount = new Big2__default.default(best.amountOut);
-      const currentAmount = new Big2__default.default(current.amountOut);
-      return currentAmount.gt(bestAmount) ? current : best;
-    });
-    const bestQuoteIndex = validQuotes.indexOf(bestQuote);
-    bestRouter = routers[bestQuoteIndex];
-    preSwapQuote = bestQuote;
-    logger.debug("DEX Aggregator - Selected best router:", {
-      routerIndex: bestQuoteIndex,
-      amountOut: bestQuote.amountOut,
-      routerType: bestRouter.getCapabilities().requiresRecipient ? "V2 (Recipient)" : "V1 (Simple)"
+        normalizedTargetAsset = normalizeDestinationAsset(normalizedTargetAsset, wrapNearContractId) || normalizedTargetAsset;
+        const slippageBps = convertSlippageToBasisPoints(slippage);
+        const intentsQuote = await intentsQuotationAdapter.quote({
+          originAsset: normalizedSourceAsset,
+          destinationAsset: normalizedTargetAsset,
+          amount: preSwapQuote.amountOut,
+          refundTo: refundTo || recipient,
+          recipient,
+          slippageTolerance: slippageBps,
+          swapType: "FLEX_INPUT",
+          ...customRecipientMsg ? { customRecipientMsg } : {}
+        });
+        if (intentsQuote.quoteStatus !== "success") {
+          throw new Error("Failed to get quote");
+        }
+        return {
+          intentsQuote,
+          preSwapQuote,
+          router,
+          finalAmountOut: intentsQuote.quoteSuccessResult?.quote?.amountOut || "0"
+        };
+      })()
     });
-    const preSwapAmountOut = preSwapQuote.amountOut;
-    if (!preSwapAmountOut || new Big2__default.default(preSwapAmountOut).lte(0)) {
-      logger.error("DEX Aggregator - Pre-swap amountOut is invalid:", {
-        amountOut: preSwapAmountOut,
-        tokenIn: sourceToken,
-        tokenOut: bluechipToken
-      });
-      throw new Error(
-        "Pre-swap returned invalid amount: amount is too small or zero"
-      );
-    }
-    logger.debug("DEX Aggregator - Pre-swap quote success:", {
-      amountOut: preSwapAmountOut,
-      tokenOut: bluechipToken.symbol,
-      decimals: bluechipToken.decimals
+  });
+  if (isTokenIntentsSupported) {
+    quotePaths.push({
+      type: "intents",
+      promise: (async () => {
+        let normalizedSourceAsset;
+        if (sourceToken.symbol) {
+          const sourceKey = sourceToken.symbol.toUpperCase();
+          const sourceTokenConfig = bluechipTokens[sourceKey];
+          if (sourceTokenConfig?.assetId) {
+            normalizedSourceAsset = sourceTokenConfig.assetId;
+          } else {
+            normalizedSourceAsset = normalizeTokenId(
+              sourceToken.address,
+              wrapNearContractId
+            );
+            if (!normalizedSourceAsset.startsWith("nep141:")) {
+              normalizedSourceAsset = `nep141:${normalizedSourceAsset}`;
+            }
+          }
+        } else {
+          normalizedSourceAsset = normalizeTokenId(
+            sourceToken.address,
+            wrapNearContractId
+          );
+          if (!normalizedSourceAsset.startsWith("nep141:")) {
+            normalizedSourceAsset = `nep141:${normalizedSourceAsset}`;
+          }
+        }
+        let normalizedTargetAsset = targetToken.address;
+        if (normalizedTargetAsset && !normalizedTargetAsset.startsWith("nep141:") && !normalizedTargetAsset.startsWith("nep245:") && normalizedTargetAsset.includes(".")) {
+          normalizedTargetAsset = `nep141:${normalizeTokenId(
+            normalizedTargetAsset,
+            wrapNearContractId
+          )}`;
+        }
+        normalizedTargetAsset = normalizeDestinationAsset(normalizedTargetAsset, wrapNearContractId) || normalizedTargetAsset;
+        const slippageBps = convertSlippageToBasisPoints(slippage);
+        const intentsQuote = await intentsQuotationAdapter.quote({
+          originAsset: normalizedSourceAsset,
+          destinationAsset: normalizedTargetAsset,
+          amount: amountIn,
+          refundTo: refundTo || recipient,
+          recipient,
+          slippageTolerance: slippageBps,
+          swapType: "EXACT_INPUT",
+          ...customRecipientMsg ? { customRecipientMsg } : {}
+        });
+        if (intentsQuote.quoteStatus !== "success") {
+          throw new Error("Failed to get quote");
+        }
+        return {
+          intentsQuote,
+          finalAmountOut: intentsQuote.quoteSuccessResult?.quote?.amountOut || "0"
+        };
+      })()
     });
   }
-  let normalizedSourceAsset;
-  if (needsPreSwap) {
-    const bluechipKey = bluechipToken.symbol?.toUpperCase() === "WNEAR" ? "NEAR" : bluechipToken.symbol?.toUpperCase();
-    const bluechipTokenConfig = bluechipKey && bluechipTokens[bluechipKey] || void 0;
-    if (bluechipTokenConfig?.assetId) {
-      normalizedSourceAsset = bluechipTokenConfig.assetId;
-      logger.debug("Using bluechip token assetId for NearIntents:", {
-        symbol: bluechipToken.symbol,
-        assetId: normalizedSourceAsset,
-        contractAddress: bluechipToken.address
+  const pathResults = await Promise.allSettled(
+    quotePaths.map((p) => p.promise)
+  );
+  const validPaths = [];
+  pathResults.forEach((result, index) => {
+    const pathType = quotePaths[index].type;
+    if (result.status === "fulfilled") {
+      validPaths.push({
+        type: pathType,
+        ...result.value
       });
-    } else {
-      normalizedSourceAsset = `nep141:${bluechipToken.address}`;
-      logger.warn(
-        "Bluechip token assetId not found, using contractAddress with prefix:",
-        {
-          symbol: bluechipToken.symbol,
-          normalizedSourceAsset
-        }
-      );
-    }
-  } else {
-    if (sourceToken.symbol) {
-      const sourceKey = sourceToken.symbol.toUpperCase();
-      const sourceTokenConfig = bluechipTokens[sourceKey];
-      if (sourceTokenConfig?.assetId) {
-        normalizedSourceAsset = sourceTokenConfig.assetId;
-      } else {
-        normalizedSourceAsset = normalizeTokenId(
-          sourceToken.address,
-          wrapNearContractId
-        );
-        if (!normalizedSourceAsset.startsWith("nep141:")) {
-          normalizedSourceAsset = `nep141:${normalizedSourceAsset}`;
-        }
-      }
-    } else {
-      normalizedSourceAsset = normalizeTokenId(
-        sourceToken.address,
-        wrapNearContractId
-      );
-      if (!normalizedSourceAsset.startsWith("nep141:")) {
-        normalizedSourceAsset = `nep141:${normalizedSourceAsset}`;
-      }
     }
-  }
-  let normalizedTargetAsset = targetToken.address;
-  if (normalizedTargetAsset && !normalizedTargetAsset.startsWith("nep141:") && !normalizedTargetAsset.startsWith("nep245:") && normalizedTargetAsset.includes(".")) {
-    normalizedTargetAsset = `nep141:${normalizeTokenId(
-      normalizedTargetAsset,
-      wrapNearContractId
-    )}`;
-  }
-  normalizedTargetAsset = normalizeDestinationAsset(normalizedTargetAsset, wrapNearContractId) || normalizedTargetAsset;
-  const slippageBps = convertSlippageToBasisPoints(slippage);
-  const intentsAmount = needsPreSwap ? preSwapQuote.amountOut : amountIn;
-  logger.debug("DEX Aggregator - Calling NearIntents quotation:", {
-    originAsset: normalizedSourceAsset,
-    destinationAsset: normalizedTargetAsset,
-    amount: intentsAmount,
-    needsPreSwap,
-    preSwapAmountOut: needsPreSwap ? preSwapQuote.amountOut : void 0
-  });
-  const swapTypeForIntents = needsPreSwap ? "FLEX_INPUT" : void 0;
-  logger.debug("DEX Aggregator - swapType for NearIntents:", {
-    needsPreSwap,
-    swapType: swapTypeForIntents || "EXACT_INPUT (default)"
-  });
-  const intentsQuote = await intentsQuotationAdapter.quote({
-    originAsset: normalizedSourceAsset,
-    destinationAsset: normalizedTargetAsset,
-    amount: intentsAmount,
-    refundTo: refundTo || recipient,
-    recipient,
-    slippageTolerance: slippageBps,
-    swapType: swapTypeForIntents
   });
-  logger.debug("DEX Aggregator - NearIntents quotation result:", {
-    quoteStatus: intentsQuote.quoteStatus,
-    message: intentsQuote.message,
-    hasDepositAddress: !!intentsQuote.quoteSuccessResult?.quote?.depositAddress
-  });
-  if (intentsQuote.quoteStatus !== "success") {
-    const errorMessage = intentsQuote.message || "Unknown error";
-    logger.error("DEX Aggregator - NearIntents quote failed:", {
-      error: errorMessage,
-      originAsset: normalizedSourceAsset,
-      destinationAsset: normalizedTargetAsset,
-      amount: intentsAmount,
-      needsPreSwap,
-      preSwapAmountOut: needsPreSwap ? preSwapQuote.amountOut : void 0
-    });
-    throw new Error(`Intents quote failed: ${errorMessage}`);
+  if (validPaths.length === 0) {
+    throw new Error("Failed to get quote");
   }
-  const depositAddress = intentsQuote.quoteSuccessResult?.quote?.depositAddress || "";
+  const bestPath = validPaths.reduce((best, current) => {
+    const bestAmount = new Big3__default.default(best.finalAmountOut);
+    const currentAmount = new Big3__default.default(current.finalAmountOut);
+    return currentAmount.gt(bestAmount) ? current : best;
+  });
+  const depositAddress = bestPath.intentsQuote.quoteSuccessResult?.quote?.depositAddress || "";
   if (!depositAddress) {
     throw new Error("Deposit address not found in intents quote");
   }
-  const finalQuote = preSwapQuote;
   return {
     intents: {
-      quote: intentsQuote,
+      quote: bestPath.intentsQuote,
       depositAddress
     },
-    preSwap: needsPreSwap && finalQuote && bestRouter ? {
-      quote: finalQuote,
+    preSwap: bestPath.preSwapQuote && bestPath.router ? {
+      quote: bestPath.preSwapQuote,
       tokenIn: sourceToken,
       tokenOut: bluechipToken,
-      executor: bestRouter
+      executor: bestPath.router,
+      routeType: bestPath.type
     } : void 0,
-    finalAmountOut: intentsQuote.quoteSuccessResult?.quote?.amountOut || "0"
+    finalAmountOut: bestPath.finalAmountOut,
+    routeType: bestPath.type
   };
 }
 
+// src/integration/quoteSameChainSwap.ts
+async function quoteSameChainSwap(params, dexRouters) {
+  const {
+    tokenIn,
+    tokenOut,
+    amountIn,
+    slippage,
+    recipient,
+    currentUserAddress
+  } = params;
+  const quoteResults = await Promise.allSettled(
+    dexRouters.map((router) => {
+      const capabilities = router.getCapabilities();
+      const quoteParams = capabilities.requiresRecipient ? {
+        tokenIn,
+        tokenOut,
+        amountIn,
+        slippage,
+        swapType: "EXACT_INPUT",
+        sender: currentUserAddress,
+        recipient
+      } : {
+        tokenIn,
+        tokenOut,
+        amountIn,
+        slippage,
+        swapType: "EXACT_INPUT",
+        recipient
+      };
+      return router.quote(quoteParams);
+    })
+  );
+  const validQuotes = quoteResults.filter(
+    (r) => r.status === "fulfilled" && r.value.success
+  ).map((r, index) => ({
+    quote: r.value,
+    router: dexRouters[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);
+    throw new Error(`All router quotes failed: ${errors.join("; ")}`);
+  }
+  return selectBestQuote(validQuotes);
+}
+
 exports.AggregateDexRouter = AggregateDexRouter;
 exports.NearSmartRouter = NearSmartRouter;
 exports.completeQuote = completeQuote;
@@ -1318,8 +1239,10 @@ exports.isNearIntentsSupportedToken = isNearIntentsSupportedToken;
 exports.logger = logger;
 exports.normalizeDestinationAsset = normalizeDestinationAsset;
 exports.normalizeTokenId = normalizeTokenId;
+exports.quoteSameChainSwap = quoteSameChainSwap;
 exports.requiresRecipient = requiresRecipient;
 exports.requiresRecipientInExecute = requiresRecipientInExecute;
+exports.selectBestQuote = selectBestQuote;
 exports.setBluechipTokensConfig = setBluechipTokensConfig;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map