@reown/appkit-react-native 2.0.0-alpha.0 → 2.0.0-alpha.2

package/src/AppKit.ts

@@ -1,45 +1,58 @@
 import {
-  AccountController,
+  type Features,
   EventsController,
   ModalController,
   ConnectionsController,
   OptionsController,
   RouterController,
   TransactionsController,
-  type Metadata,
   StorageUtil,
   type OptionsControllerState,
   ThemeController,
-  ConnectionController
+  ConnectionController,
+  SwapController,
+  OnRampController,
+  CoreHelperUtil,
+  SendController,
+  BlockchainApiController
 } from '@reown/appkit-core-react-native';
 
-import type {
-  WalletConnector,
-  BlockchainAdapter,
-  ProposalNamespaces,
-  New_ConnectorType,
-  Namespaces,
-  CaipNetworkId,
-  AppKitNetwork,
-  Provider,
-  ThemeVariables,
-  ThemeMode,
-  WalletInfo,
-  Network,
-  ChainNamespace
+import {
+  type WalletConnector,
+  type BlockchainAdapter,
+  type ProposalNamespaces,
+  type ConnectorType,
+  type Namespaces,
+  type Metadata,
+  type CaipNetworkId,
+  type AppKitNetwork,
+  type Provider,
+  type ThemeVariables,
+  type ThemeMode,
+  type WalletInfo,
+  type Network,
+  type ChainNamespace,
+  type Storage,
+  type AppKitConnectOptions,
+  type AppKitSIWEClient,
+  type ConnectionProperties,
+  type AccountType,
+  type AppKitOpenOptions,
+  ConstantsUtil,
+  type Connection
 } from '@reown/appkit-common-react-native';
+import { SIWEController } from '@reown/appkit-siwe-react-native';
 
 import { WalletConnectConnector } from './connectors/WalletConnectConnector';
 import { WcHelpersUtil } from './utils/HelpersUtil';
 import { NetworkUtil } from './utils/NetworkUtil';
-import { SIWEController, type AppKitSIWEClient } from '@reown/appkit-siwe-react-native';
-import type { OpenOptions } from './client';
 
 interface AppKitConfig {
   projectId: string;
   metadata: Metadata;
   adapters: BlockchainAdapter[];
   networks: Network[];
+  storage: Storage;
   extraConnectors?: WalletConnector[];
   clipboardClient?: OptionsControllerState['clipboardClient'];
   includeWalletIds?: OptionsControllerState['includeWalletIds'];
@@ -53,24 +66,22 @@ interface AppKitConfig {
   themeVariables?: ThemeVariables;
   siweConfig?: AppKitSIWEClient;
   defaultNetwork?: Network;
-  // features?: Features;
+  features?: Features;
   // chainImages?: Record<number, string>; //TODO: rename to networkImages
 }
 
 export class AppKit {
   private projectId: string;
-  private metadata: Metadata;
   private adapters: BlockchainAdapter[];
   private networks: AppKitNetwork[];
-  private defaultNetwork?: AppKitNetwork;
   private namespaces: ProposalNamespaces;
   private config: AppKitConfig;
   private extraConnectors: WalletConnector[];
+  private walletConnectConnector?: WalletConnector;
 
   constructor(config: AppKitConfig) {
     this.projectId = config.projectId;
-    this.metadata = config.metadata;
-    this.adapters = config.adapters;
+    this.adapters = config.adapters ?? [];
 
     // Validate adapters to ensure no duplicate chainNamespaces
     const namespaceMap = new Map<ChainNamespace, string>();
@@ -87,10 +98,22 @@ export class AppKit {
       namespaceMap.set(chainNamespace, adapterName);
     }
 
-    this.networks = NetworkUtil.formatNetworks(config.networks, this.projectId); //TODO: check this
-    this.defaultNetwork = config.defaultNetwork
-      ? NetworkUtil.formatNetwork(config.defaultNetwork, this.projectId)
-      : undefined;
+    const formattedNetworks = NetworkUtil.formatNetworks(config.networks, this.projectId);
+
+    // Use only networks that have adapters
+    const networksWithAdapters = formattedNetworks.filter(network => {
+      return this.adapters.some(
+        adapter => adapter.getSupportedNamespace() === network.chainNamespace
+      );
+    });
+
+    config.networks.forEach(network => {
+      if (!networksWithAdapters.some(n => n.id === network.id)) {
+        console.warn(`AppKit: missing adapter for network ${network.name} - ${network.id}`);
+      }
+    });
+
+    this.networks = networksWithAdapters;
     this.namespaces = WcHelpersUtil.createNamespaces(this.networks) as ProposalNamespaces;
     this.config = config;
     this.extraConnectors = config.extraConnectors || [];
@@ -102,21 +125,26 @@ export class AppKit {
   /**
    * Handles the full connection flow for a given connector type.
    * @param type - The type of connector to use.
-   * @param requestedNamespaces - Optional specific namespaces to request.
+   * @param options - Optional connection options.
    */
-  async connect(type: New_ConnectorType, requestedNamespaces?: ProposalNamespaces): Promise<void> {
+  async connect(type: ConnectorType, options?: AppKitConnectOptions): Promise<void> {
     try {
+      const { namespaces, defaultChain, universalLink } = options ?? {};
       const connector = await this.createConnector(type);
-      const defaultChain = this.defaultNetwork
-        ? NetworkUtil.getDefaultChainId(this.defaultNetwork)
-        : undefined;
+
+      const chain =
+        defaultChain ??
+        NetworkUtil.getDefaultChainId(this.namespaces, OptionsController.state.defaultNetwork);
 
       const approvedNamespaces = await connector.connect({
-        namespaces: requestedNamespaces ?? this.namespaces,
-        defaultChain
+        namespaces: namespaces ?? this.namespaces,
+        defaultChain: chain,
+        universalLink,
+        siweConfig: this.config?.siweConfig
       });
 
       const walletInfo = connector.getWalletInfo();
+      const properties = connector.getProperties();
 
       if (!approvedNamespaces || Object.keys(approvedNamespaces).length === 0) {
         throw new Error('Connection cancelled or failed: No approved namespaces returned.');
@@ -135,7 +163,7 @@ export class AppKit {
       }
 
       // Store the connection details for the successfully connected adapters
-      this.storeConnectionDetails(approvedAdapters, approvedNamespaces, walletInfo);
+      this.setConnection(approvedAdapters, approvedNamespaces, walletInfo, properties);
 
       // Store connector type and namespaces in storage
       await StorageUtil.setConnectedConnectors({
@@ -145,8 +173,14 @@ export class AppKit {
 
       this.syncAccounts(approvedAdapters);
 
-      //TODO: Replace this
-      AccountController.setIsConnected(true);
+      if (
+        OptionsController.state.isSiweEnabled &&
+        ConnectionsController.state.activeNamespace === 'eip155'
+      ) {
+        this.handleSiweChange({ isConnection: true });
+      } else {
+        ModalController.close();
+      }
     } catch (error) {
       console.warn('Connection failed:', error);
       throw error;
@@ -166,10 +200,12 @@ export class AppKit {
         return;
       }
 
-      const connection = ConnectionsController.state.connections[activeNamespace];
+      const connection = ConnectionsController.state.connections.get(
+        activeNamespace as ChainNamespace
+      );
       const connectorType = connection?.adapter?.connector?.type;
 
-      await ConnectionsController.disconnect(activeNamespace, isInternal);
+      await ConnectionsController.disconnect(activeNamespace as ChainNamespace, isInternal);
 
       if (connectorType) {
         await StorageUtil.removeConnectedConnectors(connectorType);
@@ -177,11 +213,23 @@ export class AppKit {
 
       ModalController.close();
 
-      AccountController.setIsConnected(false); // Might need adjustment based on multi-connection logic
       RouterController.reset('Connect');
-      TransactionsController.resetTransactions();
+      TransactionsController.resetState();
+      SwapController.resetState();
+      SendController.resetState();
+      OnRampController.resetState();
       ConnectionController.disconnect();
 
+      if (ConnectionsController.state.activeNamespace === undefined) {
+        ConnectionsController.setActiveNamespace(
+          OptionsController.state.defaultNetwork?.chainNamespace
+        );
+      }
+
+      if (OptionsController.state.isSiweEnabled) {
+        await SIWEController.signOut();
+      }
+
       EventsController.sendEvent({
         type: 'track',
         event: 'DISCONNECT_SUCCESS'
@@ -203,7 +251,9 @@ export class AppKit {
     const activeNamespace = namespace ?? ConnectionsController.state.activeNamespace;
     if (!activeNamespace) return null;
 
-    const connection = ConnectionsController.state.connections[activeNamespace];
+    const connection = ConnectionsController.state.connections.get(
+      activeNamespace as ChainNamespace
+    );
     if (!connection || !connection.adapter || !connection.adapter.connector) return null;
 
     return connection.adapter.connector.getProvider() as T;
@@ -214,6 +264,14 @@ export class AppKit {
   }
 
   async switchNetwork(network: AppKitNetwork): Promise<void> {
+    const { isConnected } = ConnectionsController.state;
+
+    if (!isConnected) {
+      OptionsController.setDefaultNetwork(network);
+
+      return Promise.resolve();
+    }
+
     const adapter = this.getAdapterByNamespace(network.chainNamespace);
     if (!adapter) throw new Error('No active adapter');
 
@@ -227,17 +285,14 @@ export class AppKit {
       }
     });
 
-    ConnectionsController.setActiveChain(
-      adapter.getSupportedNamespace(),
-      `${adapter.getSupportedNamespace()}:${network.id}` as CaipNetworkId
-    );
+    ConnectionsController.setActiveNetwork(network.chainNamespace, network.caipNetworkId);
 
     if (ConnectionsController.state.activeNamespace !== network.chainNamespace) {
       ConnectionsController.setActiveNamespace(network.chainNamespace);
     }
   }
 
-  open(options?: OpenOptions) {
+  open(options?: AppKitOpenOptions) {
     ModalController.open(options);
   }
 
@@ -245,18 +300,61 @@ export class AppKit {
     ModalController.close();
   }
 
-  private async createConnector(type: New_ConnectorType): Promise<WalletConnector> {
+  async switchAccountType(namespace: ChainNamespace, type: AccountType, network: AppKitNetwork) {
+    const adapter = this.getAdapterByNamespace(namespace);
+    if (!adapter) throw new Error('No active adapter');
+
+    ConnectionsController.setAccountType(namespace, type);
+
+    // Get balances from API
+    ConnectionsController.fetchBalance();
+
+    // Sync balances from adapter
+    this.syncBalances(adapter, network);
+
+    EventsController.sendEvent({
+      type: 'track',
+      event: 'SET_PREFERRED_ACCOUNT_TYPE',
+      properties: {
+        accountType: type,
+        network: network?.caipNetworkId || ''
+      }
+    });
+  }
+
+  private async createConnector(type: ConnectorType): Promise<WalletConnector> {
     // Check if an extra connector was provided by the developer
     const CustomConnector = this.extraConnectors.find(
-      connector => connector.constructor.name.toLowerCase() === type.toLowerCase()
+      connector => connector.type.toLowerCase() === type.toLowerCase()
     );
 
     if (CustomConnector) {
+      await CustomConnector.init({
+        storage: this.config.storage,
+        metadata: this.config.metadata
+      });
+
       return CustomConnector;
     }
 
     // Default to WalletConnectConnector if no custom connector matches
-    return WalletConnectConnector.create({ projectId: this.projectId, metadata: this.metadata });
+    return this.createWalletConnectConnector();
+  }
+
+  private async createWalletConnectConnector() {
+    if (this.walletConnectConnector) {
+      return this.walletConnectConnector;
+    }
+
+    this.walletConnectConnector = new WalletConnectConnector({
+      projectId: this.projectId
+    });
+    await this.walletConnectConnector.init({
+      storage: this.config.storage,
+      metadata: this.config.metadata
+    });
+
+    return this.walletConnectConnector;
   }
 
   //TODO: reuse logic with connect method
@@ -275,6 +373,7 @@ export class AppKit {
 
           const namespaces = connector.getNamespaces();
           const walletInfo = connector.getWalletInfo();
+          const properties = connector.getProperties();
 
           if (namespaces && Object.keys(namespaces).length > 0) {
             // Ensure namespaces is not empty
@@ -286,12 +385,17 @@ export class AppKit {
 
             // If adapters were successfully initialized, store the connection details
             if (initializedAdapters.length > 0) {
-              this.storeConnectionDetails(initializedAdapters, namespaces, walletInfo);
+              this.setConnection(initializedAdapters, namespaces, walletInfo, properties);
             }
 
             this.syncAccounts(initializedAdapters);
 
-            AccountController.setIsConnected(true);
+            if (
+              OptionsController.state.isSiweEnabled &&
+              ConnectionsController.state.activeNamespace === 'eip155'
+            ) {
+              this.handleSiweChange({ isConnection: true });
+            }
           }
         } catch (error) {
           // Use console.warn for non-critical initialization failures
@@ -327,57 +431,107 @@ export class AppKit {
   }
 
   private getAdapterByNamespace(namespace: ChainNamespace): BlockchainAdapter | null {
-    const namespaceConnection = ConnectionsController.state.connections[namespace];
+    const namespaceConnection = ConnectionsController.state.connections.get(namespace);
+    if (namespaceConnection) {
+      return namespaceConnection.adapter;
+    }
 
-    return namespaceConnection?.adapter ?? null;
+    return null;
   }
 
   private async syncAccounts(adapters: BlockchainAdapter[]) {
-    // Get account balances
-    adapters.map(adapter => {
+    adapters.forEach(async adapter => {
       const namespace = adapter.getSupportedNamespace();
-      const connection = ConnectionsController.state.connections[namespace];
-
-      if (!connection) return;
-
+      const connection = ConnectionsController.state.connections.get(namespace);
       const network = this.networks.find(
-        n => n.id?.toString() === connection?.activeChain?.split(':')[1]
+        n => n.id?.toString() === connection?.caipNetwork?.split(':')[1]
       );
 
-      const address =
-        adapter.getAccounts()?.find(a => a.startsWith(connection?.activeChain)) ??
-        adapter.getAccounts()?.[0];
-
-      adapter.getBalance({ address, network, tokens: this.config.tokens });
+      this.syncBalances(adapter, network);
+      this.syncIdentity(namespace, connection);
     });
   }
 
-  private storeConnectionDetails(
+  private syncBalances(adapter: BlockchainAdapter, network?: AppKitNetwork) {
+    if (adapter && network) {
+      const accounts = adapter.getAccounts();
+      if (accounts && accounts.length > 0) {
+        const addresses = accounts.filter(a => a.split(':')[1] === network?.id?.toString());
+
+        if (addresses.length > 0) {
+          addresses.forEach(address => {
+            adapter.getBalance({ address, network, tokens: this.config.tokens });
+          });
+        }
+      }
+    }
+  }
+
+  private async syncIdentity(namespace?: ChainNamespace, connection?: Connection) {
+    if (namespace !== 'eip155' || !connection?.accounts?.length) return;
+
+    const uniqueAddresses = [
+      ...new Set(connection.accounts.map(account => CoreHelperUtil.getPlainAddress(account)))
+    ];
+
+    // Process addresses sequentially to avoid race conditions
+    for (const plainAddress of uniqueAddresses) {
+      try {
+        // Validate address format before type assertion
+        if (!plainAddress || !CoreHelperUtil.isAddress(plainAddress, 'eip155')) {
+          console.warn(`Invalid Ethereum address format: ${plainAddress}`);
+          continue;
+        }
+
+        const identity = await BlockchainApiController.fetchIdentity({
+          address: plainAddress as `0x${string}`
+        });
+
+        if (identity?.name) {
+          ConnectionsController.updateIdentity(
+            namespace,
+            connection,
+            plainAddress as `0x${string}`,
+            identity
+          );
+        }
+      } catch (error) {
+        // Continue processing other addresses even if one fails
+      }
+    }
+  }
+
+  private setConnection(
     adapters: BlockchainAdapter[],
     approvedNamespaces: Namespaces,
-    wallet?: WalletInfo
+    wallet?: WalletInfo,
+    properties?: ConnectionProperties
   ) {
     adapters.forEach(async adapter => {
       const namespace = adapter.getSupportedNamespace();
       const namespaceDetails = approvedNamespaces[namespace];
-      if (!namespaceDetails) return; // Should not happen if filtering is correct
+      if (!namespaceDetails) return;
 
       const accounts = namespaceDetails.accounts ?? [];
       const chains = namespaceDetails.chains ?? [];
-      const activeChain = adapter?.connector?.getChainId(namespace);
+      const caipNetwork = adapter?.connector?.getChainId(namespace);
+      const namespaceProperties = {
+        ...properties,
+        smartAccounts: properties?.smartAccounts?.filter(account => account.startsWith(namespace))
+      };
 
-      ConnectionsController.storeConnection({
-        namespace,
-        adapter,
+      ConnectionsController.setConnection({
         accounts,
-        chains,
-        activeChain,
+        adapter,
+        caipNetwork: caipNetwork ?? chains[0]!,
+        namespace,
+        properties: namespaceProperties,
         wallet
       });
     });
 
-    const updateActiveNamespace = !Object.keys(approvedNamespaces).find(
-      n => n === ConnectionsController.state.activeNamespace
+    const updateActiveNamespace = !Object.keys(approvedNamespaces).some(
+      namespace => namespace === ConnectionsController.state.activeNamespace
     );
 
     // If the active namespace is not in the approved namespaces or is undefined, set the first connected adapter's namespace as active
@@ -387,54 +541,78 @@ export class AppKit {
   }
 
   private subscribeToAdapterEvents(adapter: BlockchainAdapter): void {
-    adapter.on('accountsChanged', ({ accounts, namespace }) => {
+    adapter.on('accountsChanged', ({ accounts }) => {
+      const namespace = adapter.getSupportedNamespace();
       //eslint-disable-next-line no-console
       console.log('accountsChanged', accounts, namespace);
       //TODO: check this
+
+      if (namespace === 'eip155') {
+        this.handleSiweChange({ isAccountChange: true });
+      }
     });
 
-    adapter.on('chainChanged', ({ chainId, namespace }) => {
+    adapter.on('chainChanged', ({ chainId }) => {
+      //eslint-disable-next-line no-console
+      console.log('chainChanged', chainId);
+      const namespace = adapter.getSupportedNamespace();
       const chain = `${namespace}:${chainId}` as CaipNetworkId;
-      ConnectionsController.setActiveChain(namespace, chain);
+      ConnectionsController.setActiveNetwork(namespace, chain);
+      const connection = ConnectionsController.state.connections.get(namespace);
+      const isAuth = !!connection?.properties?.provider;
 
       const network = this.networks.find(n => n.id?.toString() === chainId);
-      if (network) {
-        adapter.getBalance({
-          network,
-          tokens: this.config.tokens
-        });
+      this.syncBalances(adapter, network);
+      SendController.resetState();
+
+      if (isAuth) {
+        ConnectionsController.fetchBalance();
+      }
+
+      if (namespace === 'eip155') {
+        this.handleSiweChange({ isNetworkChange: true });
       }
     });
 
-    adapter.on('disconnect', ({ namespace }) => {
-      // console.log('AppKit disconnect namespace', namespace);
+    adapter.on('disconnect', () => {
+      const namespace = adapter.getSupportedNamespace();
       this.disconnect(namespace, false);
     });
 
-    adapter.on('balanceChanged', ({ namespace, address, balance }) => {
+    //TODO: Add types to this events
+    adapter.on('balanceChanged', ({ address, balance }) => {
+      //eslint-disable-next-line no-console
+      console.log('balanceChanged', address, balance);
+      const namespace = adapter.getSupportedNamespace();
       ConnectionsController.updateBalance(namespace, address, balance);
     });
   }
 
   private async initControllers(options: AppKitConfig) {
-    await this.initAsyncValues();
+    await this.initStorageAndValues(options);
 
     OptionsController.setProjectId(options.projectId);
     OptionsController.setMetadata(options.metadata);
     OptionsController.setIncludeWalletIds(options.includeWalletIds);
-    OptionsController.setExcludeWalletIds(options.excludeWalletIds);
+    this.setExcludedWallets(options);
+    this.setCustomWallets(options);
     OptionsController.setFeaturedWalletIds(options.featuredWalletIds);
     OptionsController.setTokens(options.tokens);
-    OptionsController.setCustomWallets(options.customWallets);
     OptionsController.setEnableAnalytics(options.enableAnalytics);
     OptionsController.setDebug(options.debug);
-    // OptionsController.setFeatures(options.features);
+    OptionsController.setFeatures(options.features);
+
+    if (options.defaultNetwork) {
+      const network = NetworkUtil.formatNetwork(options.defaultNetwork, this.projectId);
+      OptionsController.setDefaultNetwork(network);
+    }
 
     ThemeController.setThemeMode(options.themeMode);
     ThemeController.setThemeVariables(options.themeVariables);
 
-    //TODO: function to get sdk version based on adapters
-    // OptionsController.setSdkVersion(options._sdkVersion);
+    OptionsController.setSdkVersion(
+      CoreHelperUtil.generateSdkVersion(this.adapters, ConstantsUtil.VERSION)
+    );
 
     if (options.clipboardClient) {
       OptionsController.setClipboardClient(options.clipboardClient);
@@ -446,20 +624,128 @@ export class AppKit {
       SIWEController.setSIWEClient(options.siweConfig);
     }
 
-    // if (
-    //   (options.features?.onramp === true || options.features?.onramp === undefined) &&
-    //   (options.metadata?.redirect?.universal || options.metadata?.redirect?.native)
-    // ) {
-    //   OptionsController.setIsOnRampEnabled(true);
-    // }
+    if (
+      (options.features?.onramp === true || options.features?.onramp === undefined) &&
+      (options.metadata?.redirect?.universal || options.metadata?.redirect?.native)
+    ) {
+      OptionsController.setIsOnRampEnabled(true);
+    }
   }
 
-  private async initAsyncValues() {
+  private async initActiveNamespace() {
     const activeNamespace = await StorageUtil.getActiveNamespace();
     if (activeNamespace) {
       ConnectionsController.setActiveNamespace(activeNamespace);
-    } else if (this.defaultNetwork) {
-      ConnectionsController.setActiveNamespace(this.defaultNetwork?.chainNamespace);
+    } else if (OptionsController.state.defaultNetwork) {
+      ConnectionsController.setActiveNamespace(
+        OptionsController.state.defaultNetwork?.chainNamespace
+      );
+    }
+  }
+
+  private async initRecentWallets(options: AppKitConfig) {
+    const wallets = await StorageUtil.getRecentWallets();
+    const connectedWalletImage = await StorageUtil.getConnectedWalletImageUrl();
+
+    const filteredWallets = wallets.filter(wallet => {
+      const { includeWalletIds, excludeWalletIds } = options;
+      if (includeWalletIds) {
+        return includeWalletIds.includes(wallet.id);
+      }
+      if (excludeWalletIds) {
+        return !excludeWalletIds.includes(wallet.id);
+      }
+
+      return true;
+    });
+
+    ConnectionController.setRecentWallets(filteredWallets);
+
+    if (connectedWalletImage) {
+      ConnectionController.setConnectedWalletImageUrl(connectedWalletImage);
+    }
+  }
+
+  private setExcludedWallets(options: AppKitConfig) {
+    const excludedWallets = options.excludeWalletIds || [];
+
+    // Exclude Coinbase if the connector is not implemented
+    const excludeCoinbase = !this.extraConnectors.some(connector => connector.type === 'coinbase');
+
+    if (excludeCoinbase) {
+      excludedWallets.push(ConstantsUtil.COINBASE_EXPLORER_ID);
+    }
+
+    OptionsController.setExcludeWalletIds(excludedWallets);
+  }
+
+  private setCustomWallets(options: AppKitConfig) {
+    const { customWallets, extraConnectors, adapters } = options;
+
+    const customList = [...(customWallets ?? [])];
+
+    const addPhantom =
+      adapters.some(adapter => adapter.getSupportedNamespace() === 'solana') &&
+      extraConnectors?.some(connector => connector.type.toLowerCase() === 'phantom') &&
+      !customList.some(wallet => wallet.id === ConstantsUtil.PHANTOM_CUSTOM_WALLET.id);
+
+    if (addPhantom) {
+      customList.push(ConstantsUtil.PHANTOM_CUSTOM_WALLET);
+    }
+
+    OptionsController.setCustomWallets(customList);
+  }
+
+  private async initStorageAndValues(options: AppKitConfig) {
+    if (!options.storage) {
+      throw new Error('AppKit: Storage is not set');
+    }
+
+    OptionsController.setStorage(options.storage);
+    await this.initActiveNamespace();
+    await this.initRecentWallets(options);
+  }
+
+  private onSiweNavigation = () => {
+    if (ModalController.state.open) {
+      RouterController.push('ConnectingSiwe');
+    } else {
+      ModalController.open({ view: 'ConnectingSiwe' });
+    }
+  };
+
+  private async handleSiweChange(params?: {
+    isConnection?: boolean;
+    isNetworkChange?: boolean;
+    isAccountChange?: boolean;
+  }) {
+    const { isNetworkChange, isAccountChange, isConnection } = params ?? {};
+    const { enabled, signOutOnAccountChange, signOutOnNetworkChange } =
+      SIWEController.state._client?.options ?? {};
+
+    if (enabled) {
+      const session = await SIWEController.getSession();
+      if (session && isAccountChange) {
+        if (signOutOnAccountChange) {
+          // If the address has changed and signOnAccountChange is enabled, sign out
+          await SIWEController.signOut();
+
+          return this.onSiweNavigation();
+        }
+      } else if (isNetworkChange) {
+        if (signOutOnNetworkChange) {
+          // If the network has changed and signOnNetworkChange is enabled, sign out
+          await SIWEController.signOut();
+
+          return this.onSiweNavigation();
+        }
+      } else if (!session) {
+        // If it's connected but there's no session, show sign view
+        return this.onSiweNavigation();
+      } else if (isConnection) {
+        //Connected with 1CA
+        ModalController.close();
+      }
     }
   }
 }