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

package/src/controllers/BlockchainApiController.ts

@@ -32,14 +32,12 @@ import type {
   OnRampQuote,
   BlockchainApiOnRampWidgetRequest,
   BlockchainApiOnRampQuotesRequest,
-  OnRampFiatLimit
+  OnRampFiatLimit,
+  OnRampCountryDefaults
 } from '../utils/TypeUtil';
 import { OptionsController } from './OptionsController';
 import { ConstantsUtil } from '../utils/ConstantsUtil';
 import { ApiUtil } from '../utils/ApiUtil';
-import type { CaipAddress, CaipNetworkId } from '@reown/appkit-common-react-native';
-
-import { SnackController } from './SnackController';
 
 // -- Helpers ------------------------------------------- //
 const baseUrl = CoreHelperUtil.getBlockchainApiUrl();
@@ -56,59 +54,25 @@ const getHeaders = () => {
   };
 };
 
-// -- Types --------------------------------------------- //
-type WithCaipNetworkId = { caipNetworkId: CaipNetworkId };
+export const EXCLUDED_ONRAMP_PROVIDERS = ['BINANCECONNECT', 'COINBASEPAY'];
 
+// -- Types --------------------------------------------- //
 export interface BlockchainApiControllerState {
   clientId: string | null;
   api: FetchUtil;
-  supportedChains: { http: CaipNetworkId[]; ws: CaipNetworkId[] };
 }
 
 // -- State --------------------------------------------- //
 const state = proxy<BlockchainApiControllerState>({
   clientId: null,
-  api: new FetchUtil({ baseUrl }),
-  supportedChains: { http: [], ws: [] }
+  api: new FetchUtil({ baseUrl })
 });
 
 // -- Controller ---------------------------------------- //
 export const BlockchainApiController = {
   state,
 
-  async isNetworkSupported(networkId?: CaipNetworkId) {
-    if (!networkId) {
-      return false;
-    }
-    try {
-      if (!state.supportedChains.http.length) {
-        await BlockchainApiController.getSupportedNetworks();
-      }
-    } catch (e) {
-      return false;
-    }
-
-    return state.supportedChains.http.includes(networkId);
-  },
-
-  async getSupportedNetworks() {
-    const supportedChains = await state.api.get<BlockchainApiControllerState['supportedChains']>({
-      path: 'v1/supported-chains'
-    });
-
-    state.supportedChains = supportedChains!;
-
-    return supportedChains;
-  },
-
-  async fetchIdentity(params: BlockchainApiIdentityRequest & WithCaipNetworkId) {
-    const { address, caipNetworkId } = params;
-    const isSupported = await BlockchainApiController.isNetworkSupported(caipNetworkId);
-
-    if (!isSupported) {
-      return { avatar: '', name: '' };
-    }
-
+  fetchIdentity({ address }: BlockchainApiIdentityRequest) {
     return state.api.get<BlockchainApiIdentityResponse>({
       path: `/v1/identity/${address}`,
       params: {
@@ -118,39 +82,29 @@ export const BlockchainApiController = {
     });
   },
 
-  async fetchTransactions(params: BlockchainApiTransactionsRequest) {
-    const { account, projectId, cursor, onramp, signal, cache, chainId } = params;
-    const isSupported = await BlockchainApiController.isNetworkSupported(chainId);
-
-    if (!isSupported) {
-      return { data: [], next: undefined };
-    }
-
-    const response = await state.api.get<BlockchainApiTransactionsResponse>({
+  fetchTransactions({
+    account,
+    projectId,
+    cursor,
+    onramp,
+    signal,
+    cache
+  }: BlockchainApiTransactionsRequest) {
+    return state.api.get<BlockchainApiTransactionsResponse>({
       path: `/v1/account/${account}/history`,
       headers: getHeaders(),
       params: {
         projectId,
         cursor,
-        onramp,
-        chainId
+        onramp
       },
       signal,
       cache
     });
-
-    return response;
   },
 
-  async fetchTokenPrice(params: BlockchainApiTokenPriceRequest & WithCaipNetworkId) {
-    const { projectId, addresses, caipNetworkId } = params;
-    const isSupported = await BlockchainApiController.isNetworkSupported(caipNetworkId);
-
-    if (!isSupported) {
-      return { fungibles: [] };
-    }
-
-    const response = await state.api.post<BlockchainApiTokenPriceResponse>({
+  fetchTokenPrice({ projectId, addresses }: BlockchainApiTokenPriceRequest) {
+    return state.api.post<BlockchainApiTokenPriceResponse>({
       path: '/v1/fungible/price',
       body: {
         projectId,
@@ -159,20 +113,9 @@ export const BlockchainApiController = {
       },
       headers: getHeaders()
     });
-
-    return response;
   },
 
-  async fetchSwapAllowance(params: BlockchainApiSwapAllowanceRequest) {
-    const { projectId, tokenAddress, userAddress } = params;
-    const [namespace, chain] = userAddress.split(':');
-    const networkId: CaipNetworkId = `${namespace}:${chain}`;
-    const isSupported = await BlockchainApiController.isNetworkSupported(networkId);
-
-    if (!isSupported) {
-      return { allowance: '0' };
-    }
-
+  fetchSwapAllowance({ projectId, tokenAddress, userAddress }: BlockchainApiSwapAllowanceRequest) {
     return state.api.get<BlockchainApiSwapAllowanceResponse>({
       path: `/v1/convert/allowance`,
       params: {
@@ -184,14 +127,7 @@ export const BlockchainApiController = {
     });
   },
 
-  async fetchGasPrice(params: BlockchainApiGasPriceRequest) {
-    const { projectId, chainId } = params;
-    const isSupported = await BlockchainApiController.isNetworkSupported(chainId);
-
-    if (!isSupported) {
-      throw new Error('Network not supported for Gas Price');
-    }
-
+  fetchGasPrice({ projectId, chainId }: BlockchainApiGasPriceRequest) {
     return state.api.get<BlockchainApiGasPriceResponse>({
       path: `/v1/convert/gas-price`,
       headers: getHeaders(),
@@ -202,16 +138,14 @@ export const BlockchainApiController = {
     });
   },
 
-  async fetchSwapQuote(params: BlockchainApiSwapQuoteRequest) {
-    const { projectId, amount, userAddress, from, to, gasPrice } = params;
-    const [namespace, chain] = userAddress.split(':');
-    const networkId: CaipNetworkId = `${namespace}:${chain}`;
-    const isSupported = await BlockchainApiController.isNetworkSupported(networkId);
-
-    if (!isSupported) {
-      return { quotes: [] };
-    }
-
+  fetchSwapQuote({
+    projectId,
+    amount,
+    userAddress,
+    from,
+    to,
+    gasPrice
+  }: BlockchainApiSwapQuoteRequest) {
     return state.api.get<BlockchainApiSwapQuoteResponse>({
       path: `/v1/convert/quotes`,
       headers: getHeaders(),
@@ -226,14 +160,7 @@ export const BlockchainApiController = {
     });
   },
 
-  async fetchSwapTokens(params: BlockchainApiSwapTokensRequest) {
-    const { projectId, chainId } = params;
-    const isSupported = await BlockchainApiController.isNetworkSupported(chainId);
-
-    if (!isSupported) {
-      return { tokens: [] };
-    }
-
+  fetchSwapTokens({ projectId, chainId }: BlockchainApiSwapTokensRequest) {
     return state.api.get<BlockchainApiSwapTokensResponse>({
       path: `/v1/convert/tokens`,
       headers: getHeaders(),
@@ -244,16 +171,13 @@ export const BlockchainApiController = {
     });
   },
 
-  async generateSwapCalldata(params: BlockchainApiGenerateSwapCalldataRequest) {
-    const { amount, from, projectId, to, userAddress } = params;
-    const [namespace, chain] = userAddress.split(':');
-    const networkId: CaipNetworkId = `${namespace}:${chain}`;
-    const isSupported = await BlockchainApiController.isNetworkSupported(networkId);
-
-    if (!isSupported) {
-      throw new Error('Network not supported for Swaps');
-    }
-
+  generateSwapCalldata({
+    amount,
+    from,
+    projectId,
+    to,
+    userAddress
+  }: BlockchainApiGenerateSwapCalldataRequest) {
     return state.api.post<BlockchainApiGenerateSwapCalldataResponse>({
       path: '/v1/convert/build-transaction',
       headers: getHeaders(),
@@ -270,16 +194,12 @@ export const BlockchainApiController = {
     });
   },
 
-  async generateApproveCalldata(params: BlockchainApiGenerateApproveCalldataRequest) {
-    const { from, projectId, to, userAddress } = params;
-    const [namespace, chain] = userAddress.split(':');
-    const networkId: CaipNetworkId = `${namespace}:${chain}`;
-    const isSupported = await BlockchainApiController.isNetworkSupported(networkId);
-
-    if (!isSupported) {
-      throw new Error('Network not supported for Swaps');
-    }
-
+  generateApproveCalldata({
+    from,
+    projectId,
+    to,
+    userAddress
+  }: BlockchainApiGenerateApproveCalldataRequest) {
     return state.api.get<BlockchainApiGenerateApproveCalldataResponse>({
       path: `/v1/convert/build-approve`,
       headers: getHeaders(),
@@ -292,29 +212,15 @@ export const BlockchainApiController = {
     });
   },
 
-  async getBalance(address?: CaipAddress, forceUpdate?: CaipAddress[]) {
-    const [namespace, chain, plainAddress] = address?.split(':') ?? [];
-
-    if (!namespace || !chain || !plainAddress) {
-      throw new Error('Invalid address');
-    }
-
-    const isSupported = await BlockchainApiController.isNetworkSupported(`${namespace}:${chain}`);
-
-    if (!isSupported) {
-      SnackController.showError('Token Balance Unavailable');
-
-      return { balances: [] };
-    }
-
+  async getBalance(address: string, chainId?: string, forceUpdate?: string) {
     return state.api.get<BlockchainApiBalanceResponse>({
-      path: `/v1/account/${plainAddress}/balance`,
+      path: `/v1/account/${address}/balance`,
       headers: getHeaders(),
       params: {
         currency: 'usd',
         projectId: OptionsController.state.projectId,
-        chainId: `${namespace}:${chain}`,
-        forceUpdate: forceUpdate?.join(',')
+        chainId,
+        forceUpdate
       }
     });
   },
@@ -330,17 +236,6 @@ export const BlockchainApiController = {
     });
   },
 
-  async fetchOnRampCountries() {
-    return await state.api.get<OnRampCountry[]>({
-      path: '/v1/onramp/providers/properties',
-      headers: getHeaders(),
-      params: {
-        projectId: OptionsController.state.projectId,
-        type: 'countries'
-      }
-    });
-  },
-
   async fetchOnRampServiceProviders() {
     return await state.api.get<OnRampServiceProvider[]>({
       path: '/v1/onramp/providers',
@@ -351,48 +246,39 @@ export const BlockchainApiController = {
     });
   },
 
+  async fetchOnRampCountries() {
+    return await this.fetchProperties<OnRampCountry[]>('countries');
+  },
+
   async fetchOnRampPaymentMethods(params: { countries?: string }) {
-    return await state.api.get<OnRampPaymentMethod[]>({
-      path: '/v1/onramp/providers/properties',
-      headers: getHeaders(),
-      params: {
-        projectId: OptionsController.state.projectId,
-        type: 'payment-methods',
-        ...params
-      }
-    });
+    return await this.fetchProperties<OnRampPaymentMethod[]>('payment-methods', params);
   },
 
   async fetchOnRampCryptoCurrencies(params: { countries?: string }) {
-    return await state.api.get<OnRampCryptoCurrency[]>({
-      path: '/v1/onramp/providers/properties',
-      headers: getHeaders(),
-      params: {
-        projectId: OptionsController.state.projectId,
-        type: 'crypto-currencies',
-        ...params
-      }
-    });
+    return await this.fetchProperties<OnRampCryptoCurrency[]>('crypto-currencies', params);
   },
 
   async fetchOnRampFiatCurrencies() {
-    return await state.api.get<OnRampFiatCurrency[]>({
-      path: '/v1/onramp/providers/properties',
-      headers: getHeaders(),
-      params: {
-        projectId: OptionsController.state.projectId,
-        type: 'fiat-currencies'
-      }
-    });
+    return await this.fetchProperties<OnRampFiatCurrency[]>('fiat-currencies');
   },
 
   async fetchOnRampFiatLimits() {
-    return await state.api.get<OnRampFiatLimit[]>({
+    return await this.fetchProperties<OnRampFiatLimit[]>('fiat-purchases-limits');
+  },
+
+  async fetchOnRampCountriesDefaults() {
+    return await this.fetchProperties<OnRampCountryDefaults[]>('countries-defaults');
+  },
+
+  async fetchProperties<T>(type: string, params?: Record<string, string>) {
+    return await state.api.get<T>({
       path: '/v1/onramp/providers/properties',
       headers: getHeaders(),
       params: {
         projectId: OptionsController.state.projectId,
-        type: 'fiat-purchases-limits'
+        type,
+        excludeProviders: EXCLUDED_ONRAMP_PROVIDERS.join(','),
+        ...params
       }
     });
   },

package/src/controllers/ConnectionController.ts

@@ -4,19 +4,28 @@ import type { SocialProvider } from '@reown/appkit-common-react-native';
 import { CoreHelperUtil } from '../utils/CoreHelperUtil';
 import { StorageUtil } from '../utils/StorageUtil';
 import type {
+  Connector,
   EstimateGasTransactionArgs,
   SendTransactionArgs,
   WcWallet,
   WriteContractArgs
 } from '../utils/TypeUtil';
+import { ConnectorController } from './ConnectorController';
 
 // -- Types --------------------------------------------- //
+export interface ConnectExternalOptions {
+  id: Connector['id'];
+  type: Connector['type'];
+  provider?: Connector['provider'];
+  info?: Connector['info'];
+}
 
 export interface ConnectionControllerClient {
   connectWalletConnect: (
     onUri: (uri: string) => void,
     walletUniversalLink?: string
   ) => Promise<void>;
+  connectExternal?: (options: ConnectExternalOptions) => Promise<void>;
   signMessage: (message: string) => Promise<string>;
   sendTransaction: (args: SendTransactionArgs) => Promise<`0x${string}` | null>;
   parseUnits: (value: string, decimals: number) => bigint;
@@ -40,8 +49,9 @@ export interface ConnectionControllerState {
   wcError?: boolean;
   pressedWallet?: WcWallet;
   recentWallets?: WcWallet[];
-  connectedWalletImageUrl?: string; //TODO: remove this
-  connectedSocialProvider?: SocialProvider; // TODO: remove this
+  selectedSocialProvider?: SocialProvider;
+  connectedWalletImageUrl?: string;
+  connectedSocialProvider?: SocialProvider;
 }
 
 type StateKey = keyof ConnectionControllerState;
@@ -81,6 +91,11 @@ export const ConnectionController = {
     }, walletUniversalLink);
   },
 
+  async connectExternal(options: ConnectExternalOptions) {
+    await this._getClient().connectExternal?.(options);
+    ConnectorController.setConnectedConnector(options.type);
+  },
+
   async signMessage(message: string) {
     return this._getClient().signMessage(message);
   },
@@ -105,19 +120,14 @@ export const ConnectionController = {
     state.pressedWallet = undefined;
   },
 
-  setWcPromise(wcPromise: ConnectionControllerState['wcPromise']) {
-    state.wcPromise = wcPromise;
-  },
-
-  setWcUri(wcUri: ConnectionControllerState['wcUri']) {
-    state.wcUri = wcUri;
-    state.wcPairingExpiry = CoreHelperUtil.getPairingExpiry();
-  },
-
   setRecentWallets(wallets: ConnectionControllerState['recentWallets']) {
     state.recentWallets = wallets;
   },
 
+  setSelectedSocialProvider(provider: ConnectionControllerState['selectedSocialProvider']) {
+    state.selectedSocialProvider = provider;
+  },
+
   async setConnectedWalletImageUrl(url: ConnectionControllerState['connectedWalletImageUrl']) {
     state.connectedWalletImageUrl = url;
 
@@ -175,12 +185,14 @@ export const ConnectionController = {
   resetWcConnection() {
     this.clearUri();
     state.pressedWallet = undefined;
+    state.selectedSocialProvider = undefined;
     ConnectionController.setConnectedWalletImageUrl(undefined);
-    // ConnectorController.setConnectedConnector(undefined);
+    ConnectorController.setConnectedConnector(undefined);
     StorageUtil.removeWalletConnectDeepLink();
   },
 
   async disconnect() {
+    await this._getClient().disconnect();
     this.resetWcConnection();
     // remove transactions
     // RouterController.reset('Connect');

package/src/controllers/ConnectorController.ts

@@ -0,0 +1,63 @@
+import type { ConnectorType } from '@reown/appkit-common-react-native';
+import { subscribeKey as subKey } from 'valtio/utils';
+import { proxy, ref } from 'valtio';
+import type { Connector } from '../utils/TypeUtil';
+import { StorageUtil } from '../utils/StorageUtil';
+
+// -- Types --------------------------------------------- //
+export interface ConnectorControllerState {
+  connectors: Connector[];
+  connectedConnector?: ConnectorType;
+  authLoading?: boolean;
+}
+
+type StateKey = keyof ConnectorControllerState;
+
+// -- State --------------------------------------------- //
+const state = proxy<ConnectorControllerState>({
+  connectors: []
+});
+
+// -- Controller ---------------------------------------- //
+export const ConnectorController = {
+  state,
+
+  subscribeKey<K extends StateKey>(key: K, callback: (value: ConnectorControllerState[K]) => void) {
+    return subKey(state, key, callback);
+  },
+
+  setConnectors(connectors: ConnectorControllerState['connectors']) {
+    state.connectors = connectors.map(c => ref(c));
+  },
+
+  addConnector(connector: Connector) {
+    state.connectors = [...state.connectors, ref(connector)];
+  },
+
+  getConnectors() {
+    return state.connectors;
+  },
+
+  getAuthConnector() {
+    return state.connectors.find(c => c.type === 'AUTH');
+  },
+
+  setConnectedConnector(
+    connectorType: ConnectorControllerState['connectedConnector'],
+    saveStorage = true
+  ) {
+    state.connectedConnector = connectorType;
+
+    if (saveStorage) {
+      if (connectorType) {
+        StorageUtil.setConnectedConnector(connectorType);
+      } else {
+        StorageUtil.removeConnectedConnector();
+      }
+    }
+  },
+
+  setAuthLoading(loading: ConnectorControllerState['authLoading']) {
+    state.authLoading = loading;
+  }
+};

package/src/controllers/EnsController.ts

@@ -1,5 +1,5 @@
-import { subscribeKey as subKey } from 'valtio/vanilla/utils';
-import { proxy, subscribe as sub } from 'valtio/vanilla';
+import { subscribeKey as subKey } from 'valtio/utils';
+import { proxy, subscribe as sub } from 'valtio';
 import { BlockchainApiController } from './BlockchainApiController';
 import type { BlockchainApiEnsError } from '../utils/TypeUtil';
 

package/src/controllers/EventsController.ts

@@ -1,4 +1,4 @@
-import { proxy, subscribe as sub } from 'valtio/vanilla';
+import { proxy, subscribe as sub } from 'valtio';
 import { ApiController } from './ApiController';
 import { OptionsController } from './OptionsController';
 import { CoreHelperUtil } from '../utils/CoreHelperUtil';

package/src/controllers/ModalController.ts

@@ -1,10 +1,10 @@
 import { proxy } from 'valtio';
-import type { RouterControllerState } from './RouterController';
-import { RouterController } from './RouterController';
+import { AccountController } from './AccountController';
+import { RouterController, type RouterControllerState } from './RouterController';
 import { PublicStateController } from './PublicStateController';
 import { EventsController } from './EventsController';
 import { ApiController } from './ApiController';
-import { ConnectionsController } from './ConnectionsController';
+import { ConnectorController } from './ConnectorController';
 
 // -- Types --------------------------------------------- //
 export interface ModalControllerState {
@@ -30,11 +30,11 @@ export const ModalController = {
 
   async open(options?: ModalControllerArguments['open']) {
     await ApiController.state.prefetchPromise;
-    const isConnected = ConnectionsController.state.isConnected;
+    const connected = AccountController.state.isConnected;
     if (options?.view) {
       RouterController.reset(options.view);
-    } else if (isConnected) {
-      const isUniversalWallet = !!ConnectionsController.state.connection?.properties?.provider;
+    } else if (AccountController.state.isConnected) {
+      const isUniversalWallet = ConnectorController.state.connectedConnector === 'AUTH';
       RouterController.reset(isUniversalWallet ? 'Account' : 'AccountDefault');
     } else {
       RouterController.reset('Connect');
@@ -44,12 +44,12 @@ export const ModalController = {
     EventsController.sendEvent({
       type: 'track',
       event: 'MODAL_OPEN',
-      properties: { connected: isConnected }
+      properties: { connected }
     });
   },
 
   close() {
-    const connected = ConnectionsController.state.isConnected;
+    const connected = AccountController.state.isConnected;
     state.open = false;
     PublicStateController.set({ open: false });
     EventsController.sendEvent({

package/src/controllers/NetworkController.ts

@@ -1,5 +1,5 @@
 import { proxy, ref } from 'valtio';
-import type { CaipNetwork, CaipNetworkId } from '@reown/appkit-common-react-native';
+import type { CaipNetwork, CaipNetworkId } from '../utils/TypeUtil';
 import { PublicStateController } from './PublicStateController';
 import { NetworkUtil } from '@reown/appkit-common-react-native';
 import { ConstantsUtil } from '../utils/ConstantsUtil';