@reown/appkit-core-react-native 0.0.0-feat-onramp-20250602154313 → 0.0.0-feat-multichain-20250604171123

package/src/controllers/ConnectionsController.ts

@@ -0,0 +1,291 @@
+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 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) 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/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

@@ -134,10 +134,6 @@ export const OnRampController = {
 
   setSelectedPaymentMethod(paymentMethod: OnRampPaymentMethod) {
     state.selectedPaymentMethod = paymentMethod;
-    state.paymentMethods = [
-      paymentMethod,
-      ...state.paymentMethods.filter(m => m.paymentMethod !== paymentMethod.paymentMethod)
-    ];
 
     this.clearQuotes();
   },
@@ -188,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) {

package/src/controllers/OptionsController.ts

@@ -1,13 +1,14 @@
 import { proxy, ref } from 'valtio';
+import type { Tokens } from '@reown/appkit-common-react-native';
 import type {
   CustomWallet,
   Features,
   Metadata,
   ProjectId,
   SdkType,
-  SdkVersion,
-  Tokens
+  SdkVersion
 } from '../utils/TypeUtil';
+
 import { ConstantsUtil } from '../utils/ConstantsUtil';
 
 // -- Types --------------------------------------------- //
@@ -17,7 +18,7 @@ export interface ClipboardClient {
 
 export interface OptionsControllerState {
   projectId: ProjectId;
-  _clipboardClient?: ClipboardClient;
+  clipboardClient?: ClipboardClient;
   includeWalletIds?: string[];
   excludeWalletIds?: string[];
   featuredWalletIds?: string[];
@@ -47,7 +48,7 @@ export const OptionsController = {
   state,
 
   setClipboardClient(client: ClipboardClient) {
-    state._clipboardClient = ref(client);
+    state.clipboardClient = ref(client);
   },
 
   setProjectId(projectId: OptionsControllerState['projectId']) {
@@ -103,11 +104,11 @@ export const OptionsController = {
   },
 
   isClipboardAvailable() {
-    return !!state._clipboardClient;
+    return !!state.clipboardClient;
   },
 
   copyToClipboard(value: string) {
-    const client = state._clipboardClient;
+    const client = state.clipboardClient;
     if (client) {
       client?.setString(value);
     }

package/src/controllers/PublicStateController.ts

@@ -1,6 +1,6 @@
 import { proxy, subscribe as sub } from 'valtio';
 import { subscribeKey as subKey } from 'valtio/utils';
-import type { CaipNetworkId } from '../utils/TypeUtil.js';
+import type { CaipNetworkId } from '@reown/appkit-common-react-native';
 
 // -- Types --------------------------------------------- //
 export interface PublicStateControllerState {

package/src/controllers/RouterController.ts

@@ -1,7 +1,8 @@
 import { proxy } from 'valtio';
+import type { CaipNetwork } from '@reown/appkit-common-react-native';
+
 import type {
   WcWallet,
-  CaipNetwork,
   Connector,
   SwapInputTarget,
   OnRampTransactionResult

package/src/controllers/SendController.ts

@@ -6,8 +6,8 @@ import { ConnectionController } from './ConnectionController';
 import { SnackController } from './SnackController';
 import { CoreHelperUtil } from '../utils/CoreHelperUtil';
 import { EventsController } from './EventsController';
-import { NetworkController } from './NetworkController';
 import { RouterController } from './RouterController';
+import { ConnectionsController } from './ConnectionsController';
 
 // -- Types --------------------------------------------- //
 export interface TxParams {
@@ -100,7 +100,7 @@ export const SendController = {
           isSmartAccount: AccountController.state.preferredAccountType === 'smartAccount',
           token: this.state.token.address,
           amount: this.state.sendTokenAmount,
-          network: NetworkController.state.caipNetwork?.id || ''
+          network: ConnectionsController.state.activeNetwork?.caipNetworkId || ''
         }
       });
       this.sendERC20Token({
@@ -123,7 +123,7 @@ export const SendController = {
           isSmartAccount: AccountController.state.preferredAccountType === 'smartAccount',
           token: this.state.token?.symbol,
           amount: this.state.sendTokenAmount,
-          network: NetworkController.state.caipNetwork?.id || ''
+          network: ConnectionsController.state.activeNetwork?.caipNetworkId || ''
         }
       });
       this.sendNativeToken({
@@ -165,7 +165,7 @@ export const SendController = {
           isSmartAccount: AccountController.state.preferredAccountType === 'smartAccount',
           token: this.state.token?.symbol || '',
           amount: params.sendTokenAmount,
-          network: NetworkController.state.caipNetwork?.id || ''
+          network: ConnectionsController.state.activeNetwork?.caipNetworkId || ''
         }
       });
       this.resetSend();
@@ -178,7 +178,7 @@ export const SendController = {
           isSmartAccount: AccountController.state.preferredAccountType === 'smartAccount',
           token: this.state.token?.symbol || '',
           amount: params.sendTokenAmount,
-          network: NetworkController.state.caipNetwork?.id || ''
+          network: ConnectionsController.state.activeNetwork?.caipNetworkId || ''
         }
       });
       SnackController.showError('Something went wrong');