@reown/appkit-react-native 0.0.0-fix-ui-changes-20250829201240 → 0.0.0-fix-singleton-appkit-20251001153745

package/src/AppKit.ts

@@ -14,7 +14,9 @@ import {
   CoreHelperUtil,
   SendController,
   BlockchainApiController,
-  WalletUtil
+  WalletUtil,
+  LogController,
+  type RouterControllerState
 } from '@reown/appkit-core-react-native';
 
 import {
@@ -36,13 +38,20 @@ import {
   type Connection,
   type WcWallet
 } 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 { RouterUtil } from './utils/RouterUtil';
 import { type AppKitConfig } from './types';
+import { SIWXUtil } from './utils/SIWXUtil';
+
+const APPKIT_INSTANCE_KEY = Symbol.for('__REOWN_APPKIT_INSTANCE__');
+
+// Type helper to access the symbol-keyed property on globalThis
+interface GlobalWithAppKit {
+  [key: symbol]: AppKit | undefined;
+}
 
 export class AppKit {
   private projectId: string;
@@ -130,8 +139,7 @@ export class AppKit {
       const approvedNamespaces = await connector.connect({
         namespaces: this.namespaces,
         defaultNetwork: chain,
-        universalLink: targetWallet?.link_mode ?? undefined,
-        siweConfig: this.config?.siweConfig
+        universalLink: targetWallet?.link_mode ?? undefined
       });
 
       this.processConnection(connector, approvedNamespaces);
@@ -144,16 +152,12 @@ export class AppKit {
         });
       }
     } catch (error) {
-      console.warn('Connection failed:', error);
+      LogController.sendError(error, 'AppKit.ts', 'connect');
       throw error;
     }
   }
 
-  private processConnection(
-    connector: WalletConnector,
-    namespaces?: Namespaces,
-    shouldCloseModal: boolean = true
-  ) {
+  private async processConnection(connector: WalletConnector, namespaces?: Namespaces) {
     if (!namespaces || Object.keys(namespaces).length === 0) {
       throw new Error('No namespaces provided');
     }
@@ -173,21 +177,9 @@ export class AppKit {
     this.setConnection(initializedAdapters, namespaces, walletInfo, properties);
 
     // Sync accounts
-    this.syncAccounts(initializedAdapters);
-
-    // Handle SIWE if enabled
-    this.handleSiweConnectionIfEnabled(shouldCloseModal);
-  }
+    await this.syncAccounts(initializedAdapters);
 
-  private handleSiweConnectionIfEnabled(shouldCloseModal: boolean = true): void {
-    if (
-      OptionsController.state.isSiweEnabled &&
-      ConnectionsController.state.activeNamespace === 'eip155'
-    ) {
-      this.handleSiweChange({ isConnection: true });
-    } else if (shouldCloseModal) {
-      ModalController.close();
-    }
+    await SIWXUtil.initializeIfEnabled({ onDisconnect: this.disconnect, closeModal: true });
   }
 
   /**
@@ -195,7 +187,7 @@ export class AppKit {
    * @param namespace - The namespace to disconnect from.
    * @param isInternal - Whether the disconnect is internal (i.e. from the AppKit) or external (i.e. from wallet side).
    */
-  async disconnect(namespace?: string, isInternal?: boolean): Promise<void> {
+  async disconnect(namespace?: ChainNamespace, isInternal?: boolean): Promise<void> {
     try {
       const activeNamespace = namespace ?? ConnectionsController.state.activeNamespace;
 
@@ -229,15 +221,19 @@ export class AppKit {
         );
       }
 
-      if (OptionsController.state.isSiweEnabled) {
-        await SIWEController.signOut();
+      if (SIWXUtil.getSIWX()?.signOutOnDisconnect) {
+        await SIWXUtil.clearSessions();
       }
 
       EventsController.sendEvent({
         type: 'track',
-        event: 'DISCONNECT_SUCCESS'
+        event: 'DISCONNECT_SUCCESS',
+        properties: {
+          namespace: activeNamespace
+        }
       });
     } catch (error) {
+      LogController.sendError(error, 'AppKit.ts', 'disconnect');
       EventsController.sendEvent({
         type: 'track',
         event: 'DISCONNECT_ERROR'
@@ -284,15 +280,11 @@ export class AppKit {
       type: 'track',
       event: 'SWITCH_NETWORK',
       properties: {
-        network: network.id
+        network: network.caipNetworkId
       }
     });
 
     ConnectionsController.setActiveNetwork(network.chainNamespace, network.caipNetworkId);
-
-    if (ConnectionsController.state.activeNamespace !== network.chainNamespace) {
-      ConnectionsController.setActiveNamespace(network.chainNamespace);
-    }
   }
 
   open(options?: AppKitOpenOptions) {
@@ -301,19 +293,19 @@ export class AppKit {
 
   async close() {
     ModalController.close();
+    const isSIWXRequired = SIWXUtil.getSIWX()?.getRequired?.();
 
-    if (OptionsController.state.isSiweEnabled && ConnectionsController.state.isConnected) {
-      const session = await SIWEController.getSession();
-      if (
-        !session &&
-        SIWEController.state.status !== 'success' &&
-        ConnectionsController.state.activeNamespace === 'eip155' &&
-        !!ConnectionsController.state.activeAddress
-      ) {
-        await this.disconnect();
+    if (isSIWXRequired && ConnectionsController.state.isConnected) {
+      const sessions = await SIWXUtil.getSessions();
+      if (!sessions.length) {
+        return await this.disconnect();
       }
     }
 
+    if (RouterController.state.view === 'UnsupportedChain') {
+      return await this.disconnect();
+    }
+
     RouterUtil.checkOnRampBack();
     RouterUtil.checkSocialLoginBack();
   }
@@ -325,6 +317,13 @@ export class AppKit {
       return RouterController.goBack();
     }
 
+    const isSIWXRequired = SIWXUtil.getSIWX()?.getRequired?.();
+
+    if (isSIWXRequired) {
+      // Don't close the modal if SIWX is required
+      return;
+    }
+
     return this.close();
   }
 
@@ -395,25 +394,44 @@ export class AppKit {
    * This attempts to restore previous sessions.
    */
   private async initConnectors() {
+    ModalController.setLoading(true);
+
+    //Always init the walletconnect connector
+    await this.createWalletConnectConnector();
+
     const connectedConnectors = await StorageUtil.getConnectedConnectors();
     if (connectedConnectors.length > 0) {
-      ModalController.setLoading(true);
-
       for (const connected of connectedConnectors) {
         try {
           const connector = await this.createConnector(connected.type);
 
           const namespaces = connector.getNamespaces();
 
-          this.processConnection(connector, namespaces, false);
+          await this.processConnection(connector, namespaces);
         } catch (error) {
-          // Use console.warn for non-critical initialization failures
-          console.warn(`Failed to initialize connector type ${connected.type}:`, error);
+          LogController.sendError(error, 'AppKit.ts', 'initializeConnector', {
+            connectorType: connected.type
+          });
           await StorageUtil.removeConnectedConnectors(connected.type);
         }
       }
-      ModalController.setLoading(false);
+
+      const address = ConnectionsController.state.activeAddress;
+      const walletInfo = ConnectionsController.state.walletInfo;
+      if (address) {
+        EventsController.sendEvent({
+          type: 'track',
+          event: 'CONNECT_SUCCESS',
+          address: CoreHelperUtil.getPlainAddress(address),
+          properties: {
+            name: walletInfo?.name ?? 'Unknown',
+            reconnect: true
+          }
+        });
+      }
     }
+
+    ModalController.setLoading(false);
   }
 
   private setupAdaptersAndSubscribe(
@@ -505,12 +523,13 @@ export class AppKit {
           );
         }
       } catch (error) {
+        LogController.sendError(error, 'AppKit.ts', 'syncIdentity');
         // Continue processing other addresses even if one fails
       }
     }
   }
 
-  private async refreshBalance(fetchAllBalances: boolean = false) {
+  private refreshBalance(fetchAllBalances: boolean = false) {
     try {
       if (fetchAllBalances) {
         ConnectionsController.fetchBalance();
@@ -523,8 +542,9 @@ export class AppKit {
           this.syncNativeBalance(adapter, network);
         }
       }
-    } catch {
+    } catch (error) {
       // ignore
+      LogController.sendError(error, 'AppKit.ts', 'refreshBalance');
     }
   }
 
@@ -547,7 +567,6 @@ export class AppKit {
     const recomputePolling = () => {
       const open = ModalController.state.open;
       const view = RouterController.state.view;
-
       if (open && (view === 'Account' || view === 'AccountDefault')) {
         // fetch all balances when user is using embedded wallet
         this.startBalancePolling(view === 'Account');
@@ -555,9 +574,7 @@ export class AppKit {
         this.stopBalancePolling();
       }
     };
-
     recomputePolling();
-
     subscribeKey(RouterController.state, 'view', () => recomputePolling());
     subscribeKey(ModalController.state, 'open', () => recomputePolling());
   }
@@ -578,7 +595,8 @@ export class AppKit {
       const caipNetwork = adapter?.connector?.getChainId(namespace);
       const namespaceProperties = {
         ...properties,
-        smartAccounts: properties?.smartAccounts?.filter(account => account.startsWith(namespace))
+        smartAccounts: properties?.smartAccounts?.filter(account => account.startsWith(namespace)),
+        canAddEvmChain: wallet?.name === 'MetaMask Wallet' // MetaMask allows adding EVM chains after connecting
       };
 
       ConnectionsController.setConnection({
@@ -605,21 +623,21 @@ export class AppKit {
     adapter.on('accountsChanged', ({ accounts }) => {
       const namespace = adapter.getSupportedNamespace();
       ConnectionsController.updateAccounts(namespace, accounts);
+    });
 
-      if (namespace === 'eip155') {
-        this.handleSiweChange({ isAccountChange: true });
+    adapter.on('chainChanged', async ({ chainId }) => {
+      const isSupported = this.networks.some(network => network.id?.toString() === chainId);
+      if (!isSupported) {
+        return this.navigate('UnsupportedChain');
       }
-    });
 
-    adapter.on('chainChanged', ({ chainId }) => {
       const namespace = adapter.getSupportedNamespace();
       const chain = `${namespace}:${chainId}` as CaipNetworkId;
       ConnectionsController.setActiveNetwork(namespace, chain);
+
       const connection = ConnectionsController.state.connections.get(namespace);
       const isAuth = !!connection?.properties?.provider;
 
-      const activeNamespace = ConnectionsController.state.activeNamespace;
-
       const network = this.networks.find(n => n.id?.toString() === chainId);
       this.syncNativeBalance(adapter, network);
       SendController.resetState();
@@ -629,20 +647,14 @@ export class AppKit {
         ConnectionsController.fetchBalance();
       }
 
-      // Refresh transactions only when the active network changes
-      if (namespace === activeNamespace) {
-        const address = connection?.accounts?.find(account =>
-          account.startsWith(`${namespace}:${chainId}`)
-        );
-        if (address) {
-          TransactionsController.fetchTransactions(address, true);
-        }
+      const address = connection?.accounts?.find(account =>
+        account.startsWith(`${namespace}:${chainId}`)
+      );
+      if (address) {
+        TransactionsController.fetchTransactions(address, true);
       }
 
-      // Check if user needs to sign in again
-      if (namespace === 'eip155') {
-        this.handleSiweChange({ isNetworkChange: true });
-      }
+      SIWXUtil.initializeIfEnabled({ onDisconnect: this.disconnect, caipAddress: address });
     });
 
     adapter.on('disconnect', () => {
@@ -658,6 +670,7 @@ export class AppKit {
 
   private async initControllers(options: AppKitConfig) {
     await this.initStorageAndValues(options);
+    let defaultNetwork;
 
     OptionsController.setProjectId(options.projectId);
     OptionsController.setMetadata(options.metadata);
@@ -666,16 +679,26 @@ export class AppKit {
     this.setCustomWallets(options);
     OptionsController.setFeaturedWalletIds(options.featuredWalletIds);
     OptionsController.setEnableAnalytics(options.enableAnalytics);
-    OptionsController.setDebug(options.debug);
+    OptionsController.setDebug(options.debug && __DEV__);
+
+    // Initialize LogController after debug option is set
+    LogController.initialize();
+    LogController.sendInfo('AppKit initialization started', 'AppKit.ts', 'initControllers', {
+      projectId: options.projectId,
+      adapters: this.adapters.map(a => a.constructor.name),
+      networks: this.networks.map(n => n.name),
+      debug: options.debug
+    });
+
     OptionsController.setFeatures(options.features);
     OptionsController.setRequestedNetworks(this.networks);
 
     if (options.defaultNetwork) {
-      const network = NetworkUtil.formatNetwork(options.defaultNetwork, this.projectId);
-      OptionsController.setDefaultNetwork(network);
+      defaultNetwork = NetworkUtil.formatNetwork(options.defaultNetwork, this.projectId);
+      OptionsController.setDefaultNetwork(defaultNetwork);
     }
 
-    ThemeController.setThemeMode(options.themeMode);
+    ThemeController.setDefaultThemeMode(options.themeMode);
     ThemeController.setThemeVariables(options.themeVariables);
 
     OptionsController.setSdkVersion(
@@ -688,8 +711,8 @@ export class AppKit {
 
     ConnectionsController.setNetworks(this.networks);
 
-    if (options.siweConfig) {
-      SIWEController.setSIWEClient(options.siweConfig);
+    if (options.siwx) {
+      OptionsController.setSiwx(options.siwx);
     }
 
     if (
@@ -698,6 +721,24 @@ export class AppKit {
     ) {
       OptionsController.setIsOnRampEnabled(true);
     }
+
+    EventsController.sendEvent({
+      type: 'track',
+      event: 'INITIALIZE',
+      properties: {
+        showWallets: options.features?.showWallets,
+        themeMode: options.themeMode,
+        themeVariables: options.themeVariables,
+        networks: this.networks.map(network => network.caipNetworkId).filter(Boolean),
+        defaultNetwork: defaultNetwork?.caipNetworkId,
+        metadata: options.metadata,
+        enableAnalytics: options.enableAnalytics,
+        features: options.features,
+        adapters: this.adapters.map(adapter => adapter?.constructor?.name).filter(Boolean),
+        extraConnectors: this.extraConnectors.map(connector => connector?.type).filter(Boolean),
+        siwx: !!options.siwx
+      }
+    });
   }
 
   private async initActiveNamespace() {
@@ -784,50 +825,54 @@ export class AppKit {
     await this.initRecentWallets(options);
   }
 
-  private onSiweNavigation = () => {
+  private navigate = (routeName: RouterControllerState['view']) => {
+    if (RouterController.state.view === routeName) {
+      return;
+    }
+
     if (ModalController.state.open) {
-      RouterController.push('ConnectingSiwe');
+      RouterController.push(routeName);
     } else {
-      ModalController.open({ view: 'ConnectingSiwe' });
+      ModalController.open({ view: routeName });
     }
   };
+}
 
-  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();
+/**
+ * Creates or returns the existing AppKit singleton instance.
+ *
+ * @warning This function implements a singleton pattern. If an instance already exists,
+ * it will be returned and the provided config parameter will be IGNORED. If you need to
+ * change configuration, you must reload your application or clear the singleton manually.
+ *
+ * @param config - AppKit configuration options
+ * @returns The AppKit singleton instance
+ * @throws Error if configuration validation fails
+ */
+export function createAppKit(config: AppKitConfig): AppKit {
+  try {
+    const globalWithAppKit = globalThis as GlobalWithAppKit;
+
+    if (!globalWithAppKit[APPKIT_INSTANCE_KEY]) {
+      if (config.debug && __DEV__) {
+        // using console.log to avoid possible issues with LogController not being initialized
+        //eslint-disable-next-line no-console
+        console.log('AppKit: Creating new instance - AppKit.ts:createAppKit');
       }
+      globalWithAppKit[APPKIT_INSTANCE_KEY] = new AppKit(config);
+    } else if (config.debug && __DEV__) {
+      //eslint-disable-next-line no-console
+      console.log('AppKit: Reusing existing instance - AppKit.ts:createAppKit');
     }
-  }
-}
 
-export function createAppKit(config: AppKitConfig): AppKit {
-  return new AppKit(config);
+    return globalWithAppKit[APPKIT_INSTANCE_KEY]!;
+  } catch (error) {
+    if (__DEV__) {
+      // using console.error to avoid possible issues with LogController not being initialized
+      //eslint-disable-next-line no-console
+      console.error('AppKit: Failed to create instance - AppKit.ts:createAppKit', error);
+    }
+
+    throw error;
+  }
 }

package/src/AppKitContext.tsx

@@ -1,4 +1,4 @@
-import React, { createContext, useContext, type ReactNode } from 'react';
+import React, { createContext, useContext, useMemo, type ReactNode } from 'react';
 import { AppKit } from './AppKit';
 
 interface AppKitContextType {
@@ -26,14 +26,22 @@ export const useInternalAppKit = () => {
     throw new Error('AppKit instance is not yet available in context.');
   }
 
-  return {
-    connect: context.appKit.connect.bind(context.appKit),
-    disconnect: context.appKit.disconnect.bind(context.appKit),
-    open: context.appKit.open.bind(context.appKit),
-    close: context.appKit.close.bind(context.appKit),
-    back: context.appKit.back.bind(context.appKit),
-    switchNetwork: context.appKit.switchNetwork.bind(context.appKit),
-    getProvider: context.appKit.getProvider.bind(context.appKit),
-    switchAccountType: context.appKit.switchAccountType.bind(context.appKit)
-  };
+  const stableFunctions = useMemo(() => {
+    if (!context.appKit) {
+      throw new Error('AppKit instance is not available');
+    }
+
+    return {
+      connect: context.appKit.connect.bind(context.appKit),
+      disconnect: context.appKit.disconnect.bind(context.appKit),
+      open: context.appKit.open.bind(context.appKit),
+      close: context.appKit.close.bind(context.appKit),
+      back: context.appKit.back.bind(context.appKit),
+      switchNetwork: context.appKit.switchNetwork.bind(context.appKit),
+      getProvider: context.appKit.getProvider.bind(context.appKit),
+      switchAccountType: context.appKit.switchAccountType.bind(context.appKit)
+    };
+  }, [context.appKit]);
+
+  return stableFunctions;
 };