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

package/src/controllers/OnRampController.ts

@@ -1,26 +1,28 @@
-import { subscribeKey as subKey } from 'valtio/vanilla/utils';
-import { proxy, subscribe as sub } from 'valtio/vanilla';
-import type {
-  OnRampPaymentMethod,
-  OnRampCountry,
-  OnRampFiatCurrency,
-  OnRampQuote,
-  OnRampFiatLimit,
-  OnRampCryptoCurrency,
-  OnRampServiceProvider,
-  OnRampError,
-  OnRampErrorTypeValues
-} from '../utils/TypeUtil';
+import { subscribeKey as subKey } from 'valtio/utils';
+import { proxy, subscribe as sub } from 'valtio';
+import {
+  type OnRampPaymentMethod,
+  type OnRampCountry,
+  type OnRampFiatCurrency,
+  type OnRampQuote,
+  type OnRampFiatLimit,
+  type OnRampCryptoCurrency,
+  type OnRampServiceProvider,
+  type OnRampError,
+  type OnRampErrorTypeValues,
+  type OnRampCountryDefaults,
+  BlockchainOnRampError
+} from '@reown/appkit-common-react-native';
 
 import { CoreHelperUtil } from '../utils/CoreHelperUtil';
-import { NetworkController } from './NetworkController';
-import { AccountController } from './AccountController';
 import { OptionsController } from './OptionsController';
 import { ConstantsUtil, OnRampErrorType } from '../utils/ConstantsUtil';
 import { StorageUtil } from '../utils/StorageUtil';
 import { SnackController } from './SnackController';
+import { LogController } from './LogController';
 import { EventsController } from './EventsController';
-import { BlockchainApiController } from './BlockchainApiController';
+import { BlockchainApiController, EXCLUDED_ONRAMP_PROVIDERS } from './BlockchainApiController';
+import { ConnectionsController } from './ConnectionsController';
 
 // -- Helpers ------------------------------------------- //
 
@@ -32,23 +34,27 @@ const mapErrorMessage = (errorCode: string): OnRampError => {
   const errorMap: Record<string, { type: OnRampErrorTypeValues; message: string }> = {
     [OnRampErrorType.AMOUNT_TOO_LOW]: {
       type: OnRampErrorType.AMOUNT_TOO_LOW,
-      message: 'Amount is too low'
+      message: 'The amount is too low'
     },
     [OnRampErrorType.AMOUNT_TOO_HIGH]: {
       type: OnRampErrorType.AMOUNT_TOO_HIGH,
-      message: 'Amount is too high'
+      message: 'The amount is too high'
     },
     [OnRampErrorType.INVALID_AMOUNT]: {
       type: OnRampErrorType.INVALID_AMOUNT,
-      message: 'Please adjust amount'
+      message: 'Enter a valid amount'
     },
     [OnRampErrorType.INCOMPATIBLE_REQUEST]: {
       type: OnRampErrorType.INCOMPATIBLE_REQUEST,
-      message: 'Try different amount or payment method'
+      message: 'Enter a valid amount'
     },
     [OnRampErrorType.BAD_REQUEST]: {
       type: OnRampErrorType.BAD_REQUEST,
-      message: 'Try different amount or payment method'
+      message: 'Enter a valid amount'
+    },
+    [OnRampErrorType.NO_VALID_QUOTES]: {
+      type: OnRampErrorType.NO_VALID_QUOTES,
+      message: 'No quotes available'
     }
   };
 
@@ -63,6 +69,7 @@ const mapErrorMessage = (errorCode: string): OnRampError => {
 // -- Types --------------------------------------------- //
 export interface OnRampControllerState {
   countries: OnRampCountry[];
+  countriesDefaults?: OnRampCountryDefaults[];
   selectedCountry?: OnRampCountry;
   serviceProviders: OnRampServiceProvider[];
   selectedServiceProvider?: OnRampServiceProvider;
@@ -109,33 +116,44 @@ export const OnRampController = {
   },
 
   async setSelectedCountry(country: OnRampCountry, updateCurrency = true) {
-    state.selectedCountry = country;
-    state.loading = true;
+    try {
+      state.selectedCountry = country;
+      state.loading = true;
 
-    if (updateCurrency) {
-      const currencyCode =
-        ConstantsUtil.COUNTRY_CURRENCIES[
-          country.countryCode as keyof typeof ConstantsUtil.COUNTRY_CURRENCIES
-        ] || 'USD';
+      if (updateCurrency) {
+        const currencyCode =
+          state.countriesDefaults?.find(d => d.countryCode === country.countryCode)
+            ?.defaultCurrencyCode || 'USD';
 
-      const currency = state.paymentCurrencies?.find(c => c.currencyCode === currencyCode);
+        let currency = state.paymentCurrencies?.find(c => c.currencyCode === currencyCode);
 
-      if (currency) {
-        this.setPaymentCurrency(currency);
+        if (!currency) {
+          currency = state.paymentCurrencies?.find(c => c.currencyCode === 'USD');
+        }
+
+        if (currency) {
+          this.setPaymentCurrency(currency);
+        }
       }
-    }
 
-    await Promise.all([this.fetchPaymentMethods(), this.fetchCryptoCurrencies()]);
+      await Promise.all([this.fetchPaymentMethods(), this.fetchCryptoCurrencies()]);
+      this.clearQuotes();
 
-    state.loading = false;
+      state.loading = false;
 
-    StorageUtil.setOnRampPreferredCountry(country);
+      StorageUtil.setOnRampPreferredCountry(country);
+    } catch (error) {
+      LogController.sendError(error, 'OnRampController.ts', 'setSelectedCountry');
+      state.loading = false;
+      state.error = {
+        type: OnRampErrorType.FAILED_TO_LOAD_COUNTRIES,
+        message: 'Failed to load countries'
+      };
+    }
   },
 
   setSelectedPaymentMethod(paymentMethod: OnRampPaymentMethod) {
     state.selectedPaymentMethod = paymentMethod;
-
-    this.clearQuotes();
   },
 
   setPurchaseCurrency(currency: OnRampCryptoCurrency) {
@@ -175,16 +193,16 @@ export const OnRampController = {
 
   updateSelectedPurchaseCurrency() {
     let selectedCurrency;
-    if (NetworkController.state.caipNetwork?.id) {
+    if (ConnectionsController.state.activeNetwork?.caipNetworkId) {
       const defaultCurrency =
         ConstantsUtil.NETWORK_DEFAULT_CURRENCIES[
-          NetworkController.state.caipNetwork
-            ?.id as keyof typeof ConstantsUtil.NETWORK_DEFAULT_CURRENCIES
+          ConnectionsController.state.activeNetwork
+            ?.caipNetworkId as keyof typeof ConstantsUtil.NETWORK_DEFAULT_CURRENCIES
         ];
       selectedCurrency = state.purchaseCurrencies?.find(c => c.currencyCode === defaultCurrency);
     }
 
-    state.purchaseCurrency = selectedCurrency || state.purchaseCurrencies?.[0] || undefined;
+    state.purchaseCurrency = selectedCurrency ?? undefined;
   },
 
   getServiceProviderImage(serviceProviderName?: string) {
@@ -224,6 +242,7 @@ export const OnRampController = {
           countries.find(c => c.countryCode === countryCode) || countries[0] || undefined;
       }
     } catch (error) {
+      LogController.sendError(error, 'OnRampController.ts', 'fetchCountries');
       state.error = {
         type: OnRampErrorType.FAILED_TO_LOAD_COUNTRIES,
         message: 'Failed to load countries'
@@ -231,6 +250,28 @@ export const OnRampController = {
     }
   },
 
+  async fetchCountriesDefaults() {
+    try {
+      let countriesDefaults = await StorageUtil.getOnRampCountriesDefaults();
+
+      if (!countriesDefaults.length) {
+        countriesDefaults = (await BlockchainApiController.fetchOnRampCountriesDefaults()) ?? [];
+
+        if (countriesDefaults.length) {
+          StorageUtil.setOnRampCountriesDefaults(countriesDefaults);
+        }
+      }
+
+      state.countriesDefaults = countriesDefaults;
+    } catch (error) {
+      LogController.sendError(error, 'OnRampController.ts', 'fetchCountriesDefaults');
+      state.error = {
+        type: OnRampErrorType.FAILED_TO_LOAD_COUNTRIES,
+        message: 'Failed to load countries defaults'
+      };
+    }
+  },
+
   async fetchServiceProviders() {
     try {
       let serviceProviders = await StorageUtil.getOnRampServiceProviders();
@@ -245,6 +286,7 @@ export const OnRampController = {
 
       state.serviceProviders = serviceProviders || [];
     } catch (error) {
+      LogController.sendError(error, 'OnRampController.ts', 'fetchServiceProviders');
       state.error = {
         type: OnRampErrorType.FAILED_TO_LOAD_PROVIDERS,
         message: 'Failed to load service providers'
@@ -259,10 +301,8 @@ export const OnRampController = {
       });
 
       const defaultCountryPaymentMethods =
-        ConstantsUtil.COUNTRY_DEFAULT_PAYMENT_METHOD[
-          state.selectedCountry
-            ?.countryCode as keyof typeof ConstantsUtil.COUNTRY_DEFAULT_PAYMENT_METHOD
-        ];
+        state.countriesDefaults?.find(d => d.countryCode === state.selectedCountry?.countryCode)
+          ?.defaultPaymentMethods || [];
 
       state.paymentMethods =
         paymentMethods?.sort((a, b) => {
@@ -276,10 +316,9 @@ export const OnRampController = {
           return aIndex - bIndex;
         }) || [];
 
-      state.selectedPaymentMethod = paymentMethods?.[0] || undefined;
-
-      this.clearQuotes();
+      state.selectedPaymentMethod = state.paymentMethods[0];
     } catch (error) {
+      LogController.sendError(error, 'OnRampController.ts', 'fetchPaymentMethods');
       state.error = {
         type: OnRampErrorType.FAILED_TO_LOAD_METHODS,
         message: 'Failed to load payment methods'
@@ -298,17 +337,18 @@ export const OnRampController = {
       state.purchaseCurrencies = cryptoCurrencies || [];
 
       let selectedCurrency;
-      if (NetworkController.state.caipNetwork?.id) {
+      if (ConnectionsController.state.activeNetwork?.caipNetworkId) {
         const defaultCurrency =
           ConstantsUtil.NETWORK_DEFAULT_CURRENCIES[
-            NetworkController.state.caipNetwork
-              ?.id as keyof typeof ConstantsUtil.NETWORK_DEFAULT_CURRENCIES
-          ] || 'ETH';
+            ConnectionsController.state.activeNetwork
+              ?.caipNetworkId as keyof typeof ConstantsUtil.NETWORK_DEFAULT_CURRENCIES
+          ];
         selectedCurrency = state.purchaseCurrencies?.find(c => c.currencyCode === defaultCurrency);
       }
 
-      state.purchaseCurrency = selectedCurrency || cryptoCurrencies?.[0] || undefined;
+      state.purchaseCurrency = selectedCurrency || undefined;
     } catch (error) {
+      LogController.sendError(error, 'OnRampController.ts', 'fetchCryptoCurrencies');
       state.error = {
         type: OnRampErrorType.FAILED_TO_LOAD_CURRENCIES,
         message: 'Failed to load crypto currencies'
@@ -336,9 +376,8 @@ export const OnRampController = {
 
       if (countryCode) {
         currencyCode =
-          ConstantsUtil.COUNTRY_CURRENCIES[
-            countryCode as keyof typeof ConstantsUtil.COUNTRY_CURRENCIES
-          ];
+          state.countriesDefaults?.find(d => d.countryCode === countryCode)?.defaultCurrencyCode ||
+          'USD';
       }
 
       const preferredCurrency = await StorageUtil.getOnRampPreferredFiatCurrency();
@@ -353,6 +392,7 @@ export const OnRampController = {
         this.setPaymentCurrency(defaultCurrency);
       }
     } catch (error) {
+      LogController.sendError(error, 'OnRampController.ts', 'fetchFiatCurrencies');
       state.error = {
         type: OnRampErrorType.FAILED_TO_LOAD_CURRENCIES,
         message: 'Failed to load fiat currencies'
@@ -375,50 +415,103 @@ export const OnRampController = {
     }
   },
 
-  getQuotesDebounced: CoreHelperUtil.debounce(function () {
-    OnRampController.getQuotes();
-  }, 500),
-
   async getQuotes() {
-    if (!state.paymentAmount || state.paymentAmount <= 0) {
+    if (!this.canGenerateQuote()) {
       this.clearQuotes();
 
       return;
     }
 
-    state.quotesLoading = true;
-    state.error = undefined;
-
     this.abortGetQuotes(false);
     quotesAbortController = new AbortController();
+    const currentSignal = quotesAbortController.signal;
 
     try {
+      if (
+        !state.selectedCountry?.countryCode ||
+        !state.purchaseCurrency?.currencyCode ||
+        !state.paymentCurrency?.currencyCode ||
+        !ConnectionsController.state.activeAddress
+      ) {
+        throw new BlockchainOnRampError(OnRampErrorType.UNKNOWN, 'Invalid quote parameters');
+      }
+
+      state.quotesLoading = true;
+      state.selectedQuote = undefined;
+      state.selectedServiceProvider = undefined;
+      state.error = undefined;
+
+      const plainAddress = CoreHelperUtil.getPlainAddress(
+        ConnectionsController.state.activeAddress
+      );
+
+      if (!plainAddress) {
+        throw new Error('Invalid address');
+      }
+
       const body = {
-        countryCode: state.selectedCountry?.countryCode!,
-        paymentMethodType: state.selectedPaymentMethod?.paymentMethod!,
-        destinationCurrencyCode: state.purchaseCurrency?.currencyCode!,
-        sourceAmount: state.paymentAmount,
-        sourceCurrencyCode: state.paymentCurrency?.currencyCode!,
-        walletAddress: AccountController.state.address!
+        countryCode: state.selectedCountry.countryCode,
+        destinationCurrencyCode: state.purchaseCurrency.currencyCode,
+        sourceAmount: state.paymentAmount!,
+        sourceCurrencyCode: state.paymentCurrency.currencyCode,
+        walletAddress: plainAddress,
+        excludeProviders: EXCLUDED_ONRAMP_PROVIDERS
       };
 
-      const response = await BlockchainApiController.getOnRampQuotes(
-        body,
-        quotesAbortController.signal
-      );
+      const response = await BlockchainApiController.getOnRampQuotes(body, currentSignal);
 
       if (!response || !response.length) {
-        throw new Error('No quotes available');
+        throw new BlockchainOnRampError(OnRampErrorType.NO_VALID_QUOTES, 'No valid quotes');
       }
 
       const quotes = response.sort((a, b) => b.customerScore - a.customerScore);
 
       state.quotes = quotes;
-      state.selectedQuote = quotes[0];
+
+      //Replace payment method if it's not in the quotes
+      const isValidPaymentMethod =
+        state.selectedPaymentMethod &&
+        quotes.some(
+          quote => quote.paymentMethodType === state.selectedPaymentMethod?.paymentMethod
+        );
+
+      if (!isValidPaymentMethod) {
+        const countryMethods =
+          state.countriesDefaults?.find(d => d.countryCode === state.selectedCountry?.countryCode)
+            ?.defaultPaymentMethods || [];
+
+        const availableQuoteMethods = new Set(quotes.map(q => q.paymentMethodType));
+
+        let newPaymentMethodType: string | undefined;
+        for (const dpm of countryMethods) {
+          if (availableQuoteMethods.has(dpm)) {
+            newPaymentMethodType = dpm;
+            break;
+          }
+        }
+
+        if (newPaymentMethodType) {
+          state.selectedPaymentMethod =
+            state.paymentMethods.find(m => m.paymentMethod === newPaymentMethodType) ||
+            state.paymentMethods.find(
+              method => method.paymentMethod === quotes[0]?.paymentMethodType
+            );
+        } else {
+          state.selectedPaymentMethod = state.paymentMethods.find(
+            method => method.paymentMethod === quotes[0]?.paymentMethodType
+          );
+        }
+      }
+
+      state.selectedQuote = quotes.find(
+        quote => quote.paymentMethodType === state.selectedPaymentMethod?.paymentMethod
+      );
+
       state.selectedServiceProvider = state.serviceProviders.find(
-        sp => sp.serviceProvider === quotes[0]?.serviceProvider
+        sp => sp.serviceProvider === state.selectedQuote?.serviceProvider
       );
     } catch (error: any) {
+      LogController.sendError(error, 'OnRampController.ts', 'getQuotes');
       if (error.name === 'AbortError') {
         // Do nothing, another request was made
         return;
@@ -435,7 +528,9 @@ export const OnRampController = {
       this.clearQuotes();
       state.error = mapErrorMessage(error?.code || 'UNKNOWN_ERROR');
     } finally {
-      state.quotesLoading = false;
+      if (!currentSignal.aborted) {
+        state.quotesLoading = false;
+      }
     }
   },
 
@@ -449,7 +544,7 @@ export const OnRampController = {
       state.paymentCurrency?.currencyCode &&
       state.selectedCountry &&
       !state.loading &&
-      AccountController.state.address
+      ConnectionsController.state.activeAddress
     );
   },
 
@@ -467,6 +562,7 @@ export const OnRampController = {
 
       state.paymentCurrenciesLimits = limits;
     } catch (error) {
+      LogController.sendError(error, 'OnRampController.ts', 'fetchFiatLimits');
       state.error = {
         type: OnRampErrorType.FAILED_TO_LOAD_LIMITS,
         message: 'Failed to load fiat limits'
@@ -476,6 +572,10 @@ export const OnRampController = {
   },
 
   async generateWidget({ quote }: { quote: OnRampQuote }) {
+    if (!ConnectionsController.state.activeAddress) {
+      throw new Error('No active address');
+    }
+
     const metadata = OptionsController.state.metadata;
     const eventProperties = {
       asset: quote.destinationCurrencyCode,
@@ -492,16 +592,26 @@ export const OnRampController = {
         throw new Error('Invalid quote');
       }
 
-      const widget = await BlockchainApiController.getOnRampWidget({
+      const plainAddress = CoreHelperUtil.getPlainAddress(
+        ConnectionsController.state.activeAddress
+      );
+
+      if (!plainAddress) {
+        throw new Error('Invalid address');
+      }
+
+      const body = {
         countryCode: quote.countryCode,
         destinationCurrencyCode: quote.destinationCurrencyCode,
         paymentMethodType: quote.paymentMethodType,
         serviceProvider: quote.serviceProvider,
         sourceAmount: quote.sourceAmount,
         sourceCurrencyCode: quote.sourceCurrencyCode,
-        walletAddress: AccountController.state.address!,
+        walletAddress: plainAddress,
         redirectUrl: metadata?.redirect?.universal ?? metadata?.redirect?.native
-      });
+      };
+
+      const widget = await BlockchainApiController.getOnRampWidget(body);
 
       if (!widget || !widget.widgetUrl) {
         throw new Error('Invalid widget response');
@@ -517,6 +627,7 @@ export const OnRampController = {
 
       return widget;
     } catch (e: any) {
+      LogController.sendError(e, 'OnRampController.ts', 'generateWidget', { quote });
       EventsController.sendEvent({
         type: 'track',
         event: 'BUY_FAIL',
@@ -555,12 +666,14 @@ export const OnRampController = {
       await this.fetchServiceProviders();
 
       await Promise.all([
+        this.fetchCountriesDefaults(),
         this.fetchPaymentMethods(),
         this.fetchFiatLimits(),
         this.fetchCryptoCurrencies(),
         this.fetchFiatCurrencies()
       ]);
     } catch (error) {
+      LogController.sendError(error, 'OnRampController.ts', 'loadOnRampData');
       if (!state.error) {
         state.error = {
           type: OnRampErrorType.FAILED_TO_LOAD,

package/src/controllers/OptionsController.ts

@@ -1,6 +1,15 @@
 import { proxy, ref } from 'valtio';
-import type { Tokens, Storage, Metadata } from '@reown/appkit-common-react-native';
-import type { CustomWallet, Features, ProjectId, SdkType, SdkVersion } from '../utils/TypeUtil';
+import type {
+  Storage,
+  Metadata,
+  AppKitNetwork,
+  CustomWallet,
+  Features,
+  ProjectId,
+  SdkType,
+  SdkVersion,
+  SIWXConfig
+} from '@reown/appkit-common-react-native';
 
 import { ConstantsUtil } from '../utils/ConstantsUtil';
 
@@ -17,23 +26,25 @@ export interface OptionsControllerState {
   excludeWalletIds?: string[];
   featuredWalletIds?: string[];
   customWallets?: CustomWallet[];
-  tokens?: Tokens;
   enableAnalytics?: boolean;
   sdkType: SdkType;
   sdkVersion: SdkVersion;
   metadata?: Metadata;
-  isSiweEnabled?: boolean;
+  siwx?: SIWXConfig;
   isOnRampEnabled?: boolean;
   features?: Features;
   debug?: boolean;
+  defaultNetwork?: AppKitNetwork;
+  requestedNetworks?: AppKitNetwork[];
 }
 
 // -- State --------------------------------------------- //
 const state = proxy<OptionsControllerState>({
   projectId: '',
   sdkType: 'appkit',
-  sdkVersion: 'react-native-wagmi-undefined',
+  sdkVersion: 'react-native-undefined-undefined',
   features: ConstantsUtil.DEFAULT_FEATURES,
+  customWallets: [],
   debug: false
 });
 
@@ -61,10 +72,6 @@ export const OptionsController = {
     state.featuredWalletIds = featuredWalletIds;
   },
 
-  setTokens(tokens: OptionsControllerState['tokens']) {
-    state.tokens = tokens;
-  },
-
   setCustomWallets(customWallets: OptionsControllerState['customWallets']) {
     state.customWallets = customWallets;
   },
@@ -81,10 +88,6 @@ export const OptionsController = {
     state.metadata = metadata;
   },
 
-  setIsSiweEnabled(isSiweEnabled: OptionsControllerState['isSiweEnabled']) {
-    state.isSiweEnabled = isSiweEnabled;
-  },
-
   setFeatures(features: OptionsControllerState['features']) {
     state.features = { ...ConstantsUtil.DEFAULT_FEATURES, ...features };
   },
@@ -103,10 +106,34 @@ export const OptionsController = {
     }
   },
 
+  setDefaultNetwork(defaultNetwork?: OptionsControllerState['defaultNetwork']) {
+    state.defaultNetwork = defaultNetwork;
+  },
+
+  setRequestedNetworks(requestedNetworks?: OptionsControllerState['requestedNetworks']) {
+    state.requestedNetworks = requestedNetworks;
+  },
+
+  setSiwx(siwx?: OptionsControllerState['siwx']) {
+    if (siwx && (siwx?.signOutOnDisconnect === undefined || siwx?.signOutOnDisconnect === null)) {
+      siwx.signOutOnDisconnect = true;
+    }
+
+    state.siwx = siwx;
+  },
+
   isClipboardAvailable() {
     return !!state.clipboardClient;
   },
 
+  getStorage() {
+    if (!state.storage) {
+      throw new Error('AppKit: Storage is not set');
+    }
+
+    return state.storage;
+  },
+
   copyToClipboard(value: string) {
     const client = state.clipboardClient;
     if (client) {