@reown/appkit-core-react-native 1.1.1 → 1.2.0

package/src/controllers/ThemeController.ts

@@ -1,15 +1,15 @@
 import { proxy, subscribe as sub } from 'valtio';
-import type { ThemeMode, ThemeVariables } from '../utils/TypeUtil';
+import type { ThemeMode, ThemeVariables } from '@reown/appkit-common-react-native';
 
 // -- Types --------------------------------------------- //
 export interface ThemeControllerState {
-  themeMode: ThemeMode;
+  themeMode?: ThemeMode;
   themeVariables: ThemeVariables;
 }
 
 // -- State --------------------------------------------- //
 const state = proxy<ThemeControllerState>({
-  themeMode: 'dark',
+  themeMode: undefined,
   themeVariables: {}
 });
 

package/src/index.ts

@@ -61,10 +61,12 @@ export { WebviewController, type WebviewControllerState } from './controllers/We
 // -- Utils -------------------------------------------------------------------
 export { ApiUtil } from './utils/ApiUtil';
 export { AssetUtil } from './utils/AssetUtil';
+export { ConnectionUtil } from './utils/ConnectionUtil';
 export { ConstantsUtil } from './utils/ConstantsUtil';
 export { CoreHelperUtil } from './utils/CoreHelperUtil';
 export { StorageUtil } from './utils/StorageUtil';
 export { EventUtil } from './utils/EventUtil';
 export { RouterUtil } from './utils/RouterUtil';
+export { NetworkUtil } from './utils/NetworkUtil';
 
 export type * from './utils/TypeUtil';

package/src/utils/ConnectionUtil.ts

@@ -0,0 +1,27 @@
+import { AccountController } from '../controllers/AccountController';
+import { ConnectionController } from '../controllers/ConnectionController';
+import { EventsController } from '../controllers/EventsController';
+import { ModalController } from '../controllers/ModalController';
+import { RouterController } from '../controllers/RouterController';
+import { TransactionsController } from '../controllers/TransactionsController';
+
+export const ConnectionUtil = {
+  async disconnect() {
+    try {
+      await ConnectionController.disconnect();
+      ModalController.close();
+      AccountController.setIsConnected(false);
+      RouterController.reset('Connect');
+      TransactionsController.resetTransactions();
+      EventsController.sendEvent({
+        type: 'track',
+        event: 'DISCONNECT_SUCCESS'
+      });
+    } catch (error) {
+      EventsController.sendEvent({
+        type: 'track',
+        event: 'DISCONNECT_ERROR'
+      });
+    }
+  }
+};

package/src/utils/ConstantsUtil.ts

@@ -1,6 +1,7 @@
 import type { Features } from './TypeUtil';
 
 const defaultFeatures: Features = {
+  swaps: true,
   email: true,
   emailShowWallets: true,
   socials: ['x', 'discord', 'apple']
@@ -19,5 +20,124 @@ export const ConstantsUtil = {
 
   NATIVE_TOKEN_ADDRESS: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
 
+  SWAP_SUGGESTED_TOKENS: [
+    'ETH',
+    'UNI',
+    '1INCH',
+    'AAVE',
+    'SOL',
+    'ADA',
+    'AVAX',
+    'DOT',
+    'LINK',
+    'NITRO',
+    'GAIA',
+    'MILK',
+    'TRX',
+    'NEAR',
+    'GNO',
+    'WBTC',
+    'DAI',
+    'WETH',
+    'USDC',
+    'USDT',
+    'ARB',
+    'BAL',
+    'BICO',
+    'CRV',
+    'ENS',
+    'MATIC',
+    'OP'
+  ],
+
+  SWAP_POPULAR_TOKENS: [
+    'ETH',
+    'UNI',
+    '1INCH',
+    'AAVE',
+    'SOL',
+    'ADA',
+    'AVAX',
+    'DOT',
+    'LINK',
+    'NITRO',
+    'GAIA',
+    'MILK',
+    'TRX',
+    'NEAR',
+    'GNO',
+    'WBTC',
+    'DAI',
+    'WETH',
+    'USDC',
+    'USDT',
+    'ARB',
+    'BAL',
+    'BICO',
+    'CRV',
+    'ENS',
+    'MATIC',
+    'OP',
+    'METAL',
+    'DAI',
+    'CHAMP',
+    'WOLF',
+    'SALE',
+    'BAL',
+    'BUSD',
+    'MUST',
+    'BTCpx',
+    'ROUTE',
+    'HEX',
+    'WELT',
+    'amDAI',
+    'VSQ',
+    'VISION',
+    'AURUM',
+    'pSP',
+    'SNX',
+    'VC',
+    'LINK',
+    'CHP',
+    'amUSDT',
+    'SPHERE',
+    'FOX',
+    'GIDDY',
+    'GFC',
+    'OMEN',
+    'OX_OLD',
+    'DE',
+    'WNT'
+  ],
+
+  SWAP_SUPPORTED_NETWORKS: [
+    // Ethereum'
+    'eip155:1',
+    // Arbitrum One'
+    'eip155:42161',
+    // Optimism'
+    'eip155:10',
+    // ZKSync Era'
+    'eip155:324',
+    // Base'
+    'eip155:8453',
+    // BNB Smart Chain'
+    'eip155:56',
+    // Polygon'
+    'eip155:137',
+    // Gnosis'
+    'eip155:100',
+    // Avalanche'
+    'eip155:43114',
+    // Fantom'
+    'eip155:250',
+    // Klaytn'
+    'eip155:8217',
+    // Aurora
+    'eip155:1313161554'
+  ],
+
+  CONVERT_SLIPPAGE_TOLERANCE: 1,
+
   DEFAULT_FEATURES: defaultFeatures
 };

package/src/utils/CoreHelperUtil.ts

@@ -4,7 +4,7 @@ import { Linking, Platform } from 'react-native';
 import { ConstantsUtil as CommonConstants, type Balance } from '@reown/appkit-common-react-native';
 
 import { ConstantsUtil } from './ConstantsUtil';
-import type { CaipAddress, DataWallet, LinkingRecord } from './TypeUtil';
+import type { CaipAddress, CaipNetwork, DataWallet, LinkingRecord } from './TypeUtil';
 
 // -- Helpers -----------------------------------------------------------------
 async function isAppInstalledIos(deepLink?: string): Promise<boolean> {
@@ -57,20 +57,6 @@ export const CoreHelperUtil = {
     });
   },
 
-  debounce(func: (...args: any[]) => unknown, timeout = 500) {
-    let timer: ReturnType<typeof setTimeout> | undefined;
-
-    return (...args: unknown[]) => {
-      function next() {
-        func(...args);
-      }
-      if (timer) {
-        clearTimeout(timer);
-      }
-      timer = setTimeout(next, timeout);
-    };
-  },
-
   isHttpUrl(url: string) {
     return url.startsWith('http://') || url.startsWith('https://');
   },
@@ -282,5 +268,24 @@ export const CoreHelperUtil = {
     const [dollars, pennies] = roundedNumber.split('.');
 
     return { dollars, pennies };
+  },
+
+  sortNetworks(
+    approvedCaipNetworkIds: `${string}:${string}`[] | undefined,
+    requestedCaipNetworks: CaipNetwork[] = []
+  ) {
+    const approvedIds = approvedCaipNetworkIds;
+    const requested = [...requestedCaipNetworks];
+
+    if (approvedIds?.length) {
+      requested?.sort((a, b) => {
+        if (approvedIds.includes(a.id) && !approvedIds.includes(b.id)) return -1;
+        if (approvedIds.includes(b.id) && !approvedIds.includes(a.id)) return 1;
+
+        return 0;
+      });
+    }
+
+    return requested;
   }
 };

package/src/utils/NetworkUtil.ts

@@ -0,0 +1,33 @@
+import { RouterUtil } from './RouterUtil';
+import { RouterController } from '../controllers/RouterController';
+import { NetworkController } from '../controllers/NetworkController';
+import { AccountController } from '../controllers/AccountController';
+import { ConnectorController } from '../controllers/ConnectorController';
+import { SwapController } from '../controllers/SwapController';
+import type { CaipNetwork } from '../utils/TypeUtil';
+
+export const NetworkUtil = {
+  async handleNetworkSwitch(network: CaipNetwork) {
+    const { isConnected } = AccountController.state;
+    const { caipNetwork, approvedCaipNetworkIds, supportsAllNetworks } = NetworkController.state;
+    const isAuthConnected = ConnectorController.state.connectedConnector === 'AUTH';
+    let eventData = null;
+
+    if (isConnected && caipNetwork?.id !== network.id) {
+      if (approvedCaipNetworkIds?.includes(network.id) && !isAuthConnected) {
+        await NetworkController.switchActiveNetwork(network);
+        RouterUtil.navigateAfterNetworkSwitch(['ConnectingSiwe']);
+        eventData = { type: 'SWITCH_NETWORK', networkId: network.id };
+      } else if (supportsAllNetworks || isAuthConnected) {
+        RouterController.push('SwitchNetwork', { network });
+      }
+    } else if (!isConnected) {
+      NetworkController.setCaipNetwork(network);
+      RouterController.push('Connect');
+    }
+
+    SwapController.resetState();
+
+    return eventData;
+  }
+};

package/src/utils/RouterUtil.ts

@@ -8,7 +8,10 @@ export const RouterUtil = {
     }
 
     const { history } = RouterController.state;
-    const networkSelectIndex = history.findIndex(name => name === 'Networks');
+    const networkSelectIndex = history.findIndex(
+      name => name === 'Networks' || name === 'UnsupportedChain'
+    );
+
     if (networkSelectIndex >= 1) {
       RouterController.goBackToIndex(networkSelectIndex - 1);
     } else {

package/src/utils/SwapApiUtil.ts

@@ -1,8 +1,97 @@
 import { BlockchainApiController } from '../controllers/BlockchainApiController';
 import { OptionsController } from '../controllers/OptionsController';
 import { NetworkController } from '../controllers/NetworkController';
+import type {
+  BlockchainApiBalanceResponse,
+  BlockchainApiSwapAllowanceRequest,
+  SwapTokenWithBalance
+} from './TypeUtil';
+import { AccountController } from '../controllers/AccountController';
+import { ConnectionController } from '../controllers/ConnectionController';
 
 export const SwapApiUtil = {
+  async getTokenList() {
+    const response = await BlockchainApiController.fetchSwapTokens({
+      projectId: OptionsController.state.projectId,
+      chainId: NetworkController.state.caipNetwork?.id
+    });
+    const tokens =
+      response?.tokens?.map(
+        token =>
+          ({
+            ...token,
+            eip2612: false,
+            quantity: {
+              decimals: '0',
+              numeric: '0'
+            },
+            price: 0,
+            value: 0
+          }) as SwapTokenWithBalance
+      ) || [];
+
+    return tokens;
+  },
+
+  async fetchSwapAllowance({
+    tokenAddress,
+    userAddress,
+    sourceTokenAmount,
+    sourceTokenDecimals
+  }: Pick<BlockchainApiSwapAllowanceRequest, 'tokenAddress' | 'userAddress'> & {
+    sourceTokenAmount: string;
+    sourceTokenDecimals: number;
+  }) {
+    const projectId = OptionsController.state.projectId;
+
+    const response = await BlockchainApiController.fetchSwapAllowance({
+      projectId,
+      tokenAddress,
+      userAddress
+    });
+
+    if (response?.allowance && sourceTokenAmount && sourceTokenDecimals) {
+      const parsedValue =
+        ConnectionController.parseUnits(sourceTokenAmount, sourceTokenDecimals) || 0;
+      const hasAllowance = BigInt(response.allowance) >= parsedValue;
+
+      return hasAllowance;
+    }
+
+    return false;
+  },
+
+  async getMyTokensWithBalance(forceUpdate?: string) {
+    const address = AccountController.state.address;
+    const chainId = NetworkController.state.caipNetwork?.id;
+
+    if (!address) {
+      return [];
+    }
+
+    const response = await BlockchainApiController.getBalance(address, chainId, forceUpdate);
+    const balances = response?.balances.filter(balance => balance.quantity.decimals !== '0');
+
+    AccountController.setTokenBalance(balances);
+
+    return this.mapBalancesToSwapTokens(balances);
+  },
+
+  mapBalancesToSwapTokens(balances?: BlockchainApiBalanceResponse['balances']) {
+    return (
+      balances?.map(
+        token =>
+          ({
+            ...token,
+            address: token?.address || NetworkController.getActiveNetworkTokenAddress(),
+            decimals: parseInt(token.quantity.decimals, 10),
+            logoUri: token.iconUrl,
+            eip2612: false
+          }) as SwapTokenWithBalance
+      ) || []
+    );
+  },
+
   async fetchGasPrice() {
     const projectId = OptionsController.state.projectId;
     const caipNetwork = NetworkController.state.caipNetwork;

package/src/utils/SwapCalculationUtil.ts

@@ -1,6 +1,7 @@
 // -- Types --------------------------------------------- //
 
 import { NumberUtil } from '@reown/appkit-common-react-native';
+import type { SwapTokenWithBalance } from './TypeUtil';
 
 // -- Util ---------------------------------------- //
 export const SwapCalculationUtil = {
@@ -17,5 +18,129 @@ export const SwapCalculationUtil = {
     const gasCostInUSD = networkPriceInUSD.multipliedBy(totalGasCostInEther);
 
     return gasCostInUSD.toNumber();
+  },
+
+  getPriceImpact({
+    sourceTokenAmount,
+    sourceTokenPriceInUSD,
+    toTokenPriceInUSD,
+    toTokenAmount
+  }: {
+    sourceTokenAmount: string;
+    sourceTokenPriceInUSD: number;
+    toTokenPriceInUSD: number;
+    toTokenAmount: string;
+  }) {
+    const inputValue = NumberUtil.bigNumber(sourceTokenAmount).multipliedBy(sourceTokenPriceInUSD);
+    const outputValue = NumberUtil.bigNumber(toTokenAmount).multipliedBy(toTokenPriceInUSD);
+    const priceImpact = inputValue.minus(outputValue).dividedBy(inputValue).multipliedBy(100);
+
+    return priceImpact.toNumber();
+  },
+
+  getMaxSlippage(slippage: number, toTokenAmount: string) {
+    const slippageToleranceDecimal = NumberUtil.bigNumber(slippage).dividedBy(100);
+    const maxSlippageAmount = NumberUtil.multiply(toTokenAmount, slippageToleranceDecimal);
+
+    return maxSlippageAmount.toNumber();
+  },
+
+  getProviderFee(sourceTokenAmount: string, feePercentage = 0.0085) {
+    const providerFee = NumberUtil.bigNumber(sourceTokenAmount).multipliedBy(feePercentage);
+
+    return providerFee.toString();
+  },
+
+  getProviderFeePrice(
+    sourceTokenAmount: string,
+    sourceTokenPriceInUSD: number,
+    feePercentage = 0.0085
+  ) {
+    const providerFee = SwapCalculationUtil.getProviderFee(sourceTokenAmount, feePercentage);
+    const providerFeePrice = NumberUtil.bigNumber(providerFee).multipliedBy(sourceTokenPriceInUSD);
+
+    return providerFeePrice.toNumber();
+  },
+
+  isInsufficientNetworkTokenForGas(networkBalanceInUSD: string, gasPriceInUSD: number | undefined) {
+    const gasPrice = gasPriceInUSD ?? '0';
+
+    if (NumberUtil.bigNumber(networkBalanceInUSD).isZero()) {
+      return true;
+    }
+
+    return NumberUtil.bigNumber(NumberUtil.bigNumber(gasPrice)).isGreaterThan(networkBalanceInUSD);
+  },
+
+  isInsufficientSourceTokenForSwap(
+    sourceTokenAmount: string,
+    sourceTokenAddress: string,
+    balance: SwapTokenWithBalance[] | undefined
+  ) {
+    const sourceTokenBalance = balance?.find(token => token.address === sourceTokenAddress)
+      ?.quantity?.numeric;
+
+    const isInSufficientBalance = NumberUtil.bigNumber(sourceTokenBalance ?? '0').isLessThan(
+      sourceTokenAmount
+    );
+
+    return isInSufficientBalance;
+  },
+
+  getToTokenAmount({
+    sourceToken,
+    toToken,
+    sourceTokenPrice,
+    toTokenPrice,
+    sourceTokenAmount
+  }: {
+    sourceToken: SwapTokenWithBalance | undefined;
+    toToken: SwapTokenWithBalance | undefined;
+    sourceTokenPrice: number;
+    toTokenPrice: number;
+    sourceTokenAmount: string;
+  }) {
+    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';
+    }
+
+    // Calculate the provider fee (0.85% of the source token amount)
+    const providerFee = NumberUtil.bigNumber(sourceTokenAmount).multipliedBy(0.0085);
+
+    // Adjust the source token amount by subtracting the provider fee
+    const adjustedSourceTokenAmount = NumberUtil.bigNumber(sourceTokenAmount).minus(providerFee);
+
+    // Proceed with conversion using the adjusted source token amount
+    const sourceAmountInSmallestUnit = adjustedSourceTokenAmount.multipliedBy(
+      NumberUtil.bigNumber(10).pow(sourceTokenDecimals)
+    );
+
+    const priceRatio = NumberUtil.bigNumber(sourceTokenPriceInUSD).dividedBy(toTokenPriceInUSD);
+
+    const decimalDifference = sourceTokenDecimals - toTokenDecimals;
+    const toTokenAmountInSmallestUnit = sourceAmountInSmallestUnit
+      .multipliedBy(priceRatio)
+      .dividedBy(NumberUtil.bigNumber(10).pow(decimalDifference));
+
+    const toTokenAmount = toTokenAmountInSmallestUnit.dividedBy(
+      NumberUtil.bigNumber(10).pow(toTokenDecimals)
+    );
+
+    const amount = toTokenAmount.toFixed(toTokenDecimals).toString();
+
+    return amount;
   }
 };