@reown/appkit-core-react-native 2.0.0 → 2.0.1

package/src/controllers/BlockchainApiController.ts

@@ -32,31 +32,44 @@ import type {
   OnRampQuote,
   BlockchainApiOnRampWidgetRequest,
   BlockchainApiOnRampQuotesRequest,
-  OnRampFiatLimit
-} from '../utils/TypeUtil';
+  OnRampFiatLimit,
+  OnRampCountryDefaults,
+  CaipAddress,
+  CaipNetworkId
+} from '@reown/appkit-common-react-native';
 import { OptionsController } from './OptionsController';
 import { ConstantsUtil } from '../utils/ConstantsUtil';
 import { ApiUtil } from '../utils/ApiUtil';
-import type { CaipNetworkId } from '@reown/appkit-common-react-native';
-import { ConnectionsController } from './ConnectionsController';
+
 import { SnackController } from './SnackController';
+import { LogController } from './LogController';
 
 // -- Helpers ------------------------------------------- //
 const baseUrl = CoreHelperUtil.getBlockchainApiUrl();
 
-const getHeaders = () => {
-  const { sdkType, sdkVersion } = OptionsController.state;
+const getParams = () => {
+  const { projectId, sdkType, sdkVersion } = OptionsController.state;
+
+  return {
+    projectId,
+    st: sdkType,
+    sv: sdkVersion
+  };
+};
 
+const getHeaders = () => {
   return {
     'Content-Type': 'application/json',
-    'x-sdk-type': sdkType,
-    'x-sdk-version': sdkVersion,
     'User-Agent': ApiUtil.getUserAgent(),
     'origin': ApiUtil.getOrigin()
   };
 };
 
+export const EXCLUDED_ONRAMP_PROVIDERS = ['BINANCECONNECT', 'COINBASEPAY'];
+
 // -- Types --------------------------------------------- //
+type WithCaipNetworkId = { caipNetworkId: CaipNetworkId };
+
 export interface BlockchainApiControllerState {
   clientId: string | null;
   api: FetchUtil;
@@ -83,6 +96,8 @@ export const BlockchainApiController = {
         await BlockchainApiController.getSupportedNetworks();
       }
     } catch (e) {
+      LogController.sendError(e, 'BlockchainApiController.ts', 'isNetworkSupported');
+
       return false;
     }
 
@@ -91,7 +106,8 @@ export const BlockchainApiController = {
 
   async getSupportedNetworks() {
     const supportedChains = await state.api.get<BlockchainApiControllerState['supportedChains']>({
-      path: 'v1/supported-chains'
+      path: 'v1/supported-chains',
+      params: getParams()
     });
 
     state.supportedChains = supportedChains!;
@@ -99,35 +115,19 @@ export const BlockchainApiController = {
     return supportedChains;
   },
 
-  async fetchIdentity({ address }: BlockchainApiIdentityRequest) {
-    const isSupported = await BlockchainApiController.isNetworkSupported(
-      ConnectionsController.state.activeCaipNetworkId
-    );
-
-    if (!isSupported) {
-      return { avatar: '', name: '' };
-    }
+  async fetchIdentity(params: BlockchainApiIdentityRequest) {
+    const { address } = params;
 
     return state.api.get<BlockchainApiIdentityResponse>({
       path: `/v1/identity/${address}`,
-      params: {
-        projectId: OptionsController.state.projectId
-      },
-      headers: getHeaders()
+      headers: getHeaders(),
+      params: getParams()
     });
   },
 
-  async fetchTransactions({
-    account,
-    projectId,
-    cursor,
-    onramp,
-    signal,
-    cache,
-    chainId
-  }: BlockchainApiTransactionsRequest) {
-    const _chainId = chainId ?? ConnectionsController.state.activeCaipNetworkId;
-    const isSupported = await BlockchainApiController.isNetworkSupported(_chainId);
+  async fetchTransactions(params: BlockchainApiTransactionsRequest) {
+    const { account, cursor, signal, cache, chainId } = params;
+    const isSupported = ConstantsUtil.ACTIVITY_SUPPORTED_CHAINS.includes(chainId);
 
     if (!isSupported) {
       return { data: [], next: undefined };
@@ -137,10 +137,9 @@ export const BlockchainApiController = {
       path: `/v1/account/${account}/history`,
       headers: getHeaders(),
       params: {
-        projectId,
+        ...getParams(),
         cursor,
-        onramp,
-        chainId: _chainId
+        chainId
       },
       signal,
       cache
@@ -149,10 +148,9 @@ export const BlockchainApiController = {
     return response;
   },
 
-  async fetchTokenPrice({ projectId, addresses }: BlockchainApiTokenPriceRequest) {
-    const isSupported = await BlockchainApiController.isNetworkSupported(
-      ConnectionsController.state.activeCaipNetworkId
-    );
+  async fetchTokenPrice(params: BlockchainApiTokenPriceRequest & WithCaipNetworkId) {
+    const { projectId, addresses, caipNetworkId } = params;
+    const isSupported = await BlockchainApiController.isNetworkSupported(caipNetworkId);
 
     if (!isSupported) {
       return { fungibles: [] };
@@ -160,25 +158,23 @@ export const BlockchainApiController = {
 
     const response = await state.api.post<BlockchainApiTokenPriceResponse>({
       path: '/v1/fungible/price',
+      headers: getHeaders(),
+      params: getParams(),
       body: {
         projectId,
         currency: 'usd',
         addresses
-      },
-      headers: getHeaders()
+      }
     });
 
     return response;
   },
 
-  async fetchSwapAllowance({
-    projectId,
-    tokenAddress,
-    userAddress
-  }: BlockchainApiSwapAllowanceRequest) {
-    const isSupported = await BlockchainApiController.isNetworkSupported(
-      ConnectionsController.state.activeCaipNetworkId
-    );
+  async fetchSwapAllowance(params: BlockchainApiSwapAllowanceRequest) {
+    const { tokenAddress, userAddress } = params;
+    const [namespace, chain] = userAddress.split(':');
+    const networkId: CaipNetworkId = `${namespace}:${chain}`;
+    const isSupported = await BlockchainApiController.isNetworkSupported(networkId);
 
     if (!isSupported) {
       return { allowance: '0' };
@@ -187,7 +183,7 @@ export const BlockchainApiController = {
     return state.api.get<BlockchainApiSwapAllowanceResponse>({
       path: `/v1/convert/allowance`,
       params: {
-        projectId,
+        ...getParams(),
         tokenAddress,
         userAddress
       },
@@ -195,10 +191,9 @@ export const BlockchainApiController = {
     });
   },
 
-  async fetchGasPrice({ projectId, chainId }: BlockchainApiGasPriceRequest) {
-    const isSupported = await BlockchainApiController.isNetworkSupported(
-      ConnectionsController.state.activeCaipNetworkId
-    );
+  async fetchGasPrice(params: BlockchainApiGasPriceRequest) {
+    const { chainId } = params;
+    const isSupported = await BlockchainApiController.isNetworkSupported(chainId);
 
     if (!isSupported) {
       throw new Error('Network not supported for Gas Price');
@@ -208,23 +203,17 @@ export const BlockchainApiController = {
       path: `/v1/convert/gas-price`,
       headers: getHeaders(),
       params: {
-        projectId,
+        ...getParams(),
         chainId
       }
     });
   },
 
-  async fetchSwapQuote({
-    projectId,
-    amount,
-    userAddress,
-    from,
-    to,
-    gasPrice
-  }: BlockchainApiSwapQuoteRequest) {
-    const isSupported = await BlockchainApiController.isNetworkSupported(
-      ConnectionsController.state.activeCaipNetworkId
-    );
+  async fetchSwapQuote(params: BlockchainApiSwapQuoteRequest) {
+    const { 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: [] };
@@ -234,7 +223,7 @@ export const BlockchainApiController = {
       path: `/v1/convert/quotes`,
       headers: getHeaders(),
       params: {
-        projectId,
+        ...getParams(),
         amount,
         userAddress,
         from,
@@ -244,10 +233,9 @@ export const BlockchainApiController = {
     });
   },
 
-  async fetchSwapTokens({ projectId, chainId }: BlockchainApiSwapTokensRequest) {
-    const isSupported = await BlockchainApiController.isNetworkSupported(
-      ConnectionsController.state.activeCaipNetworkId
-    );
+  async fetchSwapTokens(params: BlockchainApiSwapTokensRequest) {
+    const { chainId } = params;
+    const isSupported = await BlockchainApiController.isNetworkSupported(chainId);
 
     if (!isSupported) {
       return { tokens: [] };
@@ -257,22 +245,17 @@ export const BlockchainApiController = {
       path: `/v1/convert/tokens`,
       headers: getHeaders(),
       params: {
-        projectId,
+        ...getParams(),
         chainId
       }
     });
   },
 
-  async generateSwapCalldata({
-    amount,
-    from,
-    projectId,
-    to,
-    userAddress
-  }: BlockchainApiGenerateSwapCalldataRequest) {
-    const isSupported = await BlockchainApiController.isNetworkSupported(
-      ConnectionsController.state.activeCaipNetworkId
-    );
+  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');
@@ -281,6 +264,7 @@ export const BlockchainApiController = {
     return state.api.post<BlockchainApiGenerateSwapCalldataResponse>({
       path: '/v1/convert/build-transaction',
       headers: getHeaders(),
+      params: getParams(),
       body: {
         amount,
         eip155: {
@@ -294,15 +278,11 @@ export const BlockchainApiController = {
     });
   },
 
-  async generateApproveCalldata({
-    from,
-    projectId,
-    to,
-    userAddress
-  }: BlockchainApiGenerateApproveCalldataRequest) {
-    const isSupported = await BlockchainApiController.isNetworkSupported(
-      ConnectionsController.state.activeCaipNetworkId
-    );
+  async generateApproveCalldata(params: BlockchainApiGenerateApproveCalldataRequest) {
+    const { from, 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');
@@ -312,7 +292,7 @@ export const BlockchainApiController = {
       path: `/v1/convert/build-approve`,
       headers: getHeaders(),
       params: {
-        projectId,
+        ...getParams(),
         userAddress,
         from,
         to
@@ -320,10 +300,15 @@ export const BlockchainApiController = {
     });
   },
 
-  async getBalance(address: string, chainId?: string, forceUpdate?: string) {
-    const isSupported = await BlockchainApiController.isNetworkSupported(
-      ConnectionsController.state.activeCaipNetworkId
-    );
+  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');
 
@@ -331,13 +316,13 @@ export const BlockchainApiController = {
     }
 
     return state.api.get<BlockchainApiBalanceResponse>({
-      path: `/v1/account/${address}/balance`,
+      path: `/v1/account/${plainAddress}/balance`,
       headers: getHeaders(),
       params: {
+        ...getParams(),
         currency: 'usd',
-        projectId: OptionsController.state.projectId,
-        chainId,
-        forceUpdate
+        chainId: `${namespace}:${chain}`,
+        forceUpdate: forceUpdate?.join(',')
       }
     });
   },
@@ -347,75 +332,53 @@ export const BlockchainApiController = {
       path: `/v1/profile/account/${name}`,
       headers: getHeaders(),
       params: {
-        projectId: OptionsController.state.projectId,
+        ...getParams(),
         apiVersion: '2'
       }
     });
   },
 
-  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',
       headers: getHeaders(),
-      params: {
-        projectId: OptionsController.state.projectId
-      }
+      params: getParams()
     });
   },
 
+  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'
+        ...getParams(),
+        type,
+        excludeProviders: EXCLUDED_ONRAMP_PROVIDERS.join(','),
+        ...params
       }
     });
   },
@@ -424,6 +387,7 @@ export const BlockchainApiController = {
     return await state.api.post<OnRampQuote[]>({
       path: '/v1/onramp/multi/quotes',
       headers: getHeaders(),
+      params: getParams(),
       body: {
         projectId: OptionsController.state.projectId,
         ...body
@@ -436,6 +400,7 @@ export const BlockchainApiController = {
     return await state.api.post<BlockchainApiOnRampWidgetResponse>({
       path: '/v1/onramp/widget',
       headers: getHeaders(),
+      params: getParams(),
       body: {
         projectId: OptionsController.state.projectId,
         sessionData: {