fix: state and local storage sync and persistent when use multiple adapters

.changeset/few-chicken-enjoy.md

@@ -0,0 +1,21 @@
+---
+'@reown/appkit-adapter-solana': patch
+'@reown/appkit-adapter-wagmi': patch
+'@reown/appkit': patch
+'@reown/appkit-common': patch
+'@reown/appkit-core': patch
+'@reown/appkit-adapter-ethers': patch
+'@reown/appkit-adapter-ethers5': patch
+'@reown/appkit-utils': patch
+'@reown/appkit-cdn': patch
+'appkit-cli': patch
+'@reown/appkit-experimental': patch
+'@reown/appkit-polyfills': patch
+'@reown/appkit-scaffold-ui': patch
+'@reown/appkit-siwe': patch
+'@reown/appkit-siwx': patch
+'@reown/appkit-ui': patch
+'@reown/appkit-wallet': patch
+---
+
+Fixes state and storage syncronization and persisting on multiple adapter instances

packages/adapters/solana/src/client.ts

@@ -6,8 +6,10 @@ import {
 } from '@reown/appkit-common'
 import {
   AlertController,
+  ChainController,
   CoreHelperUtil,
   EventsController,
+  StorageUtil,
   type ConnectorType,
   type Provider
 } from '@reown/appkit-core'
@@ -33,6 +35,7 @@ import { handleMobileWalletRedirection } from './utils/handleMobileWalletRedirec
 import { SolStoreUtil } from './utils/SolanaStoreUtil.js'
 import { watchStandard } from './utils/watchStandard.js'
 import { withSolanaNamespace } from './utils/withSolanaNamespace.js'
+import { solana } from '@reown/appkit/networks'
 
 export interface AdapterOptions {
   connectionSettings?: Commitment | ConnectionConfig
@@ -454,7 +457,8 @@ export class SolanaAdapter extends AdapterBlueprint {
 
     // For standard Solana wallets
     const address = await selectedProvider.connect()
-    const chainId = this.caipNetworks?.[0]?.id || 1
+    const { chainId: activeChainId } = StorageUtil.getActiveNetworkProps()
+    const chainId = activeChainId || solana.id
 
     this.listenProviderEvents(selectedProvider as unknown as WalletStandardProvider)
 
@@ -475,7 +479,7 @@ export class SolanaAdapter extends AdapterBlueprint {
     const walletConnectProvider = new WalletConnectProvider({
       provider: params.provider as UniversalProvider,
       chains: params.caipNetworks,
-      getActiveChain: () => params.activeCaipNetwork
+      getActiveChain: () => ChainController.state.activeCaipNetwork
     })
 
     return walletConnectProvider as unknown as UniversalProvider

packages/adapters/wagmi/src/connectors/UniversalConnector.ts

@@ -23,7 +23,7 @@ import { StorageUtil } from '@reown/appkit-core'
 import type { AppKitOptions } from '@reown/appkit'
 import type { AppKit } from '@reown/appkit'
 import { ConstantsUtil } from '@reown/appkit-common'
-import type { CaipNetwork } from '@reown/appkit-common'
+import type { CaipNetwork, ChainNamespace } from '@reown/appkit-common'
 
 type UniversalConnector = Connector & {
   onDisplayUri(uri: string): void
@@ -201,7 +201,7 @@ export function walletConnect(
         return []
       }
 
-      const accountsList = provider?.session?.namespaces['eip155']?.accounts
+      const accountsList = provider?.session?.namespaces[ConstantsUtil.CHAIN.EVM]?.accounts
 
       const accounts = accountsList?.map(account => account.split(':')[2]) ?? []
 
@@ -213,10 +213,13 @@ export function walletConnect(
         provider_?.events.setMaxListeners(Number.POSITIVE_INFINITY)
       }
 
+      const activeNamespace = StorageUtil.getActiveNamespace()
       const currentChainId = appKit.getCaipNetwork()?.id
 
-      if (chainId && currentChainId !== chainId) {
-        const storedCaipNetwork = StorageUtil.getStoredActiveCaipNetwork()
+      if (chainId && currentChainId !== chainId && activeNamespace) {
+        const storedCaipNetworkId = StorageUtil.getStoredActiveCaipNetworkId()
+        const appKitCaipNetworks = appKit?.getCaipNetworks(activeNamespace as ChainNamespace)
+        const storedCaipNetwork = appKitCaipNetworks?.find(n => n.id === storedCaipNetworkId)
 
         if (storedCaipNetwork && storedCaipNetwork.chainNamespace === ConstantsUtil.CHAIN.EVM) {
           await this.switchChain?.({ chainId: Number(storedCaipNetwork.id) })
@@ -234,7 +237,7 @@ export function walletConnect(
       }
 
       const provider = await this.getProvider()
-      const chain = provider.session?.namespaces['eip155']?.chains?.[0]
+      const chain = provider.session?.namespaces[ConstantsUtil.CHAIN.EVM]?.chains?.[0]
 
       const network = caipNetworks.find(c => c.id === chain)
 
@@ -388,7 +391,7 @@ export function walletConnect(
         return []
       }
 
-      const accounts = provider_?.session?.namespaces['eip155']?.accounts
+      const accounts = provider_?.session?.namespaces[ConstantsUtil.CHAIN.EVM]?.accounts
 
       // eslint-disable-next-line radix
       const chainIds = accounts?.map(account => Number.parseInt(account.split(':')[1] ?? '')) ?? []

packages/adapters/wagmi/src/tests/UniversalConnector.test.ts

@@ -0,0 +1,170 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest'
+import { walletConnect } from '../connectors/UniversalConnector'
+import { mainnet } from '@reown/appkit/networks'
+import { getAddress } from 'viem'
+import {
+  mockAppKit,
+  mockProvider,
+  mockSession,
+  mockAddress,
+  mockCaipNetworks,
+  mockCaipAddress
+} from './mocks/AppKit'
+
+vi.mock('@reown/appkit-core', async importOriginal => {
+  const actual = await importOriginal<typeof import('@reown/appkit-core')>()
+  return {
+    ...actual,
+    StorageUtil: {
+      getActiveNamespace: vi.fn(),
+      getStoredActiveCaipNetworkId: vi.fn()
+    }
+  }
+})
+
+const mockStorage = {
+  getItem: vi.fn(),
+  setItem: vi.fn()
+}
+
+const mockEmitter = {
+  emit: vi.fn(),
+  on: vi.fn(),
+  removeListener: vi.fn()
+}
+
+describe('UniversalConnector', () => {
+  let connectorInstance: any
+
+  beforeEach(() => {
+    const createConnector = walletConnect(
+      {
+        isNewChainsStale: false
+      } as any,
+      mockAppKit,
+      mockCaipNetworks as any
+    )
+
+    connectorInstance = createConnector({
+      chains: mockCaipNetworks,
+      options: {},
+      // @ts-expect-error - mocking Wagmi's storage
+      storage: mockStorage,
+      // @ts-expect-error - mocking Wagmi's emitter
+      emitter: mockEmitter
+    })
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('connect', () => {
+    it('should connect successfully', async () => {
+      const expectedChainId = mainnet.id
+
+      mockProvider.enable.mockResolvedValue([mockAddress])
+
+      const result = await connectorInstance.connect()
+
+      expect(result).toEqual({
+        accounts: [getAddress(mockAddress)],
+        chainId: expectedChainId
+      })
+      expect(mockProvider.on).toHaveBeenCalled()
+      expect(mockProvider.session.namespaces.eip155.accounts).toEqual([mockCaipAddress])
+    })
+
+    it('should handle user rejection', async () => {
+      mockProvider.enable.mockRejectedValue(new Error('user rejected'))
+
+      await expect(connectorInstance.connect()).rejects.toThrow('User rejected the request.')
+    })
+  })
+
+  describe('getAccounts', () => {
+    it('should return accounts from provider session', async () => {
+      mockProvider.enable.mockResolvedValue([mockAddress])
+      await connectorInstance.connect()
+      const accounts = await connectorInstance.getAccounts()
+
+      expect(accounts).toEqual([mockAddress])
+    })
+
+    it('should return empty array when no session exists', async () => {
+      // @ts-expect-error - override mockProvider only for session to test getAccounts
+      mockProvider.session = undefined
+      const accounts = await connectorInstance.getAccounts()
+
+      expect(accounts).toEqual([])
+    })
+  })
+
+  describe('disconnect', () => {
+    it('should disconnect successfully', async () => {
+      mockProvider.session = mockSession
+
+      await connectorInstance.connect()
+      await connectorInstance.disconnect()
+
+      expect(mockProvider.disconnect).toHaveBeenCalled()
+      expect(mockProvider.removeListener).toHaveBeenCalled()
+    })
+  })
+
+  describe('switchChain', () => {
+    it('should switch chain successfully', async () => {
+      mockProvider.request.mockResolvedValue(null)
+
+      const result = await connectorInstance.switchChain({ chainId: 1 })
+
+      expect(result).toEqual(
+        expect.objectContaining({
+          id: 1,
+          name: 'Ethereum'
+        })
+      )
+      expect(mockProvider.request).toHaveBeenCalledWith({
+        method: 'wallet_switchEthereumChain',
+        params: [{ chainId: '0x1' }]
+      })
+    })
+
+    it('should handle adding a new chain', async () => {
+      // First request fails, triggering add chain flow
+      mockProvider.request.mockRejectedValueOnce(new Error('chain not found'))
+      mockProvider.request.mockResolvedValueOnce(null)
+
+      const result = await connectorInstance.switchChain({ chainId: 1 })
+
+      expect(result).toEqual(
+        expect.objectContaining({
+          id: 1,
+          name: 'Ethereum'
+        })
+      )
+      expect(mockProvider.request).toHaveBeenCalledWith({
+        method: 'wallet_addEthereumChain',
+        params: [
+          expect.objectContaining({
+            chainId: '0x1',
+            chainName: 'Ethereum'
+          })
+        ]
+      })
+    })
+  })
+
+  describe.skip('isAuthorized', () => {
+    it('should return true when authorized', async () => {
+      const result = await connectorInstance.isAuthorized()
+      expect(result).toBe(true)
+    })
+
+    it('should return false when no accounts exist', async () => {
+      mockProvider.session.namespaces.eip155.accounts = []
+      const result = await connectorInstance.isAuthorized()
+      expect(result).toBe(false)
+    })
+  })
+})