@rhea-finance/cross-chain-aggregation-dex 0.1.1

package/dist/index.mjs

@@ -0,0 +1,1275 @@
+import Big2 from 'big.js';
+
+// src/types/index.ts
+function requiresRecipient(params) {
+  return "sender" in params && "recipient" in params;
+}
+function requiresRecipientInExecute(params) {
+  return "sender" in params && "receiveUser" in params;
+}
+
+// src/utils/logger.ts
+var LOG_LEVELS = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4
+};
+function getLogLevel() {
+  if (typeof process !== "undefined" && process.env?.LOG_LEVEL) {
+    const level = process.env.LOG_LEVEL.toLowerCase();
+    if (LOG_LEVELS[level] !== void 0) {
+      return level;
+    }
+  }
+  return typeof process !== "undefined" && process.env?.NODE_ENV === "production" ? "warn" : "debug";
+}
+var currentLogLevel = getLogLevel();
+var currentLevelValue = LOG_LEVELS[currentLogLevel];
+function shouldLog(level) {
+  return LOG_LEVELS[level] <= currentLevelValue;
+}
+var logger = {
+  debug: (...args) => {
+    if (shouldLog("debug")) {
+      console.debug(...args);
+    }
+  },
+  info: (...args) => {
+    if (shouldLog("info")) {
+      console.info(...args);
+    }
+  },
+  warn: (...args) => {
+    if (shouldLog("warn")) {
+      console.warn(...args);
+    }
+  },
+  error: (...args) => {
+    if (shouldLog("error")) {
+      console.error(...args);
+    }
+  }
+};
+
+// src/utils/index.ts
+var bluechipTokensConfig = null;
+function setBluechipTokensConfig(config) {
+  bluechipTokensConfig = 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) {
+  if (!token?.symbol || !token?.address) {
+    return false;
+  }
+  const config = bluechipTokens || getBluechipTokensConfig();
+  const normalizedSymbol = token.symbol.toUpperCase();
+  const symbolKey = normalizedSymbol === "NEAR" || normalizedSymbol === "WNEAR" ? "NEAR" : normalizedSymbol;
+  const tokenConfig = config[symbolKey];
+  if (!tokenConfig) {
+    return false;
+  }
+  const normalizeAddress = (addr) => addr.replace(/^nep141:/, "").toLowerCase();
+  const tokenAddress = normalizeAddress(token.address);
+  const configAddress = normalizeAddress(tokenConfig.address || "");
+  const configAssetId = tokenConfig.assetId ? normalizeAddress(tokenConfig.assetId) : "";
+  return tokenAddress === configAddress || tokenAddress === configAssetId;
+}
+function findBestBluechipToken(bluechipTokens, wrapNearContractId = "wrap.near") {
+  const preferredTokens = [];
+  if (bluechipTokens.USDT?.address) {
+    preferredTokens.push({
+      address: bluechipTokens.USDT.address,
+      symbol: "USDT",
+      decimals: bluechipTokens.USDT.decimals || 6,
+      chain: "near"
+    });
+  }
+  if (bluechipTokens.USDC?.address) {
+    preferredTokens.push({
+      address: bluechipTokens.USDC.address,
+      symbol: "USDC",
+      decimals: bluechipTokens.USDC.decimals || 6,
+      chain: "near"
+    });
+  }
+  if (bluechipTokens.NEAR?.address) {
+    preferredTokens.push({
+      address: bluechipTokens.NEAR.address,
+      symbol: "wNEAR",
+      decimals: bluechipTokens.NEAR.decimals || 24,
+      chain: "near"
+    });
+  }
+  if (preferredTokens.length === 0) {
+    logger.warn(
+      "findBestBluechipToken - No preferred tokens found, using wrap.near"
+    );
+    return {
+      address: wrapNearContractId,
+      symbol: "wNEAR",
+      decimals: 24,
+      chain: "near"
+    };
+  }
+  logger.debug("findBestBluechipToken - Selected token:", preferredTokens[0]);
+  return preferredTokens[0];
+}
+function convertSlippageToBasisPoints(slippage) {
+  if (slippage >= 1) {
+    return Math.round(slippage);
+  }
+  if (slippage > 0 && slippage < 0.01) {
+    return Math.round(slippage * 1e4);
+  }
+  if (slippage >= 0.01 && slippage < 1) {
+    return Math.round(slippage * 100);
+  }
+  return Math.round(slippage);
+}
+function normalizeDestinationAsset(assetId, wrapNearContractId = "wrap.near") {
+  if (!assetId) return assetId;
+  if (assetId.startsWith("nep141:") || assetId.startsWith("nep245:")) {
+    return assetId;
+  }
+  if (assetId === "near" || assetId === "nep141:near") {
+    return `nep141:${wrapNearContractId}`;
+  }
+  if (assetId.includes(".")) {
+    return `nep141:${normalizeTokenId(assetId, wrapNearContractId)}`;
+  }
+  return assetId;
+}
+function formatGasToTgas(gasInYoctoNEAR) {
+  if (!gasInYoctoNEAR) return "0";
+  const gasStr = String(gasInYoctoNEAR);
+  if (/[eE]/.test(gasStr)) {
+    const match = gasStr.match(/^([+-]?\d*\.?\d+)[eE]([+-]?\d+)$/);
+    if (match) {
+      const base = match[1];
+      const exponent = parseInt(match[2], 10);
+      const [intPart, fracPart = ""] = base.split(".");
+      if (exponent > 0) {
+        const newIntPart = intPart + fracPart;
+        const zerosToAdd = exponent - fracPart.length;
+        if (zerosToAdd > 0) {
+          return (newIntPart + "0".repeat(zerosToAdd)).replace(/^0+/, "") || "0";
+        } else {
+          const pointPos = intPart.length + exponent;
+          return (newIntPart.slice(0, pointPos) + "." + newIntPart.slice(pointPos)).replace(/\.?0+$/, "");
+        }
+      }
+    }
+  }
+  try {
+    const gasBigInt = BigInt(gasStr.split(".")[0]);
+    const tgasBigInt = gasBigInt / BigInt("1000000000000");
+    return tgasBigInt.toString();
+  } catch (error) {
+    logger.error("formatGasToTgas - Error formatting gas:", {
+      gasInYoctoNEAR,
+      error
+    });
+    return "0";
+  }
+}
+function formatGasString(gas) {
+  if (typeof gas === "bigint") {
+    return gas.toString();
+  }
+  const gasStr = String(gas);
+  if (!/[eE]/.test(gasStr) && !gasStr.includes(".")) {
+    return gasStr;
+  }
+  if (/[eE]/.test(gasStr)) {
+    const match = gasStr.match(/^([+-]?\d*\.?\d+)[eE]([+-]?\d+)$/);
+    if (match) {
+      const base = match[1];
+      const exponent = parseInt(match[2], 10);
+      const [intPart, fracPart = ""] = base.split(".");
+      if (exponent > 0) {
+        const newIntPart = intPart + fracPart;
+        const zerosToAdd = exponent - fracPart.length;
+        if (zerosToAdd > 0) {
+          return (newIntPart + "0".repeat(zerosToAdd)).replace(/^0+/, "") || "0";
+        } else {
+          const pointPos = intPart.length + exponent;
+          const result = newIntPart.slice(0, pointPos) + "." + newIntPart.slice(pointPos);
+          return result.replace(/\.?0+$/, "").replace(/\.$/, "");
+        }
+      } else if (exponent < 0) {
+        const absExp = Math.abs(exponent);
+        const zerosToAdd = absExp - intPart.length;
+        if (zerosToAdd > 0) {
+          return "0." + "0".repeat(zerosToAdd - 1) + intPart.replace(/^-/, "") + fracPart;
+        } else {
+          const pointPos = intPart.length - absExp;
+          return intPart.slice(0, pointPos) + "." + intPart.slice(pointPos) + fracPart;
+        }
+      }
+    }
+  }
+  if (gasStr.includes(".")) {
+    const [intPart, fracPart = ""] = gasStr.split(".");
+    return intPart + fracPart;
+  }
+  return gasStr;
+}
+var NearSmartRouter = class {
+  constructor(config) {
+    this.findPathAdapter = config.findPathAdapter;
+    this.nearChainAdapter = config.nearChainAdapter;
+    this.configAdapter = config.configAdapter;
+    this.wrapNearContractId = this.configAdapter.getWrapNearContractId();
+    this.refExchangeId = this.configAdapter.getRefExchangeId();
+    this.tokenStorageDepositRead = this.configAdapter.getTokenStorageDepositRead?.() || "1250000000000000000000";
+  }
+  /**
+   * Get a swap quote (normalizes token ids and queries FindPath for routes).
+   */
+  async quote(params) {
+    try {
+      const {
+        tokenIn,
+        tokenOut,
+        amountIn,
+        slippage,
+        swapType: _swapType = "EXACT_INPUT"
+        // Currently not used, reserved for future use
+      } = params;
+      if (!tokenIn?.address || !tokenOut?.address) {
+        return {
+          success: false,
+          tokenIn: params.tokenIn,
+          tokenOut: params.tokenOut,
+          amountIn: params.amountIn,
+          amountOut: "0",
+          minAmountOut: "0",
+          routes: [],
+          error: "Missing token address"
+        };
+      }
+      const normalizedTokenIn = normalizeTokenId(
+        tokenIn.address,
+        this.wrapNearContractId
+      );
+      const normalizedTokenOut = normalizeTokenId(
+        tokenOut.address,
+        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,
+          tokenOut: params.tokenOut,
+          amountIn: params.amountIn,
+          amountOut: "0",
+          minAmountOut: "0",
+          routes: [],
+          error: `Invalid token address: tokenIn=${normalizedTokenIn || "empty"}, tokenOut=${normalizedTokenOut || "empty"}`
+        };
+      }
+      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,
+        amountIn: String(amountIn),
+        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,
+          tokenIn,
+          tokenOut,
+          amountIn,
+          amountOut: "0",
+          minAmountOut: "0",
+          routes: [],
+          error: response?.result_msg || response?.result_message || "No route found"
+        };
+      }
+      const { routes: serverRoutes, amount_out } = response.result_data;
+      const slippageDecimal = new Big2(slippageBps).div(1e4);
+      const routes = serverRoutes.map((route) => ({
+        pools: route.pools.map((pool) => ({
+          pool_id: Number(pool.pool_id),
+          token_in: pool.token_in || normalizedTokenIn,
+          token_out: pool.token_out || normalizedTokenOut,
+          amount_in: pool.amount_in,
+          amount_out: pool.amount_out,
+          fee: pool.fee
+        })),
+        amountIn,
+        amountOut: route.amount_out || amount_out || "0"
+      }));
+      const amountOut = new Big2(amount_out || 0);
+      const minAmountOut = amountOut.mul(new Big2(1).minus(slippageDecimal)).toFixed(0, Big2.roundDown);
+      return {
+        success: true,
+        tokenIn,
+        tokenOut,
+        amountIn,
+        amountOut: amountOut.toFixed(0),
+        minAmountOut,
+        routes,
+        // Save raw serverRoutes data for executeSwap
+        rawRoutes: serverRoutes
+      };
+    } catch (error) {
+      return {
+        success: false,
+        tokenIn: params.tokenIn,
+        tokenOut: params.tokenOut,
+        amountIn: params.amountIn,
+        amountOut: "0",
+        minAmountOut: "0",
+        routes: [],
+        error: error?.message || "Quote failed"
+      };
+    }
+  }
+  /**
+   * Execute a swap: optionally adds `storage_deposit` for the recipient, then calls REF via `ft_transfer_call`.
+   */
+  async executeSwap(params) {
+    try {
+      const { quote, recipient, depositAddress } = params;
+      if (!quote.success || !quote.routes.length) {
+        return {
+          success: false,
+          error: "Invalid quote"
+        };
+      }
+      const swapActions = [];
+      const routesToUse = quote.rawRoutes || quote.routes;
+      routesToUse.forEach((route) => {
+        const pools = route.pools || [];
+        pools.forEach((pool) => {
+          const poolCopy = { ...pool };
+          if (+(poolCopy?.amount_in || 0) == 0) {
+            delete poolCopy.amount_in;
+          }
+          poolCopy.pool_id = Number(poolCopy.pool_id);
+          swapActions.push(poolCopy);
+        });
+      });
+      if (!swapActions.length) {
+        return {
+          success: false,
+          error: "No swap actions"
+        };
+      }
+      const finalRecipient = depositAddress || recipient;
+      const transactions = [];
+      if (finalRecipient && quote.tokenOut?.address) {
+        let isRegistered = false;
+        try {
+          const storageBalance = await this.nearChainAdapter.view({
+            contractId: quote.tokenOut.address,
+            methodName: "storage_balance_of",
+            args: {
+              account_id: finalRecipient
+            }
+          });
+          isRegistered = !!storageBalance;
+        } catch (err) {
+          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",
+            args: {
+              account_id: finalRecipient,
+              registration_only: true
+            },
+            gas: "50",
+            expandDeposit: this.tokenStorageDepositRead
+          });
+        }
+      }
+      const swapMsg = {
+        force: 0,
+        actions: swapActions,
+        skip_unwrap_near: false
+      };
+      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",
+        args: {
+          receiver_id: this.refExchangeId,
+          amount: quote.amountIn,
+          msg: JSON.stringify(swapMsg)
+        },
+        gas: "250",
+        // NEP-141 requires attaching 1 yoctoNEAR for certain calls.
+        expandDeposit: "1"
+      });
+      const result = await this.nearChainAdapter.call({
+        transactions
+      });
+      if (result.status === "success") {
+        return {
+          success: true,
+          txHash: result.txHash,
+          txHashArray: result.txHashArr || (result.txHash ? [result.txHash] : [])
+        };
+      } else {
+        return {
+          success: false,
+          error: result.message || "Execute swap failed"
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error?.message || "Execute swap failed"
+      };
+    }
+  }
+  /**
+   * Get Router capabilities
+   */
+  getCapabilities() {
+    return {
+      requiresRecipient: false,
+      requiresFinalizeQuote: false,
+      requiresComplexRegistration: false,
+      supportedChain: "near"
+    };
+  }
+  /**
+   * Get supported chain
+   */
+  getSupportedChain() {
+    return "near";
+  }
+};
+var AggregateDexRouter = class {
+  constructor(config) {
+    this.NEW_ACCOUNT_STORAGE_COST = "1250000000000000000000";
+    // 0.00125 NEAR in yoctoNEAR
+    this.ONE_YOCTO_NEAR = "1";
+    this.swapMultiDexPathAdapter = config.swapMultiDexPathAdapter;
+    this.nearChainAdapter = config.nearChainAdapter;
+    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"
+      );
+    }
+  }
+  /**
+   * Get Router capabilities
+   */
+  getCapabilities() {
+    return {
+      requiresRecipient: true,
+      requiresFinalizeQuote: false,
+      requiresComplexRegistration: true,
+      supportedChain: "near"
+    };
+  }
+  getSupportedChain() {
+    return "near";
+  }
+  /**
+   * Get a swap quote from V2 Router API
+   */
+  async quote(params) {
+    try {
+      if (!requiresRecipient(params)) {
+        return {
+          success: false,
+          tokenIn: params.tokenIn,
+          tokenOut: params.tokenOut,
+          amountIn: params.amountIn,
+          amountOut: "0",
+          minAmountOut: "0",
+          routes: [],
+          error: "V2 Router requires sender and recipient parameters"
+        };
+      }
+      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,
+          tokenOut: params.tokenOut,
+          amountIn: params.amountIn,
+          amountOut: "0",
+          minAmountOut: "0",
+          routes: [],
+          error: `V2 Router requires non-empty sender and recipient. Got sender="${sender}", recipient="${recipient}"`
+        };
+      }
+      if (!tokenIn?.address || !tokenOut?.address) {
+        return {
+          success: false,
+          tokenIn: params.tokenIn,
+          tokenOut: params.tokenOut,
+          amountIn: params.amountIn,
+          amountOut: "0",
+          minAmountOut: "0",
+          routes: [],
+          error: "Missing token address"
+        };
+      }
+      const normalizedTokenIn = normalizeTokenId(
+        tokenIn.address,
+        this.wrapNearContractId
+      );
+      const normalizedTokenOut = normalizeTokenId(
+        tokenOut.address,
+        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,
+          tokenOut: params.tokenOut,
+          amountIn: params.amountIn,
+          amountOut: "0",
+          minAmountOut: "0",
+          routes: [],
+          error: `Invalid token address: tokenIn=${normalizedTokenIn || "empty"}, tokenOut=${normalizedTokenOut || "empty"}`
+        };
+      }
+      const slippageBps = convertSlippageToBasisPoints(slippage);
+      const slippageDecimalForApi = slippageBps / 1e4;
+      logger.debug("AggregateDexRouter quote - Calling swapMultiDexPath:", {
+        tokenIn: normalizedTokenIn,
+        tokenOut: normalizedTokenOut,
+        amountIn,
+        slippage: slippageDecimalForApi,
+        sender,
+        recipient
+      });
+      const response = await this.swapMultiDexPathAdapter.swapMultiDexPath({
+        amountIn: String(amountIn),
+        tokenIn: normalizedTokenIn,
+        tokenOut: normalizedTokenOut,
+        slippage: slippageDecimalForApi,
+        pathDeep: 2,
+        user: sender,
+        receiveUser: recipient
+      });
+      logger.debug("AggregateDexRouter quote - swapMultiDexPath response:", {
+        result_code: response?.result_code,
+        result_message: response?.result_message,
+        hasData: !!response?.result_data
+      });
+      if (response.result_code !== 0 || !response.result_data) {
+        return {
+          success: false,
+          tokenIn,
+          tokenOut,
+          amountIn,
+          amountOut: "0",
+          minAmountOut: "0",
+          routes: [],
+          error: response.result_message || "V2 Router API call failed"
+        };
+      }
+      const {
+        amount_in,
+        amount_out,
+        min_amount_out,
+        msg,
+        signature,
+        tokens,
+        dexs
+      } = response.result_data;
+      return {
+        success: true,
+        tokenIn,
+        tokenOut,
+        amountIn: amount_in || amountIn,
+        amountOut: amount_out || "0",
+        minAmountOut: min_amount_out || "0",
+        routes: [],
+        routerMsg: msg,
+        signature,
+        tokens: tokens || [],
+        dexs: dexs || [],
+        recipient,
+        slippage
+      };
+    } catch (error) {
+      logger.error("AggregateDexRouter quote - Error:", error);
+      return {
+        success: false,
+        tokenIn: params.tokenIn,
+        tokenOut: params.tokenOut,
+        amountIn: params.amountIn,
+        amountOut: "0",
+        minAmountOut: "0",
+        routes: [],
+        error: error?.message || "Quote failed"
+      };
+    }
+  }
+  /**
+   * Finalize quote with depositAddress (deprecated)
+   * 
+   * @deprecated No longer needed. executeSwap automatically fetches final quote using receiveUser (depositAddress).
+   * Kept for interface compatibility only.
+   */
+  async finalizeQuote(params, depositAddress) {
+    if (!requiresRecipient(params)) {
+      throw new Error("V2 Router requires recipient parameters");
+    }
+    return await this.quote({
+      ...params,
+      recipient: depositAddress
+    });
+  }
+  /**
+   * Execute swap with V2 Router
+   * Automatically fetches final quote using receiveUser (depositAddress) to ensure correct routerMsg and signature.
+   */
+  async executeSwap(params) {
+    try {
+      if (!requiresRecipientInExecute(params)) {
+        return {
+          success: false,
+          error: "V2 Router requires sender and receiveUser parameters"
+        };
+      }
+      const { quote, sender, receiveUser } = params;
+      if (!quote.success) {
+        return {
+          success: false,
+          error: "Invalid quote"
+        };
+      }
+      if (!receiveUser || receiveUser.trim() === "") {
+        return {
+          success: false,
+          error: "receiveUser (depositAddress) is required"
+        };
+      }
+      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)`
+        };
+      }
+      logger.debug("AggregateDexRouter - executeSwap params:", {
+        sender,
+        receiveUser,
+        tokenIn: quote.tokenIn.address,
+        tokenOut: quote.tokenOut.address,
+        amountIn: quote.amountIn,
+        tokens: quote.tokens,
+        dexs: quote.dexs
+      });
+      const slippage = quote.slippage || 5e-3;
+      const finalQuoteParams = {
+        tokenIn: quote.tokenIn,
+        tokenOut: quote.tokenOut,
+        amountIn: quote.amountIn,
+        slippage,
+        sender,
+        recipient: receiveUser
+      };
+      let finalQuote;
+      try {
+        finalQuote = await this.quote(finalQuoteParams);
+        if (!finalQuote.success) {
+          return {
+            success: false,
+            error: `Failed to fetch quote with receiveUser="${receiveUser}": ${finalQuote.error}`
+          };
+        }
+      } 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"}`
+        };
+      }
+      const routerMsg = finalQuote.routerMsg;
+      const signature = finalQuote.signature;
+      if (!routerMsg || !signature) {
+        return {
+          success: false,
+          error: `Quote fetched with receiveUser="${receiveUser}" is missing routerMsg or signature.`
+        };
+      }
+      logger.debug("AggregateDexRouter - Successfully fetched final quote:", {
+        receiveUser,
+        quoteRecipient: finalQuote.recipient,
+        routerMsgLength: routerMsg.length,
+        signatureLength: signature.length
+      });
+      const tokens = finalQuote.tokens || [];
+      const dexs = finalQuote.dexs || [];
+      const transactions = [];
+      const getStorageBalance = async (tokenId, accountId) => {
+        try {
+          return await this.nearChainAdapter.view({
+            contractId: tokenId,
+            methodName: "storage_balance_of",
+            args: { account_id: accountId }
+          });
+        } catch (error) {
+          return null;
+        }
+      };
+      const isNativeNear = finalQuote.tokenIn.symbol === "NEAR" || finalQuote.tokenIn.address === "near" || !finalQuote.tokenIn.address && finalQuote.tokenIn.symbol === "NEAR";
+      if (isNativeNear) {
+        const wrapNearStorageBalance = await getStorageBalance(
+          this.wrapNearContractId,
+          sender
+        ).catch(() => null);
+        if (!wrapNearStorageBalance) {
+          transactions.push({
+            contractId: this.wrapNearContractId,
+            methodName: "storage_deposit",
+            args: {
+              account_id: sender,
+              registration_only: true
+            },
+            gas: "50000000000000",
+            expandDeposit: this.NEW_ACCOUNT_STORAGE_COST
+          });
+        }
+        transactions.push({
+          contractId: this.wrapNearContractId,
+          methodName: "near_deposit",
+          args: {},
+          gas: "50000000000000",
+          expandDeposit: finalQuote.amountIn
+        });
+      }
+      const tokensToCheck = dexs.length > 1 ? tokens : [finalQuote.tokenOut.address];
+      const tokenStorageBalances = await Promise.all(
+        tokensToCheck.map(
+          (tokenId) => getStorageBalance(tokenId, sender).catch(() => null)
+        )
+      );
+      tokensToCheck.forEach((tokenId, index) => {
+        if (!tokenStorageBalances[index]) {
+          transactions.push({
+            contractId: tokenId,
+            methodName: "storage_deposit",
+            args: {
+              account_id: sender,
+              registration_only: true
+            },
+            gas: "50000000000000",
+            expandDeposit: this.NEW_ACCOUNT_STORAGE_COST
+          });
+        }
+      });
+      if (receiveUser && receiveUser !== sender) {
+        logger.debug("AggregateDexRouter - Checking receiveUser registration in tokenOut:", {
+          receiveUser,
+          tokenOut: finalQuote.tokenOut.address,
+          tokenOutSymbol: finalQuote.tokenOut.symbol
+        });
+        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;
+        });
+        if (!receiveUserStorageBalance) {
+          logger.debug("AggregateDexRouter - receiveUser not registered in tokenOut, adding registration transaction:", {
+            receiveUser,
+            tokenOut: finalQuote.tokenOut.address,
+            tokenOutSymbol: finalQuote.tokenOut.symbol,
+            storageCost: this.NEW_ACCOUNT_STORAGE_COST
+          });
+          transactions.push({
+            contractId: finalQuote.tokenOut.address,
+            methodName: "storage_deposit",
+            args: {
+              account_id: receiveUser,
+              registration_only: true
+            },
+            gas: "50000000000000",
+            expandDeposit: this.NEW_ACCOUNT_STORAGE_COST
+          });
+        }
+      }
+      const aggregateDexStorageBalances = await Promise.all(
+        tokens.map(
+          (tokenId) => getStorageBalance(tokenId, this.aggregateDexContractId).catch(
+            () => null
+          )
+        )
+      );
+      tokens.forEach((tokenId, index) => {
+        if (!aggregateDexStorageBalances[index]) {
+          transactions.push({
+            contractId: tokenId,
+            methodName: "storage_deposit",
+            args: {
+              account_id: this.aggregateDexContractId,
+              registration_only: true
+            },
+            gas: "50000000000000",
+            expandDeposit: this.NEW_ACCOUNT_STORAGE_COST
+          });
+        }
+      });
+      if (tokens.length > 0) {
+        const registeredStatus = await this.queryUserTokensRegistered({
+          user: sender,
+          tokens
+        });
+        const unregisteredTokens = tokens.filter(
+          (_, index) => !registeredStatus[index]
+        );
+        if (unregisteredTokens.length > 0) {
+          const depositPerToken = new Big2("0.005").mul(
+            new Big2("1000000000000000000000000")
+          );
+          const totalDeposit2 = depositPerToken.mul(unregisteredTokens.length);
+          transactions.push({
+            contractId: this.aggregateDexContractId,
+            methodName: "tokens_storage_deposit",
+            args: {
+              user: sender,
+              tokens: unregisteredTokens
+            },
+            gas: "30000000000000",
+            expandDeposit: totalDeposit2.toFixed(0)
+          });
+        }
+      }
+      const msgString = JSON.stringify({
+        msg: routerMsg,
+        signature
+      });
+      transactions.push({
+        contractId: finalQuote.tokenIn.address,
+        methodName: "ft_transfer_call",
+        args: {
+          receiver_id: this.aggregateDexContractId,
+          amount: finalQuote.amountIn,
+          msg: msgString
+        },
+        gas: "300000000000000",
+        expandDeposit: this.ONE_YOCTO_NEAR
+      });
+      const totalDeposit = transactions.reduce((sum, tx) => {
+        if (tx.expandDeposit) {
+          return sum.plus(tx.expandDeposit);
+        }
+        return sum;
+      }, new Big2(0));
+      logger.debug("AggregateDexRouter - Executing swap (following mature codebase logic):", {
+        contractId: finalQuote.tokenIn.address,
+        receiver_id: this.aggregateDexContractId,
+        amount: finalQuote.amountIn,
+        transactionsCount: transactions.length,
+        sender,
+        receiveUser,
+        tokens: tokens.length,
+        dexs: dexs.length,
+        totalDepositYocto: totalDeposit.toFixed(0),
+        totalDepositNEAR: totalDeposit.div(new Big2("1000000000000000000000000")).toFixed(6),
+        transactions: transactions.map((tx, idx) => ({
+          index: idx,
+          contractId: tx.contractId,
+          methodName: tx.methodName,
+          expandDeposit: tx.expandDeposit,
+          expandDepositNEAR: tx.expandDeposit ? new Big2(tx.expandDeposit).div(new Big2("1000000000000000000000000")).toFixed(6) : "0"
+        }))
+      });
+      const result = await this.nearChainAdapter.call({
+        transactions
+      });
+      if (result.status === "success") {
+        return {
+          success: true,
+          txHash: result.txHash,
+          txHashArray: result.txHashArr || (result.txHash ? [result.txHash] : [])
+        };
+      } else {
+        return {
+          success: false,
+          error: result.message || "Execute swap failed"
+        };
+      }
+    } catch (error) {
+      logger.error("AggregateDexRouter executeSwap - Error:", error);
+      return {
+        success: false,
+        error: error?.message || "Execute swap failed"
+      };
+    }
+  }
+  /**
+   * Query user token registration status in AGGREGATE_DEX contract
+   */
+  async queryUserTokensRegistered({
+    user,
+    tokens
+  }) {
+    try {
+      return await this.nearChainAdapter.view({
+        contractId: this.aggregateDexContractId,
+        methodName: "query_user_tokens_registered",
+        args: {
+          user,
+          tokens
+        }
+      });
+    } catch (error) {
+      logger.error(
+        "AggregateDexRouter - Failed to query user tokens registered:",
+        error
+      );
+      return tokens.map(() => false);
+    }
+  }
+};
+async function completeQuote(params, config) {
+  const {
+    sourceToken,
+    targetToken,
+    sourceChain,
+    targetChain: _targetChain,
+    // Reserved for future use
+    amountIn,
+    slippage,
+    recipient,
+    refundTo
+  } = params;
+  const {
+    intentsQuotationAdapter,
+    dexRouters,
+    dexRouter,
+    bluechipTokens,
+    configAdapter,
+    currentUserAddress
+  } = config;
+  const wrapNearContractId = configAdapter.getWrapNearContractId();
+  const routers = dexRouters || (dexRouter ? [dexRouter] : []);
+  if (routers.length === 0) {
+    throw new Error("At least one DEX router is required");
+  }
+  const userAddress = currentUserAddress || recipient;
+  if (!userAddress) {
+    throw new Error("currentUserAddress or recipient is required for V2 Router");
+  }
+  if (!sourceToken?.address) {
+    throw new Error("Source token address is required");
+  }
+  if (!targetToken?.address) {
+    throw new Error("Target token address is required");
+  }
+  const needsPreSwap = sourceChain === "near" && !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
+      },
+      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}`;
+        }
+        if (r.status === "fulfilled" && !r.value.success) {
+          return `Router ${index}: ${r.value.error}`;
+        }
+        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(best.amountOut);
+      const currentAmount = new Big2(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)"
+    });
+    const preSwapAmountOut = preSwapQuote.amountOut;
+    if (!preSwapAmountOut || new Big2(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
+    });
+  }
+  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
+      });
+    } 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}`);
+  }
+  const depositAddress = intentsQuote.quoteSuccessResult?.quote?.depositAddress || "";
+  if (!depositAddress) {
+    throw new Error("Deposit address not found in intents quote");
+  }
+  const finalQuote = preSwapQuote;
+  return {
+    intents: {
+      quote: intentsQuote,
+      depositAddress
+    },
+    preSwap: needsPreSwap && finalQuote && bestRouter ? {
+      quote: finalQuote,
+      tokenIn: sourceToken,
+      tokenOut: bluechipToken,
+      executor: bestRouter
+    } : void 0,
+    finalAmountOut: intentsQuote.quoteSuccessResult?.quote?.amountOut || "0"
+  };
+}
+
+export { AggregateDexRouter, NearSmartRouter, completeQuote, convertSlippageToBasisPoints, findBestBluechipToken, formatGasString, formatGasToTgas, getBluechipTokensConfig, isNearIntentsSupportedToken, logger, normalizeDestinationAsset, normalizeTokenId, requiresRecipient, requiresRecipientInExecute, setBluechipTokensConfig };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map