@reown/appkit-core-react-native 0.0.0-feat-multi-social-20250715153550 → 0.0.0-feat-onramp-20250718185718

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 { ConnectionsController } from './ConnectionsController';
-import { SnackController } from './SnackController';
 
 // -- Helpers ------------------------------------------- //
 const baseUrl = CoreHelperUtil.getBlockchainApiUrl();
@@ -60,54 +58,19 @@ const getHeaders = () => {
 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({ address }: BlockchainApiIdentityRequest) {
-    const isSupported = await BlockchainApiController.isNetworkSupported(
-      ConnectionsController.state.activeCaipNetworkId
-    );
-
-    if (!isSupported) {
-      return { avatar: '', name: '' };
-    }
-
+  fetchIdentity({ address }: BlockchainApiIdentityRequest) {
     return state.api.get<BlockchainApiIdentityResponse>({
       path: `/v1/identity/${address}`,
       params: {
@@ -117,48 +80,29 @@ export const BlockchainApiController = {
     });
   },
 
-  async fetchTransactions({
+  fetchTransactions({
     account,
     projectId,
     cursor,
     onramp,
     signal,
-    cache,
-    chainId
+    cache
   }: BlockchainApiTransactionsRequest) {
-    const _chainId = chainId ?? ConnectionsController.state.activeCaipNetworkId;
-    const isSupported = await BlockchainApiController.isNetworkSupported(_chainId);
-
-    if (!isSupported) {
-      return { data: [], next: undefined };
-    }
-
-    const response = await state.api.get<BlockchainApiTransactionsResponse>({
+    return state.api.get<BlockchainApiTransactionsResponse>({
       path: `/v1/account/${account}/history`,
       headers: getHeaders(),
       params: {
         projectId,
         cursor,
-        onramp,
-        chainId: _chainId
+        onramp
       },
       signal,
       cache
     });
-
-    return response;
   },
 
-  async fetchTokenPrice({ projectId, addresses }: BlockchainApiTokenPriceRequest) {
-    const isSupported = await BlockchainApiController.isNetworkSupported(
-      ConnectionsController.state.activeCaipNetworkId
-    );
-
-    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,
@@ -167,23 +111,9 @@ export const BlockchainApiController = {
       },
       headers: getHeaders()
     });
-
-    return response;
   },
 
-  async fetchSwapAllowance({
-    projectId,
-    tokenAddress,
-    userAddress
-  }: BlockchainApiSwapAllowanceRequest) {
-    const isSupported = await BlockchainApiController.isNetworkSupported(
-      ConnectionsController.state.activeCaipNetworkId
-    );
-
-    if (!isSupported) {
-      return { allowance: '0' };
-    }
-
+  fetchSwapAllowance({ projectId, tokenAddress, userAddress }: BlockchainApiSwapAllowanceRequest) {
     return state.api.get<BlockchainApiSwapAllowanceResponse>({
       path: `/v1/convert/allowance`,
       params: {
@@ -195,15 +125,7 @@ export const BlockchainApiController = {
     });
   },
 
-  async fetchGasPrice({ projectId, chainId }: BlockchainApiGasPriceRequest) {
-    const isSupported = await BlockchainApiController.isNetworkSupported(
-      ConnectionsController.state.activeCaipNetworkId
-    );
-
-    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(),
@@ -214,7 +136,7 @@ export const BlockchainApiController = {
     });
   },
 
-  async fetchSwapQuote({
+  fetchSwapQuote({
     projectId,
     amount,
     userAddress,
@@ -222,14 +144,6 @@ export const BlockchainApiController = {
     to,
     gasPrice
   }: BlockchainApiSwapQuoteRequest) {
-    const isSupported = await BlockchainApiController.isNetworkSupported(
-      ConnectionsController.state.activeCaipNetworkId
-    );
-
-    if (!isSupported) {
-      return { quotes: [] };
-    }
-
     return state.api.get<BlockchainApiSwapQuoteResponse>({
       path: `/v1/convert/quotes`,
       headers: getHeaders(),
@@ -244,15 +158,7 @@ export const BlockchainApiController = {
     });
   },
 
-  async fetchSwapTokens({ projectId, chainId }: BlockchainApiSwapTokensRequest) {
-    const isSupported = await BlockchainApiController.isNetworkSupported(
-      ConnectionsController.state.activeCaipNetworkId
-    );
-
-    if (!isSupported) {
-      return { tokens: [] };
-    }
-
+  fetchSwapTokens({ projectId, chainId }: BlockchainApiSwapTokensRequest) {
     return state.api.get<BlockchainApiSwapTokensResponse>({
       path: `/v1/convert/tokens`,
       headers: getHeaders(),
@@ -263,21 +169,13 @@ export const BlockchainApiController = {
     });
   },
 
-  async generateSwapCalldata({
+  generateSwapCalldata({
     amount,
     from,
     projectId,
     to,
     userAddress
   }: BlockchainApiGenerateSwapCalldataRequest) {
-    const isSupported = await BlockchainApiController.isNetworkSupported(
-      ConnectionsController.state.activeCaipNetworkId
-    );
-
-    if (!isSupported) {
-      throw new Error('Network not supported for Swaps');
-    }
-
     return state.api.post<BlockchainApiGenerateSwapCalldataResponse>({
       path: '/v1/convert/build-transaction',
       headers: getHeaders(),
@@ -294,20 +192,12 @@ export const BlockchainApiController = {
     });
   },
 
-  async generateApproveCalldata({
+  generateApproveCalldata({
     from,
     projectId,
     to,
     userAddress
   }: BlockchainApiGenerateApproveCalldataRequest) {
-    const isSupported = await BlockchainApiController.isNetworkSupported(
-      ConnectionsController.state.activeCaipNetworkId
-    );
-
-    if (!isSupported) {
-      throw new Error('Network not supported for Swaps');
-    }
-
     return state.api.get<BlockchainApiGenerateApproveCalldataResponse>({
       path: `/v1/convert/build-approve`,
       headers: getHeaders(),
@@ -320,30 +210,15 @@ export const BlockchainApiController = {
     });
   },
 
-  async getBalance(address?: CaipAddress, forceUpdate?: CaipAddress[]) {
-    const isSupported = await BlockchainApiController.isNetworkSupported(
-      ConnectionsController.state.activeCaipNetworkId
-    );
-    if (!isSupported) {
-      SnackController.showError('Token Balance Unavailable');
-
-      return { balances: [] };
-    }
-
-    const [namespace, chain, plainAddress] = address?.split(':') ?? [];
-
-    if (!namespace || !chain || !plainAddress) {
-      throw new Error('Invalid address');
-    }
-
+  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
       }
     });
   },
@@ -426,12 +301,24 @@ export const BlockchainApiController = {
     });
   },
 
+  async fetchOnRampCountriesDefaults() {
+    return await state.api.get<OnRampCountryDefaults[]>({
+      path: '/v1/onramp/providers/properties',
+      headers: getHeaders(),
+      params: {
+        projectId: OptionsController.state.projectId,
+        type: 'countries-defaults'
+      }
+    });
+  },
+
   async getOnRampQuotes(body: BlockchainApiOnRampQuotesRequest, signal?: AbortSignal) {
     return await state.api.post<OnRampQuote[]>({
       path: '/v1/onramp/multi/quotes',
       headers: getHeaders(),
       body: {
         projectId: OptionsController.state.projectId,
+        excludedProviders: ['BINANCECONNECT', 'COINBASEPAY'],
         ...body
       },
       signal

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,11 +1,10 @@
 import { proxy } from 'valtio';
 import { AccountController } from './AccountController';
-import type { RouterControllerState } from './RouterController';
-import { RouterController } from './RouterController';
+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 {
@@ -35,7 +34,7 @@ export const ModalController = {
     if (options?.view) {
       RouterController.reset(options.view);
     } else if (AccountController.state.isConnected) {
-      const isUniversalWallet = !!ConnectionsController.state.connection?.properties?.provider;
+      const isUniversalWallet = ConnectorController.state.connectedConnector === 'AUTH';
       RouterController.reset(isUniversalWallet ? 'Account' : 'AccountDefault');
     } else {
       RouterController.reset('Connect');

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';