@reown/appkit-core-react-native 1.2.3 → 2.0.0-alpha.0

package/src/utils/CoreHelperUtil.ts

@@ -1,11 +1,17 @@
 /* eslint-disable no-bitwise */
 
 import { Linking, Platform } from 'react-native';
-import { ConstantsUtil as CommonConstants, type Balance } from '@reown/appkit-common-react-native';
+import {
+  ConstantsUtil as CommonConstants,
+  type Balance,
+  type CaipAddress,
+  type CaipNetwork
+} from '@reown/appkit-common-react-native';
 
-import { ConstantsUtil } from './ConstantsUtil';
-import type { CaipAddress, CaipNetwork, DataWallet, LinkingRecord } from './TypeUtil';
+import * as ct from 'countries-and-timezones';
 
+import { ConstantsUtil } from './ConstantsUtil';
+import type { DataWallet, LinkingRecord } from './TypeUtil';
 // -- Helpers -----------------------------------------------------------------
 async function isAppInstalledIos(deepLink?: string): Promise<boolean> {
   try {
@@ -172,10 +178,25 @@ export const CoreHelperUtil = {
     return CommonConstants.BLOCKCHAIN_API_RPC_URL;
   },
 
+  getBlockchainStagingApiUrl() {
+    return CommonConstants.BLOCKCHAIN_API_RPC_URL_STAGING;
+  },
+
   getAnalyticsUrl() {
     return CommonConstants.PULSE_API_URL;
   },
 
+  getCountryFromTimezone() {
+    try {
+      const { timeZone } = new Intl.DateTimeFormat().resolvedOptions();
+      const country = ct.getCountryForTimezone(timeZone);
+
+      return country ? country.id : 'US'; // 'id' is the ISO country code (e.g., "GB" for United Kingdom)
+    } catch (error) {
+      return 'US';
+    }
+  },
+
   getUUID() {
     if ((global as any)?.crypto.getRandomValues) {
       const buffer = new Uint8Array(16);
@@ -287,5 +308,19 @@ export const CoreHelperUtil = {
     }
 
     return requested;
+  },
+
+  debounce<F extends (...args: any[]) => any>(func: F, wait: number) {
+    let timeout: ReturnType<typeof setTimeout> | null = null;
+
+    return function (...args: Parameters<F>) {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+
+      timeout = setTimeout(() => {
+        func(...args);
+      }, wait);
+    };
   }
 };

package/src/utils/FetchUtil.ts

@@ -8,7 +8,7 @@ interface Options {
 
 interface RequestArguments {
   path: string;
-  headers?: HeadersInit_;
+  headers?: HeadersInit;
   params?: Record<string, string | undefined>;
   cache?: RequestCache;
   signal?: AbortSignal;
@@ -28,41 +28,44 @@ export class FetchUtil {
     this.clientId = clientId;
   }
 
-  public async get<T>({ headers, ...args }: RequestArguments) {
+  public async get<T>({ headers, signal, ...args }: RequestArguments) {
     const url = this.createUrl(args);
-    const response = await fetch(url, { method: 'GET', headers });
+    const response = await fetch(url, { method: 'GET', headers, signal });
 
     return this.processResponse<T>(response);
   }
 
-  public async post<T>({ body, headers, ...args }: PostArguments) {
+  public async post<T>({ body, headers, signal, ...args }: PostArguments) {
     const url = this.createUrl(args);
     const response = await fetch(url, {
       method: 'POST',
       headers,
-      body: body ? JSON.stringify(body) : undefined
+      body: body ? JSON.stringify(body) : undefined,
+      signal
     });
 
     return this.processResponse<T>(response);
   }
 
-  public async put<T>({ body, headers, ...args }: PostArguments) {
+  public async put<T>({ body, headers, signal, ...args }: PostArguments) {
     const url = this.createUrl(args);
     const response = await fetch(url, {
       method: 'PUT',
       headers,
-      body: body ? JSON.stringify(body) : undefined
+      body: body ? JSON.stringify(body) : undefined,
+      signal
     });
 
     return this.processResponse<T>(response);
   }
 
-  public async delete<T>({ body, headers, ...args }: PostArguments) {
+  public async delete<T>({ body, headers, signal, ...args }: PostArguments) {
     const url = this.createUrl(args);
     const response = await fetch(url, {
       method: 'DELETE',
       headers,
-      body: body ? JSON.stringify(body) : undefined
+      body: body ? JSON.stringify(body) : undefined,
+      signal
     });
 
     return this.processResponse<T>(response);
@@ -103,6 +106,10 @@ export class FetchUtil {
 
   private async processResponse<T>(response: Response) {
     if (!response.ok) {
+      if (response.headers.get('content-type')?.includes('application/json')) {
+        return Promise.reject((await response.json()) as T);
+      }
+
       const errorText = await response.text();
 
       return Promise.reject(`Code: ${response.status} - ${response.statusText} - ${errorText}`);

package/src/utils/NetworkUtil.ts

@@ -4,7 +4,7 @@ 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';
+import { type CaipNetwork } from '@reown/appkit-common-react-native';
 
 export const NetworkUtil = {
   async handleNetworkSwitch(network: CaipNetwork) {

package/src/utils/StorageUtil.ts

@@ -1,14 +1,34 @@
 /* eslint-disable no-console */
 import AsyncStorage from '@react-native-async-storage/async-storage';
-import type { WcWallet } from './TypeUtil';
-import type { SocialProvider, ConnectorType } from '@reown/appkit-common-react-native';
+import type {
+  OnRampCountry,
+  OnRampFiatCurrency,
+  OnRampFiatLimit,
+  OnRampServiceProvider,
+  WcWallet
+} from './TypeUtil';
+import {
+  DateUtil,
+  type SocialProvider,
+  type New_ConnectorType,
+  type ConnectorType,
+  type ChainNamespace
+} 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';
 
 // -- Utility -----------------------------------------------------------------
 export const StorageUtil = {
@@ -84,6 +104,7 @@ export const StorageUtil = {
     return [];
   },
 
+  //TODO: remove this
   async setConnectedConnector(connectorType: ConnectorType) {
     try {
       await AsyncStorage.setItem(CONNECTED_CONNECTOR, JSON.stringify(connectorType));
@@ -112,6 +133,47 @@ export const StorageUtil = {
     }
   },
 
+  async setConnectedConnectors({
+    type,
+    namespaces
+  }: {
+    type: New_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 AsyncStorage.setItem(CONNECTED_CONNECTORS, JSON.stringify(updatedConnectors));
+      }
+    } catch {
+      console.info('Unable to set Connected Connector');
+    }
+  },
+
+  async getConnectedConnectors(): Promise<{ type: New_ConnectorType; namespaces: string[] }[]> {
+    try {
+      const connectors = await AsyncStorage.getItem(CONNECTED_CONNECTORS);
+
+      return connectors ? JSON.parse(connectors) : [];
+    } catch {
+      console.info('Unable to get Connected Connector');
+    }
+
+    return [];
+  },
+
+  async removeConnectedConnectors(type: New_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');
+    }
+  },
+
   async setConnectedWalletImageUrl(url: string) {
     try {
       await AsyncStorage.setItem(CONNECTED_WALLET_IMAGE_URL, url);
@@ -164,5 +226,208 @@ export const StorageUtil = {
     } catch {
       console.info('Unable to remove Connected Social Provider');
     }
+  },
+
+  async setOnRampPreferredCountry(country: OnRampCountry) {
+    try {
+      await AsyncStorage.setItem(ONRAMP_PREFERRED_COUNTRY, JSON.stringify(country));
+    } catch {
+      console.info('Unable to set OnRamp Preferred Country');
+    }
+  },
+
+  async getOnRampPreferredCountry() {
+    try {
+      const country = await AsyncStorage.getItem(ONRAMP_PREFERRED_COUNTRY);
+
+      return country ? (JSON.parse(country) as OnRampCountry) : undefined;
+    } catch {
+      console.info('Unable to get OnRamp Preferred Country');
+    }
+
+    return undefined;
+  },
+
+  async setOnRampPreferredFiatCurrency(currency: OnRampFiatCurrency) {
+    try {
+      await AsyncStorage.setItem(ONRAMP_PREFERRED_FIAT_CURRENCY, JSON.stringify(currency));
+    } catch {
+      console.info('Unable to set OnRamp Preferred Fiat Currency');
+    }
+  },
+
+  async getOnRampPreferredFiatCurrency() {
+    try {
+      const currency = await AsyncStorage.getItem(ONRAMP_PREFERRED_FIAT_CURRENCY);
+
+      return currency ? (JSON.parse(currency) as OnRampFiatCurrency) : undefined;
+    } catch {
+      console.info('Unable to get OnRamp Preferred Fiat Currency');
+    }
+
+    return undefined;
+  },
+
+  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);
+
+      return countries ? (JSON.parse(countries) as OnRampCountry[]) : [];
+    } catch {
+      console.info('Unable to get OnRamp Countries');
+    }
+
+    return [];
+  },
+
+  async setOnRampServiceProviders(serviceProviders: OnRampServiceProvider[]) {
+    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');
+    }
+  },
+
+  async getOnRampServiceProviders() {
+    try {
+      const result = await AsyncStorage.getItem(ONRAMP_SERVICE_PROVIDERS);
+
+      if (!result) {
+        return [];
+      }
+
+      const { data, timestamp } = JSON.parse(result);
+
+      // Cache for 1 week
+      if (timestamp && DateUtil.isMoreThanOneWeekAgo(timestamp)) {
+        return [];
+      }
+
+      return data ? (data as OnRampServiceProvider[]) : [];
+    } catch (err) {
+      console.error(err);
+      console.info('Unable to get OnRamp Service Providers');
+    }
+
+    return [];
+  },
+
+  async setOnRampFiatLimits(fiatLimits: OnRampFiatLimit[]) {
+    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');
+    }
+  },
+
+  async getOnRampFiatLimits() {
+    try {
+      const result = await AsyncStorage.getItem(ONRAMP_FIAT_LIMITS);
+
+      if (!result) {
+        return [];
+      }
+
+      const { data, timestamp } = JSON.parse(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 [];
+  },
+
+  async setOnRampFiatCurrencies(fiatCurrencies: OnRampFiatCurrency[]) {
+    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');
+    }
+  },
+
+  async getOnRampFiatCurrencies() {
+    try {
+      const result = await AsyncStorage.getItem(ONRAMP_FIAT_CURRENCIES);
+
+      if (!result) {
+        return [];
+      }
+
+      const { data, timestamp } = JSON.parse(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 [];
+  },
+
+  async setActiveNamespace(namespace?: ChainNamespace) {
+    try {
+      if (!namespace) {
+        await AsyncStorage.removeItem(ACTIVE_NAMESPACE);
+
+        return;
+      }
+
+      await AsyncStorage.setItem(ACTIVE_NAMESPACE, namespace);
+    } catch {
+      console.info('Unable to set Active Namespace');
+    }
+  },
+
+  async getActiveNamespace() {
+    try {
+      const namespace = (await AsyncStorage.getItem(ACTIVE_NAMESPACE)) as ChainNamespace;
+
+      return namespace ?? undefined;
+    } catch (err) {
+      console.info('Unable to get Active Namespace');
+    }
+
+    return undefined;
+  },
+
+  async removeActiveNamespace() {
+    try {
+      await AsyncStorage.removeItem(ACTIVE_NAMESPACE);
+    } catch {
+      console.info('Unable to remove Active Namespace');
+    }
   }
 };

package/src/utils/SwapApiUtil.ts

@@ -8,12 +8,14 @@ import type {
 } from './TypeUtil';
 import { AccountController } from '../controllers/AccountController';
 import { ConnectionController } from '../controllers/ConnectionController';
+import { ConnectionsController } from '../controllers/ConnectionsController';
 
 export const SwapApiUtil = {
   async getTokenList() {
+    const chainId = ConnectionsController.state.activeNetwork?.caipNetworkId ?? 'eip155:1';
     const response = await BlockchainApiController.fetchSwapTokens({
       projectId: OptionsController.state.projectId,
-      chainId: NetworkController.state.caipNetwork?.id
+      chainId
     });
     const tokens =
       response?.tokens?.map(
@@ -62,14 +64,18 @@ export const SwapApiUtil = {
   },
 
   async getMyTokensWithBalance(forceUpdate?: string) {
-    const address = AccountController.state.address;
-    const chainId = NetworkController.state.caipNetwork?.id;
+    const { activeAddress, activeNetwork: network } = ConnectionsController.state;
+    const address = activeAddress?.split(':')[2];
 
     if (!address) {
       return [];
     }
 
-    const response = await BlockchainApiController.getBalance(address, chainId, forceUpdate);
+    const response = await BlockchainApiController.getBalance(
+      address,
+      network?.caipNetworkId,
+      forceUpdate
+    );
     const balances = response?.balances.filter(balance => balance.quantity.decimals !== '0');
 
     AccountController.setTokenBalance(balances);