@meshconnect/uwc-core 1.4.0 → 1.4.1-snapshot.1a75c56

package/src/services/connection-service.test.ts

@@ -1,5 +1,9 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-import { ConnectionService } from './connection-service'
+import {
+  ConnectionService,
+  SIBLING_REFRESH_MAX_ATTEMPTS,
+  SIBLING_REFRESH_DELAY_MS
+} from './connection-service'
 import { SessionManager } from '../managers/session-manager'
 import { EventManager } from '../managers/event-manager'
 import type {
@@ -863,5 +867,750 @@ describe('ConnectionService', () => {
       // No connection → no lifecycle evaluation, so no "unavailable" noise.
       expect(unavail).toHaveLength(0)
     })
+
+    it('a real accountsChanged from the connector updates activeAddress and emits sessionChanged', async () => {
+      let emitAccounts!: (accounts: string[]) => void
+      mockConnector.onAccountsChanged = (l: (accounts: string[]) => void) => {
+        emitAccounts = l
+        return () => {}
+      }
+      const sessions: Array<{ activeAddress: string | null }> = []
+      eventManager.on('sessionChanged', d =>
+        sessions.push({ activeAddress: d.session.activeAddress })
+      )
+
+      await connectionService.connect('injected', 'metamask', 'eip155:1')
+      emitAccounts(['0xNEW'])
+
+      expect(sessionManager.getSession().activeAddress).toBe('0xNEW')
+      expect(sessions[sessions.length - 1]?.activeAddress).toBe('0xNEW')
+    })
+
+    it('updates the matching availableAddresses entries for the changed namespace', async () => {
+      let emitAccounts!: (accounts: string[]) => void
+      mockConnector.onAccountsChanged = (l: (accounts: string[]) => void) => {
+        emitAccounts = l
+        return () => {}
+      }
+
+      await connectionService.connect('injected', 'metamask', 'eip155:1')
+      emitAccounts(['0xNEW'])
+
+      expect(sessionManager.getSession().availableAddresses).toEqual([
+        { address: '0xNEW', networkId: 'eip155:1' }
+      ])
+    })
+
+    it('an empty accounts list triggers a full disconnect AND calls connector.disconnect for local-state cleanup', async () => {
+      // The wallet already ended the session on its own side, but the
+      // connector's own LOCAL state (e.g. EthereumWalletService's cached
+      // account/uuid) still needs clearing — otherwise a later connect to a
+      // DIFFERENT wallet reads the stale cached account via
+      // checkExistingConnections() and never rebinds to the new wallet's
+      // provider/uuid. disconnect() must still be called here; it's a
+      // fire-and-forget, error-swallowed call (see the next test) so a
+      // protocol-based connector that rejects on an already-closed session
+      // can't break this path.
+      let emitAccounts!: (accounts: string[]) => void
+      mockConnector.onAccountsChanged = (l: (accounts: string[]) => void) => {
+        emitAccounts = l
+        return () => {}
+      }
+      const disconnectSpy = vi.fn().mockResolvedValue(undefined)
+      mockConnector.disconnect = disconnectSpy
+
+      await connectionService.connect('injected', 'metamask', 'eip155:1')
+      emitAccounts([])
+
+      expect(sessionManager.getSession().activeAddress).toBeNull()
+      expect(sessionManager.getSession().connectionMode).toBeNull()
+      expect(disconnectSpy).toHaveBeenCalledTimes(1)
+    })
+
+    it('does not let a rejecting connector.disconnect() break the wallet-initiated disconnect path', async () => {
+      let emitAccounts!: (accounts: string[]) => void
+      mockConnector.onAccountsChanged = (l: (accounts: string[]) => void) => {
+        emitAccounts = l
+        return () => {}
+      }
+      mockConnector.disconnect = vi
+        .fn()
+        .mockRejectedValue(new Error('already closed'))
+
+      await connectionService.connect('injected', 'metamask', 'eip155:1')
+
+      expect(() => emitAccounts([])).not.toThrow()
+      expect(sessionManager.getSession().activeAddress).toBeNull()
+      // Let the fire-and-forget rejection settle so it doesn't surface as an
+      // unhandled rejection in a later test.
+      await Promise.resolve()
+      await Promise.resolve()
+    })
+
+    it('a wallet that double-fires an empty accountsChanged does not double-emit disconnected/sessionChanged', async () => {
+      // handleAccountsChanged([]) -> finishDisconnect() runs synchronously
+      // FROM INSIDE the connector's own accountsChanged dispatch (the
+      // teardown it triggers removes that very listener re-entrantly). If a
+      // wallet emits the empty-array disconnect signal twice in quick
+      // succession — or the second emission slips through before teardown
+      // takes effect — finishDisconnect must be a no-op the second time
+      // rather than clearing an already-cleared session and re-emitting.
+      let emitAccounts!: (accounts: string[]) => void
+      mockConnector.onAccountsChanged = (l: (accounts: string[]) => void) => {
+        emitAccounts = l
+        return () => {}
+      }
+      mockConnector.disconnect = vi.fn().mockResolvedValue(undefined)
+      const disconnectedEvents: unknown[] = []
+      const sessionChangedEvents: unknown[] = []
+      eventManager.on('disconnected', d => disconnectedEvents.push(d))
+      eventManager.on('sessionChanged', d => sessionChangedEvents.push(d))
+
+      await connectionService.connect('injected', 'metamask', 'eip155:1')
+      sessionChangedEvents.length = 0 // drop the connect's own sessionChanged
+
+      emitAccounts([])
+      emitAccounts([]) // the wallet (or a race) delivers the same signal again
+
+      expect(disconnectedEvents).toHaveLength(1)
+      expect(sessionChangedEvents).toHaveLength(1)
+      expect(mockConnector.disconnect).toHaveBeenCalledTimes(1)
+    })
+
+    it('reattachLifecycle() seeds address-echo suppression with the just-active address', async () => {
+      const accountSubscribers: Array<(accounts: string[]) => void> = []
+      mockConnector.onAccountsChanged = (l: (accounts: string[]) => void) => {
+        accountSubscribers.push(l)
+        return () => {}
+      }
+      const sessions: unknown[] = []
+      eventManager.on('sessionChanged', d => sessions.push(d))
+
+      await connectionService.connect('injected', 'metamask', 'eip155:1')
+      sessions.length = 0
+      connectionService.reattachLifecycle()
+
+      // The reattached provider echoes the session's own current address →
+      // suppressed, no redundant sessionChanged.
+      accountSubscribers[1]!(['0x1234'])
+      expect(sessions).toHaveLength(0)
+
+      // A later, genuinely different address is a real change.
+      accountSubscribers[1]!(['0xDIFFERENT'])
+      expect(sessions).toHaveLength(1)
+    })
+
+    it("does not move activeAddress when the changed namespace no longer matches the session's active namespace (stale subscription after a cross-namespace switch)", async () => {
+      let emitAccounts!: (accounts: string[]) => void
+      mockConnector.onAccountsChanged = (l: (accounts: string[]) => void) => {
+        emitAccounts = l
+        return () => {}
+      }
+
+      await connectionService.connect('injected', 'metamask', 'eip155:1')
+      const connectTimeAddress = sessionManager.getSession().activeAddress
+
+      // Simulate the session's active network having already moved to a
+      // different namespace (e.g. mid-cross-namespace-switch) WITHOUT this
+      // stream having been reattached yet — it's still the eip155 one from
+      // connect time.
+      sessionManager.updateSession({
+        activeNetwork: {
+          ...sessionManager.getSession().activeNetwork,
+          namespace: 'solana'
+        } as any
+      })
+
+      emitAccounts(['0xNEW'])
+
+      // activeAddress belongs to the now-active (solana) namespace and must
+      // not be clobbered by a stale eip155 subscription's account change.
+      expect(sessionManager.getSession().activeAddress).toBe(connectTimeAddress)
+      // availableAddresses for the eip155 entry IS still updated — the address
+      // change is real, just not the currently-active one.
+      expect(sessionManager.getSession().availableAddresses).toEqual([
+        { address: '0xNEW', networkId: 'eip155:1' }
+      ])
+    })
+  })
+
+  describe('secondary-namespace account sync', () => {
+    // A multi-namespace wallet (e.g. MetaMask with Solana support) connected
+    // on a SOLANA-active session: the cross-namespace gather seeds eip155
+    // addresses into availableAddresses at connect time, but the lifecycle
+    // attach used to observe only the ACTIVE namespace — an eip155 account
+    // switch in the extension was never observed and the session served the
+    // connect-time eip155 addresses forever.
+    let accountSubs: Map<string, (accounts: string[]) => void>
+    let teardownsByNamespace: Map<string, number>
+
+    beforeEach(() => {
+      networks.push({
+        id: 'solana:mainnet',
+        internalId: 101,
+        namespace: 'solana',
+        name: 'Solana',
+        logoUrl: '',
+        nativeCurrency: { name: 'SOL', symbol: 'SOL', decimals: 9 },
+        networkType: 'solana'
+      } as never)
+      wallets[0]!.extensionInjectedProvider = {
+        supportedNetworkIds: ['solana:mainnet', 'eip155:1']
+      } as never
+      mockConnector.connect = vi.fn().mockResolvedValue({
+        networkId: 'solana:mainnet',
+        address: 'SoLAddr111',
+        availableAddresses: [
+          { address: 'SoLAddr111', networkId: 'solana:mainnet' },
+          { address: '0x1234', networkId: 'eip155:1' }
+        ]
+      })
+      accountSubs = new Map()
+      teardownsByNamespace = new Map()
+      mockConnector.onAccountsChanged = ((
+        listener: (accounts: string[]) => void,
+        context: { namespace: string }
+      ) => {
+        accountSubs.set(context.namespace, listener)
+        return () => {
+          teardownsByNamespace.set(
+            context.namespace,
+            (teardownsByNamespace.get(context.namespace) ?? 0) + 1
+          )
+        }
+      }) as never
+    })
+
+    it('attaches an accounts-sync subscription for every namespace present in availableAddresses, not only the active one', async () => {
+      await connectionService.connect('injected', 'metamask', 'solana:mainnet')
+
+      expect([...accountSubs.keys()].sort()).toEqual(['eip155', 'solana'])
+    })
+
+    it("a secondary namespace's accountsChanged updates its availableAddresses entries without touching activeAddress", async () => {
+      await connectionService.connect('injected', 'metamask', 'solana:mainnet')
+
+      accountSubs.get('eip155')!(['0xSWITCHED'])
+
+      const session = sessionManager.getSession()
+      expect(session.activeAddress).toBe('SoLAddr111')
+      expect(session.availableAddresses).toEqual([
+        { address: 'SoLAddr111', networkId: 'solana:mainnet' },
+        { address: '0xSWITCHED', networkId: 'eip155:1' }
+      ])
+    })
+
+    it('an empty accounts list from a SECONDARY namespace does not disconnect the session', async () => {
+      // Only the ACTIVE namespace's stream may signal the full
+      // wallet-initiated disconnect — a secondary namespace reporting []
+      // means that namespace's own authorization ended, not the session.
+      const disconnectSpy = vi.fn().mockResolvedValue(undefined)
+      mockConnector.disconnect = disconnectSpy
+
+      await connectionService.connect('injected', 'metamask', 'solana:mainnet')
+      accountSubs.get('eip155')!([])
+
+      const session = sessionManager.getSession()
+      expect(session.connectionMode).toBe('injected')
+      expect(session.activeAddress).toBe('SoLAddr111')
+      expect(disconnectSpy).not.toHaveBeenCalled()
+    })
+
+    it('disconnect() tears down the secondary subscriptions too', async () => {
+      await connectionService.connect('injected', 'metamask', 'solana:mainnet')
+
+      await connectionService.disconnect()
+
+      expect(teardownsByNamespace.get('eip155')).toBe(1)
+      expect(teardownsByNamespace.get('solana')).toBe(1)
+    })
+
+    it('reattachLifecycle() re-derives the secondary set for the CURRENT session without stacking duplicates', async () => {
+      await connectionService.connect('injected', 'metamask', 'solana:mainnet')
+
+      connectionService.reattachLifecycle()
+
+      // Old eip155 secondary attachment released, exactly one fresh one live.
+      expect(teardownsByNamespace.get('eip155')).toBe(1)
+      accountSubs.get('eip155')!(['0xAFTER'])
+      expect(
+        sessionManager
+          .getSession()
+          .availableAddresses.find(a => a.networkId === 'eip155:1')?.address
+      ).toBe('0xAFTER')
+    })
+  })
+
+  describe('cross-namespace account refresh on switch', () => {
+    // Multi-namespace injected wallets (MetaMask/Trust/Phantom) derive every
+    // namespace's address from ONE underlying account. The wallet fires
+    // accountsChanged for a SINGLE namespace on a switch; the sibling
+    // namespaces' addresses change too but emit no event of their own, so
+    // `refreshSiblingNamespaces` re-reads each connected sibling's LIVE
+    // account and folds any real change into the session. Session is seeded
+    // SOLANA-active (the real-bug shape: an eip155 switch must still move the
+    // active solana address).
+    let accountSubs: Map<string, (accounts: string[]) => void>
+
+    beforeEach(() => {
+      networks.push({
+        id: 'solana:mainnet',
+        internalId: 101,
+        namespace: 'solana',
+        name: 'Solana',
+        logoUrl: '',
+        nativeCurrency: { name: 'SOL', symbol: 'SOL', decimals: 9 },
+        networkType: 'solana'
+      } as never)
+      wallets[0]!.extensionInjectedProvider = {
+        supportedNetworkIds: ['solana:mainnet', 'eip155:1']
+      } as never
+      mockConnector.connect = vi.fn().mockResolvedValue({
+        networkId: 'solana:mainnet',
+        address: 'SoLAddr111',
+        availableAddresses: [
+          { address: 'SoLAddr111', networkId: 'solana:mainnet' },
+          { address: '0x1234', networkId: 'eip155:1' }
+        ]
+      })
+      accountSubs = new Map()
+      mockConnector.onAccountsChanged = ((
+        listener: (accounts: string[]) => void,
+        context: { namespace: string }
+      ) => {
+        accountSubs.set(context.namespace, listener)
+        return () => {}
+      }) as never
+    })
+
+    it('a Solana-active session follows an eip155 switch: the solana sibling is refreshed and activeAddress moves with it', async () => {
+      const liveAccount = vi.fn(async (ns: string) =>
+        ns === 'solana' ? 'SoLAddr_NEW' : null
+      )
+      ;(mockConnector as any).getLiveAccount = liveAccount
+
+      const sessions: unknown[] = []
+      eventManager.on('sessionChanged', d => sessions.push(d))
+
+      await connectionService.connect('injected', 'metamask', 'solana:mainnet')
+      sessions.length = 0 // drop the connect's own sessionChanged
+
+      accountSubs.get('eip155')!(['0xSWITCHED'])
+
+      await vi.waitFor(() => {
+        expect(
+          sessionManager
+            .getSession()
+            .availableAddresses.find(a => a.networkId === 'solana:mainnet')
+            ?.address
+        ).toBe('SoLAddr_NEW')
+      })
+
+      const session = sessionManager.getSession()
+      expect(session.activeAddress).toBe('SoLAddr_NEW')
+      expect(session.availableAddresses).toEqual([
+        { address: 'SoLAddr_NEW', networkId: 'solana:mainnet' },
+        { address: '0xSWITCHED', networkId: 'eip155:1' }
+      ])
+      expect(sessions.length).toBeGreaterThan(0)
+    })
+
+    it('polls a lagging sibling until its live address differs from the stored one', async () => {
+      vi.useFakeTimers()
+      try {
+        let call = 0
+        const liveAccount = vi.fn(async (ns: string) => {
+          if (ns !== 'solana') return null
+          call++
+          // First read still reflects the OLD (stored) address — the wallet
+          // hasn't finished re-deriving the sibling yet.
+          return call === 1 ? 'SoLAddr111' : 'SoLAddr_NEW'
+        })
+        ;(mockConnector as any).getLiveAccount = liveAccount
+
+        await connectionService.connect(
+          'injected',
+          'metamask',
+          'solana:mainnet'
+        )
+
+        accountSubs.get('eip155')!(['0xSWITCHED'])
+
+        await vi.advanceTimersByTimeAsync(SIBLING_REFRESH_DELAY_MS)
+
+        const session = sessionManager.getSession()
+        expect(
+          session.availableAddresses.find(a => a.networkId === 'solana:mainnet')
+            ?.address
+        ).toBe('SoLAddr_NEW')
+        expect(session.activeAddress).toBe('SoLAddr_NEW')
+      } finally {
+        vi.useRealTimers()
+      }
+    })
+
+    it('gives up after the poll cap when the sibling never changes, without an extra update or emit', async () => {
+      vi.useFakeTimers()
+      try {
+        const liveAccount = vi.fn(async (ns: string) =>
+          ns === 'solana' ? 'SoLAddr111' : null
+        )
+        ;(mockConnector as any).getLiveAccount = liveAccount
+
+        const sessions: unknown[] = []
+        eventManager.on('sessionChanged', d => sessions.push(d))
+
+        await connectionService.connect(
+          'injected',
+          'metamask',
+          'solana:mainnet'
+        )
+        sessions.length = 0 // drop the connect's own sessionChanged
+
+        accountSubs.get('eip155')!(['0xSWITCHED'])
+        // The eip155 switch's own sessionChanged fires synchronously above.
+        expect(sessions.length).toBe(1)
+
+        await vi.advanceTimersByTimeAsync(
+          SIBLING_REFRESH_MAX_ATTEMPTS * SIBLING_REFRESH_DELAY_MS
+        )
+
+        const session = sessionManager.getSession()
+        expect(
+          session.availableAddresses.find(a => a.networkId === 'solana:mainnet')
+            ?.address
+        ).toBe('SoLAddr111')
+        expect(session.activeAddress).toBe('SoLAddr111')
+        // No additional sessionChanged beyond the firing namespace's own one.
+        expect(sessions.length).toBe(1)
+      } finally {
+        vi.useRealTimers()
+      }
+    })
+
+    it('an empty accounts list (disconnect) does not trigger a sibling refresh', async () => {
+      const liveAccount = vi.fn(async () => 'SoLAddr_NEW')
+      ;(mockConnector as any).getLiveAccount = liveAccount
+      mockConnector.disconnect = vi.fn().mockResolvedValue(undefined)
+
+      await connectionService.connect('injected', 'metamask', 'solana:mainnet')
+
+      accountSubs.get('solana')!([]) // active namespace's own disconnect signal
+
+      expect(liveAccount).not.toHaveBeenCalled()
+      const session = sessionManager.getSession()
+      expect(session.activeAddress).toBeNull()
+      expect(session.connectionMode).toBeNull()
+    })
+
+    it('cancels an in-flight poll when a newer switch supersedes it — the later switch wins', async () => {
+      vi.useFakeTimers()
+      try {
+        // Keyed by CALL ORDER, not by a single shared "current live value"
+        // variable — a shared variable would let the superseded refresh's
+        // later read silently converge with whatever the second refresh just
+        // wrote, passing even with the generation guard deleted. Instead:
+        //   call #1 = refresh #1 (superseded), attempt 0 → equals the stored
+        //     address, so refresh #1 does NOT resolve yet and keeps polling.
+        //   call #2 = refresh #2 (superseding), attempt 0 → differs from the
+        //     stored address, so refresh #2 resolves immediately and writes
+        //     the correct value.
+        //   call #3 = refresh #1, attempt 1 — reached ONLY if refresh #1 is
+        //     allowed to keep going after being superseded (i.e. the
+        //     generation guard is missing). Returns a THIRD address that is
+        //     neither the original stored value nor refresh #2's correct
+        //     value, so if refresh #1 is ever allowed to write here, it
+        //     visibly clobbers the correct value with this stale one.
+        let solanaCallCount = 0
+        const liveAccount = vi.fn(async (ns: string) => {
+          if (ns !== 'solana') return null
+          solanaCallCount++
+          if (solanaCallCount === 1) return 'SoLAddr111'
+          if (solanaCallCount === 2) return 'SoLAddr_FROM_SECOND'
+          return 'SoLAddr_STALE_FROM_FIRST'
+        })
+        ;(mockConnector as any).getLiveAccount = liveAccount
+
+        await connectionService.connect(
+          'injected',
+          'metamask',
+          'solana:mainnet'
+        )
+
+        accountSubs.get('eip155')!(['0xSWITCHED1'])
+        // Let the first refresh's attempt-0 read (call #1) resolve and enter
+        // its poll wait.
+        await vi.advanceTimersByTimeAsync(0)
+
+        // A newer switch fires before the first refresh's next attempt — it
+        // supersedes the generation token. Its own attempt-0 read (call #2)
+        // resolves synchronously below, since the stored address hasn't
+        // moved yet.
+        accountSubs.get('eip155')!(['0xSWITCHED2'])
+
+        // Drain everything: the first refresh's remaining attempts must bail
+        // out on the generation check rather than issuing call #3 and writing
+        // its stale value over the second refresh's correct one.
+        await vi.advanceTimersByTimeAsync(
+          SIBLING_REFRESH_MAX_ATTEMPTS * SIBLING_REFRESH_DELAY_MS
+        )
+
+        const session = sessionManager.getSession()
+        expect(
+          session.availableAddresses.find(a => a.networkId === 'solana:mainnet')
+            ?.address
+        ).toBe('SoLAddr_FROM_SECOND')
+        expect(session.activeAddress).toBe('SoLAddr_FROM_SECOND')
+        // Never the superseded refresh's later, stale read (call #3) — this
+        // is the write the generation guard exists to prevent.
+        expect(session.availableAddresses.map(a => a.address)).not.toContain(
+          'SoLAddr_STALE_FROM_FIRST'
+        )
+      } finally {
+        vi.useRealTimers()
+      }
+    })
+
+    it('is a no-op (no throw, no sibling change) when the connector has no getLiveAccount', async () => {
+      // Backward compat: connectors that predate `getLiveAccount` (Task A)
+      // must not break the switch path.
+      expect((mockConnector as any).getLiveAccount).toBeUndefined()
+
+      await connectionService.connect('injected', 'metamask', 'solana:mainnet')
+
+      expect(() => accountSubs.get('eip155')!(['0xSWITCHED'])).not.toThrow()
+
+      const session = sessionManager.getSession()
+      expect(
+        session.availableAddresses.find(a => a.networkId === 'solana:mainnet')
+          ?.address
+      ).toBe('SoLAddr111')
+    })
+
+    it('treats an eip155 sibling address as unchanged when it differs from stored only by case', async () => {
+      vi.useFakeTimers()
+      try {
+        // Changed namespace is SOLANA here; eip155 is the sibling under test.
+        const liveAccount = vi.fn(async (ns: string) =>
+          ns === 'eip155' ? '0X1234' : null
+        )
+        ;(mockConnector as any).getLiveAccount = liveAccount
+
+        await connectionService.connect(
+          'injected',
+          'metamask',
+          'solana:mainnet'
+        )
+
+        accountSubs.get('solana')!(['SoLAddr_NEW'])
+
+        await vi.advanceTimersByTimeAsync(
+          SIBLING_REFRESH_MAX_ATTEMPTS * SIBLING_REFRESH_DELAY_MS
+        )
+
+        const session = sessionManager.getSession()
+        expect(
+          session.availableAddresses.find(a => a.networkId === 'eip155:1')
+            ?.address
+        ).toBe('0x1234')
+      } finally {
+        vi.useRealTimers()
+      }
+    })
+  })
+
+  describe('Solana account-change event + sibling-poll coexistence (Task 3.3)', () => {
+    // 3.1/3.2 wire a REAL solana `onAccountsChanged` into core — active-
+    // namespace path via `attachLifecycle`, secondary-namespace path via
+    // `attachSecondaryAccountSync`. Separately, `refreshSiblingNamespaces`
+    // polls every OTHER connected namespace's live account after a sibling's
+    // switch. These tests confirm the two mechanisms coexist for a solana
+    // session: no double `sessionChanged` emit, no re-entrant loop, no stale
+    // clobber of a fresher value, and an empty solana event on a SECONDARY
+    // namespace never ends the session.
+    let accountSubs: Map<string, (accounts: string[]) => void>
+
+    beforeEach(() => {
+      networks.push({
+        id: 'solana:mainnet',
+        internalId: 101,
+        namespace: 'solana',
+        name: 'Solana',
+        logoUrl: '',
+        nativeCurrency: { name: 'SOL', symbol: 'SOL', decimals: 9 },
+        networkType: 'solana'
+      } as never)
+      wallets[0]!.extensionInjectedProvider = {
+        supportedNetworkIds: ['solana:mainnet', 'eip155:1']
+      } as never
+      accountSubs = new Map()
+      mockConnector.onAccountsChanged = ((
+        listener: (accounts: string[]) => void,
+        context: { namespace: string }
+      ) => {
+        accountSubs.set(context.namespace, listener)
+        return () => {}
+      }) as never
+    })
+
+    it('a solana accountsChanged on a SOLANA-active session updates the address + activeAddress with exactly ONE sessionChanged (no double-emit)', async () => {
+      mockConnector.connect = vi.fn().mockResolvedValue({
+        networkId: 'solana:mainnet',
+        address: 'SoLAddr111',
+        availableAddresses: [
+          { address: 'SoLAddr111', networkId: 'solana:mainnet' },
+          { address: '0x1234', networkId: 'eip155:1' }
+        ]
+      })
+      // No getLiveAccount on this connector: isolates the direct-event path
+      // from the sibling-poll path for this assertion.
+      expect((mockConnector as any).getLiveAccount).toBeUndefined()
+
+      await connectionService.connect('injected', 'metamask', 'solana:mainnet')
+
+      const sessions: unknown[] = []
+      eventManager.on('sessionChanged', d => sessions.push(d))
+
+      accountSubs.get('solana')!(['SoLAddr_NEW'])
+
+      const session = sessionManager.getSession()
+      expect(session.activeAddress).toBe('SoLAddr_NEW')
+      expect(session.availableAddresses).toEqual([
+        { address: 'SoLAddr_NEW', networkId: 'solana:mainnet' },
+        { address: '0x1234', networkId: 'eip155:1' }
+      ])
+      expect(sessions.length).toBe(1)
+    })
+
+    it('a solana accountsChanged on an EIP155-active session updates only the solana sibling entry, leaves activeAddress alone, and does not end the session', async () => {
+      mockConnector.connect = vi.fn().mockResolvedValue({
+        networkId: 'eip155:1',
+        address: '0x1234',
+        availableAddresses: [
+          { address: 'SoLAddr111', networkId: 'solana:mainnet' },
+          { address: '0x1234', networkId: 'eip155:1' }
+        ]
+      })
+
+      await connectionService.connect('injected', 'metamask', 'eip155:1')
+
+      accountSubs.get('solana')!(['SoLAddr_NEW'])
+
+      const session = sessionManager.getSession()
+      expect(session.connectionMode).toBe('injected')
+      expect(session.activeAddress).toBe('0x1234')
+      expect(session.availableAddresses).toEqual([
+        { address: 'SoLAddr_NEW', networkId: 'solana:mainnet' },
+        { address: '0x1234', networkId: 'eip155:1' }
+      ])
+    })
+
+    it('an empty solana accountsChanged on the SECONDARY (non-active) namespace is a no-op — it does not end the session', async () => {
+      const disconnectSpy = vi.fn().mockResolvedValue(undefined)
+      mockConnector.disconnect = disconnectSpy
+      mockConnector.connect = vi.fn().mockResolvedValue({
+        networkId: 'eip155:1',
+        address: '0x1234',
+        availableAddresses: [
+          { address: 'SoLAddr111', networkId: 'solana:mainnet' },
+          { address: '0x1234', networkId: 'eip155:1' }
+        ]
+      })
+
+      await connectionService.connect('injected', 'metamask', 'eip155:1')
+
+      accountSubs.get('solana')!([])
+
+      const session = sessionManager.getSession()
+      expect(session.connectionMode).toBe('injected')
+      expect(session.activeAddress).toBe('0x1234')
+      expect(session.availableAddresses).toEqual([
+        { address: 'SoLAddr111', networkId: 'solana:mainnet' },
+        { address: '0x1234', networkId: 'eip155:1' }
+      ])
+      expect(disconnectSpy).not.toHaveBeenCalled()
+    })
+
+    it('a direct solana event and an eip155-triggered sibling poll converge on the same address without a stale clobber (generation guard)', async () => {
+      vi.useFakeTimers()
+      try {
+        mockConnector.connect = vi.fn().mockResolvedValue({
+          networkId: 'solana:mainnet',
+          address: 'SoLAddr111',
+          availableAddresses: [
+            { address: 'SoLAddr111', networkId: 'solana:mainnet' },
+            { address: '0x1234', networkId: 'eip155:1' }
+          ]
+        })
+        let solanaLiveCalls = 0
+        const liveAccount = vi.fn(async (ns: string) => {
+          if (ns === 'solana') {
+            solanaLiveCalls++
+            // First read still reflects the OLD (stored) address — unchanged,
+            // so the poll keeps going. A SECOND read is reached only if the
+            // superseded refresh is wrongly allowed to continue; it returns a
+            // value that is neither the original nor the direct event's
+            // value, so any write from it is a visible clobber.
+            return solanaLiveCalls === 1
+              ? 'SoLAddr111'
+              : 'SoLAddr_STALE_FROM_POLL'
+          }
+          // eip155 sibling (queried by the solana-event-triggered refresh):
+          // never resolves — the direct event's own change already landed
+          // through the non-polling path.
+          return null
+        })
+        ;(mockConnector as any).getLiveAccount = liveAccount
+
+        const sessions: unknown[] = []
+        eventManager.on('sessionChanged', d => sessions.push(d))
+
+        await connectionService.connect(
+          'injected',
+          'metamask',
+          'solana:mainnet'
+        )
+        sessions.length = 0 // drop the connect's own sessionChanged
+
+        // eip155 fires first: updates its own entry and kicks off a sibling
+        // poll of solana (generation N).
+        accountSubs.get('eip155')!(['0xSWITCHED'])
+        await vi.advanceTimersByTimeAsync(0) // let attempt-0's read land (unchanged, keeps polling)
+
+        // A REAL solana accounts-change event lands next (the 3.1/3.2 direct
+        // path) carrying the same new address the poll is chasing. It writes
+        // directly and starts its OWN sibling refresh (generation N+1),
+        // superseding the still-polling eip155-triggered one.
+        accountSubs.get('solana')!(['SoLAddr_NEW'])
+
+        // Drain both: the superseded refresh must bail on the generation
+        // check instead of issuing a second solana read and clobbering.
+        await vi.advanceTimersByTimeAsync(
+          SIBLING_REFRESH_MAX_ATTEMPTS * SIBLING_REFRESH_DELAY_MS
+        )
+
+        const session = sessionManager.getSession()
+        expect(
+          session.availableAddresses.find(a => a.networkId === 'solana:mainnet')
+            ?.address
+        ).toBe('SoLAddr_NEW')
+        expect(session.activeAddress).toBe('SoLAddr_NEW')
+        expect(
+          session.availableAddresses.find(a => a.networkId === 'eip155:1')
+            ?.address
+        ).toBe('0xSWITCHED')
+        expect(session.availableAddresses.map(a => a.address)).not.toContain(
+          'SoLAddr_STALE_FROM_POLL'
+        )
+        // The superseded refresh never got a second read in.
+        expect(solanaLiveCalls).toBe(1)
+        // Exactly two emits: the eip155 event's own, and the solana event's
+        // own. Neither sibling-refresh resolves a sibling, so neither adds an
+        // extra emit — confirming no double-emit / no loop.
+        expect(sessions.length).toBe(2)
+      } finally {
+        vi.useRealTimers()
+      }
+    })
   })
 })