@reown/appkit-core-react-native 0.0.0-feat-coinbase-20250722202925 → 0.0.0-feat-onramp-20250722205908

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;
@@ -88,20 +88,41 @@ export class FetchUtil {
   }
 
   private createUrl({ path, params }: RequestArguments) {
-    const url = new URL(path, this.baseUrl);
-    if (params) {
-      Object.entries(params).forEach(([key, value]) => {
-        if (value) {
-          url.searchParams.append(key, value);
-        }
-      });
+    let fullUrl: string;
+
+    const isAbsoluteUrl = path.startsWith('http://') || path.startsWith('https://');
+
+    if (isAbsoluteUrl) {
+      fullUrl = path;
+    } else {
+      const baseUrl = this.baseUrl.endsWith('/') ? this.baseUrl : `${this.baseUrl}/`;
+      const pathUrl = path.startsWith('/') ? path.substring(1) : path;
+      fullUrl = `${baseUrl}${pathUrl}`;
     }
 
+    const allParams: Record<string, string | undefined> = { ...params };
     if (this.clientId) {
-      url.searchParams.append('clientId', this.clientId);
+      allParams['clientId'] = this.clientId;
+    }
+
+    const queryParams: string[] = [];
+    for (const key in allParams) {
+      const value = allParams[key];
+      if (value !== undefined) {
+        queryParams.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+      }
+    }
+
+    if (queryParams.length > 0) {
+      const queryString = queryParams.join('&');
+      if (fullUrl.includes('?')) {
+        fullUrl = `${fullUrl}&${queryString}`;
+      } else {
+        fullUrl = `${fullUrl}?${queryString}`;
+      }
     }
 
-    return url.toString();
+    return fullUrl;
   }
 
   private async processResponse<T>(response: Response) {

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/StorageUtil.ts

@@ -2,6 +2,7 @@
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import type {
   OnRampCountry,
+  OnRampCountryDefaults,
   OnRampFiatCurrency,
   OnRampFiatLimit,
   OnRampServiceProvider,
@@ -10,24 +11,22 @@ import type {
 import {
   DateUtil,
   type SocialProvider,
-  type ConnectorType,
-  type ChainNamespace
+  type ConnectorType
 } 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_CONNECTORS = '@appkit/connected_connectors';
+const CONNECTED_CONNECTOR = '@w3m/connected_connector';
 const CONNECTED_SOCIAL = '@appkit/connected_social';
 const ONRAMP_PREFERRED_COUNTRY = '@appkit/onramp_preferred_country';
 const ONRAMP_COUNTRIES = '@appkit/onramp_countries';
+const ONRAMP_COUNTRIES_DEFAULTS = '@appkit/onramp_countries_defaults';
 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 = {
   setWalletConnectDeepLink({ href, name }: { href: string; name: string }) {
@@ -102,42 +101,29 @@ export const StorageUtil = {
     return [];
   },
 
-  async setConnectedConnectors({
-    type,
-    namespaces
-  }: {
-    type: ConnectorType;
-    namespaces: string[];
-  }) {
+  async setConnectedConnector(connectorType: ConnectorType) {
     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));
-      }
+      await AsyncStorage.setItem(CONNECTED_CONNECTOR, JSON.stringify(connectorType));
     } catch {
       console.info('Unable to set Connected Connector');
     }
   },
 
-  async getConnectedConnectors(): Promise<{ type: ConnectorType; namespaces: string[] }[]> {
+  async getConnectedConnector(): Promise<ConnectorType | undefined> {
     try {
-      const connectors = await AsyncStorage.getItem(CONNECTED_CONNECTORS);
+      const connector = (await AsyncStorage.getItem(CONNECTED_CONNECTOR)) as ConnectorType;
 
-      return connectors ? JSON.parse(connectors) : [];
+      return connector ? JSON.parse(connector) : undefined;
     } catch {
       console.info('Unable to get Connected Connector');
     }
 
-    return [];
+    return undefined;
   },
 
-  async removeConnectedConnectors(type: ConnectorType) {
+  async removeConnectedConnector() {
     try {
-      const currentConnectors = await StorageUtil.getConnectedConnectors();
-      const updatedConnectors = currentConnectors.filter(c => c.type !== type);
-      await AsyncStorage.setItem(CONNECTED_CONNECTORS, JSON.stringify(updatedConnectors));
+      await AsyncStorage.removeItem(CONNECTED_CONNECTOR);
     } catch {
       console.info('Unable to remove Connected Connector');
     }
@@ -257,6 +243,42 @@ export const StorageUtil = {
     return [];
   },
 
+  async setOnRampCountriesDefaults(countriesDefaults: OnRampCountryDefaults[]) {
+    try {
+      const timestamp = Date.now();
+
+      await AsyncStorage.setItem(
+        ONRAMP_COUNTRIES_DEFAULTS,
+        JSON.stringify({ data: countriesDefaults, timestamp })
+      );
+    } catch {
+      console.info('Unable to set OnRamp Countries Defaults');
+    }
+  },
+
+  async getOnRampCountriesDefaults() {
+    try {
+      const result = await AsyncStorage.getItem(ONRAMP_COUNTRIES_DEFAULTS);
+
+      if (!result) {
+        return [];
+      }
+
+      const { data, timestamp } = JSON.parse(result);
+
+      // Cache for 1 week
+      if (timestamp && DateUtil.isMoreThanOneWeekAgo(timestamp)) {
+        return [];
+      }
+
+      return data ? (data as OnRampCountryDefaults[]) : [];
+    } catch {
+      console.info('Unable to get OnRamp Countries Defaults');
+    }
+
+    return [];
+  },
+
   async setOnRampServiceProviders(serviceProviders: OnRampServiceProvider[]) {
     try {
       const timestamp = Date.now();
@@ -364,39 +386,5 @@ export const StorageUtil = {
     }
 
     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

@@ -1,17 +1,19 @@
-import type { Balance, CaipNetworkId } from '@reown/appkit-common-react-native';
 import { BlockchainApiController } from '../controllers/BlockchainApiController';
 import { OptionsController } from '../controllers/OptionsController';
-import type { BlockchainApiSwapAllowanceRequest, SwapTokenWithBalance } from './TypeUtil';
-import { ConnectionsController } from '../controllers/ConnectionsController';
-import { ConstantsUtil } from './ConstantsUtil';
+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 chainId: CaipNetworkId =
-      ConnectionsController.state.activeNetwork?.caipNetworkId ?? 'eip155:1';
     const response = await BlockchainApiController.fetchSwapTokens({
       projectId: OptionsController.state.projectId,
-      chainId
+      chainId: NetworkController.state.caipNetwork?.id
     });
     const tokens =
       response?.tokens?.map(
@@ -50,7 +52,7 @@ export const SwapApiUtil = {
 
     if (response?.allowance && sourceTokenAmount && sourceTokenDecimals) {
       const parsedValue =
-        ConnectionsController.parseUnits(sourceTokenAmount, sourceTokenDecimals) || 0;
+        ConnectionController.parseUnits(sourceTokenAmount, sourceTokenDecimals) || 0;
       const hasAllowance = BigInt(response.allowance) >= parsedValue;
 
       return hasAllowance;
@@ -59,31 +61,40 @@ export const SwapApiUtil = {
     return false;
   },
 
-  mapBalancesToSwapTokens(balances?: Balance[]) {
-    const { activeNamespace, activeCaipNetworkId } = ConnectionsController.state;
-    const address = activeNamespace
-      ? ConstantsUtil.NATIVE_TOKEN_ADDRESS[activeNamespace]
-      : undefined;
+  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
-        ?.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
-        ) || []
+      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 = ConnectionsController.state.activeNetwork;
+    const caipNetwork = NetworkController.state.caipNetwork;
 
     if (!caipNetwork) {
       return null;
@@ -91,7 +102,7 @@ export const SwapApiUtil = {
 
     return await BlockchainApiController.fetchGasPrice({
       projectId,
-      chainId: caipNetwork.caipNetworkId
+      chainId: caipNetwork.id
     });
   }
 };