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

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) {
@@ -58,8 +58,6 @@ var logger = {
     }
   }
 };
-
-// src/utils/index.ts
 var bluechipTokensConfig = null;
 function setBluechipTokensConfig(config) {
   bluechipTokensConfig = config;
@@ -247,6 +245,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;
@@ -345,7 +350,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 +363,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,
@@ -697,7 +702,7 @@ var AggregateDexRouter = class {
     });
   }
   async reFetchQuoteWithBalance(quoteParams, actualBalance, context) {
-    const balanceBig = new Big2__default.default(actualBalance);
+    const balanceBig = new Big3__default.default(actualBalance);
     const adjustedParams = {
       ...quoteParams,
       amountIn: balanceBig.toFixed(0)
@@ -714,18 +719,18 @@ var AggregateDexRouter = class {
     }
   }
   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";
       }
     }
@@ -745,7 +750,7 @@ var AggregateDexRouter = class {
       throw new Error(`Failed to fetch quote: ${quote.error || "Unknown error"}`);
     }
     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)`);
       }
@@ -943,8 +948,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({
@@ -1055,7 +1060,8 @@ async function completeQuote(params, config) {
   const {
     sourceToken,
     targetToken,
-    sourceChain,
+    sourceChain: _sourceChain,
+    // Reserved for future use
     targetChain: _targetChain,
     // Reserved for future use
     amountIn,
@@ -1069,7 +1075,8 @@ async function completeQuote(params, config) {
     dexRouter,
     bluechipTokens,
     configAdapter,
-    currentUserAddress
+    currentUserAddress,
+    isIntentsSupportedToken: customIsIntentsSupportedToken
   } = config;
   const wrapNearContractId = configAdapter.getWrapNearContractId();
   const routers = dexRouters || (dexRouter ? [dexRouter] : []);
@@ -1086,7 +1093,7 @@ 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
@@ -1098,214 +1105,241 @@ async function completeQuote(params, config) {
     });
     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(
+            `${routeType} pre-swap failed: ${preSwapQuote.error}`
+          );
         }
-        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"
+        });
+        if (intentsQuote.quoteStatus !== "success") {
+          throw new Error(
+            `${routeType} Intents quote failed: ${intentsQuote.message}`
+          );
+        }
+        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"
+        });
+        if (intentsQuote.quoteStatus !== "success") {
+          throw new Error(
+            `Direct Intents quote failed: ${intentsQuote.message}`
+          );
+        }
+        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}`;
-      }
+      logger.warn(`Path ${pathType} failed:`, result.reason);
     }
-  }
-  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("Cross-chain Quote Comparison:", {
+    paths: validPaths.map((p) => ({
+      type: p.type.toUpperCase(),
+      finalAmountOut: p.finalAmountOut
+    }))
   });
-  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) {
+    const errors = pathResults.map((r, index) => {
+      const pathType = quotePaths[index].type;
+      if (r.status === "rejected") {
+        return `${pathType}: ${r.reason}`;
+      }
+      return null;
+    }).filter(Boolean);
+    throw new Error(`All quote paths failed: ${errors.join("; ")}`);
   }
-  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;
+  });
+  logger.debug(
+    `\u2713 Selected best path: [${bestPath.type.toUpperCase()}] with finalAmountOut: ${bestPath.finalAmountOut}`
+  );
+  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 +1352,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