fix(controllers): scope one-click auth chains to the connector's namespace

`WalletConnectConnector.authenticate()` passed `this.chains` to
`SIWXUtil.universalProviderAuthenticate`. That getter resolves to
`ChainController.getCaipNetworks()` with no namespace argument, i.e.
`getAllRequestedCaipNetworks()` — every registered namespace rather than
the connector's own, even though the connector is constructed per
namespace and already stores it as `this.chain`.

`universalProviderAuthenticate` then bails early:

    const namespaces = new Set(chains.map(chain => chain.split(':')[0]))
    if (!siwx || namespaces.size !== 1 || !namespaces.has('eip155')) {
      return false
    }

So registering any second namespace alongside EVM — Solana, for example —
made that set `{eip155, solana}` and silently disabled one-click auth for
every wallet. `connectWalletConnect()` fell back to `provider.connect()`
followed by a separate `personal_sign` round trip on every login, which is
markedly less reliable on mobile wallets; it reproduces as "Error signing
message" on Trust Wallet.

`getCaipNetworks()` already accepts a namespace, so pass `this.chain`.
Single-namespace apps are unaffected: the set was already of size one.
Scoped in `authenticate()` rather than in the `chains` getter because
`chains` is part of the public `ChainAdapterConnector` surface — the
bitcoin, tron and ton adapters read `connector.chains[0]` — so narrowing it
deserves its own change.

Added a regression test covering both an eip155 and a non-eip155 connector
while two namespaces are registered.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: svenvoskamp

.changeset/wc-one-click-auth-namespace-scope.md

@@ -0,0 +1,7 @@
+---
+'@reown/appkit-controllers': patch
+---
+
+Fixed WalletConnect one-click auth being silently skipped whenever more than one chain namespace is registered.
+
+`WalletConnectConnector.authenticate()` passed `this.chains` — which resolves to every registered namespace rather than the connector's own — to `SIWXUtil.universalProviderAuthenticate`, which only proceeds for a single `eip155` namespace. Any app registering a second namespace alongside EVM (for example Solana) therefore lost one-click auth for every wallet and fell back to connecting first and requesting a separate `personal_sign`. The chain list is now scoped to the connector's own namespace.

packages/controllers/src/controllers/AdapterController/WalletConnectConnector.ts

@@ -56,7 +56,13 @@ export class WalletConnectConnector<Namespace extends ChainNamespace = ChainName
   }
 
   async authenticate(): Promise<boolean> {
-    const chains = this.chains.map(network => network.caipNetworkId)
+    /*
+     * Scope to this connector's own namespace. `this.chains` resolves to every registered
+     * namespace, while `SIWXUtil.universalProviderAuthenticate` only proceeds for a single
+     * `eip155` namespace — so passing the unscoped list silently disabled one-click auth for
+     * every wallet as soon as a second namespace (e.g. Solana) was registered.
+     */
+    const chains = this.getCaipNetworks(this.chain).map(network => network.caipNetworkId)
 
     return SIWXUtil.universalProviderAuthenticate({
       universalProvider: this.provider,

packages/controllers/tests/controllers/WalletConnectConnector.test.ts

@@ -0,0 +1,73 @@
+import type UniversalProvider from '@walletconnect/universal-provider'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { ChainController, SIWXUtil } from '../../exports/index.js'
+import { extendedMainnet, solanaCaipNetwork, updateChainsMap } from '../../exports/testing.js'
+import { WalletConnectConnector } from '../../src/controllers/AdapterController/WalletConnectConnector.js'
+
+const mockProvider = {
+  client: { core: { crypto: { getClientId: vi.fn().mockResolvedValue('client-id') } } },
+  session: undefined
+} as unknown as UniversalProvider
+
+describe('WalletConnectConnector', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+
+    updateChainsMap('eip155', {
+      namespace: 'eip155',
+      networkState: { requestedCaipNetworks: [extendedMainnet] }
+    })
+    updateChainsMap('solana', {
+      namespace: 'solana',
+      networkState: { requestedCaipNetworks: [solanaCaipNetwork] }
+    })
+  })
+
+  afterEach(() => {
+    ChainController.state.chains.delete('eip155')
+    ChainController.state.chains.delete('solana')
+  })
+
+  describe('authenticate', () => {
+    it('should only pass its own namespace chains when several namespaces are registered', async () => {
+      const authenticateSpy = vi
+        .spyOn(SIWXUtil, 'universalProviderAuthenticate')
+        .mockResolvedValue(true)
+
+      const connector = new WalletConnectConnector({
+        provider: mockProvider,
+        caipNetworks: [extendedMainnet, solanaCaipNetwork],
+        namespace: 'eip155'
+      })
+
+      await expect(connector.authenticate()).resolves.toBe(true)
+
+      /*
+       * `universalProviderAuthenticate` bails unless every chain shares the `eip155` namespace,
+       * so leaking the Solana network here would silently disable one-click auth.
+       */
+      expect(authenticateSpy).toHaveBeenCalledWith(
+        expect.objectContaining({ chains: ['eip155:1'] })
+      )
+    })
+
+    it('should pass its own namespace chains for a non-eip155 connector', async () => {
+      const authenticateSpy = vi
+        .spyOn(SIWXUtil, 'universalProviderAuthenticate')
+        .mockResolvedValue(false)
+
+      const connector = new WalletConnectConnector({
+        provider: mockProvider,
+        caipNetworks: [extendedMainnet, solanaCaipNetwork],
+        namespace: 'solana'
+      })
+
+      await expect(connector.authenticate()).resolves.toBe(false)
+
+      expect(authenticateSpy).toHaveBeenCalledWith(
+        expect.objectContaining({ chains: [solanaCaipNetwork.caipNetworkId] })
+      )
+    })
+  })
+})