@reown/appkit-core-react-native 0.0.0-feat-multi-social-20250701185040 → 0.0.0-feat-multi-social-20250708154835

package/src/controllers/ConnectionsController.ts

@@ -7,23 +7,25 @@ import {
   type CaipAddress,
   type CaipNetworkId,
   type ChainNamespace,
-  type GetBalanceResponse,
+  type Balance,
   type WalletInfo,
-  type ConnectionProperties
+  type ConnectionProperties,
+  type AccountType
 } from '@reown/appkit-common-react-native';
 import { StorageUtil } from '../utils/StorageUtil';
+import { BlockchainApiController } from './BlockchainApiController';
+import { SnackController } from './SnackController';
+import { OptionsController } from './OptionsController';
 
 // -- Types --------------------------------------------- //
-type Balance = GetBalanceResponse;
-
-//TODO: balance could be elsewhere
 interface Connection {
   accounts: CaipAddress[];
-  balances: Record<CaipAddress, Balance>; //TODO: make this an array of balances
+  balances: Map<CaipAddress, Balance[]>;
   adapter: BlockchainAdapter;
   caipNetwork: CaipNetworkId;
   wallet?: WalletInfo;
   properties?: ConnectionProperties;
+  type?: AccountType;
 }
 
 export interface ConnectionsControllerState {
@@ -39,59 +41,118 @@ const baseState = proxy<ConnectionsControllerState>({
   networks: []
 });
 
+// -- Helper Functions --------------------------------------------- //
+const getActiveConnection = (snap: ConnectionsControllerState): Connection | undefined => {
+  if (!snap.activeNamespace) return undefined;
+
+  return snap.connections.get(snap.activeNamespace);
+};
+
+const hasValidAccounts = (connection: Connection): boolean => {
+  return connection?.accounts && connection.accounts.length > 0;
+};
+
+const findSmartAccountForNetwork = (connection: Connection): CaipAddress | undefined => {
+  return connection.properties?.smartAccounts?.find(account =>
+    account.startsWith(connection.caipNetwork)
+  );
+};
+
+const findEOAForNetwork = (connection: Connection): CaipAddress | undefined => {
+  const smartAccounts = connection.properties?.smartAccounts || [];
+
+  return connection.accounts.find(
+    account => account.startsWith(connection.caipNetwork) && !smartAccounts.includes(account)
+  );
+};
+
+const getActiveAddress = (connection: Connection): CaipAddress | undefined => {
+  if (!hasValidAccounts(connection)) {
+    return undefined;
+  }
+
+  // For smart accounts, prioritize smart account addresses
+  if (connection.type === 'smartAccount') {
+    const smartAccount = findSmartAccountForNetwork(connection);
+    if (smartAccount) {
+      return smartAccount;
+    }
+  }
+
+  // Fall back to EOA or any account that matches the network
+  return findEOAForNetwork(connection);
+};
+
+const updateConnection = (
+  namespace: ChainNamespace,
+  connection: Connection,
+  updates: Partial<Connection>
+) => {
+  if (!connection) return;
+  const newConnectionsMap = new Map(baseState.connections);
+  newConnectionsMap.set(namespace, { ...connection, ...updates });
+  baseState.connections = newConnectionsMap;
+};
+
 const derivedState = derive(
   {
     activeAddress: (get): CaipAddress | undefined => {
       const snap = get(baseState);
+      const connection = getActiveConnection(snap);
 
-      if (!snap.activeNamespace) {
+      return connection ? getActiveAddress(connection) : undefined;
+    },
+    activeBalance: (get): Balance | undefined => {
+      const snap = get(baseState);
+      const connection = getActiveConnection(snap);
+
+      if (!connection) {
         return undefined;
       }
 
-      const connection = snap.connections.get(snap.activeNamespace);
-
-      if (!connection || !connection.accounts || connection.accounts.length === 0) {
+      const activeAddress = getActiveAddress(connection);
+      if (!activeAddress || !connection.balances || connection.balances.size === 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) {
+      const addressBalances = connection.balances.get(activeAddress);
+      if (!addressBalances || addressBalances.length === 0) {
         return undefined;
       }
 
-      const activeAccount = connection.accounts.find(account =>
-        account.startsWith(connection.caipNetwork)
+      // Check if there's a specific token configured in OptionsController
+      const configuredTokens = OptionsController.state.tokens;
+      const activeNetwork = snap.networks.find(
+        network =>
+          network.chainNamespace === snap.activeNamespace &&
+          network.id?.toString() === connection.caipNetwork?.split(':')[1]
       );
 
-      if (
-        !connection ||
-        !connection.balances ||
-        !activeAccount ||
-        Object.keys(connection.balances).length === 0
-      ) {
-        return undefined;
+      if (configuredTokens && activeNetwork) {
+        const configuredToken = configuredTokens[activeNetwork.caipNetworkId];
+        if (configuredToken) {
+          // Find the configured token in the balances
+          const specificToken = addressBalances.find(
+            balance => balance.address === configuredToken.address
+          );
+          if (specificToken) {
+            return specificToken;
+          }
+        }
       }
 
-      return connection.balances[activeAccount];
+      // Return the native token (first balance without address)
+      const nativeToken = addressBalances.find(balance => !balance.address);
+      if (nativeToken) {
+        return nativeToken;
+      }
+
+      // Fallback to first available balance
+      return addressBalances[0];
     },
     activeNetwork: (get): AppKitNetwork | undefined => {
       const snap = get(baseState);
-
-      if (!snap.activeNamespace) return undefined;
-
-      const connection = snap.connections.get(snap.activeNamespace);
+      const connection = getActiveConnection(snap);
 
       if (!connection) return undefined;
 
@@ -103,21 +164,41 @@ const derivedState = derive(
     },
     activeCaipNetworkId: (get): CaipNetworkId | undefined => {
       const snap = get(baseState);
+      const connection = getActiveConnection(snap);
 
-      if (!snap.activeNamespace) return undefined;
+      return connection?.caipNetwork;
+    },
+    accountType: (get): AccountType | undefined => {
+      const snap = get(baseState);
+      const connection = getActiveConnection(snap);
 
-      const connection = snap.connections.get(snap.activeNamespace);
+      return connection?.type;
+    },
+    connection: (get): Connection | undefined => {
+      const snap = get(baseState);
 
-      if (!connection) return undefined;
+      return getActiveConnection(snap);
+    },
+    balances: (get): Balance[] | undefined => {
+      const snap = get(baseState);
+
+      const _connection = getActiveConnection(snap);
+
+      if (!_connection) {
+        return undefined;
+      }
+
+      const _activeAddress = getActiveAddress(_connection);
+
+      if (!_activeAddress) return [];
 
-      return connection.caipNetwork;
+      return _connection?.balances.get(_activeAddress);
     },
     walletInfo: (get): WalletInfo | undefined => {
       const snap = get(baseState);
+      const connection = getActiveConnection(snap);
 
-      if (!snap.activeNamespace) return undefined;
-
-      return snap.connections.get(snap.activeNamespace)?.wallet;
+      return connection?.wallet;
     }
   },
   {
@@ -135,30 +216,34 @@ export const ConnectionsController = {
   },
 
   setConnection({
-    namespace,
-    adapter,
     accounts,
-    chains,
-    wallet,
+    adapter,
     caipNetwork,
-    properties
+    namespace,
+    properties,
+    wallet
   }: {
-    namespace: ChainNamespace;
-    adapter: BlockchainAdapter;
     accounts: CaipAddress[];
-    chains: CaipNetworkId[];
-    wallet?: WalletInfo;
-    caipNetwork?: CaipNetworkId;
+    adapter: BlockchainAdapter;
+    caipNetwork: CaipNetworkId;
+    namespace: ChainNamespace;
     properties?: ConnectionProperties;
+    wallet?: WalletInfo;
   }) {
-    const newConnectionEntry = {
-      balances: {},
-      caipNetwork: caipNetwork ?? chains[0]!,
+    const type: AccountType =
+      properties?.smartAccounts?.length &&
+      properties.smartAccounts.find(account => account.startsWith(caipNetwork))
+        ? 'smartAccount'
+        : 'eoa';
+
+    const newConnectionEntry: Connection = {
+      balances: new Map<CaipAddress, Balance[]>(),
+      caipNetwork,
       adapter: ref(adapter),
       accounts,
-      chains,
       wallet,
-      properties
+      properties,
+      type
     };
 
     // Create a new Map to ensure Valtio detects the change
@@ -182,14 +267,34 @@ export const ConnectionsController = {
   updateBalance(namespace: ChainNamespace, address: CaipAddress, balance: Balance) {
     const connection = baseState.connections.get(namespace);
     if (!connection) {
+      console.warn(`No connection found for namespace: ${namespace}`);
+
       return;
     }
+    const newBalances = new Map(connection.balances);
+    const existingBalances = connection.balances.get(address) || [];
+    // Check if this token already exists by contract address or symbol
+    const existingIndex = existingBalances.findIndex(existingBalance => {
+      if (balance.address) {
+        return existingBalance.address === balance.address;
+      }
 
-    const newBalances = { ...connection.balances, [address]: balance };
-    const updatedConnection = { ...connection, balances: newBalances };
-    const newConnectionsMap = new Map(baseState.connections);
-    newConnectionsMap.set(namespace, updatedConnection);
-    baseState.connections = newConnectionsMap;
+      return existingBalance.symbol === balance.symbol;
+    });
+    let updatedBalances: Balance[];
+    if (existingIndex >= 0) {
+      // Update existing token
+      updatedBalances = [...existingBalances];
+      updatedBalances[existingIndex] = {
+        ...updatedBalances[existingIndex],
+        ...balance
+      };
+    } else {
+      // Add new token
+      updatedBalances = [...existingBalances, balance];
+    }
+    newBalances.set(address, updatedBalances);
+    updateConnection(namespace, connection, { balances: newBalances });
   },
 
   setActiveNetwork(namespace: ChainNamespace, networkId: CaipNetworkId) {
@@ -218,6 +323,16 @@ export const ConnectionsController = {
     );
   },
 
+  setAccountType(namespace: ChainNamespace, type: AccountType) {
+    const connection = baseState.connections.get(namespace);
+    if (!connection) return;
+
+    const newConnectionsMap = new Map(baseState.connections);
+    const newConnection = { ...connection, type };
+    newConnectionsMap.set(namespace, newConnection);
+    baseState.connections = newConnectionsMap;
+  },
+
   async disconnect(namespace: ChainNamespace, isInternal = true) {
     const connection = baseState.connections.get(namespace);
     if (!connection) return;
@@ -292,7 +407,6 @@ export const ConnectionsController = {
     if (!baseState.activeNamespace) return undefined;
 
     const adapter = baseState.connections.get(baseState.activeNamespace)?.adapter;
-
     if (adapter instanceof EVMAdapter) {
       return adapter.sendTransaction(args);
     }
@@ -304,11 +418,81 @@ export const ConnectionsController = {
     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;
+  },
+
+  async writeContract(args: any) {
+    if (!baseState.activeNamespace) return undefined;
+
+    const adapter = baseState.connections.get(baseState.activeNamespace)?.adapter;
+    if (adapter instanceof EVMAdapter) {
+      return adapter.writeContract(args);
+    }
+
+    return undefined;
+  },
+
+  async fetchBalance(forceUpdateAddresses?: CaipAddress[]) {
+    const connection = getActiveConnection(baseState);
+    if (!connection) {
+      throw new Error('No active connection found for balance fetch');
+    }
+
+    const chainId = connection.caipNetwork;
+    const address = getActiveAddress(connection);
+    const namespace = baseState.activeNamespace;
+    if (!namespace || !address || !chainId) {
+      throw new Error('Missing required data for balance fetch');
+    }
+
+    try {
+      const response = await BlockchainApiController.getBalance(address, forceUpdateAddresses);
+      if (!response) {
+        throw new Error('Failed to fetch token balance');
+      }
+      // Update balances for each token in the response
+      response.balances.forEach(balance => {
+        this.updateBalance(namespace, address, {
+          name: balance.name,
+          symbol: balance.symbol,
+          amount: balance.quantity.numeric,
+          address: balance.address,
+          quantity: balance.quantity,
+          price: balance.price,
+          value: balance.value,
+          iconUrl: balance.iconUrl
+        });
+      });
+    } catch (error) {
+      SnackController.showError('Failed to get account balance');
+    }
+  },
+
+  getSmartAccountEnabledNetworks(): AppKitNetwork[] {
+    const activeConnection = getActiveConnection(baseState);
+    if (!activeConnection) {
+      return [];
+    }
+    if (!activeConnection.properties?.smartAccounts?.length) {
+      return [];
+    }
+    const smartAccountNetworks = new Set<CaipNetworkId>();
+    activeConnection.properties.smartAccounts.forEach(smartAccount => {
+      const parts = smartAccount.split(':');
+      if (parts.length >= 2) {
+        const networkId: CaipNetworkId = `${parts[0]}:${parts[1]}`;
+        smartAccountNetworks.add(networkId);
+      }
+    });
+
+    return baseState.networks.filter(network => {
+      const networkId: CaipNetworkId = `${network.chainNamespace}:${network.id}`;
+
+      return smartAccountNetworks.has(networkId);
+    });
   }
 };

package/src/controllers/ModalController.ts

@@ -5,7 +5,7 @@ import { RouterController } from './RouterController';
 import { PublicStateController } from './PublicStateController';
 import { EventsController } from './EventsController';
 import { ApiController } from './ApiController';
-import { ConnectorController } from './ConnectorController';
+import { ConnectionsController } from './ConnectionsController';
 
 // -- Types --------------------------------------------- //
 export interface ModalControllerState {
@@ -35,7 +35,7 @@ export const ModalController = {
     if (options?.view) {
       RouterController.reset(options.view);
     } else if (AccountController.state.isConnected) {
-      const isUniversalWallet = ConnectorController.state.connectedConnector === 'AUTH';
+      const isUniversalWallet = !!ConnectionsController.state.connection?.properties?.provider;
       RouterController.reset(isUniversalWallet ? 'Account' : 'AccountDefault');
     } else {
       RouterController.reset('Connect');

package/src/controllers/RouterController.ts

@@ -46,7 +46,6 @@ export interface RouterControllerState {
     | 'UpdateEmailSecondaryOtp'
     | 'UpdateEmailWallet'
     | 'UpgradeEmailWallet'
-    | 'UpgradeToSmartAccount'
     | 'WalletCompatibleNetworks'
     | 'WalletReceive'
     | 'WalletSend'

package/src/controllers/SendController.ts

@@ -1,8 +1,7 @@
 import { subscribeKey as subKey } from 'valtio/vanilla/utils';
 import { proxy, ref, subscribe as sub } from 'valtio/vanilla';
 import { ContractUtil, type Balance } from '@reown/appkit-common-react-native';
-import { AccountController } from './AccountController';
-import { ConnectionController } from './ConnectionController';
+
 import { SnackController } from './SnackController';
 import { CoreHelperUtil } from '../utils/CoreHelperUtil';
 import { EventsController } from './EventsController';
@@ -97,7 +96,7 @@ export const SendController = {
         type: 'track',
         event: 'SEND_INITIATED',
         properties: {
-          isSmartAccount: AccountController.state.preferredAccountType === 'smartAccount',
+          isSmartAccount: ConnectionsController.state.accountType === 'smartAccount',
           token: this.state.token.address,
           amount: this.state.sendTokenAmount,
           network: ConnectionsController.state.activeNetwork?.caipNetworkId || ''
@@ -107,20 +106,20 @@ export const SendController = {
         receiverAddress: this.state.receiverAddress,
         tokenAddress: this.state.token.address,
         sendTokenAmount: this.state.sendTokenAmount,
-        decimals: this.state.token.quantity.decimals
+        decimals: this.state.token.quantity?.decimals || '0'
       });
     } else if (
       this.state.receiverAddress &&
       this.state.sendTokenAmount &&
       this.state.gasPrice &&
-      this.state.token?.quantity.decimals
+      this.state.token?.quantity?.decimals
     ) {
       state.loading = true;
       EventsController.sendEvent({
         type: 'track',
         event: 'SEND_INITIATED',
         properties: {
-          isSmartAccount: AccountController.state.preferredAccountType === 'smartAccount',
+          isSmartAccount: ConnectionsController.state.accountType === 'smartAccount',
           token: this.state.token?.symbol,
           amount: this.state.sendTokenAmount,
           network: ConnectionsController.state.activeNetwork?.caipNetworkId || ''
@@ -142,15 +141,21 @@ export const SendController = {
     });
 
     const to = params.receiverAddress as `0x${string}`;
-    const address = AccountController.state.address as `0x${string}`;
-    const value = ConnectionController.parseUnits(
+    const address = CoreHelperUtil.getPlainAddress(
+      ConnectionsController.state.activeAddress
+    ) as `0x${string}`;
+    if (!address) {
+      throw new Error('Invalid address');
+    }
+
+    const value = ConnectionsController.parseUnits(
       params.sendTokenAmount.toString(),
       Number(params.decimals)
     );
     const data = '0x';
 
     try {
-      await ConnectionController.sendTransaction({
+      await ConnectionsController.sendTransaction({
         to,
         address,
         data,
@@ -162,7 +167,7 @@ export const SendController = {
         type: 'track',
         event: 'SEND_SUCCESS',
         properties: {
-          isSmartAccount: AccountController.state.preferredAccountType === 'smartAccount',
+          isSmartAccount: ConnectionsController.state.accountType === 'smartAccount',
           token: this.state.token?.symbol || '',
           amount: params.sendTokenAmount,
           network: ConnectionsController.state.activeNetwork?.caipNetworkId || ''
@@ -175,7 +180,7 @@ export const SendController = {
         type: 'track',
         event: 'SEND_ERROR',
         properties: {
-          isSmartAccount: AccountController.state.preferredAccountType === 'smartAccount',
+          isSmartAccount: ConnectionsController.state.accountType === 'smartAccount',
           token: this.state.token?.symbol || '',
           amount: params.sendTokenAmount,
           network: ConnectionsController.state.activeNetwork?.caipNetworkId || ''
@@ -191,14 +196,14 @@ export const SendController = {
       goBack: false
     });
 
-    const amount = ConnectionController.parseUnits(
+    const amount = ConnectionsController.parseUnits(
       params.sendTokenAmount.toString(),
       Number(params.decimals)
     );
 
     try {
       if (
-        AccountController.state.address &&
+        ConnectionsController.state.activeAddress &&
         params.sendTokenAmount &&
         params.receiverAddress &&
         params.tokenAddress
@@ -206,8 +211,16 @@ export const SendController = {
         const tokenAddress = CoreHelperUtil.getPlainAddress(
           params.tokenAddress as `${string}:${string}:${string}`
         ) as `0x${string}`;
-        await ConnectionController.writeContract({
-          fromAddress: AccountController.state.address as `0x${string}`,
+
+        const fromAddress = CoreHelperUtil.getPlainAddress(
+          ConnectionsController.state.activeAddress
+        ) as `0x${string}`;
+        if (!fromAddress) {
+          throw new Error('Invalid address');
+        }
+
+        await ConnectionsController.writeContract({
+          fromAddress,
           tokenAddress,
           receiverAddress: params.receiverAddress as `0x${string}`,
           tokenAmount: amount,