@multiversx/sdk-dapp-liquidity 1.0.12 → 1.0.14

package/index-C49C5Rxf.js

@@ -0,0 +1,743 @@
+#!/usr/bin/env node
+"use strict";
+const bitcoin = require("./bitcoin-DAvQGpeP.js");
+const react = require("./react-BzZcQig5.js");
+const ifDefined = require("./if-defined-CJ5EZLw2.js");
+require("./index-CtFcWwAd.js");
+require("./index-BBwuv2SS.js");
+const SwapCalculationUtil = {
+  getGasPriceInEther(gas, gasPrice) {
+    const totalGasCostInWei = gasPrice * gas;
+    const totalGasCostInEther = Number(totalGasCostInWei) / 1e18;
+    return totalGasCostInEther;
+  },
+  getGasPriceInUSD(networkPrice, gas, gasPrice) {
+    const totalGasCostInEther = SwapCalculationUtil.getGasPriceInEther(gas, gasPrice);
+    const networkPriceInUSD = react.NumberUtil.bigNumber(networkPrice);
+    const gasCostInUSD = networkPriceInUSD.times(totalGasCostInEther);
+    return gasCostInUSD.toNumber();
+  },
+  getPriceImpact({ sourceTokenAmount, sourceTokenPriceInUSD, toTokenPriceInUSD, toTokenAmount }) {
+    const inputValue = react.NumberUtil.bigNumber(sourceTokenAmount).times(sourceTokenPriceInUSD);
+    const outputValue = react.NumberUtil.bigNumber(toTokenAmount).times(toTokenPriceInUSD);
+    const priceImpact = inputValue.minus(outputValue).div(inputValue).times(100);
+    return priceImpact.toNumber();
+  },
+  getMaxSlippage(slippage, toTokenAmount) {
+    const slippageToleranceDecimal = react.NumberUtil.bigNumber(slippage).div(100);
+    const maxSlippageAmount = react.NumberUtil.multiply(toTokenAmount, slippageToleranceDecimal);
+    return maxSlippageAmount.toNumber();
+  },
+  getProviderFee(sourceTokenAmount, feePercentage = 85e-4) {
+    const providerFee = react.NumberUtil.bigNumber(sourceTokenAmount).times(feePercentage);
+    return providerFee.toString();
+  },
+  isInsufficientNetworkTokenForGas(networkBalanceInUSD, gasPriceInUSD) {
+    const gasPrice = gasPriceInUSD || "0";
+    if (react.NumberUtil.bigNumber(networkBalanceInUSD).eq(0)) {
+      return true;
+    }
+    return react.NumberUtil.bigNumber(react.NumberUtil.bigNumber(gasPrice)).gt(networkBalanceInUSD);
+  },
+  isInsufficientSourceTokenForSwap(sourceTokenAmount, sourceTokenAddress, balance) {
+    var _a, _b;
+    const sourceTokenBalance = (_b = (_a = balance == null ? void 0 : balance.find((token) => token.address === sourceTokenAddress)) == null ? void 0 : _a.quantity) == null ? void 0 : _b.numeric;
+    const isInSufficientBalance = react.NumberUtil.bigNumber(sourceTokenBalance || "0").lt(sourceTokenAmount);
+    return isInSufficientBalance;
+  },
+  getToTokenAmount({ sourceToken, toToken, sourceTokenPrice, toTokenPrice, sourceTokenAmount }) {
+    if (sourceTokenAmount === "0") {
+      return "0";
+    }
+    if (!sourceToken || !toToken) {
+      return "0";
+    }
+    const sourceTokenDecimals = sourceToken.decimals;
+    const sourceTokenPriceInUSD = sourceTokenPrice;
+    const toTokenDecimals = toToken.decimals;
+    const toTokenPriceInUSD = toTokenPrice;
+    if (toTokenPriceInUSD <= 0) {
+      return "0";
+    }
+    const providerFee = react.NumberUtil.bigNumber(sourceTokenAmount).times(85e-4);
+    const adjustedSourceTokenAmount = react.NumberUtil.bigNumber(sourceTokenAmount).minus(providerFee);
+    const sourceAmountInSmallestUnit = adjustedSourceTokenAmount.times(react.NumberUtil.bigNumber(10).pow(sourceTokenDecimals));
+    const priceRatio = react.NumberUtil.bigNumber(sourceTokenPriceInUSD).div(toTokenPriceInUSD);
+    const decimalDifference = sourceTokenDecimals - toTokenDecimals;
+    const toTokenAmountInSmallestUnit = sourceAmountInSmallestUnit.times(priceRatio).div(react.NumberUtil.bigNumber(10).pow(decimalDifference));
+    const toTokenAmount = toTokenAmountInSmallestUnit.div(react.NumberUtil.bigNumber(10).pow(toTokenDecimals));
+    const amount = toTokenAmount.toFixed(toTokenDecimals).toString();
+    return amount;
+  }
+};
+const INITIAL_GAS_LIMIT = 15e4;
+const TO_AMOUNT_DECIMALS = 6;
+const initialState = {
+  // Loading states
+  initializing: false,
+  initialized: false,
+  loadingPrices: false,
+  loadingQuote: false,
+  loadingApprovalTransaction: false,
+  loadingBuildTransaction: false,
+  loadingTransaction: false,
+  // Error states
+  fetchError: false,
+  // Approval & Swap transaction states
+  approvalTransaction: void 0,
+  swapTransaction: void 0,
+  transactionError: void 0,
+  // Input values
+  sourceToken: void 0,
+  sourceTokenAmount: "",
+  sourceTokenPriceInUSD: 0,
+  toToken: void 0,
+  toTokenAmount: "",
+  toTokenPriceInUSD: 0,
+  networkPrice: "0",
+  networkBalanceInUSD: "0",
+  networkTokenSymbol: "",
+  inputError: void 0,
+  // Request values
+  slippage: react.ConstantsUtil.CONVERT_SLIPPAGE_TOLERANCE,
+  // Tokens
+  tokens: void 0,
+  popularTokens: void 0,
+  suggestedTokens: void 0,
+  foundTokens: void 0,
+  myTokensWithBalance: void 0,
+  tokensPriceMap: {},
+  // Calculations
+  gasFee: "0",
+  gasPriceInUSD: 0,
+  priceImpact: void 0,
+  maxSlippage: void 0,
+  providerFee: void 0
+};
+const state = bitcoin.proxy(initialState);
+const controller = {
+  state,
+  subscribe(callback) {
+    return bitcoin.subscribe(state, () => callback(state));
+  },
+  subscribeKey(key, callback) {
+    return bitcoin.subscribeKey(state, key, callback);
+  },
+  getParams() {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const caipAddress = react.ChainController.state.activeCaipAddress;
+    const namespace = react.ChainController.state.activeChain;
+    const address = react.CoreHelperUtil.getPlainAddress(caipAddress);
+    const networkAddress = react.getActiveNetworkTokenAddress();
+    const connectorId = react.ConnectorController.getConnectorId(namespace);
+    if (!address) {
+      throw new Error("No address found to swap the tokens from.");
+    }
+    const invalidToToken = !((_a = state.toToken) == null ? void 0 : _a.address) || !((_b = state.toToken) == null ? void 0 : _b.decimals);
+    const invalidSourceToken = !((_c = state.sourceToken) == null ? void 0 : _c.address) || !((_d = state.sourceToken) == null ? void 0 : _d.decimals) || !react.NumberUtil.bigNumber(state.sourceTokenAmount).gt(0);
+    const invalidSourceTokenAmount = !state.sourceTokenAmount;
+    return {
+      networkAddress,
+      fromAddress: address,
+      fromCaipAddress: caipAddress,
+      sourceTokenAddress: (_e = state.sourceToken) == null ? void 0 : _e.address,
+      toTokenAddress: (_f = state.toToken) == null ? void 0 : _f.address,
+      toTokenAmount: state.toTokenAmount,
+      toTokenDecimals: (_g = state.toToken) == null ? void 0 : _g.decimals,
+      sourceTokenAmount: state.sourceTokenAmount,
+      sourceTokenDecimals: (_h = state.sourceToken) == null ? void 0 : _h.decimals,
+      invalidToToken,
+      invalidSourceToken,
+      invalidSourceTokenAmount,
+      availableToSwap: caipAddress && !invalidToToken && !invalidSourceToken && !invalidSourceTokenAmount,
+      isAuthConnector: connectorId === react.ConstantsUtil$1.CONNECTOR_ID.AUTH
+    };
+  },
+  setSourceToken(sourceToken) {
+    if (!sourceToken) {
+      state.sourceToken = sourceToken;
+      state.sourceTokenAmount = "";
+      state.sourceTokenPriceInUSD = 0;
+      return;
+    }
+    state.sourceToken = sourceToken;
+    SwapController.setTokenPrice(sourceToken.address, "sourceToken");
+  },
+  setSourceTokenAmount(amount) {
+    state.sourceTokenAmount = amount;
+  },
+  setToToken(toToken) {
+    if (!toToken) {
+      state.toToken = toToken;
+      state.toTokenAmount = "";
+      state.toTokenPriceInUSD = 0;
+      return;
+    }
+    state.toToken = toToken;
+    SwapController.setTokenPrice(toToken.address, "toToken");
+  },
+  setToTokenAmount(amount) {
+    state.toTokenAmount = amount ? react.NumberUtil.formatNumberToLocalString(amount, TO_AMOUNT_DECIMALS) : "";
+  },
+  async setTokenPrice(address, target) {
+    let price = state.tokensPriceMap[address] || 0;
+    if (!price) {
+      state.loadingPrices = true;
+      price = await SwapController.getAddressPrice(address);
+    }
+    if (target === "sourceToken") {
+      state.sourceTokenPriceInUSD = price;
+    } else if (target === "toToken") {
+      state.toTokenPriceInUSD = price;
+    }
+    if (state.loadingPrices) {
+      state.loadingPrices = false;
+    }
+    if (SwapController.getParams().availableToSwap) {
+      SwapController.swapTokens();
+    }
+  },
+  switchTokens() {
+    if (state.initializing || !state.initialized) {
+      return;
+    }
+    const newSourceToken = state.toToken ? { ...state.toToken } : void 0;
+    const newToToken = state.sourceToken ? { ...state.sourceToken } : void 0;
+    const newSourceTokenAmount = newSourceToken && state.toTokenAmount === "" ? "1" : state.toTokenAmount;
+    SwapController.setSourceToken(newSourceToken);
+    SwapController.setToToken(newToToken);
+    SwapController.setSourceTokenAmount(newSourceTokenAmount);
+    SwapController.setToTokenAmount("");
+    SwapController.swapTokens();
+  },
+  resetState() {
+    state.myTokensWithBalance = initialState.myTokensWithBalance;
+    state.tokensPriceMap = initialState.tokensPriceMap;
+    state.initialized = initialState.initialized;
+    state.sourceToken = initialState.sourceToken;
+    state.sourceTokenAmount = initialState.sourceTokenAmount;
+    state.sourceTokenPriceInUSD = initialState.sourceTokenPriceInUSD;
+    state.toToken = initialState.toToken;
+    state.toTokenAmount = initialState.toTokenAmount;
+    state.toTokenPriceInUSD = initialState.toTokenPriceInUSD;
+    state.networkPrice = initialState.networkPrice;
+    state.networkTokenSymbol = initialState.networkTokenSymbol;
+    state.networkBalanceInUSD = initialState.networkBalanceInUSD;
+    state.inputError = initialState.inputError;
+    state.myTokensWithBalance = initialState.myTokensWithBalance;
+  },
+  resetValues() {
+    var _a;
+    const { networkAddress } = SwapController.getParams();
+    const networkToken = (_a = state.tokens) == null ? void 0 : _a.find((token) => token.address === networkAddress);
+    SwapController.setSourceToken(networkToken);
+    SwapController.setToToken(void 0);
+  },
+  getApprovalLoadingState() {
+    return state.loadingApprovalTransaction;
+  },
+  clearError() {
+    state.transactionError = void 0;
+  },
+  async initializeState() {
+    if (state.initializing) {
+      return;
+    }
+    state.initializing = true;
+    if (!state.initialized) {
+      try {
+        await SwapController.fetchTokens();
+        state.initialized = true;
+      } catch (error) {
+        state.initialized = false;
+        react.SnackController.showError("Failed to initialize swap");
+        react.RouterController.goBack();
+      }
+    }
+    state.initializing = false;
+  },
+  async fetchTokens() {
+    var _a;
+    const { networkAddress } = SwapController.getParams();
+    await SwapController.getTokenList();
+    await SwapController.getNetworkTokenPrice();
+    await SwapController.getMyTokensWithBalance();
+    const networkToken = (_a = state.tokens) == null ? void 0 : _a.find((token) => token.address === networkAddress);
+    if (networkToken) {
+      state.networkTokenSymbol = networkToken.symbol;
+      SwapController.setSourceToken(networkToken);
+      SwapController.setSourceTokenAmount("1");
+    }
+  },
+  async getTokenList() {
+    const tokens = await react.SwapApiUtil.getTokenList();
+    state.tokens = tokens;
+    state.popularTokens = tokens.sort((aTokenInfo, bTokenInfo) => {
+      if (aTokenInfo.symbol < bTokenInfo.symbol) {
+        return -1;
+      }
+      if (aTokenInfo.symbol > bTokenInfo.symbol) {
+        return 1;
+      }
+      return 0;
+    });
+    state.suggestedTokens = tokens.filter((token) => {
+      if (react.ConstantsUtil.SWAP_SUGGESTED_TOKENS.includes(token.symbol)) {
+        return true;
+      }
+      return false;
+    }, {});
+  },
+  async getAddressPrice(address) {
+    var _a, _b;
+    const existPrice = state.tokensPriceMap[address];
+    if (existPrice) {
+      return existPrice;
+    }
+    const response = await react.BlockchainApiController.fetchTokenPrice({
+      addresses: [address]
+    });
+    const fungibles = (response == null ? void 0 : response.fungibles) || [];
+    const allTokens = [...state.tokens || [], ...state.myTokensWithBalance || []];
+    const symbol = (_a = allTokens == null ? void 0 : allTokens.find((token) => token.address === address)) == null ? void 0 : _a.symbol;
+    const price = ((_b = fungibles.find((p) => p.symbol.toLowerCase() === (symbol == null ? void 0 : symbol.toLowerCase()))) == null ? void 0 : _b.price) || 0;
+    const priceAsFloat = parseFloat(price.toString());
+    state.tokensPriceMap[address] = priceAsFloat;
+    return priceAsFloat;
+  },
+  async getNetworkTokenPrice() {
+    var _a;
+    const { networkAddress } = SwapController.getParams();
+    const response = await react.BlockchainApiController.fetchTokenPrice({
+      addresses: [networkAddress]
+    }).catch(() => {
+      react.SnackController.showError("Failed to fetch network token price");
+      return { fungibles: [] };
+    });
+    const token = (_a = response.fungibles) == null ? void 0 : _a[0];
+    const price = (token == null ? void 0 : token.price.toString()) || "0";
+    state.tokensPriceMap[networkAddress] = parseFloat(price);
+    state.networkTokenSymbol = (token == null ? void 0 : token.symbol) || "";
+    state.networkPrice = price;
+  },
+  async getMyTokensWithBalance(forceUpdate) {
+    const balances = await react.BalanceUtil.getMyTokensWithBalance(forceUpdate);
+    const swapBalances = react.SwapApiUtil.mapBalancesToSwapTokens(balances);
+    if (!swapBalances) {
+      return;
+    }
+    await SwapController.getInitialGasPrice();
+    SwapController.setBalances(swapBalances);
+  },
+  setBalances(balances) {
+    const { networkAddress } = SwapController.getParams();
+    const caipNetwork = react.ChainController.state.activeCaipNetwork;
+    if (!caipNetwork) {
+      return;
+    }
+    const networkToken = balances.find((token) => token.address === networkAddress);
+    balances.forEach((token) => {
+      state.tokensPriceMap[token.address] = token.price || 0;
+    });
+    state.myTokensWithBalance = balances.filter((token) => token.address.startsWith(caipNetwork.caipNetworkId));
+    state.networkBalanceInUSD = networkToken ? react.NumberUtil.multiply(networkToken.quantity.numeric, networkToken.price).toString() : "0";
+  },
+  async getInitialGasPrice() {
+    var _a, _b;
+    const res = await react.SwapApiUtil.fetchGasPrice();
+    if (!res) {
+      return { gasPrice: null, gasPriceInUSD: null };
+    }
+    switch ((_b = (_a = react.ChainController.state) == null ? void 0 : _a.activeCaipNetwork) == null ? void 0 : _b.chainNamespace) {
+      case "solana":
+        state.gasFee = res.standard ?? "0";
+        state.gasPriceInUSD = react.NumberUtil.multiply(res.standard, state.networkPrice).div(1e9).toNumber();
+        return {
+          gasPrice: BigInt(state.gasFee),
+          gasPriceInUSD: Number(state.gasPriceInUSD)
+        };
+      case "eip155":
+      default:
+        const value = res.standard ?? "0";
+        const gasFee = BigInt(value);
+        const gasLimit = BigInt(INITIAL_GAS_LIMIT);
+        const gasPrice = SwapCalculationUtil.getGasPriceInUSD(state.networkPrice, gasLimit, gasFee);
+        state.gasFee = value;
+        state.gasPriceInUSD = gasPrice;
+        return { gasPrice: gasFee, gasPriceInUSD: gasPrice };
+    }
+  },
+  // -- Swap -------------------------------------- //
+  async swapTokens() {
+    var _a, _b;
+    const address = react.AccountController.state.address;
+    const sourceToken = state.sourceToken;
+    const toToken = state.toToken;
+    const haveSourceTokenAmount = react.NumberUtil.bigNumber(state.sourceTokenAmount).gt(0);
+    if (!haveSourceTokenAmount) {
+      SwapController.setToTokenAmount("");
+    }
+    if (!toToken || !sourceToken || state.loadingPrices || !haveSourceTokenAmount) {
+      return;
+    }
+    state.loadingQuote = true;
+    const amountDecimal = react.NumberUtil.bigNumber(state.sourceTokenAmount).times(10 ** sourceToken.decimals).round(0);
+    try {
+      const quoteResponse = await react.BlockchainApiController.fetchSwapQuote({
+        userAddress: address,
+        from: sourceToken.address,
+        to: toToken.address,
+        gasPrice: state.gasFee,
+        amount: amountDecimal.toString()
+      });
+      state.loadingQuote = false;
+      const quoteToAmount = (_b = (_a = quoteResponse == null ? void 0 : quoteResponse.quotes) == null ? void 0 : _a[0]) == null ? void 0 : _b.toAmount;
+      if (!quoteToAmount) {
+        react.AlertController.open({
+          shortMessage: "Incorrect amount",
+          longMessage: "Please enter a valid amount"
+        }, "error");
+        return;
+      }
+      const toTokenAmount = react.NumberUtil.bigNumber(quoteToAmount).div(10 ** toToken.decimals).toString();
+      SwapController.setToTokenAmount(toTokenAmount);
+      const isInsufficientToken = SwapController.hasInsufficientToken(state.sourceTokenAmount, sourceToken.address);
+      if (isInsufficientToken) {
+        state.inputError = "Insufficient balance";
+      } else {
+        state.inputError = void 0;
+        SwapController.setTransactionDetails();
+      }
+    } catch (error) {
+      state.loadingQuote = false;
+      state.inputError = "Insufficient balance";
+    }
+  },
+  // -- Create Transactions -------------------------------------- //
+  async getTransaction() {
+    const { fromCaipAddress, availableToSwap } = SwapController.getParams();
+    const sourceToken = state.sourceToken;
+    const toToken = state.toToken;
+    if (!fromCaipAddress || !availableToSwap || !sourceToken || !toToken || state.loadingQuote) {
+      return void 0;
+    }
+    try {
+      state.loadingBuildTransaction = true;
+      const hasAllowance = await react.SwapApiUtil.fetchSwapAllowance({
+        userAddress: fromCaipAddress,
+        tokenAddress: sourceToken.address,
+        sourceTokenAmount: state.sourceTokenAmount,
+        sourceTokenDecimals: sourceToken.decimals
+      });
+      let transaction = void 0;
+      if (hasAllowance) {
+        transaction = await SwapController.createSwapTransaction();
+      } else {
+        transaction = await SwapController.createAllowanceTransaction();
+      }
+      state.loadingBuildTransaction = false;
+      state.fetchError = false;
+      return transaction;
+    } catch (error) {
+      react.RouterController.goBack();
+      react.SnackController.showError("Failed to check allowance");
+      state.loadingBuildTransaction = false;
+      state.approvalTransaction = void 0;
+      state.swapTransaction = void 0;
+      state.fetchError = true;
+      return void 0;
+    }
+  },
+  async createAllowanceTransaction() {
+    const { fromCaipAddress, sourceTokenAddress, toTokenAddress } = SwapController.getParams();
+    if (!fromCaipAddress || !toTokenAddress) {
+      return void 0;
+    }
+    if (!sourceTokenAddress) {
+      throw new Error("createAllowanceTransaction - No source token address found.");
+    }
+    try {
+      const response = await react.BlockchainApiController.generateApproveCalldata({
+        from: sourceTokenAddress,
+        to: toTokenAddress,
+        userAddress: fromCaipAddress
+      });
+      const transaction = {
+        data: response.tx.data,
+        to: react.CoreHelperUtil.getPlainAddress(response.tx.from),
+        gasPrice: BigInt(response.tx.eip155.gasPrice),
+        value: BigInt(response.tx.value),
+        toAmount: state.toTokenAmount
+      };
+      state.swapTransaction = void 0;
+      state.approvalTransaction = {
+        data: transaction.data,
+        to: transaction.to,
+        gasPrice: transaction.gasPrice,
+        value: transaction.value,
+        toAmount: transaction.toAmount
+      };
+      return {
+        data: transaction.data,
+        to: transaction.to,
+        gasPrice: transaction.gasPrice,
+        value: transaction.value,
+        toAmount: transaction.toAmount
+      };
+    } catch (error) {
+      react.RouterController.goBack();
+      react.SnackController.showError("Failed to create approval transaction");
+      state.approvalTransaction = void 0;
+      state.swapTransaction = void 0;
+      state.fetchError = true;
+      return void 0;
+    }
+  },
+  async createSwapTransaction() {
+    var _a;
+    const { networkAddress, fromCaipAddress, sourceTokenAmount } = SwapController.getParams();
+    const sourceToken = state.sourceToken;
+    const toToken = state.toToken;
+    if (!fromCaipAddress || !sourceTokenAmount || !sourceToken || !toToken) {
+      return void 0;
+    }
+    const amount = (_a = react.ConnectionController.parseUnits(sourceTokenAmount, sourceToken.decimals)) == null ? void 0 : _a.toString();
+    try {
+      const response = await react.BlockchainApiController.generateSwapCalldata({
+        userAddress: fromCaipAddress,
+        from: sourceToken.address,
+        to: toToken.address,
+        amount,
+        disableEstimate: true
+      });
+      const isSourceTokenIsNetworkToken = sourceToken.address === networkAddress;
+      const gas = BigInt(response.tx.eip155.gas);
+      const gasPrice = BigInt(response.tx.eip155.gasPrice);
+      const transaction = {
+        data: response.tx.data,
+        to: react.CoreHelperUtil.getPlainAddress(response.tx.to),
+        gas,
+        gasPrice,
+        value: isSourceTokenIsNetworkToken ? BigInt(amount ?? "0") : BigInt("0"),
+        toAmount: state.toTokenAmount
+      };
+      state.gasPriceInUSD = SwapCalculationUtil.getGasPriceInUSD(state.networkPrice, gas, gasPrice);
+      state.approvalTransaction = void 0;
+      state.swapTransaction = transaction;
+      return transaction;
+    } catch (error) {
+      react.RouterController.goBack();
+      react.SnackController.showError("Failed to create transaction");
+      state.approvalTransaction = void 0;
+      state.swapTransaction = void 0;
+      state.fetchError = true;
+      return void 0;
+    }
+  },
+  // -- Send Transactions --------------------------------- //
+  async sendTransactionForApproval(data) {
+    var _a, _b, _c;
+    const { fromAddress, isAuthConnector } = SwapController.getParams();
+    state.loadingApprovalTransaction = true;
+    const approveLimitMessage = `Approve limit increase in your wallet`;
+    if (isAuthConnector) {
+      react.RouterController.pushTransactionStack({
+        onSuccess() {
+          react.SnackController.showLoading(approveLimitMessage);
+        }
+      });
+    } else {
+      react.SnackController.showLoading(approveLimitMessage);
+    }
+    try {
+      await react.ConnectionController.sendTransaction({
+        address: fromAddress,
+        to: data.to,
+        data: data.data,
+        value: data.value,
+        chainNamespace: "eip155"
+      });
+      await SwapController.swapTokens();
+      await SwapController.getTransaction();
+      state.approvalTransaction = void 0;
+      state.loadingApprovalTransaction = false;
+    } catch (err) {
+      const error = err;
+      state.transactionError = error == null ? void 0 : error.shortMessage;
+      state.loadingApprovalTransaction = false;
+      react.SnackController.showError((error == null ? void 0 : error.shortMessage) || "Transaction error");
+      react.EventsController.sendEvent({
+        type: "track",
+        event: "SWAP_APPROVAL_ERROR",
+        properties: {
+          message: (error == null ? void 0 : error.shortMessage) || (error == null ? void 0 : error.message) || "Unknown",
+          network: ((_a = react.ChainController.state.activeCaipNetwork) == null ? void 0 : _a.caipNetworkId) || "",
+          swapFromToken: ((_b = SwapController.state.sourceToken) == null ? void 0 : _b.symbol) || "",
+          swapToToken: ((_c = SwapController.state.toToken) == null ? void 0 : _c.symbol) || "",
+          swapFromAmount: SwapController.state.sourceTokenAmount || "",
+          swapToAmount: SwapController.state.toTokenAmount || "",
+          isSmartAccount: react.getPreferredAccountType("eip155") === react.W3mFrameRpcConstants.ACCOUNT_TYPES.SMART_ACCOUNT
+        }
+      });
+    }
+  },
+  async sendTransactionForSwap(data) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    if (!data) {
+      return void 0;
+    }
+    const { fromAddress, toTokenAmount, isAuthConnector } = SwapController.getParams();
+    state.loadingTransaction = true;
+    const snackbarPendingMessage = `Swapping ${(_a = state.sourceToken) == null ? void 0 : _a.symbol} to ${react.NumberUtil.formatNumberToLocalString(toTokenAmount, 3)} ${(_b = state.toToken) == null ? void 0 : _b.symbol}`;
+    const snackbarSuccessMessage = `Swapped ${(_c = state.sourceToken) == null ? void 0 : _c.symbol} to ${react.NumberUtil.formatNumberToLocalString(toTokenAmount, 3)} ${(_d = state.toToken) == null ? void 0 : _d.symbol}`;
+    if (isAuthConnector) {
+      react.RouterController.pushTransactionStack({
+        onSuccess() {
+          react.RouterController.replace("Account");
+          react.SnackController.showLoading(snackbarPendingMessage);
+          controller.resetState();
+        }
+      });
+    } else {
+      react.SnackController.showLoading("Confirm transaction in your wallet");
+    }
+    try {
+      const forceUpdateAddresses = [(_e = state.sourceToken) == null ? void 0 : _e.address, (_f = state.toToken) == null ? void 0 : _f.address].join(",");
+      const transactionHash = await react.ConnectionController.sendTransaction({
+        address: fromAddress,
+        to: data.to,
+        data: data.data,
+        value: data.value,
+        chainNamespace: "eip155"
+      });
+      state.loadingTransaction = false;
+      react.SnackController.showSuccess(snackbarSuccessMessage);
+      react.EventsController.sendEvent({
+        type: "track",
+        event: "SWAP_SUCCESS",
+        properties: {
+          network: ((_g = react.ChainController.state.activeCaipNetwork) == null ? void 0 : _g.caipNetworkId) || "",
+          swapFromToken: ((_h = SwapController.state.sourceToken) == null ? void 0 : _h.symbol) || "",
+          swapToToken: ((_i = SwapController.state.toToken) == null ? void 0 : _i.symbol) || "",
+          swapFromAmount: SwapController.state.sourceTokenAmount || "",
+          swapToAmount: SwapController.state.toTokenAmount || "",
+          isSmartAccount: react.getPreferredAccountType("eip155") === react.W3mFrameRpcConstants.ACCOUNT_TYPES.SMART_ACCOUNT
+        }
+      });
+      controller.resetState();
+      if (!isAuthConnector) {
+        react.RouterController.replace("Account");
+      }
+      controller.getMyTokensWithBalance(forceUpdateAddresses);
+      return transactionHash;
+    } catch (err) {
+      const error = err;
+      state.transactionError = error == null ? void 0 : error.shortMessage;
+      state.loadingTransaction = false;
+      react.SnackController.showError((error == null ? void 0 : error.shortMessage) || "Transaction error");
+      react.EventsController.sendEvent({
+        type: "track",
+        event: "SWAP_ERROR",
+        properties: {
+          message: (error == null ? void 0 : error.shortMessage) || (error == null ? void 0 : error.message) || "Unknown",
+          network: ((_j = react.ChainController.state.activeCaipNetwork) == null ? void 0 : _j.caipNetworkId) || "",
+          swapFromToken: ((_k = SwapController.state.sourceToken) == null ? void 0 : _k.symbol) || "",
+          swapToToken: ((_l = SwapController.state.toToken) == null ? void 0 : _l.symbol) || "",
+          swapFromAmount: SwapController.state.sourceTokenAmount || "",
+          swapToAmount: SwapController.state.toTokenAmount || "",
+          isSmartAccount: react.getPreferredAccountType("eip155") === react.W3mFrameRpcConstants.ACCOUNT_TYPES.SMART_ACCOUNT
+        }
+      });
+      return void 0;
+    }
+  },
+  // -- Checks -------------------------------------------- //
+  hasInsufficientToken(sourceTokenAmount, sourceTokenAddress) {
+    const isInsufficientSourceTokenForSwap = SwapCalculationUtil.isInsufficientSourceTokenForSwap(sourceTokenAmount, sourceTokenAddress, state.myTokensWithBalance);
+    return isInsufficientSourceTokenForSwap;
+  },
+  // -- Calculations -------------------------------------- //
+  setTransactionDetails() {
+    const { toTokenAddress, toTokenDecimals } = SwapController.getParams();
+    if (!toTokenAddress || !toTokenDecimals) {
+      return;
+    }
+    state.gasPriceInUSD = SwapCalculationUtil.getGasPriceInUSD(state.networkPrice, BigInt(state.gasFee), BigInt(INITIAL_GAS_LIMIT));
+    state.priceImpact = SwapCalculationUtil.getPriceImpact({
+      sourceTokenAmount: state.sourceTokenAmount,
+      sourceTokenPriceInUSD: state.sourceTokenPriceInUSD,
+      toTokenPriceInUSD: state.toTokenPriceInUSD,
+      toTokenAmount: state.toTokenAmount
+    });
+    state.maxSlippage = SwapCalculationUtil.getMaxSlippage(state.slippage, state.toTokenAmount);
+    state.providerFee = SwapCalculationUtil.getProviderFee(state.sourceTokenAmount);
+  }
+};
+const SwapController = react.withErrorBoundary(controller);
+const styles = bitcoin.i`
+  :host {
+    display: block;
+  }
+
+  :host > button {
+    gap: var(--wui-spacing-xxs);
+    padding: var(--wui-spacing-xs);
+    padding-right: var(--wui-spacing-1xs);
+    height: 40px;
+    border-radius: var(--wui-border-radius-l);
+    background: var(--wui-color-gray-glass-002);
+    border-width: 0px;
+    box-shadow: inset 0 0 0 1px var(--wui-color-gray-glass-002);
+  }
+
+  :host > button wui-image {
+    width: 24px;
+    height: 24px;
+    border-radius: var(--wui-border-radius-s);
+    box-shadow: inset 0 0 0 1px var(--wui-color-gray-glass-010);
+  }
+`;
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+let WuiTokenButton = class WuiTokenButton2 extends bitcoin.i$1 {
+  constructor() {
+    super(...arguments);
+    this.text = "";
+  }
+  render() {
+    return bitcoin.x`
+      <button>
+        ${this.tokenTemplate()}
+        <wui-text variant="paragraph-600" color="fg-100">${this.text}</wui-text>
+      </button>
+    `;
+  }
+  tokenTemplate() {
+    if (this.imageSrc) {
+      return bitcoin.x`<wui-image src=${this.imageSrc}></wui-image>`;
+    }
+    return bitcoin.x`
+      <wui-icon-box
+        size="sm"
+        iconColor="fg-200"
+        backgroundColor="fg-300"
+        icon="networkPlaceholder"
+      ></wui-icon-box>
+    `;
+  }
+};
+WuiTokenButton.styles = [bitcoin.resetStyles, bitcoin.elementStyles, styles];
+__decorate([
+  ifDefined.n()
+], WuiTokenButton.prototype, "imageSrc", void 0);
+__decorate([
+  ifDefined.n()
+], WuiTokenButton.prototype, "text", void 0);
+WuiTokenButton = __decorate([
+  ifDefined.customElement("wui-token-button")
+], WuiTokenButton);
+exports.SwapController = SwapController;