@reown/appkit-core-react-native 2.0.0 → 2.0.1

package/src/utils/StorageUtil.ts

@@ -1,53 +1,43 @@
 /* eslint-disable no-console */
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import type {
-  OnRampCountry,
-  OnRampFiatCurrency,
-  OnRampFiatLimit,
-  OnRampServiceProvider,
-  WcWallet
-} from './TypeUtil';
 import {
+  type OnRampCountry,
+  type OnRampFiatCurrency,
+  type OnRampFiatLimit,
+  type OnRampServiceProvider,
+  type OnRampCountryDefaults,
+  type WcWallet,
   DateUtil,
-  type SocialProvider,
-  type New_ConnectorType,
   type ConnectorType,
-  type ChainNamespace
+  type ChainNamespace,
+  type WalletDeepLink,
+  SafeStorageKeys
 } from '@reown/appkit-common-react-native';
-
-// -- Helpers -----------------------------------------------------------------
-const WC_DEEPLINK = 'WALLETCONNECT_DEEPLINK_CHOICE';
-const RECENT_WALLET = '@w3m/recent';
-const CONNECTED_WALLET_IMAGE_URL = '@w3m/connected_wallet_image_url';
-const CONNECTED_CONNECTOR = '@w3m/connected_connector';
-const CONNECTED_CONNECTORS = '@appkit/connected_connectors';
-const CONNECTED_SOCIAL = '@appkit/connected_social';
-const ONRAMP_PREFERRED_COUNTRY = '@appkit/onramp_preferred_country';
-const ONRAMP_COUNTRIES = '@appkit/onramp_countries';
-const ONRAMP_SERVICE_PROVIDERS = '@appkit/onramp_service_providers';
-const ONRAMP_FIAT_LIMITS = '@appkit/onramp_fiat_limits';
-const ONRAMP_FIAT_CURRENCIES = '@appkit/onramp_fiat_currencies';
-const ONRAMP_PREFERRED_FIAT_CURRENCY = '@appkit/onramp_preferred_fiat_currency';
-const ACTIVE_NAMESPACE = '@appkit/active_namespace';
+import { OptionsController } from '../controllers/OptionsController';
+import { LogController } from '../controllers/LogController';
 
 // -- Utility -----------------------------------------------------------------
 export const StorageUtil = {
-  setWalletConnectDeepLink({ href, name }: { href: string; name: string }) {
+  setWalletConnectDeepLink({ href, name }: WalletDeepLink) {
     try {
-      AsyncStorage.setItem(WC_DEEPLINK, JSON.stringify({ href, name }));
-    } catch {
-      console.info('Unable to set WalletConnect deep link');
+      OptionsController.getStorage().setItem(SafeStorageKeys.WC_DEEPLINK, {
+        href,
+        name
+      });
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setWalletConnectDeepLink');
     }
   },
 
   async getWalletConnectDeepLink() {
     try {
-      const deepLink = await AsyncStorage.getItem(WC_DEEPLINK);
+      const deepLink = await OptionsController.getStorage().getItem<WalletDeepLink>(
+        SafeStorageKeys.WC_DEEPLINK
+      );
       if (deepLink) {
-        return JSON.parse(deepLink);
+        return deepLink;
       }
-    } catch {
-      console.info('Unable to get WalletConnect deep link');
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getWalletConnectDeepLink');
     }
 
     return undefined;
@@ -55,9 +45,9 @@ export const StorageUtil = {
 
   async removeWalletConnectDeepLink() {
     try {
-      await AsyncStorage.removeItem(WC_DEEPLINK);
-    } catch {
-      console.info('Unable to delete WalletConnect deep link');
+      await OptionsController.getStorage().removeItem(SafeStorageKeys.WC_DEEPLINK);
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'removeWalletConnectDeepLink');
     }
   },
 
@@ -74,11 +64,11 @@ export const StorageUtil = {
       if (recentWallets.length > 2) {
         recentWallets.pop();
       }
-      AsyncStorage.setItem(RECENT_WALLET, JSON.stringify(recentWallets));
+      OptionsController.getStorage().setItem(SafeStorageKeys.RECENT_WALLET, recentWallets);
 
       return recentWallets;
-    } catch {
-      console.info('Unable to set recent wallet');
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'addRecentWallet');
 
       return undefined;
     }
@@ -86,58 +76,29 @@ export const StorageUtil = {
 
   async setRecentWallets(wallets: WcWallet[]) {
     try {
-      await AsyncStorage.setItem(RECENT_WALLET, JSON.stringify(wallets));
-    } catch {
-      console.info('Unable to set recent wallets');
+      await OptionsController.getStorage().setItem(SafeStorageKeys.RECENT_WALLET, wallets);
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setRecentWallets');
     }
   },
 
   async getRecentWallets(): Promise<WcWallet[]> {
     try {
-      const recent = await AsyncStorage.getItem(RECENT_WALLET);
+      const recent = await OptionsController.getStorage().getItem(SafeStorageKeys.RECENT_WALLET);
 
-      return recent ? JSON.parse(recent) : [];
-    } catch {
-      console.info('Unable to get recent wallets');
+      return recent ?? [];
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getRecentWallets');
     }
 
     return [];
   },
 
-  //TODO: remove this
-  async setConnectedConnector(connectorType: ConnectorType) {
-    try {
-      await AsyncStorage.setItem(CONNECTED_CONNECTOR, JSON.stringify(connectorType));
-    } catch {
-      console.info('Unable to set Connected Connector');
-    }
-  },
-
-  async getConnectedConnector(): Promise<ConnectorType | undefined> {
-    try {
-      const connector = (await AsyncStorage.getItem(CONNECTED_CONNECTOR)) as ConnectorType;
-
-      return connector ? JSON.parse(connector) : undefined;
-    } catch {
-      console.info('Unable to get Connected Connector');
-    }
-
-    return undefined;
-  },
-
-  async removeConnectedConnector() {
-    try {
-      await AsyncStorage.removeItem(CONNECTED_CONNECTOR);
-    } catch {
-      console.info('Unable to remove Connected Connector');
-    }
-  },
-
   async setConnectedConnectors({
     type,
     namespaces
   }: {
-    type: New_ConnectorType;
+    type: ConnectorType;
     namespaces: string[];
   }) {
     try {
@@ -145,144 +106,148 @@ export const StorageUtil = {
       // Only add if it doesn't exist already
       if (!currentConnectors.some(c => c.type === type)) {
         const updatedConnectors = [...currentConnectors, { type, namespaces }];
-        await AsyncStorage.setItem(CONNECTED_CONNECTORS, JSON.stringify(updatedConnectors));
+        await OptionsController.getStorage().setItem(
+          SafeStorageKeys.CONNECTED_CONNECTORS,
+          updatedConnectors
+        );
       }
-    } catch {
-      console.info('Unable to set Connected Connector');
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setConnectedConnectors');
     }
   },
 
-  async getConnectedConnectors(): Promise<{ type: New_ConnectorType; namespaces: string[] }[]> {
+  async getConnectedConnectors(): Promise<{ type: ConnectorType; namespaces: string[] }[]> {
     try {
-      const connectors = await AsyncStorage.getItem(CONNECTED_CONNECTORS);
+      const connectors = await OptionsController.getStorage().getItem<
+        { type: ConnectorType; namespaces: string[] }[]
+      >(SafeStorageKeys.CONNECTED_CONNECTORS);
 
-      return connectors ? JSON.parse(connectors) : [];
-    } catch {
-      console.info('Unable to get Connected Connector');
+      return connectors ?? [];
+    } catch (err) {
+      LogController.sendError(err, 'StorageUtil.ts', 'getConnectedConnectors');
     }
 
     return [];
   },
 
-  async removeConnectedConnectors(type: New_ConnectorType) {
+  async removeConnectedConnectors(type: ConnectorType) {
     try {
       const currentConnectors = await StorageUtil.getConnectedConnectors();
       const updatedConnectors = currentConnectors.filter(c => c.type !== type);
-      await AsyncStorage.setItem(CONNECTED_CONNECTORS, JSON.stringify(updatedConnectors));
-    } catch {
-      console.info('Unable to remove Connected Connector');
+      await OptionsController.getStorage().setItem(
+        SafeStorageKeys.CONNECTED_CONNECTORS,
+        updatedConnectors
+      );
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'removeConnectedConnectors');
     }
   },
 
-  async setConnectedWalletImageUrl(url: string) {
+  async setOnRampPreferredCountry(country: OnRampCountry) {
     try {
-      await AsyncStorage.setItem(CONNECTED_WALLET_IMAGE_URL, url);
-    } catch {
-      console.info('Unable to set Connected Wallet Image URL');
+      await OptionsController.getStorage().setItem(
+        SafeStorageKeys.ONRAMP_PREFERRED_COUNTRY,
+        country
+      );
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setOnRampPreferredCountry');
     }
   },
 
-  async getConnectedWalletImageUrl() {
+  async getOnRampPreferredCountry() {
     try {
-      return await AsyncStorage.getItem(CONNECTED_WALLET_IMAGE_URL);
+      const country = await OptionsController.getStorage().getItem<OnRampCountry>(
+        SafeStorageKeys.ONRAMP_PREFERRED_COUNTRY
+      );
+
+      return country ?? undefined;
     } catch {
-      console.info('Unable to get Connected Wallet Image URL');
+      console.info('Unable to get OnRamp Preferred Country');
     }
 
     return undefined;
   },
 
-  async removeConnectedWalletImageUrl() {
-    try {
-      await AsyncStorage.removeItem(CONNECTED_WALLET_IMAGE_URL);
-    } catch {
-      console.info('Unable to remove Connected Wallet Image URL');
-    }
-  },
-
-  async setConnectedSocialProvider(provider: SocialProvider) {
+  async setOnRampPreferredFiatCurrency(currency: OnRampFiatCurrency) {
     try {
-      await AsyncStorage.setItem(CONNECTED_SOCIAL, JSON.stringify(provider));
-    } catch {
-      console.info('Unable to set Connected Social Provider');
+      await OptionsController.getStorage().setItem(
+        SafeStorageKeys.ONRAMP_PREFERRED_FIAT_CURRENCY,
+        currency
+      );
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setOnRampPreferredFiatCurrency');
     }
   },
 
-  async getConnectedSocialProvider() {
+  async getOnRampPreferredFiatCurrency() {
     try {
-      const provider = (await AsyncStorage.getItem(CONNECTED_SOCIAL)) as SocialProvider;
+      const currency = await OptionsController.getStorage().getItem<OnRampFiatCurrency>(
+        SafeStorageKeys.ONRAMP_PREFERRED_FIAT_CURRENCY
+      );
 
-      return provider ? JSON.parse(provider) : undefined;
-    } catch {
-      console.info('Unable to get Connected Social Provider');
+      return currency ?? undefined;
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getOnRampPreferredFiatCurrency');
     }
 
     return undefined;
   },
 
-  async removeConnectedSocialProvider() {
-    try {
-      await AsyncStorage.removeItem(CONNECTED_SOCIAL);
-    } catch {
-      console.info('Unable to remove Connected Social Provider');
-    }
-  },
-
-  async setOnRampPreferredCountry(country: OnRampCountry) {
+  async setOnRampCountries(countries: OnRampCountry[]) {
     try {
-      await AsyncStorage.setItem(ONRAMP_PREFERRED_COUNTRY, JSON.stringify(country));
-    } catch {
-      console.info('Unable to set OnRamp Preferred Country');
+      await OptionsController.getStorage().setItem(SafeStorageKeys.ONRAMP_COUNTRIES, countries);
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setOnRampCountries');
     }
   },
 
-  async getOnRampPreferredCountry() {
+  async getOnRampCountries() {
     try {
-      const country = await AsyncStorage.getItem(ONRAMP_PREFERRED_COUNTRY);
+      const countries = await OptionsController.getStorage().getItem<OnRampCountry[]>(
+        SafeStorageKeys.ONRAMP_COUNTRIES
+      );
 
-      return country ? (JSON.parse(country) as OnRampCountry) : undefined;
-    } catch {
-      console.info('Unable to get OnRamp Preferred Country');
+      return countries ?? [];
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getOnRampCountries');
     }
 
-    return undefined;
+    return [];
   },
 
-  async setOnRampPreferredFiatCurrency(currency: OnRampFiatCurrency) {
+  async setOnRampCountriesDefaults(countriesDefaults: OnRampCountryDefaults[]) {
     try {
-      await AsyncStorage.setItem(ONRAMP_PREFERRED_FIAT_CURRENCY, JSON.stringify(currency));
-    } catch {
-      console.info('Unable to set OnRamp Preferred Fiat Currency');
+      const timestamp = Date.now();
+
+      await OptionsController.getStorage().setItem(SafeStorageKeys.ONRAMP_COUNTRIES_DEFAULTS, {
+        data: countriesDefaults,
+        timestamp
+      });
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setOnRampCountriesDefaults');
     }
   },
 
-  async getOnRampPreferredFiatCurrency() {
+  async getOnRampCountriesDefaults() {
     try {
-      const currency = await AsyncStorage.getItem(ONRAMP_PREFERRED_FIAT_CURRENCY);
+      const result = await OptionsController.getStorage().getItem(
+        SafeStorageKeys.ONRAMP_COUNTRIES_DEFAULTS
+      );
 
-      return currency ? (JSON.parse(currency) as OnRampFiatCurrency) : undefined;
-    } catch {
-      console.info('Unable to get OnRamp Preferred Fiat Currency');
-    }
+      if (!result) {
+        return [];
+      }
 
-    return undefined;
-  },
+      const { data, timestamp } = result;
 
-  async setOnRampCountries(countries: OnRampCountry[]) {
-    try {
-      await AsyncStorage.setItem(ONRAMP_COUNTRIES, JSON.stringify(countries));
-    } catch {
-      console.info('Unable to set OnRamp Countries');
-    }
-  },
-
-  async getOnRampCountries() {
-    try {
-      const countries = await AsyncStorage.getItem(ONRAMP_COUNTRIES);
+      // Cache for 1 week
+      if (timestamp && DateUtil.isMoreThanOneWeekAgo(timestamp)) {
+        return [];
+      }
 
-      return countries ? (JSON.parse(countries) as OnRampCountry[]) : [];
-    } catch {
-      console.info('Unable to get OnRamp Countries');
+      return (data as OnRampCountryDefaults[]) ?? [];
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getOnRampCountriesDefaults');
     }
 
     return [];
@@ -292,34 +257,35 @@ export const StorageUtil = {
     try {
       const timestamp = Date.now();
 
-      await AsyncStorage.setItem(
-        ONRAMP_SERVICE_PROVIDERS,
-        JSON.stringify({ data: serviceProviders, timestamp })
-      );
-    } catch {
-      console.info('Unable to set OnRamp Service Providers');
+      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 AsyncStorage.getItem(ONRAMP_SERVICE_PROVIDERS);
+      const result = await OptionsController.getStorage().getItem(
+        SafeStorageKeys.ONRAMP_SERVICE_PROVIDERS
+      );
 
       if (!result) {
         return [];
       }
 
-      const { data, timestamp } = JSON.parse(result);
+      const { data, timestamp } = result;
 
       // Cache for 1 week
       if (timestamp && DateUtil.isMoreThanOneWeekAgo(timestamp)) {
         return [];
       }
 
-      return data ? (data as OnRampServiceProvider[]) : [];
+      return (data as OnRampServiceProvider[]) ?? [];
     } catch (err) {
-      console.error(err);
-      console.info('Unable to get OnRamp Service Providers');
+      LogController.sendError(err, 'StorageUtil.ts', 'getOnRampServiceProviders');
     }
 
     return [];
@@ -329,33 +295,35 @@ export const StorageUtil = {
     try {
       const timestamp = Date.now();
 
-      await AsyncStorage.setItem(
-        ONRAMP_FIAT_LIMITS,
-        JSON.stringify({ data: fiatLimits, timestamp })
-      );
-    } catch {
-      console.info('Unable to set OnRamp Fiat Limits');
+      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 AsyncStorage.getItem(ONRAMP_FIAT_LIMITS);
+      const result = await OptionsController.getStorage().getItem(
+        SafeStorageKeys.ONRAMP_FIAT_LIMITS
+      );
 
       if (!result) {
         return [];
       }
 
-      const { data, timestamp } = JSON.parse(result);
+      const { data, timestamp } = result;
 
       // Cache for 1 week
       if (timestamp && DateUtil.isMoreThanOneWeekAgo(timestamp)) {
         return [];
       }
 
-      return data ? (data as OnRampFiatLimit[]) : [];
-    } catch {
-      console.info('Unable to get OnRamp Fiat Limits');
+      return (data as OnRampFiatLimit[]) ?? [];
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getOnRampFiatLimits');
     }
 
     return [];
@@ -365,33 +333,35 @@ export const StorageUtil = {
     try {
       const timestamp = Date.now();
 
-      await AsyncStorage.setItem(
-        ONRAMP_FIAT_CURRENCIES,
-        JSON.stringify({ data: fiatCurrencies, timestamp })
-      );
-    } catch {
-      console.info('Unable to set OnRamp Fiat Currencies');
+      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 AsyncStorage.getItem(ONRAMP_FIAT_CURRENCIES);
+      const result = await OptionsController.getStorage().getItem(
+        SafeStorageKeys.ONRAMP_FIAT_CURRENCIES
+      );
 
       if (!result) {
         return [];
       }
 
-      const { data, timestamp } = JSON.parse(result);
+      const { data, timestamp } = result;
 
       // Cache for 1 week
       if (timestamp && DateUtil.isMoreThanOneWeekAgo(timestamp)) {
         return [];
       }
 
-      return data ? (data as OnRampFiatCurrency[]) : [];
-    } catch {
-      console.info('Unable to get OnRamp Fiat Currencies');
+      return (data as OnRampFiatCurrency[]) ?? [];
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getOnRampFiatCurrencies');
     }
 
     return [];
@@ -400,24 +370,26 @@ export const StorageUtil = {
   async setActiveNamespace(namespace?: ChainNamespace) {
     try {
       if (!namespace) {
-        await AsyncStorage.removeItem(ACTIVE_NAMESPACE);
+        await OptionsController.getStorage().removeItem(SafeStorageKeys.ACTIVE_NAMESPACE);
 
         return;
       }
 
-      await AsyncStorage.setItem(ACTIVE_NAMESPACE, namespace);
-    } catch {
-      console.info('Unable to set Active Namespace');
+      await OptionsController.getStorage().setItem(SafeStorageKeys.ACTIVE_NAMESPACE, namespace);
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setActiveNamespace');
     }
   },
 
   async getActiveNamespace() {
     try {
-      const namespace = (await AsyncStorage.getItem(ACTIVE_NAMESPACE)) as ChainNamespace;
+      const namespace = (await OptionsController.getStorage().getItem(
+        SafeStorageKeys.ACTIVE_NAMESPACE
+      )) as ChainNamespace;
 
       return namespace ?? undefined;
     } catch (err) {
-      console.info('Unable to get Active Namespace');
+      LogController.sendError(err, 'StorageUtil.ts', 'getActiveNamespace');
     }
 
     return undefined;
@@ -425,9 +397,9 @@ export const StorageUtil = {
 
   async removeActiveNamespace() {
     try {
-      await AsyncStorage.removeItem(ACTIVE_NAMESPACE);
-    } catch {
-      console.info('Unable to remove Active Namespace');
+      await OptionsController.getStorage().removeItem(SafeStorageKeys.ACTIVE_NAMESPACE);
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'removeActiveNamespace');
     }
   }
 };

package/src/utils/SwapApiUtil.ts

@@ -1,13 +1,12 @@
-import { BlockchainApiController } from '../controllers/BlockchainApiController';
-import { OptionsController } from '../controllers/OptionsController';
 import type {
-  BlockchainApiBalanceResponse,
+  Balance,
+  CaipNetworkId,
   BlockchainApiSwapAllowanceRequest,
   SwapTokenWithBalance
-} from './TypeUtil';
-import { AccountController } from '../controllers/AccountController';
+} from '@reown/appkit-common-react-native';
+import { BlockchainApiController } from '../controllers/BlockchainApiController';
+import { OptionsController } from '../controllers/OptionsController';
 import { ConnectionsController } from '../controllers/ConnectionsController';
-import type { CaipNetworkId } from '@reown/appkit-common-react-native';
 import { ConstantsUtil } from './ConstantsUtil';
 
 export const SwapApiUtil = {
@@ -64,43 +63,25 @@ export const SwapApiUtil = {
     return false;
   },
 
-  async getMyTokensWithBalance(forceUpdate?: string) {
-    const { activeAddress, activeNetwork: network } = ConnectionsController.state;
-    const address = activeAddress?.split(':')[2];
-
-    if (!address) {
-      return [];
-    }
-
-    const response = await BlockchainApiController.getBalance(
-      address,
-      network?.caipNetworkId,
-      forceUpdate
-    );
-    const balances = response?.balances.filter(balance => balance.quantity.decimals !== '0');
-
-    AccountController.setTokenBalance(balances);
-
-    return this.mapBalancesToSwapTokens(balances);
-  },
-
-  mapBalancesToSwapTokens(balances?: BlockchainApiBalanceResponse['balances']) {
+  mapBalancesToSwapTokens(balances?: Balance[]) {
     const { activeNamespace, activeCaipNetworkId } = ConnectionsController.state;
     const address = activeNamespace
       ? ConstantsUtil.NATIVE_TOKEN_ADDRESS[activeNamespace]
       : undefined;
 
     return (
-      balances?.map(
-        token =>
-          ({
-            ...token,
-            address: token?.address ?? `${token?.chainId ?? activeCaipNetworkId}:${address}`,
-            decimals: parseInt(token.quantity.decimals, 10),
-            logoUri: token.iconUrl,
-            eip2612: false
-          }) as SwapTokenWithBalance
-      ) || []
+      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
+        ) || []
     );
   },
 

package/src/utils/SwapCalculationUtil.ts

@@ -1,7 +1,6 @@
 // -- Types --------------------------------------------- //
 
-import { NumberUtil } from '@reown/appkit-common-react-native';
-import type { SwapTokenWithBalance } from './TypeUtil';
+import { NumberUtil, type SwapTokenWithBalance } from '@reown/appkit-common-react-native';
 
 // -- Util ---------------------------------------- //
 export const SwapCalculationUtil = {