@reown/appkit-wagmi-react-native 2.0.0 → 2.0.2

package/src/adapter.ts

@@ -1,7 +1,7 @@
 import {
   EVMAdapter,
-  WalletConnector,
   type AppKitNetwork,
+  type BlockchainAdapterInitParams,
   type CaipAddress,
   type ChainNamespace,
   type GetBalanceParams,
@@ -15,7 +15,8 @@ import {
   switchChain as switchChainWagmi,
   disconnect as disconnectWagmiCore,
   connect as connectWagmi,
-  type Connector
+  type Connector,
+  watchAccount
 } from '@wagmi/core';
 import type { Chain } from 'wagmi/chains';
 import { getTransport } from './utils/helpers';
@@ -25,7 +26,6 @@ import { UniversalConnector } from './connectors/UniversalConnector';
 type ConfigParams = Partial<CreateConfigParameters> & {
   networks: readonly [Chain, ...Chain[]];
   projectId: string;
-  connectors?: Connector[];
 };
 
 export class WagmiAdapter extends EVMAdapter {
@@ -33,22 +33,18 @@ export class WagmiAdapter extends EVMAdapter {
   public wagmiChains: readonly Chain[] | undefined;
   public wagmiConfig!: Config;
   private wagmiConfigConnector?: Connector;
+  private unsubscribeWatchAccount?: () => void;
 
   constructor(configParams: ConfigParams) {
     super({
-      projectId: configParams.projectId,
-      supportedNamespace: WagmiAdapter.supportedNamespace
+      supportedNamespace: WagmiAdapter.supportedNamespace,
+      adapterType: 'wagmi'
     });
     this.wagmiChains = configParams.networks;
     this.wagmiConfig = this.createWagmiInternalConfig(configParams);
   }
 
   private createWagmiInternalConfig(configParams: ConfigParams): Config {
-    // Connectors are typically added via wagmiConfig.connectors, but here AppKit manages the connection.
-    // We'll use the `connect` action with our dynamically created connector instance.
-    // So, the `connectors` array for createConfig can be empty and is added later.
-    const initialConnectors: (() => Connector)[] = [];
-
     const transportsArr = configParams.networks.map(chain => [
       chain.id,
       getTransport({ chainId: chain.id, projectId: configParams.projectId })
@@ -57,7 +53,7 @@ export class WagmiAdapter extends EVMAdapter {
 
     return createConfig({
       chains: configParams.networks,
-      connectors: initialConnectors, // Empty, as we connect programmatically
+      connectors: [...(configParams.connectors ?? [])],
       transports,
       multiInjectedProviderDiscovery: false
     });
@@ -105,7 +101,7 @@ export class WagmiAdapter extends EVMAdapter {
     const formattedBalance = {
       amount: formatUnits(balance.value, balance.decimals),
       symbol: balance.symbol,
-      contractAddress: token ? (`${network.caipNetworkId}:${token}` as CaipAddress) : undefined
+      address: token ? (`${network.caipNetworkId}:${token}` as CaipAddress) : undefined
     };
 
     this.emit('balanceChanged', { address: balanceAddress, balance: formattedBalance });
@@ -130,6 +126,11 @@ export class WagmiAdapter extends EVMAdapter {
   }
 
   async disconnect(): Promise<void> {
+    if (this.unsubscribeWatchAccount) {
+      this.unsubscribeWatchAccount();
+      this.unsubscribeWatchAccount = undefined;
+    }
+
     if (this.wagmiConfigConnector) {
       await disconnectWagmiCore(this.wagmiConfig, { connector: this.wagmiConfigConnector });
       this.wagmiConfigConnector = undefined;
@@ -148,8 +149,14 @@ export class WagmiAdapter extends EVMAdapter {
     return WagmiAdapter.supportedNamespace;
   }
 
-  override setConnector(_connector: WalletConnector): void {
-    super.setConnector(_connector);
+  // Override subscribeToEvents to prevent double subscription
+  // Wagmi handles provider events through its connector system and watchAccount
+  override subscribeToEvents(): void {
+    // Do nothing - wagmi's watchAccount in setupWatchers handles all events
+  }
+
+  override init({ connector: _connector }: BlockchainAdapterInitParams): void {
+    super.init({ connector: _connector });
 
     if (_connector && this.wagmiChains) {
       if (!this.wagmiConfigConnector) {
@@ -176,5 +183,39 @@ export class WagmiAdapter extends EVMAdapter {
         }
       }
     }
+
+    this.setupWatchers();
+  }
+
+  setupWatchers() {
+    // Clean up existing subscription if any
+    this.unsubscribeWatchAccount?.();
+
+    this.unsubscribeWatchAccount = watchAccount(this.wagmiConfig, {
+      onChange: (accountData, prevAccountData) => {
+        if (!this.connector) return;
+
+        // Handle disconnect
+        if (accountData.status === 'disconnected' && prevAccountData.address) {
+          this.onDisconnect();
+
+          return;
+        }
+
+        // Handle account address changes
+        if (
+          accountData?.addresses &&
+          accountData?.address &&
+          accountData.address !== prevAccountData?.address
+        ) {
+          this.onAccountsChanged([...accountData.addresses]);
+        }
+
+        // Handle chain changes
+        if (accountData?.chainId && accountData.chainId !== prevAccountData?.chainId) {
+          this.onChainChanged(accountData.chainId?.toString());
+        }
+      }
+    });
   }
 }

package/src/connectors/UniversalConnector.ts

@@ -1,62 +1,75 @@
-import type {
-  Provider,
-  RequestArguments,
-  WalletConnector
-} from '@reown/appkit-common-react-native';
+import type { Provider, WalletConnector } from '@reown/appkit-common-react-native';
+
 import {
   getAddress,
   numberToHex,
+  RpcError,
   SwitchChainError,
   UserRejectedRequestError,
   type Hex
 } from 'viem';
-import { ChainNotConfiguredError, createConnector, ProviderNotFoundError } from 'wagmi';
-import { formatNetwork } from '../utils/helpers';
+import {
+  ChainNotConfiguredError,
+  createConnector,
+  ProviderNotFoundError,
+  type Connector
+} from 'wagmi';
+
+type UniversalConnector = Connector & {
+  onSessionDelete(data: { topic: string }): void;
+};
+
+type Properties = {
+  onSessionDelete(data: { topic: string }): void;
+};
 
 export function UniversalConnector(appKitProvidedConnector: WalletConnector) {
   let provider: Provider | undefined;
 
-  let accountsChangedHandler: ((accounts: string[]) => void) | undefined;
-  let chainChangedHandler: ((chainId: string | number) => void) | undefined;
-  let disconnectHandler: ((error?: Error) => void) | undefined;
+  let accountsChanged: UniversalConnector['onAccountsChanged'] | undefined;
+  let chainChanged: UniversalConnector['onChainChanged'] | undefined;
+  let sessionDelete: UniversalConnector['onSessionDelete'] | undefined;
+  let disconnect: UniversalConnector['onDisconnect'] | undefined;
 
-  type AppKitConnectorProperties = { ready: boolean };
+  function cleanupEventListeners(_provider?: Provider | null) {
+    if (accountsChanged) {
+      _provider?.off('accountsChanged', accountsChanged);
+      accountsChanged = undefined;
+    }
+    if (chainChanged) {
+      _provider?.off('chainChanged', chainChanged);
+      chainChanged = undefined;
+    }
+    if (disconnect) {
+      _provider?.off('disconnect', disconnect);
+      disconnect = undefined;
+    }
+    if (sessionDelete) {
+      _provider?.off('session_delete', sessionDelete);
+      sessionDelete = undefined;
+    }
+  }
 
-  return createConnector<Provider, AppKitConnectorProperties>(config => ({
+  return createConnector<Provider, Properties>(config => ({
     id: 'walletconnect',
     name: 'WalletConnect',
     type: 'walletconnect' as const,
-    ready: !!appKitProvidedConnector.getProvider(),
+    ready: !!appKitProvidedConnector.getProvider('eip155'),
 
     async setup() {
-      provider = appKitProvidedConnector.getProvider();
-      if (provider?.on) {
-        accountsChangedHandler = (accounts: string[]) => {
-          const hexAccounts = accounts.map(acc => getAddress(acc));
-          config.emitter.emit('change', { accounts: hexAccounts });
-          if (hexAccounts.length === 0) {
-            config.emitter.emit('disconnect');
-          }
-        };
-        chainChangedHandler = (chainId: string | number) => {
-          const newChainId = typeof chainId === 'string' ? parseInt(chainId, 10) : chainId;
-          config.emitter.emit('change', { chainId: newChainId });
-        };
-        disconnectHandler = (error?: Error) => {
-          config.emitter.emit('disconnect');
-          if (error) config.emitter.emit('error', { error });
-        };
-
-        if (accountsChangedHandler) provider.on('accountsChanged', accountsChangedHandler);
-        if (chainChangedHandler) provider.on('chainChanged', chainChangedHandler);
-        if (disconnectHandler) provider.on('disconnect', disconnectHandler);
-        if (disconnectHandler) provider.on('session_delete', disconnectHandler);
+      const _provider = await this.getProvider().catch(() => null);
+      if (!_provider) {
+        return;
+      }
+      if (!sessionDelete) {
+        sessionDelete = this.onSessionDelete.bind(this);
+        _provider.on('session_delete', sessionDelete);
       }
     },
 
     async connect({ chainId } = {}) {
       try {
-        const _provider = await this.getProvider();
+        const _provider = appKitProvidedConnector.getProvider('eip155');
         if (!_provider) throw new ProviderNotFoundError();
 
         // AppKit connector is already connected or handles its own connection.
@@ -75,8 +88,22 @@ export function UniversalConnector(appKitProvidedConnector: WalletConnector) {
           await this.switchChain?.({ chainId });
           currentChainId = chainId;
         }
-
-        this.ready = true;
+        if (!accountsChanged) {
+          accountsChanged = this.onAccountsChanged.bind(this);
+          _provider.on('accountsChanged', accountsChanged);
+        }
+        if (!chainChanged) {
+          chainChanged = this.onChainChanged.bind(this);
+          _provider.on('chainChanged', chainChanged);
+        }
+        if (!disconnect) {
+          disconnect = this.onDisconnect.bind(this);
+          _provider.on('disconnect', disconnect);
+        }
+        if (!sessionDelete) {
+          sessionDelete = this.onSessionDelete.bind(this);
+          _provider.on('session_delete', sessionDelete);
+        }
 
         return { accounts: accountAddresses, chainId: currentChainId };
       } catch (error) {
@@ -86,24 +113,22 @@ export function UniversalConnector(appKitProvidedConnector: WalletConnector) {
     },
 
     async disconnect() {
-      await appKitProvidedConnector.disconnect();
-      config.emitter.emit('message', { type: 'externalDisconnect' });
-      if (provider?.off && accountsChangedHandler && chainChangedHandler && disconnectHandler) {
-        provider.off('accountsChanged', accountsChangedHandler);
-        provider.off('chainChanged', chainChangedHandler);
-        provider.off('disconnect', disconnectHandler);
-        provider.off('session_delete', disconnectHandler);
-        accountsChangedHandler = undefined;
-        chainChangedHandler = undefined;
-        disconnectHandler = undefined;
+      const _provider = await this.getProvider().catch(() => null);
+      try {
+        await appKitProvidedConnector.disconnect();
+        config.emitter.emit('message', { type: 'externalDisconnect' });
+      } catch (error) {
+        if (!/No matching key/i.test((error as Error).message)) {
+          throw error;
+        }
+      } finally {
+        cleanupEventListeners(_provider);
       }
-      this.ready = false;
     },
 
     async getAccounts() {
       const namespaces = appKitProvidedConnector.getNamespaces();
-      // @ts-ignore
-      const eip155Accounts = namespaces?.eip155?.accounts;
+      const eip155Accounts = namespaces?.['eip155']?.accounts as string[] | undefined;
       if (!eip155Accounts) return [] as readonly Hex[];
 
       return eip155Accounts
@@ -123,8 +148,7 @@ export function UniversalConnector(appKitProvidedConnector: WalletConnector) {
 
       // Fallback: Try to get from CAIP accounts if available
       const namespaces = appKitProvidedConnector.getNamespaces();
-      // @ts-ignore
-      const eip155Accounts = namespaces?.eip155?.accounts;
+      const eip155Accounts = namespaces?.['eip155']?.accounts as string[] | undefined;
       if (eip155Accounts && eip155Accounts.length > 0) {
         const parts = eip155Accounts[0]?.split(':');
         if (parts && parts.length > 1 && typeof parts[1] === 'string') {
@@ -140,20 +164,10 @@ export function UniversalConnector(appKitProvidedConnector: WalletConnector) {
 
     async getProvider() {
       if (!provider) {
-        provider = appKitProvidedConnector.getProvider();
+        provider = appKitProvidedConnector.getProvider('eip155');
       }
 
-      const chainId = await this.getChainId();
-
-      //TODO: Review this with gancho
-      const _provider = {
-        ...provider,
-        request: (args: RequestArguments) => {
-          return provider?.request(args, `eip155:${chainId}`);
-        }
-      };
-
-      return Promise.resolve(_provider as Provider);
+      return provider;
     },
 
     async isAuthorized() {
@@ -167,7 +181,7 @@ export function UniversalConnector(appKitProvidedConnector: WalletConnector) {
     },
 
     async switchChain({ chainId }) {
-      const _provider = await this.getProvider();
+      const _provider = appKitProvidedConnector.getProvider('eip155');
       if (!_provider) throw new Error('Provider not available for switching chain.');
       const newChain = config.chains.find(c => c.id === chainId);
 
@@ -179,28 +193,27 @@ export function UniversalConnector(appKitProvidedConnector: WalletConnector) {
           params: [{ chainId: numberToHex(chainId) }]
         });
 
-        config.emitter.emit('change', { chainId });
-
         return newChain;
-      } catch (error) {
-        // Try to add chain if switch failed (common pattern)
-        //4902 in MetaMask: Unrecognized chain ID
+      } catch (err) {
+        const error = err as RpcError;
+
+        if (/(user rejected)/i.test(error.message)) throw new UserRejectedRequestError(error);
+
         if ((error as any)?.code === 4902 || (error as any)?.data?.originalError?.code === 4902) {
+          // Indicates chain is not added to provider
           try {
+            const addEthereumChainParams = {
+              chainId: numberToHex(chainId),
+              chainName: newChain.name,
+              nativeCurrency: newChain.nativeCurrency,
+              rpcUrls: [newChain.rpcUrls.default?.http[0] ?? ''],
+              blockExplorerUrls: [newChain.blockExplorers?.default?.url]
+            };
+
             await _provider.request({
               method: 'wallet_addEthereumChain',
-              params: [
-                {
-                  chainId: numberToHex(chainId),
-                  chainName: newChain.name,
-                  nativeCurrency: newChain.nativeCurrency,
-                  rpcUrls: [newChain.rpcUrls.default?.http[0] ?? ''], // Take first default HTTP RPC URL
-                  blockExplorerUrls: [newChain.blockExplorers?.default?.url]
-                }
-              ]
+              params: [addEthereumChainParams]
             });
-            await appKitProvidedConnector.switchNetwork(formatNetwork(newChain));
-            config.emitter.emit('change', { chainId });
 
             return newChain;
           } catch (addError) {
@@ -212,17 +225,41 @@ export function UniversalConnector(appKitProvidedConnector: WalletConnector) {
     },
 
     onAccountsChanged(accounts: string[]) {
-      if (accounts.length === 0) this.onDisconnect();
-      else config.emitter.emit('change', { accounts: accounts.map(x => getAddress(x)) });
+      //Only emit if the account is an evm account
+      const shouldEmit = accounts.some(account => account.startsWith('0x'));
+
+      if (accounts.length === 0) {
+        this.onDisconnect();
+      } else if (shouldEmit) {
+        config.emitter.emit('change', { accounts: accounts.map(x => getAddress(x)) });
+      }
     },
 
     onChainChanged(chain: string) {
       const chainId = Number(chain);
-      config.emitter.emit('change', { chainId });
+
+      //Only emit if the chain is in the config (evm)
+      const shouldEmit = config.chains.some(c => c.id === chainId);
+      if (shouldEmit) {
+        config.emitter.emit('change', { chainId });
+      }
     },
 
-    onDisconnect: () => {
+    async onDisconnect() {
       config.emitter.emit('disconnect');
+
+      try {
+        const _provider = await this.getProvider();
+        cleanupEventListeners(_provider);
+      } catch (error) {
+        // If provider is not available, still clean up local references
+        // to prevent memory leaks
+        cleanupEventListeners(null);
+      }
+    },
+
+    onSessionDelete() {
+      this.onDisconnect();
     }
   }));
 }

package/src/utils/helpers.ts

@@ -1,14 +1,13 @@
-import { CoreHelperUtil } from '@reown/appkit-react-native';
+import { http } from 'viem';
 import {
   PresetsUtil,
   ConstantsUtil,
   type AppKitNetwork,
   type Network
 } from '@reown/appkit-common-react-native';
-import { http } from 'viem';
 
 export function getTransport({ chainId, projectId }: { chainId: number; projectId: string }) {
-  const RPC_URL = CoreHelperUtil.getBlockchainApiUrl();
+  const RPC_URL = ConstantsUtil.BLOCKCHAIN_API_RPC_URL;
 
   if (!PresetsUtil.RpcChainIds.includes(chainId)) {
     return http();