@reown/appkit-core-react-native 0.0.0-feat-onramp-20250409135734 → 0.0.0-feat-multichain-20250513150920

package/src/controllers/BlockchainApiController.ts

@@ -37,6 +37,9 @@ import type {
 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';
 
 // -- Helpers ------------------------------------------- //
 const baseUrl = CoreHelperUtil.getBlockchainApiUrl();
@@ -57,19 +60,54 @@ const getHeaders = () => {
 export interface BlockchainApiControllerState {
   clientId: string | null;
   api: FetchUtil;
+  supportedChains: { http: CaipNetworkId[]; ws: CaipNetworkId[] };
 }
 
 // -- State --------------------------------------------- //
 const state = proxy<BlockchainApiControllerState>({
   clientId: null,
   api: new FetchUtil({ baseUrl }),
+  supportedChains: { http: [], ws: [] }
 });
 
 // -- Controller ---------------------------------------- //
 export const BlockchainApiController = {
   state,
 
-  fetchIdentity({ address }: BlockchainApiIdentityRequest) {
+  async isNetworkSupported(networkId?: CaipNetworkId) {
+    if (!networkId) {
+      return false;
+    }
+    try {
+      if (!state.supportedChains.http.length) {
+        await BlockchainApiController.getSupportedNetworks();
+      }
+    } catch (e) {
+      return false;
+    }
+
+    return state.supportedChains.http.includes(networkId);
+  },
+
+  async getSupportedNetworks() {
+    const supportedChains = await state.api.get<BlockchainApiControllerState['supportedChains']>({
+      path: 'v1/supported-chains'
+    });
+
+    state.supportedChains = supportedChains!;
+
+    return supportedChains;
+  },
+
+  async fetchIdentity({ address }: BlockchainApiIdentityRequest) {
+    const isSupported = await BlockchainApiController.isNetworkSupported(
+      ConnectionsController.state.activeCaipNetworkId
+    );
+
+    if (!isSupported) {
+      return { avatar: '', name: '' };
+    }
+
     return state.api.get<BlockchainApiIdentityResponse>({
       path: `/v1/identity/${address}`,
       params: {
@@ -79,29 +117,48 @@ export const BlockchainApiController = {
     });
   },
 
-  fetchTransactions({
+  async fetchTransactions({
     account,
     projectId,
     cursor,
     onramp,
     signal,
-    cache
+    cache,
+    chainId
   }: BlockchainApiTransactionsRequest) {
-    return state.api.get<BlockchainApiTransactionsResponse>({
+    const _chainId = chainId ?? ConnectionsController.state.activeCaipNetworkId;
+    const isSupported = await BlockchainApiController.isNetworkSupported(_chainId);
+
+    if (!isSupported) {
+      return { data: [], next: undefined };
+    }
+
+    const response = await state.api.get<BlockchainApiTransactionsResponse>({
       path: `/v1/account/${account}/history`,
       headers: getHeaders(),
       params: {
         projectId,
         cursor,
-        onramp
+        onramp,
+        chainId: _chainId
       },
       signal,
       cache
     });
+
+    return response;
   },
 
-  fetchTokenPrice({ projectId, addresses }: BlockchainApiTokenPriceRequest) {
-    return state.api.post<BlockchainApiTokenPriceResponse>({
+  async fetchTokenPrice({ projectId, addresses }: BlockchainApiTokenPriceRequest) {
+    const isSupported = await BlockchainApiController.isNetworkSupported(
+      ConnectionsController.state.activeCaipNetworkId
+    );
+
+    if (!isSupported) {
+      return { fungibles: [] };
+    }
+
+    const response = await state.api.post<BlockchainApiTokenPriceResponse>({
       path: '/v1/fungible/price',
       body: {
         projectId,
@@ -110,9 +167,23 @@ export const BlockchainApiController = {
       },
       headers: getHeaders()
     });
+
+    return response;
   },
 
-  fetchSwapAllowance({ projectId, tokenAddress, userAddress }: BlockchainApiSwapAllowanceRequest) {
+  async fetchSwapAllowance({
+    projectId,
+    tokenAddress,
+    userAddress
+  }: BlockchainApiSwapAllowanceRequest) {
+    const isSupported = await BlockchainApiController.isNetworkSupported(
+      ConnectionsController.state.activeCaipNetworkId
+    );
+
+    if (!isSupported) {
+      return { allowance: '0' };
+    }
+
     return state.api.get<BlockchainApiSwapAllowanceResponse>({
       path: `/v1/convert/allowance`,
       params: {
@@ -124,7 +195,15 @@ export const BlockchainApiController = {
     });
   },
 
-  fetchGasPrice({ projectId, chainId }: BlockchainApiGasPriceRequest) {
+  async fetchGasPrice({ projectId, chainId }: BlockchainApiGasPriceRequest) {
+    const isSupported = await BlockchainApiController.isNetworkSupported(
+      ConnectionsController.state.activeCaipNetworkId
+    );
+
+    if (!isSupported) {
+      throw new Error('Network not supported for Gas Price');
+    }
+
     return state.api.get<BlockchainApiGasPriceResponse>({
       path: `/v1/convert/gas-price`,
       headers: getHeaders(),
@@ -135,7 +214,7 @@ export const BlockchainApiController = {
     });
   },
 
-  fetchSwapQuote({
+  async fetchSwapQuote({
     projectId,
     amount,
     userAddress,
@@ -143,6 +222,14 @@ export const BlockchainApiController = {
     to,
     gasPrice
   }: BlockchainApiSwapQuoteRequest) {
+    const isSupported = await BlockchainApiController.isNetworkSupported(
+      ConnectionsController.state.activeCaipNetworkId
+    );
+
+    if (!isSupported) {
+      return { quotes: [] };
+    }
+
     return state.api.get<BlockchainApiSwapQuoteResponse>({
       path: `/v1/convert/quotes`,
       headers: getHeaders(),
@@ -157,7 +244,15 @@ export const BlockchainApiController = {
     });
   },
 
-  fetchSwapTokens({ projectId, chainId }: BlockchainApiSwapTokensRequest) {
+  async fetchSwapTokens({ projectId, chainId }: BlockchainApiSwapTokensRequest) {
+    const isSupported = await BlockchainApiController.isNetworkSupported(
+      ConnectionsController.state.activeCaipNetworkId
+    );
+
+    if (!isSupported) {
+      return { tokens: [] };
+    }
+
     return state.api.get<BlockchainApiSwapTokensResponse>({
       path: `/v1/convert/tokens`,
       headers: getHeaders(),
@@ -168,13 +263,21 @@ export const BlockchainApiController = {
     });
   },
 
-  generateSwapCalldata({
+  async generateSwapCalldata({
     amount,
     from,
     projectId,
     to,
     userAddress
   }: BlockchainApiGenerateSwapCalldataRequest) {
+    const isSupported = await BlockchainApiController.isNetworkSupported(
+      ConnectionsController.state.activeCaipNetworkId
+    );
+
+    if (!isSupported) {
+      throw new Error('Network not supported for Swaps');
+    }
+
     return state.api.post<BlockchainApiGenerateSwapCalldataResponse>({
       path: '/v1/convert/build-transaction',
       headers: getHeaders(),
@@ -191,12 +294,20 @@ export const BlockchainApiController = {
     });
   },
 
-  generateApproveCalldata({
+  async generateApproveCalldata({
     from,
     projectId,
     to,
     userAddress
   }: BlockchainApiGenerateApproveCalldataRequest) {
+    const isSupported = await BlockchainApiController.isNetworkSupported(
+      ConnectionsController.state.activeCaipNetworkId
+    );
+
+    if (!isSupported) {
+      throw new Error('Network not supported for Swaps');
+    }
+
     return state.api.get<BlockchainApiGenerateApproveCalldataResponse>({
       path: `/v1/convert/build-approve`,
       headers: getHeaders(),
@@ -210,6 +321,15 @@ export const BlockchainApiController = {
   },
 
   async getBalance(address: string, chainId?: string, forceUpdate?: string) {
+    const isSupported = await BlockchainApiController.isNetworkSupported(
+      ConnectionsController.state.activeCaipNetworkId
+    );
+    if (!isSupported) {
+      SnackController.showError('Token Balance Unavailable');
+
+      return { balances: [] };
+    }
+
     return state.api.get<BlockchainApiBalanceResponse>({
       path: `/v1/account/${address}/balance`,
       headers: getHeaders(),

package/src/controllers/ConnectionController.ts

@@ -120,6 +120,15 @@ export const ConnectionController = {
     state.pressedWallet = undefined;
   },
 
+  setWcPromise(wcPromise: ConnectionControllerState['wcPromise']) {
+    state.wcPromise = wcPromise;
+  },
+
+  setWcUri(wcUri: ConnectionControllerState['wcUri']) {
+    state.wcUri = wcUri;
+    state.wcPairingExpiry = CoreHelperUtil.getPairingExpiry();
+  },
+
   setRecentWallets(wallets: ConnectionControllerState['recentWallets']) {
     state.recentWallets = wallets;
   },
@@ -192,7 +201,6 @@ export const ConnectionController = {
   },
 
   async disconnect() {
-    await this._getClient().disconnect();
     this.resetWcConnection();
     // remove transactions
     // RouterController.reset('Connect');

package/src/controllers/ConnectionsController.ts

@@ -0,0 +1,235 @@
+import { proxy, ref } from 'valtio';
+import { derive } from 'valtio/utils';
+import type {
+  AppKitNetwork,
+  BlockchainAdapter,
+  CaipAddress,
+  CaipNetworkId,
+  ChainNamespace,
+  GetBalanceResponse,
+  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;
+  chains: CaipNetworkId[];
+  activeChain: CaipNetworkId;
+  wallet?: WalletInfo;
+}
+
+export interface ConnectionsControllerState {
+  activeNamespace?: ChainNamespace;
+  connections: Record<string, Connection>;
+  networks: AppKitNetwork[];
+}
+
+// -- State --------------------------------------------- //
+const baseState = proxy<ConnectionsControllerState>({
+  activeNamespace: undefined,
+  connections: {},
+  networks: []
+});
+
+const derivedState = derive(
+  {
+    activeAddress: (get): CaipAddress | undefined => {
+      const snap = get(baseState);
+
+      if (!snap.activeNamespace) return undefined;
+
+      const connection = snap.connections[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.activeChain)
+      );
+
+      return activeAccount;
+    },
+    activeBalance: (get): Balance | undefined => {
+      const snap = get(baseState);
+
+      if (!snap.activeNamespace) return undefined;
+      const connection = snap.connections[snap.activeNamespace];
+
+      if (!connection || !connection.accounts || connection.accounts.length === 0) {
+        return undefined;
+      }
+
+      const activeAccount = connection.accounts.find(account =>
+        account.startsWith(connection.activeChain)
+      );
+
+      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[snap.activeNamespace];
+
+      if (!connection) return undefined;
+
+      return snap.networks.find(
+        network =>
+          (network.chainNamespace ?? 'eip155') === snap.activeNamespace &&
+          network.id?.toString() === connection.activeChain?.split(':')[1]
+      );
+    },
+    activeCaipNetworkId: (get): CaipNetworkId | undefined => {
+      const snap = get(baseState);
+
+      if (!snap.activeNamespace) return undefined;
+
+      const connection = snap.connections[snap.activeNamespace];
+
+      if (!connection) return undefined;
+
+      return connection.activeChain;
+    },
+    walletInfo: (get): WalletInfo | undefined => {
+      const snap = get(baseState);
+
+      if (!snap.activeNamespace) return undefined;
+
+      return snap.connections[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,
+    activeChain
+  }: {
+    namespace: string;
+    adapter: BlockchainAdapter;
+    accounts: CaipAddress[];
+    chains: CaipNetworkId[];
+    wallet?: WalletInfo;
+    activeChain?: CaipNetworkId;
+  }) {
+    baseState.connections[namespace] = {
+      balances: {},
+      activeChain: activeChain ?? chains[0]!,
+      adapter: ref(adapter),
+      accounts,
+      chains,
+      wallet
+    };
+  },
+
+  updateAccounts(namespace: string, accounts: CaipAddress[]) {
+    const connection = baseState.connections[namespace];
+    if (!connection) {
+      return;
+    }
+    connection.accounts = accounts;
+  },
+
+  updateBalance(namespace: string, address: CaipAddress, balance: Balance) {
+    const connection = baseState.connections[namespace];
+    if (!connection) {
+      return;
+    }
+    connection.balances[address] = balance;
+  },
+
+  setActiveChain(namespace: string, chain: CaipNetworkId) {
+    const connection = baseState.connections[namespace];
+
+    if (!connection) {
+      return;
+    }
+
+    connection.activeChain = chain;
+  },
+
+  setNetworks(networks: AppKitNetwork[]) {
+    baseState.networks = networks;
+  },
+
+  getConnectedNetworks() {
+    return baseState.networks.filter(
+      network => baseState.connections[network.chainNamespace ?? 'eip155']
+    );
+  },
+
+  async disconnect(namespace: string, isInternal = true) {
+    const connection = baseState.connections[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 = Object.keys(baseState.connections).filter(
+      ns => baseState.connections[ns]?.adapter.connector === connector
+    );
+
+    // Unsubscribe all event listeners from the adapter
+    namespacesUsingConnector.forEach(ns => {
+      const _connection = baseState.connections[ns];
+      if (_connection?.adapter) {
+        _connection.adapter.removeAllListeners();
+      }
+    });
+
+    // Disconnect the adapter
+    if (isInternal) {
+      await connection.adapter.disconnect();
+    }
+
+    // Remove all namespaces that used this connector
+    namespacesUsingConnector.forEach(ns => {
+      delete baseState.connections[ns];
+    });
+
+    // 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);
+    }
+  }
+};

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/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/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/SwapController.ts

@@ -17,6 +17,7 @@ import { CoreHelperUtil } from '../utils/CoreHelperUtil';
 import { ConnectionController } from './ConnectionController';
 import { TransactionsController } from './TransactionsController';
 import { EventsController } from './EventsController';
+import { ConnectionsController } from './ConnectionsController';
 
 // -- Constants ---------------------------------------- //
 export const INITIAL_GAS_LIMIT = 150000;
@@ -158,9 +159,17 @@ export const SwapController = {
   },
 
   getParams() {
-    const caipAddress = AccountController.state.caipAddress;
-    const address = CoreHelperUtil.getPlainAddress(caipAddress);
-    const networkAddress = NetworkController.getActiveNetworkTokenAddress();
+    const { activeAddress, activeNamespace, activeNetwork } = ConnectionsController.state;
+    const address = CoreHelperUtil.getPlainAddress(activeAddress);
+
+    if (!activeNamespace || !activeNetwork) {
+      throw new Error('No active namespace or network found to swap the tokens from.');
+    }
+
+    const networkAddress = `${activeNetwork.caipNetworkId ?? 'eip155:1'}:${
+      ConstantsUtil.NATIVE_TOKEN_ADDRESS[activeNamespace]
+    }`;
+
     const type = ConnectorController.state.connectedConnector;
 
     if (!address) {
@@ -178,7 +187,7 @@ export const SwapController = {
     return {
       networkAddress,
       fromAddress: address,
-      fromCaipAddress: caipAddress,
+      fromCaipAddress: activeAddress,
       sourceTokenAddress: state.sourceToken?.address,
       toTokenAddress: state.toToken?.address,
       toTokenAmount: state.toTokenAmount,
@@ -189,7 +198,7 @@ export const SwapController = {
       invalidSourceToken,
       invalidSourceTokenAmount,
       availableToSwap:
-        caipAddress && !invalidToToken && !invalidSourceToken && !invalidSourceTokenAmount,
+        activeAddress && !invalidToToken && !invalidSourceToken && !invalidSourceTokenAmount,
       isAuthConnector: type === 'AUTH'
     };
   },

package/src/controllers/ThemeController.ts

@@ -1,10 +1,11 @@
+import { Appearance } from 'react-native';
 import { proxy, subscribe as sub } from 'valtio';
 import type { ThemeMode, ThemeVariables } from '@reown/appkit-common-react-native';
 
 // -- Types --------------------------------------------- //
 export interface ThemeControllerState {
   themeMode?: ThemeMode;
-  themeVariables: ThemeVariables;
+  themeVariables?: ThemeVariables;
 }
 
 // -- State --------------------------------------------- //
@@ -22,10 +23,18 @@ export const ThemeController = {
   },
 
   setThemeMode(themeMode: ThemeControllerState['themeMode']) {
-    state.themeMode = themeMode;
+    if (!themeMode) {
+      state.themeMode = Appearance.getColorScheme() as ThemeMode;
+    } else {
+      state.themeMode = themeMode;
+    }
   },
 
   setThemeVariables(themeVariables: ThemeControllerState['themeVariables']) {
+    if (!themeVariables) {
+      state.themeVariables = {};
+    }
+
     state.themeVariables = { ...state.themeVariables, ...themeVariables };
   }
 };