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

package/src/controllers/AccountController.ts

@@ -1,12 +1,12 @@
 import { proxy } from 'valtio';
 import { subscribeKey as subKey } from 'valtio/utils';
-import type { Balance } from '@reown/appkit-common-react-native';
+import type { AccountType, CaipAddress } from '@reown/appkit-common-react-native';
 
 import { CoreHelperUtil } from '../utils/CoreHelperUtil';
-import type { AppKitFrameAccountType, CaipAddress, ConnectedWalletInfo } from '../utils/TypeUtil';
-import { NetworkController } from './NetworkController';
-import { BlockchainApiController } from './BlockchainApiController';
-import { SnackController } from './SnackController';
+import type { ConnectedWalletInfo, BlockchainApiBalance } from '../utils/TypeUtil';
+// import { NetworkController } from './NetworkController';
+// import { BlockchainApiController } from './BlockchainApiController';
+// import { SnackController } from './SnackController';
 
 // -- Types --------------------------------------------- //
 export interface AccountControllerState {
@@ -15,12 +15,12 @@ export interface AccountControllerState {
   address?: string;
   balance?: string;
   balanceSymbol?: string;
-  tokenBalance?: Balance[];
+  tokenBalance?: BlockchainApiBalance[];
   profileName?: string;
   profileImage?: string;
   addressExplorerUrl?: string;
   connectedWalletInfo?: ConnectedWalletInfo;
-  preferredAccountType?: AppKitFrameAccountType;
+  preferredAccountType?: AccountType;
   smartAccountDeployed?: boolean;
 }
 
@@ -89,26 +89,22 @@ export const AccountController = {
   },
 
   async fetchTokenBalance() {
-    const chainId = NetworkController.state.caipNetwork?.id;
-    const address = AccountController.state.address;
-
-    try {
-      if (address && chainId) {
-        const response = await BlockchainApiController.getBalance(address, chainId);
-
-        if (!response) {
-          throw new Error('Failed to fetch token balance');
-        }
-
-        const filteredBalances = response.balances.filter(
-          balance => balance.quantity.decimals !== '0'
-        );
-
-        this.setTokenBalance(filteredBalances);
-      }
-    } catch (error) {
-      SnackController.showError('Failed to fetch token balance');
-    }
+    // const chainId = NetworkController.state.caipNetwork?.id;
+    // const address = AccountController.state.address;
+    // try {
+    //   if (address && chainId) {
+    //     const response = await BlockchainApiController.getBalance(address, chainId);
+    //     if (!response) {
+    //       throw new Error('Failed to fetch token balance');
+    //     }
+    //     const filteredBalances = response.balances.filter(
+    //       balance => balance.quantity.decimals !== '0'
+    //     );
+    //     this.setTokenBalance(filteredBalances);
+    //   }
+    // } catch (error) {
+    //   SnackController.showError('Failed to fetch token balance');
+    // }
   },
 
   resetAccount() {

package/src/controllers/ApiController.ts

@@ -12,12 +12,13 @@ import type {
   WcWallet
 } from '../utils/TypeUtil';
 import { AssetController } from './AssetController';
-import { NetworkController } from './NetworkController';
 import { OptionsController } from './OptionsController';
-import { ConnectorController } from './ConnectorController';
+// import { ConnectorController } from './ConnectorController';
 import { ConnectionController } from './ConnectionController';
 import { ApiUtil } from '../utils/ApiUtil';
 import { SnackController } from './SnackController';
+import { ConnectionsController } from './ConnectionsController';
+import { PresetsUtil } from '@reown/appkit-common-react-native';
 
 // -- Helpers ------------------------------------------- //
 const baseUrl = CoreHelperUtil.getApiUrl();
@@ -92,16 +93,22 @@ export const ApiController = {
     }
   },
 
-  async _fetchNetworkImage(imageId: string) {
+  async _fetchNetworkImage(networkId: string) {
+    const imageId = PresetsUtil.NetworkImageIds[networkId];
+    if (!imageId) {
+      return;
+    }
+
     const headers = ApiController._getApiHeaders();
     const url = await api.fetchImage(`/public/getAssetImage/${imageId}`, headers);
     if (url) {
-      AssetController.setNetworkImage(imageId, url);
+      AssetController.setNetworkImage(networkId, url);
     }
   },
 
   async fetchConnectorImages() {
-    const { connectors } = ConnectorController.state;
+    //TODO: check this with coinbase
+    const connectors = [{ imageId: PresetsUtil.ConnectorImageIds['WALLET_CONNECT'] }];
     const ids = connectors.map(({ imageId }) => imageId).filter(Boolean);
     await CoreHelperUtil.allSettled(
       (ids as string[]).map(id => ApiController._fetchConnectorImage(id))
@@ -109,11 +116,10 @@ export const ApiController = {
   },
 
   async fetchNetworkImages() {
-    const { requestedCaipNetworks } = NetworkController.state;
-    const ids = requestedCaipNetworks?.map(({ imageId }) => imageId).filter(Boolean);
-    if (ids) {
+    const networks = ConnectionsController.state.networks;
+    if (networks) {
       await CoreHelperUtil.allSettled(
-        (ids as string[]).map(id => ApiController._fetchNetworkImage(id))
+        networks.map(network => ApiController._fetchNetworkImage(network.id as string))
       );
     }
   },
@@ -201,6 +207,18 @@ export const ApiController = {
     }
   },
 
+  async fetchCustomWalletImages() {
+    const { customWallets } = OptionsController.state;
+    if (!customWallets?.length) {
+      return;
+    }
+
+    const images = customWallets.map(w => w.image_id).filter(Boolean);
+    await CoreHelperUtil.allSettled(
+      (images as string[]).map(id => ApiController._fetchWalletImage(id))
+    );
+  },
+
   async fetchRecommendedWallets() {
     const { installed } = ApiController.state;
     const { includeWalletIds, excludeWalletIds, featuredWalletIds } = OptionsController.state;
@@ -339,7 +357,8 @@ export const ApiController = {
         ApiController.fetchFeaturedWallets(),
         ApiController.fetchRecommendedWallets(),
         ApiController.fetchNetworkImages(),
-        ApiController.fetchConnectorImages()
+        ApiController.fetchConnectorImages(),
+        ApiController.fetchCustomWalletImages()
       ];
       if (OptionsController.state.enableAnalytics === undefined) {
         promises.push(ApiController.fetchAnalyticsConfig());

package/src/controllers/BlockchainApiController.ts

@@ -32,12 +32,14 @@ import type {
   OnRampQuote,
   BlockchainApiOnRampWidgetRequest,
   BlockchainApiOnRampQuotesRequest,
-  OnRampFiatLimit,
-  OnRampCountryDefaults
+  OnRampFiatLimit
 } 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();
@@ -54,25 +56,59 @@ const getHeaders = () => {
   };
 };
 
-export const EXCLUDED_ONRAMP_PROVIDERS = ['BINANCECONNECT', 'COINBASEPAY'];
-
 // -- Types --------------------------------------------- //
+type WithCaipNetworkId = { caipNetworkId: CaipNetworkId };
+
 export interface BlockchainApiControllerState {
   clientId: string | null;
   api: FetchUtil;
+  supportedChains: { http: CaipNetworkId[]; ws: CaipNetworkId[] };
 }
 
 // -- State --------------------------------------------- //
 const state = proxy<BlockchainApiControllerState>({
   clientId: null,
-  api: new FetchUtil({ baseUrl })
+  api: new FetchUtil({ baseUrl }),
+  supportedChains: { http: [], ws: [] }
 });
 
 // -- Controller ---------------------------------------- //
 export const BlockchainApiController = {
   state,
 
-  fetchIdentity({ address }: BlockchainApiIdentityRequest) {
+  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: '' };
+    }
+
     return state.api.get<BlockchainApiIdentityResponse>({
       path: `/v1/identity/${address}`,
       params: {
@@ -82,29 +118,39 @@ export const BlockchainApiController = {
     });
   },
 
-  fetchTransactions({
-    account,
-    projectId,
-    cursor,
-    onramp,
-    signal,
-    cache
-  }: BlockchainApiTransactionsRequest) {
-    return state.api.get<BlockchainApiTransactionsResponse>({
+  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>({
       path: `/v1/account/${account}/history`,
       headers: getHeaders(),
       params: {
         projectId,
         cursor,
-        onramp
+        onramp,
+        chainId
       },
       signal,
       cache
     });
+
+    return response;
   },
 
-  fetchTokenPrice({ projectId, addresses }: BlockchainApiTokenPriceRequest) {
-    return state.api.post<BlockchainApiTokenPriceResponse>({
+  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>({
       path: '/v1/fungible/price',
       body: {
         projectId,
@@ -113,9 +159,20 @@ export const BlockchainApiController = {
       },
       headers: getHeaders()
     });
+
+    return response;
   },
 
-  fetchSwapAllowance({ projectId, tokenAddress, userAddress }: BlockchainApiSwapAllowanceRequest) {
+  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' };
+    }
+
     return state.api.get<BlockchainApiSwapAllowanceResponse>({
       path: `/v1/convert/allowance`,
       params: {
@@ -127,7 +184,14 @@ export const BlockchainApiController = {
     });
   },
 
-  fetchGasPrice({ projectId, chainId }: BlockchainApiGasPriceRequest) {
+  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');
+    }
+
     return state.api.get<BlockchainApiGasPriceResponse>({
       path: `/v1/convert/gas-price`,
       headers: getHeaders(),
@@ -138,14 +202,16 @@ export const BlockchainApiController = {
     });
   },
 
-  fetchSwapQuote({
-    projectId,
-    amount,
-    userAddress,
-    from,
-    to,
-    gasPrice
-  }: BlockchainApiSwapQuoteRequest) {
+  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: [] };
+    }
+
     return state.api.get<BlockchainApiSwapQuoteResponse>({
       path: `/v1/convert/quotes`,
       headers: getHeaders(),
@@ -160,7 +226,14 @@ export const BlockchainApiController = {
     });
   },
 
-  fetchSwapTokens({ projectId, chainId }: BlockchainApiSwapTokensRequest) {
+  async fetchSwapTokens(params: BlockchainApiSwapTokensRequest) {
+    const { projectId, chainId } = params;
+    const isSupported = await BlockchainApiController.isNetworkSupported(chainId);
+
+    if (!isSupported) {
+      return { tokens: [] };
+    }
+
     return state.api.get<BlockchainApiSwapTokensResponse>({
       path: `/v1/convert/tokens`,
       headers: getHeaders(),
@@ -171,13 +244,16 @@ export const BlockchainApiController = {
     });
   },
 
-  generateSwapCalldata({
-    amount,
-    from,
-    projectId,
-    to,
-    userAddress
-  }: BlockchainApiGenerateSwapCalldataRequest) {
+  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');
+    }
+
     return state.api.post<BlockchainApiGenerateSwapCalldataResponse>({
       path: '/v1/convert/build-transaction',
       headers: getHeaders(),
@@ -194,12 +270,16 @@ export const BlockchainApiController = {
     });
   },
 
-  generateApproveCalldata({
-    from,
-    projectId,
-    to,
-    userAddress
-  }: BlockchainApiGenerateApproveCalldataRequest) {
+  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');
+    }
+
     return state.api.get<BlockchainApiGenerateApproveCalldataResponse>({
       path: `/v1/convert/build-approve`,
       headers: getHeaders(),
@@ -212,15 +292,29 @@ export const BlockchainApiController = {
     });
   },
 
-  async getBalance(address: string, chainId?: string, forceUpdate?: string) {
+  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: [] };
+    }
+
     return state.api.get<BlockchainApiBalanceResponse>({
-      path: `/v1/account/${address}/balance`,
+      path: `/v1/account/${plainAddress}/balance`,
       headers: getHeaders(),
       params: {
         currency: 'usd',
         projectId: OptionsController.state.projectId,
-        chainId,
-        forceUpdate
+        chainId: `${namespace}:${chain}`,
+        forceUpdate: forceUpdate?.join(',')
       }
     });
   },
@@ -236,6 +330,17 @@ 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',
@@ -246,39 +351,48 @@ export const BlockchainApiController = {
     });
   },
 
-  async fetchOnRampCountries() {
-    return await this.fetchProperties<OnRampCountry[]>('countries');
-  },
-
   async fetchOnRampPaymentMethods(params: { countries?: string }) {
-    return await this.fetchProperties<OnRampPaymentMethod[]>('payment-methods', params);
+    return await state.api.get<OnRampPaymentMethod[]>({
+      path: '/v1/onramp/providers/properties',
+      headers: getHeaders(),
+      params: {
+        projectId: OptionsController.state.projectId,
+        type: 'payment-methods',
+        ...params
+      }
+    });
   },
 
   async fetchOnRampCryptoCurrencies(params: { countries?: string }) {
-    return await this.fetchProperties<OnRampCryptoCurrency[]>('crypto-currencies', params);
+    return await state.api.get<OnRampCryptoCurrency[]>({
+      path: '/v1/onramp/providers/properties',
+      headers: getHeaders(),
+      params: {
+        projectId: OptionsController.state.projectId,
+        type: 'crypto-currencies',
+        ...params
+      }
+    });
   },
 
   async fetchOnRampFiatCurrencies() {
-    return await this.fetchProperties<OnRampFiatCurrency[]>('fiat-currencies');
+    return await state.api.get<OnRampFiatCurrency[]>({
+      path: '/v1/onramp/providers/properties',
+      headers: getHeaders(),
+      params: {
+        projectId: OptionsController.state.projectId,
+        type: 'fiat-currencies'
+      }
+    });
   },
 
   async fetchOnRampFiatLimits() {
-    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>({
+    return await state.api.get<OnRampFiatLimit[]>({
       path: '/v1/onramp/providers/properties',
       headers: getHeaders(),
       params: {
         projectId: OptionsController.state.projectId,
-        type,
-        excludeProviders: EXCLUDED_ONRAMP_PROVIDERS.join(','),
-        ...params
+        type: 'fiat-purchases-limits'
       }
     });
   },

package/src/controllers/ConnectionController.ts

@@ -1,31 +1,22 @@
 import { proxy, ref } from 'valtio';
 import { subscribeKey as subKey } from 'valtio/utils';
-import type { SocialProvider } from '@reown/appkit-common-react-native';
+import type { SocialProvider, WalletDeepLink } 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;
@@ -42,16 +33,12 @@ export interface ConnectionControllerState {
   wcUri?: string;
   wcPromise?: Promise<void>;
   wcPairingExpiry?: number;
-  wcLinking?: {
-    href: string;
-    name: string;
-  };
+  wcLinking?: WalletDeepLink;
   wcError?: boolean;
   pressedWallet?: WcWallet;
   recentWallets?: WcWallet[];
-  selectedSocialProvider?: SocialProvider;
-  connectedWalletImageUrl?: string;
-  connectedSocialProvider?: SocialProvider;
+  connectedWalletImageUrl?: string; //TODO: remove this
+  connectedSocialProvider?: SocialProvider; // TODO: remove this
 }
 
 type StateKey = keyof ConnectionControllerState;
@@ -91,11 +78,6 @@ 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);
   },
@@ -120,12 +102,17 @@ export const ConnectionController = {
     state.pressedWallet = undefined;
   },
 
-  setRecentWallets(wallets: ConnectionControllerState['recentWallets']) {
-    state.recentWallets = wallets;
+  setWcPromise(wcPromise: ConnectionControllerState['wcPromise']) {
+    state.wcPromise = wcPromise;
   },
 
-  setSelectedSocialProvider(provider: ConnectionControllerState['selectedSocialProvider']) {
-    state.selectedSocialProvider = provider;
+  setWcUri(wcUri: ConnectionControllerState['wcUri']) {
+    state.wcUri = wcUri;
+    state.wcPairingExpiry = CoreHelperUtil.getPairingExpiry();
+  },
+
+  setRecentWallets(wallets: ConnectionControllerState['recentWallets']) {
+    state.recentWallets = wallets;
   },
 
   async setConnectedWalletImageUrl(url: ConnectionControllerState['connectedWalletImageUrl']) {
@@ -185,14 +172,12 @@ 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');