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

package/src/utils/StorageUtil.ts

@@ -0,0 +1,405 @@
+/* eslint-disable no-console */
+import {
+  type OnRampCountry,
+  type OnRampFiatCurrency,
+  type OnRampFiatLimit,
+  type OnRampServiceProvider,
+  type OnRampCountryDefaults,
+  type WcWallet,
+  DateUtil,
+  type ConnectorType,
+  type ChainNamespace,
+  type WalletDeepLink,
+  SafeStorageKeys
+} from '@reown/appkit-common-react-native';
+import { OptionsController } from '../controllers/OptionsController';
+import { LogController } from '../controllers/LogController';
+
+// -- Utility -----------------------------------------------------------------
+export const StorageUtil = {
+  setWalletConnectDeepLink({ href, name }: WalletDeepLink) {
+    try {
+      OptionsController.getStorage().setItem(SafeStorageKeys.WC_DEEPLINK, {
+        href,
+        name
+      });
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setWalletConnectDeepLink');
+    }
+  },
+
+  async getWalletConnectDeepLink() {
+    try {
+      const deepLink = await OptionsController.getStorage().getItem<WalletDeepLink>(
+        SafeStorageKeys.WC_DEEPLINK
+      );
+      if (deepLink) {
+        return deepLink;
+      }
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getWalletConnectDeepLink');
+    }
+
+    return undefined;
+  },
+
+  async removeWalletConnectDeepLink() {
+    try {
+      await OptionsController.getStorage().removeItem(SafeStorageKeys.WC_DEEPLINK);
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'removeWalletConnectDeepLink');
+    }
+  },
+
+  async addRecentWallet(wallet: WcWallet) {
+    try {
+      const recentWallets = await StorageUtil.getRecentWallets();
+      const recentIndex = recentWallets.findIndex(w => w.id === wallet.id);
+
+      if (recentIndex > -1) {
+        recentWallets.splice(recentIndex, 1);
+      }
+
+      recentWallets.unshift(wallet);
+      if (recentWallets.length > 2) {
+        recentWallets.pop();
+      }
+      OptionsController.getStorage().setItem(SafeStorageKeys.RECENT_WALLET, recentWallets);
+
+      return recentWallets;
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'addRecentWallet');
+
+      return undefined;
+    }
+  },
+
+  async setRecentWallets(wallets: WcWallet[]) {
+    try {
+      await OptionsController.getStorage().setItem(SafeStorageKeys.RECENT_WALLET, wallets);
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setRecentWallets');
+    }
+  },
+
+  async getRecentWallets(): Promise<WcWallet[]> {
+    try {
+      const recent = await OptionsController.getStorage().getItem(SafeStorageKeys.RECENT_WALLET);
+
+      return recent ?? [];
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getRecentWallets');
+    }
+
+    return [];
+  },
+
+  async setConnectedConnectors({
+    type,
+    namespaces
+  }: {
+    type: ConnectorType;
+    namespaces: string[];
+  }) {
+    try {
+      const currentConnectors = (await StorageUtil.getConnectedConnectors()) || [];
+      // Only add if it doesn't exist already
+      if (!currentConnectors.some(c => c.type === type)) {
+        const updatedConnectors = [...currentConnectors, { type, namespaces }];
+        await OptionsController.getStorage().setItem(
+          SafeStorageKeys.CONNECTED_CONNECTORS,
+          updatedConnectors
+        );
+      }
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setConnectedConnectors');
+    }
+  },
+
+  async getConnectedConnectors(): Promise<{ type: ConnectorType; namespaces: string[] }[]> {
+    try {
+      const connectors = await OptionsController.getStorage().getItem<
+        { type: ConnectorType; namespaces: string[] }[]
+      >(SafeStorageKeys.CONNECTED_CONNECTORS);
+
+      return connectors ?? [];
+    } catch (err) {
+      LogController.sendError(err, 'StorageUtil.ts', 'getConnectedConnectors');
+    }
+
+    return [];
+  },
+
+  async removeConnectedConnectors(type: ConnectorType) {
+    try {
+      const currentConnectors = await StorageUtil.getConnectedConnectors();
+      const updatedConnectors = currentConnectors.filter(c => c.type !== type);
+      await OptionsController.getStorage().setItem(
+        SafeStorageKeys.CONNECTED_CONNECTORS,
+        updatedConnectors
+      );
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'removeConnectedConnectors');
+    }
+  },
+
+  async setOnRampPreferredCountry(country: OnRampCountry) {
+    try {
+      await OptionsController.getStorage().setItem(
+        SafeStorageKeys.ONRAMP_PREFERRED_COUNTRY,
+        country
+      );
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setOnRampPreferredCountry');
+    }
+  },
+
+  async getOnRampPreferredCountry() {
+    try {
+      const country = await OptionsController.getStorage().getItem<OnRampCountry>(
+        SafeStorageKeys.ONRAMP_PREFERRED_COUNTRY
+      );
+
+      return country ?? undefined;
+    } catch {
+      console.info('Unable to get OnRamp Preferred Country');
+    }
+
+    return undefined;
+  },
+
+  async setOnRampPreferredFiatCurrency(currency: OnRampFiatCurrency) {
+    try {
+      await OptionsController.getStorage().setItem(
+        SafeStorageKeys.ONRAMP_PREFERRED_FIAT_CURRENCY,
+        currency
+      );
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setOnRampPreferredFiatCurrency');
+    }
+  },
+
+  async getOnRampPreferredFiatCurrency() {
+    try {
+      const currency = await OptionsController.getStorage().getItem<OnRampFiatCurrency>(
+        SafeStorageKeys.ONRAMP_PREFERRED_FIAT_CURRENCY
+      );
+
+      return currency ?? undefined;
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getOnRampPreferredFiatCurrency');
+    }
+
+    return undefined;
+  },
+
+  async setOnRampCountries(countries: OnRampCountry[]) {
+    try {
+      await OptionsController.getStorage().setItem(SafeStorageKeys.ONRAMP_COUNTRIES, countries);
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setOnRampCountries');
+    }
+  },
+
+  async getOnRampCountries() {
+    try {
+      const countries = await OptionsController.getStorage().getItem<OnRampCountry[]>(
+        SafeStorageKeys.ONRAMP_COUNTRIES
+      );
+
+      return countries ?? [];
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getOnRampCountries');
+    }
+
+    return [];
+  },
+
+  async setOnRampCountriesDefaults(countriesDefaults: OnRampCountryDefaults[]) {
+    try {
+      const timestamp = Date.now();
+
+      await OptionsController.getStorage().setItem(SafeStorageKeys.ONRAMP_COUNTRIES_DEFAULTS, {
+        data: countriesDefaults,
+        timestamp
+      });
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setOnRampCountriesDefaults');
+    }
+  },
+
+  async getOnRampCountriesDefaults() {
+    try {
+      const result = await OptionsController.getStorage().getItem(
+        SafeStorageKeys.ONRAMP_COUNTRIES_DEFAULTS
+      );
+
+      if (!result) {
+        return [];
+      }
+
+      const { data, timestamp } = result;
+
+      // Cache for 1 week
+      if (timestamp && DateUtil.isMoreThanOneWeekAgo(timestamp)) {
+        return [];
+      }
+
+      return (data as OnRampCountryDefaults[]) ?? [];
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getOnRampCountriesDefaults');
+    }
+
+    return [];
+  },
+
+  async setOnRampServiceProviders(serviceProviders: OnRampServiceProvider[]) {
+    try {
+      const timestamp = Date.now();
+
+      await OptionsController.getStorage().setItem(SafeStorageKeys.ONRAMP_SERVICE_PROVIDERS, {
+        data: serviceProviders,
+        timestamp
+      });
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setOnRampServiceProviders');
+    }
+  },
+
+  async getOnRampServiceProviders() {
+    try {
+      const result = await OptionsController.getStorage().getItem(
+        SafeStorageKeys.ONRAMP_SERVICE_PROVIDERS
+      );
+
+      if (!result) {
+        return [];
+      }
+
+      const { data, timestamp } = result;
+
+      // Cache for 1 week
+      if (timestamp && DateUtil.isMoreThanOneWeekAgo(timestamp)) {
+        return [];
+      }
+
+      return (data as OnRampServiceProvider[]) ?? [];
+    } catch (err) {
+      LogController.sendError(err, 'StorageUtil.ts', 'getOnRampServiceProviders');
+    }
+
+    return [];
+  },
+
+  async setOnRampFiatLimits(fiatLimits: OnRampFiatLimit[]) {
+    try {
+      const timestamp = Date.now();
+
+      await OptionsController.getStorage().setItem(SafeStorageKeys.ONRAMP_FIAT_LIMITS, {
+        data: fiatLimits,
+        timestamp
+      });
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setOnRampFiatLimits');
+    }
+  },
+
+  async getOnRampFiatLimits() {
+    try {
+      const result = await OptionsController.getStorage().getItem(
+        SafeStorageKeys.ONRAMP_FIAT_LIMITS
+      );
+
+      if (!result) {
+        return [];
+      }
+
+      const { data, timestamp } = result;
+
+      // Cache for 1 week
+      if (timestamp && DateUtil.isMoreThanOneWeekAgo(timestamp)) {
+        return [];
+      }
+
+      return (data as OnRampFiatLimit[]) ?? [];
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getOnRampFiatLimits');
+    }
+
+    return [];
+  },
+
+  async setOnRampFiatCurrencies(fiatCurrencies: OnRampFiatCurrency[]) {
+    try {
+      const timestamp = Date.now();
+
+      await OptionsController.getStorage().setItem(SafeStorageKeys.ONRAMP_FIAT_CURRENCIES, {
+        data: fiatCurrencies,
+        timestamp
+      });
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setOnRampFiatCurrencies');
+    }
+  },
+
+  async getOnRampFiatCurrencies() {
+    try {
+      const result = await OptionsController.getStorage().getItem(
+        SafeStorageKeys.ONRAMP_FIAT_CURRENCIES
+      );
+
+      if (!result) {
+        return [];
+      }
+
+      const { data, timestamp } = result;
+
+      // Cache for 1 week
+      if (timestamp && DateUtil.isMoreThanOneWeekAgo(timestamp)) {
+        return [];
+      }
+
+      return (data as OnRampFiatCurrency[]) ?? [];
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getOnRampFiatCurrencies');
+    }
+
+    return [];
+  },
+
+  async setActiveNamespace(namespace?: ChainNamespace) {
+    try {
+      if (!namespace) {
+        await OptionsController.getStorage().removeItem(SafeStorageKeys.ACTIVE_NAMESPACE);
+
+        return;
+      }
+
+      await OptionsController.getStorage().setItem(SafeStorageKeys.ACTIVE_NAMESPACE, namespace);
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setActiveNamespace');
+    }
+  },
+
+  async getActiveNamespace() {
+    try {
+      const namespace = (await OptionsController.getStorage().getItem(
+        SafeStorageKeys.ACTIVE_NAMESPACE
+      )) as ChainNamespace;
+
+      return namespace ?? undefined;
+    } catch (err) {
+      LogController.sendError(err, 'StorageUtil.ts', 'getActiveNamespace');
+    }
+
+    return undefined;
+  },
+
+  async removeActiveNamespace() {
+    try {
+      await OptionsController.getStorage().removeItem(SafeStorageKeys.ACTIVE_NAMESPACE);
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'removeActiveNamespace');
+    }
+  }
+};

package/src/utils/SwapApiUtil.ts

@@ -0,0 +1,101 @@
+import type {
+  Balance,
+  CaipNetworkId,
+  BlockchainApiSwapAllowanceRequest,
+  SwapTokenWithBalance
+} from '@reown/appkit-common-react-native';
+import { BlockchainApiController } from '../controllers/BlockchainApiController';
+import { OptionsController } from '../controllers/OptionsController';
+import { ConnectionsController } from '../controllers/ConnectionsController';
+import { ConstantsUtil } from './ConstantsUtil';
+
+export const SwapApiUtil = {
+  async getTokenList() {
+    const chainId: CaipNetworkId =
+      ConnectionsController.state.activeNetwork?.caipNetworkId ?? 'eip155:1';
+    const response = await BlockchainApiController.fetchSwapTokens({
+      projectId: OptionsController.state.projectId,
+      chainId
+    });
+    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 =
+        ConnectionsController.parseUnits(sourceTokenAmount, sourceTokenDecimals) || 0;
+      const hasAllowance = BigInt(response.allowance) >= parsedValue;
+
+      return hasAllowance;
+    }
+
+    return false;
+  },
+
+  mapBalancesToSwapTokens(balances?: Balance[]) {
+    const { activeNamespace, activeCaipNetworkId } = ConnectionsController.state;
+    const address = activeNamespace
+      ? ConstantsUtil.NATIVE_TOKEN_ADDRESS[activeNamespace]
+      : undefined;
+
+    return (
+      balances
+        ?.filter(balance => balance?.quantity?.numeric)
+        .map(
+          token =>
+            ({
+              ...token,
+              address: token?.address ?? `${token?.chainId ?? activeCaipNetworkId}:${address}`,
+              decimals: parseInt(token.quantity?.decimals ?? '0', 10),
+              logoUri: token.iconUrl,
+              eip2612: false
+            }) as SwapTokenWithBalance
+        ) || []
+    );
+  },
+
+  async fetchGasPrice() {
+    const projectId = OptionsController.state.projectId;
+    const caipNetwork = ConnectionsController.state.activeNetwork;
+
+    if (!caipNetwork) {
+      return null;
+    }
+
+    return await BlockchainApiController.fetchGasPrice({
+      projectId,
+      chainId: caipNetwork.caipNetworkId
+    });
+  }
+};

package/src/utils/SwapCalculationUtil.ts

@@ -0,0 +1,145 @@
+// -- Types --------------------------------------------- //
+
+import { NumberUtil, type SwapTokenWithBalance } from '@reown/appkit-common-react-native';
+
+// -- Util ---------------------------------------- //
+export const SwapCalculationUtil = {
+  getGasPriceInEther(gas: bigint, gasPrice: bigint) {
+    const totalGasCostInWei = gasPrice * gas;
+    const totalGasCostInEther = Number(totalGasCostInWei) / 1e18;
+
+    return totalGasCostInEther;
+  },
+
+  getGasPriceInUSD(networkPrice: string, gas: bigint, gasPrice: bigint) {
+    const totalGasCostInEther = SwapCalculationUtil.getGasPriceInEther(gas, gasPrice);
+    const networkPriceInUSD = NumberUtil.bigNumber(networkPrice);
+    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;
+  }
+};

package/src/utils/WalletUtil.ts

@@ -0,0 +1,14 @@
+import type { WcWallet } from '@reown/appkit-common-react-native';
+import { ApiController } from '../controllers/ApiController';
+import { OptionsController } from '../controllers/OptionsController';
+
+export const WalletUtil = {
+  getWallet: (walletId: string): WcWallet | undefined => {
+    const { wallets, recommended, featured, installed } = ApiController.state;
+    const customWallets = OptionsController.state.customWallets ?? [];
+    const allWallets = [...wallets, ...recommended, ...featured, ...installed, ...customWallets];
+    const wallet = allWallets.find(w => w.id === walletId);
+
+    return wallet;
+  }
+};