@reown/appkit-core-react-native 0.0.0-accounts-canary.1-20251023174733

package/lib/module/controllers/SwapController.js

@@ -0,0 +1,671 @@
+"use strict";
+
+import { subscribeKey as subKey } from 'valtio/utils';
+import { proxy, subscribe as sub } from 'valtio';
+import { NumberUtil } from '@reown/appkit-common-react-native';
+import { ConstantsUtil } from '../utils/ConstantsUtil';
+import { SwapApiUtil } from '../utils/SwapApiUtil';
+import { BlockchainApiController } from './BlockchainApiController';
+import { OptionsController } from './OptionsController';
+import { SwapCalculationUtil } from '../utils/SwapCalculationUtil';
+import { SnackController } from './SnackController';
+import { LogController } from './LogController';
+import { RouterController } from './RouterController';
+import { CoreHelperUtil } from '../utils/CoreHelperUtil';
+import { TransactionsController } from './TransactionsController';
+import { EventsController } from './EventsController';
+import { ConnectionsController } from './ConnectionsController';
+
+// -- Constants ---------------------------------------- //
+export const INITIAL_GAS_LIMIT = 150000;
+export const TO_AMOUNT_DECIMALS = 6;
+
+// -- Types --------------------------------------------- //
+
+class TransactionError extends Error {
+  constructor(message, shortMessage) {
+    super(message);
+    this.name = 'TransactionError';
+    this.shortMessage = shortMessage;
+  }
+}
+// -- State --------------------------------------------- //
+const initialState = {
+  // Loading states
+  loadingTokens: false,
+  loadingPrices: false,
+  loadingQuote: false,
+  loadingApprovalTransaction: false,
+  loadingBuildTransaction: false,
+  loadingTransaction: false,
+  // Error states
+  fetchError: false,
+  // Approval & Swap transaction states
+  approvalTransaction: undefined,
+  swapTransaction: undefined,
+  transactionError: undefined,
+  // Input values
+  sourceToken: undefined,
+  sourceTokenAmount: '',
+  sourceTokenPriceInUSD: 0,
+  toToken: undefined,
+  toTokenAmount: '',
+  toTokenPriceInUSD: 0,
+  networkPrice: '0',
+  networkTokenSymbol: '',
+  inputError: undefined,
+  // Request values
+  slippage: ConstantsUtil.CONVERT_SLIPPAGE_TOLERANCE,
+  // Tokens
+  tokens: undefined,
+  popularTokens: undefined,
+  suggestedTokens: undefined,
+  foundTokens: undefined,
+  myTokensWithBalance: undefined,
+  tokensPriceMap: {},
+  // Calculations
+  gasFee: '0',
+  gasPriceInUSD: 0,
+  priceImpact: undefined,
+  maxSlippage: undefined,
+  providerFee: undefined
+};
+const state = proxy({
+  ...initialState
+});
+
+// -- Controller ---------------------------------------- //
+export const SwapController = {
+  state,
+  subscribe(callback) {
+    return sub(state, () => callback(state));
+  },
+  subscribeKey(key, callback) {
+    return subKey(state, key, callback);
+  },
+  getParams() {
+    const {
+      activeAddress,
+      activeNamespace,
+      activeNetwork,
+      connection
+    } = ConnectionsController.state;
+    const address = CoreHelperUtil.getPlainAddress(activeAddress);
+    if (!activeNamespace || !activeNetwork) {
+      throw new Error('No active namespace or network found to swap the tokens from.');
+    }
+    const networkAddress = `${activeNetwork.caipNetworkId}:${ConstantsUtil.NATIVE_TOKEN_ADDRESS[activeNamespace]}`;
+    if (!address) {
+      throw new Error('No address found to swap the tokens from.');
+    }
+    const invalidToToken = !state.toToken?.address || !state.toToken?.decimals;
+    const invalidSourceToken = !state.sourceToken?.address || !state.sourceToken?.decimals || state.sourceToken.address === state.toToken?.address || !NumberUtil.bigNumber(state.sourceTokenAmount).isGreaterThan(0);
+    const invalidSourceTokenAmount = !state.sourceTokenAmount;
+    return {
+      networkAddress,
+      network: activeNetwork,
+      fromAddress: address,
+      fromCaipAddress: activeAddress,
+      sourceTokenAddress: state.sourceToken?.address,
+      toTokenAddress: state.toToken?.address,
+      toTokenAmount: state.toTokenAmount,
+      toTokenDecimals: state.toToken?.decimals,
+      sourceTokenAmount: state.sourceTokenAmount,
+      sourceTokenDecimals: state.sourceToken?.decimals,
+      invalidToToken,
+      invalidSourceToken,
+      invalidSourceTokenAmount,
+      availableToSwap: activeAddress && !invalidToToken && !invalidSourceToken && !invalidSourceTokenAmount,
+      isAuthConnector: !!connection?.properties?.provider
+    };
+  },
+  switchTokens() {
+    if (state.loadingTokens) {
+      return;
+    }
+    let newSourceToken = state.toToken ? {
+      ...state.toToken
+    } : undefined;
+    const sourceTokenWithBalance = state.myTokensWithBalance?.find(token => token.address === newSourceToken?.address);
+    if (sourceTokenWithBalance) {
+      newSourceToken = sourceTokenWithBalance;
+    }
+    const newToToken = state.sourceToken ? {
+      ...state.sourceToken
+    } : undefined;
+    const newSourceTokenAmount = newSourceToken && state.toTokenAmount === '' ? '1' : state.toTokenAmount;
+    this.setSourceToken(newSourceToken);
+    this.setToToken(newToToken);
+    this.setSourceTokenAmount(newSourceTokenAmount);
+    this.setToTokenAmount('');
+    this.swapTokens();
+  },
+  async fetchTokens() {
+    try {
+      const {
+        networkAddress
+      } = this.getParams();
+      state.loadingTokens = true;
+      await this.getTokenList();
+      await this.getNetworkTokenPrice();
+      await this.getMyTokensWithBalance();
+      const networkToken = state.tokens?.find(token => token.address === networkAddress);
+      if (networkToken) {
+        state.networkTokenSymbol = networkToken.symbol;
+      }
+
+      // Set default source token if not set
+      if (!state.sourceToken && state.myTokensWithBalance?.length) {
+        const sourceToken = state.myTokensWithBalance?.find(token => token.address.startsWith(networkAddress)) || state.myTokensWithBalance?.[0];
+        this.setSourceToken(sourceToken);
+        this.setSourceTokenAmount('1');
+      }
+    } catch (error) {
+      LogController.sendError(error, 'SwapController.ts', 'initializeState');
+      SnackController.showError('Failed to initialize swap');
+      RouterController.goBack();
+    } finally {
+      state.loadingTokens = false;
+    }
+  },
+  async getTokenList() {
+    const tokens = await 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 (ConstantsUtil.SWAP_SUGGESTED_TOKENS.includes(token.symbol)) {
+        return true;
+      }
+      return false;
+    }, {});
+  },
+  async getMyTokensWithBalance(forceUpdate) {
+    await ConnectionsController.fetchBalance(forceUpdate);
+    const swapBalances = SwapApiUtil.mapBalancesToSwapTokens(ConnectionsController.state.balances);
+    if (!swapBalances) {
+      return;
+    }
+    await this.getInitialGasPrice();
+    this.setBalances(swapBalances);
+  },
+  getFilteredPopularTokens(balances) {
+    if (!balances) {
+      return state.popularTokens;
+    }
+    return state.popularTokens?.filter(token => !balances.some(t => t.address === token.address));
+  },
+  setSourceToken(sourceToken) {
+    if (!sourceToken) {
+      state.sourceToken = sourceToken;
+      state.sourceTokenAmount = '';
+      state.sourceTokenPriceInUSD = 0;
+      return;
+    }
+    state.sourceToken = sourceToken;
+    this.setTokenPrice(sourceToken.address, 'sourceToken');
+  },
+  setSourceTokenAmount(amount) {
+    state.sourceTokenAmount = amount;
+    if (amount === '') {
+      state.toTokenAmount = '';
+    }
+  },
+  async getAddressPrice(address) {
+    const [namespace, chain] = address.split(':');
+    const networkId = `${namespace}:${chain}`;
+    const existPrice = state.tokensPriceMap[address];
+    if (existPrice) {
+      return existPrice;
+    }
+    const response = await BlockchainApiController.fetchTokenPrice({
+      projectId: OptionsController.state.projectId,
+      addresses: [address],
+      caipNetworkId: networkId
+    });
+    const fungibles = response?.fungibles || [];
+    const allTokens = [...(state.tokens || []), ...(state.myTokensWithBalance || [])];
+    const symbol = allTokens?.find(token => token.address === address)?.symbol;
+    const price = fungibles.find(p => p.symbol.toLowerCase() === symbol?.toLowerCase())?.price || 0;
+    const priceAsFloat = parseFloat(price.toString());
+    state.tokensPriceMap[address] = priceAsFloat;
+    return priceAsFloat;
+  },
+  async getNetworkTokenPrice() {
+    const {
+      networkAddress
+    } = this.getParams();
+    const [namespace, chain] = networkAddress.split(':');
+    const networkId = `${namespace}:${chain}`;
+    const response = await BlockchainApiController.fetchTokenPrice({
+      projectId: OptionsController.state.projectId,
+      addresses: [networkAddress],
+      caipNetworkId: networkId
+    });
+    const token = response?.fungibles?.[0];
+    const price = token?.price.toString() || '0';
+    state.tokensPriceMap[networkAddress] = parseFloat(price);
+    state.networkTokenSymbol = token?.symbol || '';
+    state.networkPrice = price;
+  },
+  async getInitialGasPrice() {
+    const res = await SwapApiUtil.fetchGasPrice();
+    if (!res) {
+      return {
+        gasPrice: null,
+        gasPriceInUsd: null
+      };
+    }
+    const value = res.standard;
+    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: state.gasPriceInUSD
+    };
+  },
+  getProviderFeePrice() {
+    return SwapCalculationUtil.getProviderFeePrice(state.sourceTokenAmount, state.sourceTokenPriceInUSD);
+  },
+  setBalances(balances) {
+    state.myTokensWithBalance = balances;
+    balances.forEach(token => {
+      state.tokensPriceMap[token.address] = token.price || 0;
+    });
+  },
+  setToToken(toToken) {
+    if (!toToken) {
+      state.toToken = toToken;
+      state.toTokenAmount = '';
+      state.toTokenPriceInUSD = 0;
+      return;
+    }
+    state.toToken = toToken;
+    this.setTokenPrice(toToken.address, 'toToken');
+  },
+  setToTokenAmount(amount) {
+    state.toTokenAmount = amount ? NumberUtil.formatNumberToLocalString(amount, TO_AMOUNT_DECIMALS) : '';
+  },
+  async setTokenPrice(address, target) {
+    let price = state.tokensPriceMap[address] || 0;
+    if (!price) {
+      state.loadingPrices = true;
+      price = await this.getAddressPrice(address);
+    }
+    if (target === 'sourceToken') {
+      state.sourceTokenPriceInUSD = price;
+    } else if (target === 'toToken') {
+      state.toTokenPriceInUSD = price;
+    }
+    if (state.loadingPrices) {
+      state.loadingPrices = false;
+    }
+    if (this.getParams().availableToSwap) {
+      this.swapTokens();
+    }
+  },
+  // -- Swap ---------------------------------------------- //
+  async swapTokens() {
+    const address = ConnectionsController.state.activeAddress;
+    const sourceToken = state.sourceToken;
+    const toToken = state.toToken;
+    const haveSourceTokenAmount = NumberUtil.bigNumber(state.sourceTokenAmount).isGreaterThan(0);
+    if (!toToken || !sourceToken || state.loadingPrices || !haveSourceTokenAmount || !address) {
+      return;
+    }
+    state.loadingQuote = true;
+    const amountDecimal = NumberUtil.bigNumber(state.sourceTokenAmount).multipliedBy(10 ** sourceToken.decimals).integerValue();
+    try {
+      const quoteResponse = await BlockchainApiController.fetchSwapQuote({
+        userAddress: address,
+        projectId: OptionsController.state.projectId,
+        from: sourceToken.address,
+        to: toToken.address,
+        gasPrice: state.gasFee,
+        amount: amountDecimal.toString()
+      });
+      const quoteToAmount = quoteResponse?.quotes?.[0]?.toAmount;
+      if (!quoteToAmount) {
+        state.loadingQuote = false;
+        return;
+      }
+      const toTokenAmount = NumberUtil.bigNumber(quoteToAmount).dividedBy(10 ** toToken.decimals).toString();
+      this.setToTokenAmount(toTokenAmount);
+      const isInsufficientToken = this.hasInsufficientToken(state.sourceTokenAmount, sourceToken.address);
+      if (isInsufficientToken) {
+        state.inputError = 'Insufficient balance';
+      } else {
+        state.inputError = undefined;
+        this.setTransactionDetails();
+      }
+    } catch (error) {
+      LogController.sendError(error, 'SwapController.ts', 'getQuote');
+      SnackController.showError('Failed to get swap quote');
+    } finally {
+      state.loadingQuote = false;
+    }
+  },
+  // -- Create Transactions -------------------------------------- //
+  async getTransaction() {
+    const {
+      fromCaipAddress,
+      availableToSwap
+    } = this.getParams();
+    const sourceToken = state.sourceToken;
+    const toToken = state.toToken;
+    if (!fromCaipAddress || !availableToSwap || !sourceToken || !toToken || state.loadingQuote) {
+      return undefined;
+    }
+    try {
+      state.loadingBuildTransaction = true;
+      const hasAllowance = await SwapApiUtil.fetchSwapAllowance({
+        userAddress: fromCaipAddress,
+        tokenAddress: sourceToken.address,
+        sourceTokenAmount: state.sourceTokenAmount,
+        sourceTokenDecimals: sourceToken.decimals
+      });
+      let transaction;
+      if (hasAllowance) {
+        transaction = await this.createSwapTransaction();
+      } else {
+        transaction = await this.createAllowanceTransaction();
+      }
+      state.loadingBuildTransaction = false;
+      state.fetchError = false;
+      return transaction;
+    } catch (error) {
+      RouterController.goBack();
+      SnackController.showError('Failed to check allowance');
+      state.loadingBuildTransaction = false;
+      state.approvalTransaction = undefined;
+      state.swapTransaction = undefined;
+      state.fetchError = true;
+      return undefined;
+    }
+  },
+  async createAllowanceTransaction() {
+    const {
+      fromCaipAddress,
+      fromAddress,
+      sourceTokenAddress,
+      toTokenAddress
+    } = this.getParams();
+    if (!fromCaipAddress || !toTokenAddress) {
+      return undefined;
+    }
+    if (!sourceTokenAddress) {
+      throw new Error('createAllowanceTransaction - No source token address found.');
+    }
+    try {
+      const response = await BlockchainApiController.generateApproveCalldata({
+        projectId: OptionsController.state.projectId,
+        from: sourceTokenAddress,
+        to: toTokenAddress,
+        userAddress: fromCaipAddress
+      });
+      if (!response) {
+        throw new Error('createAllowanceTransaction - No response from generateApproveCalldata');
+      }
+      const gasLimit = await ConnectionsController.estimateGas({
+        address: fromAddress,
+        to: CoreHelperUtil.getPlainAddress(response.tx.to),
+        data: response.tx.data
+      });
+      const transaction = {
+        data: response.tx.data,
+        to: CoreHelperUtil.getPlainAddress(response.tx.from),
+        gas: gasLimit,
+        gasPrice: BigInt(response.tx.eip155.gasPrice),
+        value: BigInt(response.tx.value),
+        toAmount: state.toTokenAmount
+      };
+      state.swapTransaction = undefined;
+      state.approvalTransaction = {
+        data: transaction.data,
+        to: transaction.to,
+        gas: transaction.gas ?? BigInt(0),
+        gasPrice: transaction.gasPrice,
+        value: transaction.value,
+        toAmount: transaction.toAmount
+      };
+      return {
+        data: transaction.data,
+        to: transaction.to,
+        gas: transaction.gas ?? BigInt(0),
+        gasPrice: transaction.gasPrice,
+        value: transaction.value,
+        toAmount: transaction.toAmount
+      };
+    } catch (error) {
+      RouterController.goBack();
+      SnackController.showError('Failed to create approval transaction');
+      state.approvalTransaction = undefined;
+      state.swapTransaction = undefined;
+      state.fetchError = true;
+      return undefined;
+    }
+  },
+  async createSwapTransaction() {
+    const {
+      networkAddress,
+      fromCaipAddress,
+      sourceTokenAmount
+    } = this.getParams();
+    const sourceToken = state.sourceToken;
+    const toToken = state.toToken;
+    if (!fromCaipAddress || !sourceTokenAmount || !sourceToken || !toToken) {
+      return undefined;
+    }
+    const amount = ConnectionsController.parseUnits(sourceTokenAmount, sourceToken.decimals)?.toString();
+    try {
+      const response = await BlockchainApiController.generateSwapCalldata({
+        projectId: OptionsController.state.projectId,
+        userAddress: fromCaipAddress,
+        from: sourceToken.address,
+        to: toToken.address,
+        amount: amount
+      });
+      if (!response) {
+        throw new Error('createSwapTransaction - No response from generateSwapCalldata');
+      }
+      const isSourceNetworkToken = sourceToken.address === networkAddress;
+      const gas = BigInt(response.tx.eip155.gas);
+      const gasPrice = BigInt(response.tx.eip155.gasPrice);
+      const transaction = {
+        data: response.tx.data,
+        to: CoreHelperUtil.getPlainAddress(response.tx.to),
+        gas,
+        gasPrice,
+        value: isSourceNetworkToken ? BigInt(amount ?? '0') : BigInt('0'),
+        toAmount: state.toTokenAmount
+      };
+      state.gasPriceInUSD = SwapCalculationUtil.getGasPriceInUSD(state.networkPrice, gas, gasPrice);
+      state.approvalTransaction = undefined;
+      state.swapTransaction = transaction;
+      return transaction;
+    } catch (error) {
+      RouterController.goBack();
+      SnackController.showError('Failed to create transaction');
+      state.approvalTransaction = undefined;
+      state.swapTransaction = undefined;
+      state.fetchError = true;
+      return undefined;
+    }
+  },
+  async sendTransactionForApproval(data) {
+    const {
+      fromAddress,
+      network
+    } = this.getParams();
+    state.loadingApprovalTransaction = true;
+    SnackController.showLoading('Approve limit increase in your wallet');
+    try {
+      await ConnectionsController.sendTransaction({
+        address: fromAddress,
+        to: data.to,
+        data: data.data,
+        value: BigInt(data.value),
+        gasPrice: BigInt(data.gasPrice),
+        chainNamespace: ConnectionsController.state.activeNamespace,
+        network
+      });
+      await this.swapTokens();
+      await this.getTransaction();
+      state.approvalTransaction = undefined;
+    } catch (err) {
+      const error = err;
+      state.transactionError = error?.shortMessage;
+      SnackController.showError(error?.shortMessage ?? 'Transaction error');
+    } finally {
+      state.loadingApprovalTransaction = false;
+    }
+  },
+  async sendTransactionForSwap(data) {
+    if (!data) {
+      return undefined;
+    }
+    const {
+      fromAddress,
+      isAuthConnector,
+      network
+    } = this.getParams();
+    state.loadingTransaction = true;
+    const snackbarSuccessMessage = `Swapped ${state.sourceToken?.symbol} to ${state.toToken?.symbol}`;
+    SnackController.showLoading('Confirm transaction in your wallet');
+    try {
+      const forceUpdateAddresses = [state.sourceToken?.address, state.toToken?.address].filter(Boolean);
+      const transactionHash = await ConnectionsController.sendTransaction({
+        address: fromAddress,
+        to: data.to,
+        data: data.data,
+        gas: data.gas,
+        gasPrice: BigInt(data.gasPrice),
+        value: data.value,
+        chainNamespace: ConnectionsController.state.activeNamespace,
+        network
+      });
+      state.loadingTransaction = false;
+      SnackController.showSuccess(snackbarSuccessMessage, true);
+      EventsController.sendEvent({
+        type: 'track',
+        event: 'SWAP_SUCCESS',
+        properties: {
+          network: ConnectionsController.state.activeNetwork?.caipNetworkId,
+          swapFromToken: this.state.sourceToken?.symbol || '',
+          swapToToken: this.state.toToken?.symbol || '',
+          swapFromAmount: this.state.sourceTokenAmount || '',
+          swapToAmount: this.state.toTokenAmount || '',
+          isSmartAccount: ConnectionsController.state.accountType === 'smartAccount'
+        }
+      });
+      RouterController.replace(isAuthConnector ? 'Account' : 'AccountDefault');
+      SwapController.clearTokens();
+      SwapController.getMyTokensWithBalance(forceUpdateAddresses);
+      setTimeout(() => {
+        if (ConnectionsController.state.activeAddress) {
+          TransactionsController.fetchTransactions(ConnectionsController.state.activeAddress, true);
+        }
+      }, 5000);
+      return transactionHash;
+    } catch (err) {
+      const error = err;
+      LogController.sendError(error, 'SwapController.ts', 'sendTransactionForSwap', {
+        sourceToken: this.state.sourceToken?.symbol,
+        toToken: this.state.toToken?.symbol,
+        amount: this.state.sourceTokenAmount
+      });
+      state.transactionError = error?.shortMessage;
+      state.loadingTransaction = false;
+      SnackController.showError(error?.shortMessage ?? 'Transaction error');
+      EventsController.sendEvent({
+        type: 'track',
+        event: 'SWAP_ERROR',
+        properties: {
+          message: error?.shortMessage ?? error?.message ?? 'Unknown',
+          network: ConnectionsController.state.activeNetwork?.caipNetworkId,
+          swapFromToken: this.state.sourceToken?.symbol || '',
+          swapToToken: this.state.toToken?.symbol || '',
+          swapFromAmount: this.state.sourceTokenAmount || '',
+          swapToAmount: this.state.toTokenAmount || '',
+          isSmartAccount: ConnectionsController.state.accountType === 'smartAccount'
+        }
+      });
+      return undefined;
+    }
+  },
+  clearTransactionLoaders() {
+    state.loadingApprovalTransaction = false;
+    state.loadingBuildTransaction = false;
+    state.loadingTransaction = false;
+  },
+  clearTokens() {
+    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.inputError = initialState.inputError;
+    state.loadingApprovalTransaction = initialState.loadingApprovalTransaction;
+    state.loadingBuildTransaction = initialState.loadingBuildTransaction;
+    state.loadingTransaction = initialState.loadingTransaction;
+    state.fetchError = initialState.fetchError;
+    state.transactionError = initialState.transactionError;
+    state.swapTransaction = initialState.swapTransaction;
+    state.approvalTransaction = initialState.approvalTransaction;
+  },
+  resetState() {
+    this.clearTokens();
+    state.myTokensWithBalance = initialState.myTokensWithBalance;
+    state.tokensPriceMap = initialState.tokensPriceMap;
+    state.networkPrice = initialState.networkPrice;
+    state.networkTokenSymbol = initialState.networkTokenSymbol;
+  },
+  // -- Checks -------------------------------------------- //
+  hasInsufficientToken(sourceTokenAmount, sourceTokenAddress) {
+    const {
+      balances
+    } = ConnectionsController.state;
+    const networkToken = balances?.find(t => t.address === undefined);
+    const networkBalanceInUSD = networkToken ? NumberUtil.multiply(networkToken.quantity?.numeric ?? '0', networkToken.price).toString() : '0';
+    const isInsufficientSourceTokenForSwap = SwapCalculationUtil.isInsufficientSourceTokenForSwap(sourceTokenAmount, sourceTokenAddress, state.myTokensWithBalance);
+    let insufficientNetworkTokenForGas = true;
+    if (ConnectionsController.state.accountType === 'smartAccount') {
+      // Smart Accounts may pay gas in any ERC20 token
+      insufficientNetworkTokenForGas = false;
+    } else {
+      insufficientNetworkTokenForGas = SwapCalculationUtil.isInsufficientNetworkTokenForGas(networkBalanceInUSD, state.gasPriceInUSD);
+    }
+    return insufficientNetworkTokenForGas || isInsufficientSourceTokenForSwap;
+  },
+  // -- Calculations -------------------------------------- //
+  setTransactionDetails() {
+    const {
+      toTokenAddress,
+      toTokenDecimals
+    } = this.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);
+  }
+};
+//# sourceMappingURL=SwapController.js.map