@reown/appkit-core-react-native 0.0.0-feat-onramp-20250626173252 → 0.0.0-feat-multi-social-20250630195637

package/src/controllers/ConnectionController.ts

@@ -49,8 +49,7 @@ export interface ConnectionControllerState {
   wcError?: boolean;
   pressedWallet?: WcWallet;
   recentWallets?: WcWallet[];
-  selectedSocialProvider?: SocialProvider;
-  connectedWalletImageUrl?: string;
+  connectedWalletImageUrl?: string; //TODO: remove this
   connectedSocialProvider?: SocialProvider;
 }
 
@@ -120,12 +119,17 @@ export const ConnectionController = {
     state.pressedWallet = undefined;
   },
 
-  setRecentWallets(wallets: ConnectionControllerState['recentWallets']) {
-    state.recentWallets = wallets;
+  setWcPromise(wcPromise: ConnectionControllerState['wcPromise']) {
+    state.wcPromise = wcPromise;
+  },
+
+  setWcUri(wcUri: ConnectionControllerState['wcUri']) {
+    state.wcUri = wcUri;
+    state.wcPairingExpiry = CoreHelperUtil.getPairingExpiry();
   },
 
-  setSelectedSocialProvider(provider: ConnectionControllerState['selectedSocialProvider']) {
-    state.selectedSocialProvider = provider;
+  setRecentWallets(wallets: ConnectionControllerState['recentWallets']) {
+    state.recentWallets = wallets;
   },
 
   async setConnectedWalletImageUrl(url: ConnectionControllerState['connectedWalletImageUrl']) {
@@ -185,14 +189,12 @@ export const ConnectionController = {
   resetWcConnection() {
     this.clearUri();
     state.pressedWallet = undefined;
-    state.selectedSocialProvider = undefined;
     ConnectionController.setConnectedWalletImageUrl(undefined);
     ConnectorController.setConnectedConnector(undefined);
     StorageUtil.removeWalletConnectDeepLink();
   },
 
   async disconnect() {
-    await this._getClient().disconnect();
     this.resetWcConnection();
     // remove transactions
     // RouterController.reset('Connect');

package/src/controllers/ConnectionsController.ts

@@ -0,0 +1,309 @@
+import { proxy, ref } from 'valtio';
+import { derive } from 'valtio/utils';
+import {
+  EVMAdapter,
+  type AppKitNetwork,
+  type BlockchainAdapter,
+  type CaipAddress,
+  type CaipNetworkId,
+  type ChainNamespace,
+  type GetBalanceResponse,
+  type WalletInfo
+} from '@reown/appkit-common-react-native';
+import { StorageUtil } from '../utils/StorageUtil';
+
+// -- Types --------------------------------------------- //
+type Balance = GetBalanceResponse;
+
+//TODO: balance could be elsewhere
+interface Connection {
+  accounts: CaipAddress[];
+  balances: Record<CaipAddress, Balance>; //TODO: make this an array of balances
+  adapter: BlockchainAdapter;
+  caipNetwork: CaipNetworkId;
+  wallet?: WalletInfo;
+}
+
+export interface ConnectionsControllerState {
+  activeNamespace?: ChainNamespace;
+  connections: Map<ChainNamespace, Connection>;
+  networks: AppKitNetwork[];
+}
+
+// -- State --------------------------------------------- //
+const baseState = proxy<ConnectionsControllerState>({
+  activeNamespace: undefined,
+  connections: new Map<ChainNamespace, Connection>(),
+  networks: []
+});
+
+const derivedState = derive(
+  {
+    activeAddress: (get): CaipAddress | undefined => {
+      const snap = get(baseState);
+
+      if (!snap.activeNamespace) {
+        return undefined;
+      }
+
+      const connection = snap.connections.get(snap.activeNamespace);
+
+      if (!connection || !connection.accounts || connection.accounts.length === 0) {
+        return undefined;
+      }
+
+      //TODO: what happens if there are several accounts on the same chain?
+      const activeAccount = connection.accounts.find(account =>
+        account.startsWith(connection.caipNetwork)
+      );
+
+      return activeAccount;
+    },
+    activeBalance: (get): Balance | undefined => {
+      const snap = get(baseState);
+
+      if (!snap.activeNamespace) return undefined;
+      const connection = snap.connections.get(snap.activeNamespace);
+
+      if (!connection || !connection.accounts || connection.accounts.length === 0) {
+        return undefined;
+      }
+
+      const activeAccount = connection.accounts.find(account =>
+        account.startsWith(connection.caipNetwork)
+      );
+
+      if (
+        !connection ||
+        !connection.balances ||
+        !activeAccount ||
+        Object.keys(connection.balances).length === 0
+      ) {
+        return undefined;
+      }
+
+      return connection.balances[activeAccount];
+    },
+    activeNetwork: (get): AppKitNetwork | undefined => {
+      const snap = get(baseState);
+
+      if (!snap.activeNamespace) return undefined;
+
+      const connection = snap.connections.get(snap.activeNamespace);
+
+      if (!connection) return undefined;
+
+      return snap.networks.find(
+        network =>
+          network.chainNamespace === snap.activeNamespace &&
+          network.id?.toString() === connection.caipNetwork?.split(':')[1]
+      );
+    },
+    activeCaipNetworkId: (get): CaipNetworkId | undefined => {
+      const snap = get(baseState);
+
+      if (!snap.activeNamespace) return undefined;
+
+      const connection = snap.connections.get(snap.activeNamespace);
+
+      if (!connection) return undefined;
+
+      return connection.caipNetwork;
+    },
+    walletInfo: (get): WalletInfo | undefined => {
+      const snap = get(baseState);
+
+      if (!snap.activeNamespace) return undefined;
+
+      return snap.connections.get(snap.activeNamespace)?.wallet;
+    }
+  },
+  {
+    proxy: baseState // Link derived proxy to the base state proxy
+  }
+);
+
+// -- Controller ---------------------------------------- //
+export const ConnectionsController = {
+  state: derivedState,
+
+  setActiveNamespace(namespace?: ChainNamespace) {
+    baseState.activeNamespace = namespace;
+    StorageUtil.setActiveNamespace(namespace);
+  },
+
+  storeConnection({
+    namespace,
+    adapter,
+    accounts,
+    chains,
+    wallet,
+    caipNetwork
+  }: {
+    namespace: ChainNamespace;
+    adapter: BlockchainAdapter;
+    accounts: CaipAddress[];
+    chains: CaipNetworkId[];
+    wallet?: WalletInfo;
+    caipNetwork?: CaipNetworkId;
+  }) {
+    const newConnectionEntry = {
+      balances: {},
+      caipNetwork: caipNetwork ?? chains[0]!,
+      adapter: ref(adapter),
+      accounts,
+      chains,
+      wallet
+    };
+
+    // Create a new Map to ensure Valtio detects the change
+    const newConnectionsMap = new Map(baseState.connections);
+    newConnectionsMap.set(namespace, newConnectionEntry);
+    baseState.connections = newConnectionsMap;
+  },
+
+  updateAccounts(namespace: ChainNamespace, accounts: CaipAddress[]) {
+    const connection = baseState.connections.get(namespace);
+    if (!connection) {
+      return;
+    }
+
+    const newConnectionsMap = new Map(baseState.connections);
+    const updatedConnection = { ...connection, accounts };
+    newConnectionsMap.set(namespace, updatedConnection);
+    baseState.connections = newConnectionsMap;
+  },
+
+  updateBalance(namespace: ChainNamespace, address: CaipAddress, balance: Balance) {
+    const connection = baseState.connections.get(namespace);
+    if (!connection) {
+      return;
+    }
+
+    const newBalances = { ...connection.balances, [address]: balance };
+    const updatedConnection = { ...connection, balances: newBalances };
+    const newConnectionsMap = new Map(baseState.connections);
+    newConnectionsMap.set(namespace, updatedConnection);
+    baseState.connections = newConnectionsMap;
+  },
+
+  setActiveNetwork(namespace: ChainNamespace, networkId: CaipNetworkId) {
+    const connection = baseState.connections.get(namespace);
+
+    if (!connection) {
+      return;
+    }
+
+    baseState.connections.set(namespace, {
+      ...connection,
+      caipNetwork: networkId
+    });
+  },
+
+  setNetworks(networks: AppKitNetwork[]) {
+    baseState.networks = networks;
+  },
+
+  getConnectedNetworks() {
+    return baseState.networks.filter(
+      network =>
+        baseState.connections
+          .get(network.chainNamespace)
+          ?.accounts.some(account => account.startsWith(network.caipNetworkId))
+    );
+  },
+
+  async disconnect(namespace: ChainNamespace, isInternal = true) {
+    const connection = baseState.connections.get(namespace);
+    if (!connection) return;
+
+    // Get the current connector from the adapter
+    const connector = connection.adapter.connector;
+    if (!connector) return;
+
+    // Find all namespaces that use the same connector
+    const namespacesUsingConnector = Array.from(baseState.connections.keys()).filter(
+      ns => baseState.connections.get(ns)?.adapter.connector === connector
+    );
+
+    // Unsubscribe all event listeners from the adapter
+    namespacesUsingConnector.forEach(ns => {
+      const _connection = baseState.connections.get(ns);
+      if (_connection?.adapter) {
+        _connection.adapter.removeAllListeners();
+      }
+    });
+
+    // Disconnect the adapter
+    if (isInternal) {
+      await connection.adapter.disconnect();
+    }
+
+    // Remove all namespaces that used this connector
+    const newConnectionsMap = new Map(baseState.connections);
+    namespacesUsingConnector.forEach(ns => {
+      newConnectionsMap.delete(ns);
+    });
+    baseState.connections = newConnectionsMap;
+
+    // Remove activeNamespace if it is in the list of namespaces using the connector
+    if (
+      baseState.activeNamespace &&
+      (baseState.activeNamespace === namespace ||
+        namespacesUsingConnector.includes(baseState.activeNamespace))
+    ) {
+      baseState.activeNamespace = undefined;
+      StorageUtil.setActiveNamespace(undefined);
+    }
+  },
+
+  parseUnits(value: string, decimals: number) {
+    if (!baseState.activeNamespace) return undefined;
+
+    return baseState.connections
+      .get(baseState.activeNamespace)
+      ?.adapter.parseUnits(value, decimals);
+  },
+
+  async signMessage(address: CaipAddress, message: string) {
+    if (!baseState.activeNamespace) return undefined;
+
+    const [namespace, chainId, plainAddress] = address.split(':');
+
+    if (!namespace || namespace !== baseState.activeNamespace || !chainId || !plainAddress) {
+      return undefined;
+    }
+
+    const adapter = baseState.connections.get(baseState.activeNamespace)?.adapter;
+
+    if (adapter instanceof EVMAdapter && plainAddress && chainId) {
+      return adapter.signMessage(plainAddress, message, chainId);
+    }
+
+    return undefined;
+  },
+
+  async sendTransaction(args: any) {
+    if (!baseState.activeNamespace) return undefined;
+
+    const adapter = baseState.connections.get(baseState.activeNamespace)?.adapter;
+
+    if (adapter instanceof EVMAdapter) {
+      return adapter.sendTransaction(args);
+    }
+
+    return undefined;
+  },
+
+  async estimateGas(args: any) {
+    if (!baseState.activeNamespace || baseState.activeNamespace !== 'eip155') return undefined;
+
+    const adapter = baseState.connections.get(baseState.activeNamespace)?.adapter;
+
+    if (adapter instanceof EVMAdapter) {
+      return adapter.estimateGas(args);
+    }
+
+    return undefined;
+  }
+};

package/src/controllers/ConnectorController.ts

@@ -50,6 +50,7 @@ export const ConnectorController = {
 
     if (saveStorage) {
       if (connectorType) {
+        //TODO: Check this
         StorageUtil.setConnectedConnector(connectorType);
       } else {
         StorageUtil.removeConnectedConnector();

package/src/controllers/EnsController.ts

@@ -1,5 +1,5 @@
-import { subscribeKey as subKey } from 'valtio/utils';
-import { proxy, subscribe as sub } from 'valtio';
+import { subscribeKey as subKey } from 'valtio/vanilla/utils';
+import { proxy, subscribe as sub } from 'valtio/vanilla';
 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';
+import { proxy, subscribe as sub } from 'valtio/vanilla';
 import { ApiController } from './ApiController';
 import { OptionsController } from './OptionsController';
 import { CoreHelperUtil } from '../utils/CoreHelperUtil';

package/src/controllers/ModalController.ts

@@ -1,6 +1,7 @@
 import { proxy } from 'valtio';
 import { AccountController } from './AccountController';
-import { RouterController, type RouterControllerState } from './RouterController';
+import type { RouterControllerState } from './RouterController';
+import { RouterController } from './RouterController';
 import { PublicStateController } from './PublicStateController';
 import { EventsController } from './EventsController';
 import { ApiController } from './ApiController';

package/src/controllers/NetworkController.ts

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

package/src/controllers/OnRampController.ts

@@ -9,8 +9,7 @@ import type {
   OnRampCryptoCurrency,
   OnRampServiceProvider,
   OnRampError,
-  OnRampErrorTypeValues,
-  OnRampCountryDefaults
+  OnRampErrorTypeValues
 } from '../utils/TypeUtil';
 
 import { CoreHelperUtil } from '../utils/CoreHelperUtil';
@@ -33,23 +32,23 @@ const mapErrorMessage = (errorCode: string): OnRampError => {
   const errorMap: Record<string, { type: OnRampErrorTypeValues; message: string }> = {
     [OnRampErrorType.AMOUNT_TOO_LOW]: {
       type: OnRampErrorType.AMOUNT_TOO_LOW,
-      message: 'The amount is too low'
+      message: 'Amount is too low'
     },
     [OnRampErrorType.AMOUNT_TOO_HIGH]: {
       type: OnRampErrorType.AMOUNT_TOO_HIGH,
-      message: 'The amount is too high'
+      message: 'Amount is too high'
     },
     [OnRampErrorType.INVALID_AMOUNT]: {
       type: OnRampErrorType.INVALID_AMOUNT,
-      message: 'Enter a valid amount'
+      message: 'Please adjust amount'
     },
     [OnRampErrorType.INCOMPATIBLE_REQUEST]: {
       type: OnRampErrorType.INCOMPATIBLE_REQUEST,
-      message: 'Enter a valid amount'
+      message: 'Try different amount or payment method'
     },
     [OnRampErrorType.BAD_REQUEST]: {
       type: OnRampErrorType.BAD_REQUEST,
-      message: 'Enter a valid amount'
+      message: 'Try different amount or payment method'
     }
   };
 
@@ -64,7 +63,6 @@ const mapErrorMessage = (errorCode: string): OnRampError => {
 // -- Types --------------------------------------------- //
 export interface OnRampControllerState {
   countries: OnRampCountry[];
-  countriesDefaults?: OnRampCountryDefaults[];
   selectedCountry?: OnRampCountry;
   serviceProviders: OnRampServiceProvider[];
   selectedServiceProvider?: OnRampServiceProvider;
@@ -116,8 +114,9 @@ export const OnRampController = {
 
     if (updateCurrency) {
       const currencyCode =
-        state.countriesDefaults?.find(d => d.countryCode === country.countryCode)
-          ?.defaultCurrencyCode || 'USD';
+        ConstantsUtil.COUNTRY_CURRENCIES[
+          country.countryCode as keyof typeof ConstantsUtil.COUNTRY_CURRENCIES
+        ] || 'USD';
 
       const currency = state.paymentCurrencies?.find(c => c.currencyCode === currencyCode);
 
@@ -127,7 +126,6 @@ export const OnRampController = {
     }
 
     await Promise.all([this.fetchPaymentMethods(), this.fetchCryptoCurrencies()]);
-    this.clearQuotes();
 
     state.loading = false;
 
@@ -136,6 +134,8 @@ export const OnRampController = {
 
   setSelectedPaymentMethod(paymentMethod: OnRampPaymentMethod) {
     state.selectedPaymentMethod = paymentMethod;
+
+    this.clearQuotes();
   },
 
   setPurchaseCurrency(currency: OnRampCryptoCurrency) {
@@ -184,7 +184,7 @@ export const OnRampController = {
       selectedCurrency = state.purchaseCurrencies?.find(c => c.currencyCode === defaultCurrency);
     }
 
-    state.purchaseCurrency = selectedCurrency ?? state.purchaseCurrencies?.[0] ?? undefined;
+    state.purchaseCurrency = selectedCurrency || state.purchaseCurrencies?.[0] || undefined;
   },
 
   getServiceProviderImage(serviceProviderName?: string) {
@@ -231,27 +231,6 @@ 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) {
-      state.error = {
-        type: OnRampErrorType.FAILED_TO_LOAD_COUNTRIES,
-        message: 'Failed to load countries defaults'
-      };
-    }
-  },
-
   async fetchServiceProviders() {
     try {
       let serviceProviders = await StorageUtil.getOnRampServiceProviders();
@@ -280,8 +259,10 @@ export const OnRampController = {
       });
 
       const defaultCountryPaymentMethods =
-        state.countriesDefaults?.find(d => d.countryCode === state.selectedCountry?.countryCode)
-          ?.defaultPaymentMethods || [];
+        ConstantsUtil.COUNTRY_DEFAULT_PAYMENT_METHOD[
+          state.selectedCountry
+            ?.countryCode as keyof typeof ConstantsUtil.COUNTRY_DEFAULT_PAYMENT_METHOD
+        ];
 
       state.paymentMethods =
         paymentMethods?.sort((a, b) => {
@@ -295,7 +276,9 @@ export const OnRampController = {
           return aIndex - bIndex;
         }) || [];
 
-      state.selectedPaymentMethod = state.paymentMethods[0];
+      state.selectedPaymentMethod = paymentMethods?.[0] || undefined;
+
+      this.clearQuotes();
     } catch (error) {
       state.error = {
         type: OnRampErrorType.FAILED_TO_LOAD_METHODS,
@@ -353,8 +336,9 @@ export const OnRampController = {
 
       if (countryCode) {
         currencyCode =
-          state.countriesDefaults?.find(d => d.countryCode === countryCode)?.defaultCurrencyCode ||
-          'USD';
+          ConstantsUtil.COUNTRY_CURRENCIES[
+            countryCode as keyof typeof ConstantsUtil.COUNTRY_CURRENCIES
+          ];
       }
 
       const preferredCurrency = await StorageUtil.getOnRampPreferredFiatCurrency();
@@ -403,24 +387,25 @@ export const OnRampController = {
     }
 
     state.quotesLoading = true;
-    state.selectedQuote = undefined;
-    state.selectedServiceProvider = undefined;
     state.error = undefined;
 
     this.abortGetQuotes(false);
     quotesAbortController = new AbortController();
-    const currentSignal = quotesAbortController.signal;
 
     try {
       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!
       };
 
-      const response = await BlockchainApiController.getOnRampQuotes(body, currentSignal);
+      const response = await BlockchainApiController.getOnRampQuotes(
+        body,
+        quotesAbortController.signal
+      );
 
       if (!response || !response.length) {
         throw new Error('No quotes available');
@@ -429,48 +414,9 @@ export const OnRampController = {
       const quotes = response.sort((a, b) => b.customerScore - a.customerScore);
 
       state.quotes = quotes;
-
-      //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.selectedQuote = quotes[0];
       state.selectedServiceProvider = state.serviceProviders.find(
-        sp => sp.serviceProvider === state.selectedQuote?.serviceProvider
+        sp => sp.serviceProvider === quotes[0]?.serviceProvider
       );
     } catch (error: any) {
       if (error.name === 'AbortError') {
@@ -489,9 +435,7 @@ export const OnRampController = {
       this.clearQuotes();
       state.error = mapErrorMessage(error?.code || 'UNKNOWN_ERROR');
     } finally {
-      if (!currentSignal.aborted) {
-        state.quotesLoading = false;
-      }
+      state.quotesLoading = false;
     }
   },
 
@@ -548,7 +492,7 @@ export const OnRampController = {
         throw new Error('Invalid quote');
       }
 
-      const body = {
+      const widget = await BlockchainApiController.getOnRampWidget({
         countryCode: quote.countryCode,
         destinationCurrencyCode: quote.destinationCurrencyCode,
         paymentMethodType: quote.paymentMethodType,
@@ -557,9 +501,7 @@ export const OnRampController = {
         sourceCurrencyCode: quote.sourceCurrencyCode,
         walletAddress: AccountController.state.address!,
         redirectUrl: metadata?.redirect?.universal ?? metadata?.redirect?.native
-      };
-
-      const widget = await BlockchainApiController.getOnRampWidget(body);
+      });
 
       if (!widget || !widget.widgetUrl) {
         throw new Error('Invalid widget response');
@@ -613,7 +555,6 @@ export const OnRampController = {
       await this.fetchServiceProviders();
 
       await Promise.all([
-        this.fetchCountriesDefaults(),
         this.fetchPaymentMethods(),
         this.fetchFiatLimits(),
         this.fetchCryptoCurrencies(),