@meshconnect/uwc-core 1.2.3-snapshot.bd9aae7 → 1.2.3-snapshot.dcfdbbf

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

@@ -863,5 +863,277 @@ 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')
+    })
   })
 })

package/src/services/connection-service.ts

@@ -26,6 +26,12 @@ export class ConnectionService {
   private activeConnector: Connector | null = null
   /** Tears down the post-connect lifecycle subscription; set while connected. */
   private lifecycleTeardown: (() => void) | undefined
+  /**
+   * Teardowns for the accounts-sync attachments of the session's SECONDARY
+   * namespaces (see `attachSecondaryAccountSync`); set while connected,
+   * cleared together with `lifecycleTeardown`.
+   */
+  private secondaryAccountSyncTeardowns: Array<() => void> = []
   /**
    * Abort handle for the CURRENT in-flight connect attempt. A re-entrant
    * connect() aborts this before starting, so a superseded attempt's URI poll
@@ -200,6 +206,11 @@ export class ConnectionService {
     // disconnect, expiry) from the live provider — telemetry only, never changes
     // connection behaviour. Torn down on disconnect.
     this.attachLifecycle(connectionMode, wallet.id, network.namespace)
+    this.attachSecondaryAccountSync(
+      connectionMode,
+      wallet.id,
+      network.namespace
+    )
   }
 
   /** Wire the active connector's lifecycle stream onto the bus (or signal absence). */
@@ -207,7 +218,7 @@ export class ConnectionService {
     connectionMode: ConnectionMode,
     walletId: string,
     namespace: Namespace,
-    initialSwitch?: { chainId: NetworkId; at: number }
+    initialSwitch?: { chainId: NetworkId; address?: string; at: number }
   ): void {
     this.teardownLifecycle()
     const connector = this.activeConnector
@@ -227,6 +238,16 @@ export class ConnectionService {
               walletId
             })
         : undefined,
+      subscribeAccounts: connector?.onAccountsChanged
+        ? listener =>
+            connector.onAccountsChanged!(listener, {
+              connectionMode,
+              namespace,
+              walletId
+            })
+        : undefined,
+      onAccountsChanged: accounts =>
+        this.handleAccountsChanged(accounts, namespace),
       getRouting: () => {
         const s = this.sessionManager.getSession()
         return {
@@ -249,6 +270,63 @@ export class ConnectionService {
     })
   }
 
+  /**
+   * Apply a REAL account-list change (from `Connector.onAccountsChanged`, via
+   * the lifecycle bridge's second stream) to the session. `namespace` is the
+   * namespace of the provider that reported the change — `activeAddress`
+   * only moves when that matches the session's currently active network; an
+   * empty list is a full, wallet-initiated disconnect.
+   */
+  private handleAccountsChanged(
+    accounts: string[],
+    namespace: Namespace
+  ): void {
+    if (accounts.length === 0) {
+      // Idempotency guard: this runs synchronously FROM INSIDE the
+      // connector's own accountsChanged dispatch — finishDisconnect() below
+      // tears down (among other things) the very subscription that is
+      // currently delivering this callback. If a wallet double-fires the
+      // empty-array disconnect signal (or one slips through before teardown
+      // takes effect), `activeConnector` is already null from the first call
+      // — skip re-clearing an already-cleared session and re-emitting
+      // disconnected/sessionChanged a second time. Scoped to THIS wallet-
+      // initiated path only; the public disconnect() below still always
+      // runs finishDisconnect() defensively, even with no active connector.
+      if (this.activeConnector === null) return
+      // The wallet ended the session on its own side, but the connector's
+      // OWN local state (e.g. EthereumWalletService's cached account/
+      // provider/uuid) is never cleared by finishDisconnect() below — it
+      // only clears core's sessionManager. Left uncleared, a later connect
+      // to a DIFFERENT wallet reads that stale cached account via
+      // checkExistingConnections() and never rebinds to the new wallet's
+      // provider/uuid, silently keeping the old wallet's address live under
+      // the new wallet's session. disconnect() is fire-and-forget and
+      // error-swallowed here: for injected connectors it's local-only
+      // cleanup (safe to call any number of times), and for protocol-based
+      // connectors that might reject on an already-closed session, there is
+      // no caller to propagate that error to anyway.
+      this.activeConnector?.disconnect?.().catch(() => {})
+      this.finishDisconnect()
+      return
+    }
+    const newAddress = accounts[0]!
+    const session = this.sessionManager.getSession()
+    const availableAddresses = session.availableAddresses.map(addr => {
+      const network = this.networks.find(n => n.id === addr.networkId)
+      return network?.namespace === namespace
+        ? { ...addr, address: newAddress }
+        : addr
+    })
+    const activeAddress =
+      session.activeNetwork?.namespace === namespace
+        ? newAddress
+        : session.activeAddress
+    this.sessionManager.updateSession({ activeAddress, availableAddresses })
+    this.eventManager.emit('sessionChanged', {
+      session: this.sessionManager.getSession()
+    })
+  }
+
   /**
    * Remove the active provider-lifecycle subscription (EIP-1193 `.on` / wallet-
    * adapter / SignClient listeners) WITHOUT disconnecting the wallet. Idempotent.
@@ -259,6 +337,8 @@ export class ConnectionService {
   teardownLifecycle(): void {
     this.lifecycleTeardown?.()
     this.lifecycleTeardown = undefined
+    for (const teardown of this.secondaryAccountSyncTeardowns) teardown()
+    this.secondaryAccountSyncTeardowns = []
   }
 
   /**
@@ -283,11 +363,93 @@ export class ConnectionService {
       session.connectionMode,
       session.activeWallet.id,
       session.activeNetwork.namespace,
-      // The reattach follows a JUST-completed switch to the now-active chain —
-      // arm echo suppression for it so the new provider's echo isn't mistaken
-      // for a wallet-initiated change (one-shot, same as bus-armed switches).
-      { chainId: session.activeNetwork.id, at: Date.now() }
+      // The reattach follows a JUST-completed switch to the now-active chain
+      // (and address) — arm echo suppression for both so the new provider's
+      // echo isn't mistaken for a wallet-initiated change (one-shot, same as
+      // bus-armed switches).
+      {
+        chainId: session.activeNetwork.id,
+        ...(session.activeAddress && { address: session.activeAddress }),
+        at: Date.now()
+      }
     )
+    // Re-derive the secondary set against the NOW-active namespace — a
+    // cross-namespace switch swaps which namespace is "secondary" (the
+    // attachLifecycle above already tore the previous set down via
+    // teardownLifecycle).
+    this.attachSecondaryAccountSync(
+      session.connectionMode,
+      session.activeWallet.id,
+      session.activeNetwork.namespace
+    )
+  }
+
+  /**
+   * Attach account-sync for every OTHER namespace the session's
+   * `availableAddresses` span. `attachLifecycle` observes only the ACTIVE
+   * network's namespace, but the cross-namespace gather seeds addresses from
+   * other namespaces' live surfaces at connect time — without their own
+   * subscription, a wallet-side account switch on such a namespace is never
+   * observed and the session serves the connect-time addresses forever (e.g.
+   * a Solana-active MetaMask session whose eip155 addresses never follow the
+   * extension's account switch).
+   *
+   * Accounts-sync ONLY, no lifecycle-telemetry stream: the active namespace
+   * stays the single source of wallet* telemetry and of the wallet-initiated
+   * disconnect signal.
+   */
+  private attachSecondaryAccountSync(
+    connectionMode: ConnectionMode,
+    walletId: string,
+    activeNamespace: Namespace
+  ): void {
+    const connector = this.activeConnector
+    if (!connector?.onAccountsChanged) return
+
+    const session = this.sessionManager.getSession()
+    const secondaryNamespaces = new Set<Namespace>()
+    for (const addr of session.availableAddresses) {
+      const namespace = this.networks.find(
+        n => n.id === addr.networkId
+      )?.namespace
+      if (namespace && namespace !== activeNamespace) {
+        secondaryNamespaces.add(namespace)
+      }
+    }
+
+    const runtime =
+      (globalThis as { UWCBridgeChildInitialized?: boolean })
+        .UWCBridgeChildInitialized === true
+        ? ('iframe' as const)
+        : ('direct' as const)
+
+    for (const namespace of secondaryNamespaces) {
+      this.secondaryAccountSyncTeardowns.push(
+        attachLifecycle({
+          eventManager: this.eventManager,
+          subscribe: undefined,
+          subscribeAccounts: listener =>
+            connector.onAccountsChanged!(listener, {
+              connectionMode,
+              namespace,
+              walletId
+            }),
+          onAccountsChanged: accounts => {
+            // An empty list from a SECONDARY namespace means that namespace's
+            // own authorization ended — NOT the session. Only the active
+            // namespace's stream may signal the full wallet-initiated
+            // disconnect (handleAccountsChanged's empty-list path).
+            if (accounts.length === 0) return
+            this.handleAccountsChanged(accounts, namespace)
+          },
+          getRouting: () => ({ connectionMode, walletId, namespace }),
+          connectionMode,
+          walletId,
+          namespace,
+          runtime
+        })
+      )
+    }
   }
 
   private async connectWithURIPoll(
@@ -486,14 +648,32 @@ export class ConnectionService {
         await this.activeConnector.disconnect()
       }
     } finally {
-      this.activeConnector = null
-      this.sessionManager.clearSession()
-      const session = this.sessionManager.getSession()
-      this.eventManager.emit('disconnected', undefined)
-      this.eventManager.emit('sessionChanged', { session })
+      this.finishDisconnect()
     }
   }
 
+  /**
+   * Clears core's own local state (session, active connector reference,
+   * lifecycle subscription) and emits the disconnect events. Does NOT itself
+   * call the connector's `disconnect()` — that happens in each CALLER,
+   * because the two callers need different semantics: the public
+   * `disconnect()` above awaits it (the caller may care whether the wallet
+   * side actually tore down); the wallet-initiated path in
+   * `handleAccountsChanged` fires it and swallows the result (the wallet
+   * already ended the session on its own side, but the connector's own
+   * LOCAL state — e.g. a cached account/uuid — still needs clearing, or a
+   * later connect to a different wallet reads it as stale and never
+   * rebinds).
+   */
+  private finishDisconnect(): void {
+    this.teardownLifecycle()
+    this.activeConnector = null
+    this.sessionManager.clearSession()
+    const session = this.sessionManager.getSession()
+    this.eventManager.emit('disconnected', undefined)
+    this.eventManager.emit('sessionChanged', { session })
+  }
+
   getConnectionURI(): string | undefined {
     if (
       this.activeConnector &&

package/src/services/network-switch-service.test.ts

@@ -234,4 +234,37 @@ describe('NetworkSwitchService', () => {
     expect(events[0].data.operation).toBe('switchNetwork')
     expect(events[0].data.chainId).toBe('eip155:137')
   })
+
+  it('includes the new address on the emitted networkSwitched event', async () => {
+    sessionManager.updateSession({
+      connectionMode: 'injected',
+      activeWallet: {
+        id: 'metamask',
+        name: 'MetaMask',
+        metadata: {
+          icon: 'test',
+          downloadUrl: 'test',
+          supportedChains: ['eip155:1', 'eip155:137']
+        },
+        extensionInjectedProvider: {
+          supportedNetworkIds: ['eip155:1', 'eip155:137']
+        }
+      } as any
+    })
+    mockConnector.switchNetwork = vi.fn().mockResolvedValue({
+      address: '0xabc',
+      availableAddresses: [{ address: '0xabc', networkId: 'eip155:137' }]
+    })
+    const switched: Array<{ network: unknown; address?: string }> = []
+    eventManager.on('networkSwitched', d => switched.push(d))
+
+    await networkSwitchService.switchNetwork('eip155:137')
+
+    expect(switched).toEqual([
+      {
+        network: expect.objectContaining({ id: 'eip155:137' }),
+        address: '0xabc'
+      }
+    ])
+  })
 })

package/src/services/network-switch-service.ts

@@ -188,7 +188,10 @@ export class NetworkSwitchService {
         })
       })
 
-      this.eventManager.emit('networkSwitched', { network })
+      this.eventManager.emit('networkSwitched', {
+        network,
+        address: result.address
+      })
       this.eventManager.emit('sessionChanged', {
         session: this.sessionManager.getSession()
       })

package/src/universal-wallet-connector.ts

@@ -325,17 +325,7 @@ export class UniversalWalletConnector {
           (error: unknown) =>
             this.eventManager.emit('walletConnectInitError', {
               error: toWalletError(error)
-            }),
-          // Relay transport dropped — capture the FACT (+ scrubbed reason if any) so a
-          // socket death during a wallet deep-link is visible, not silent (CARE-263).
-          (detail: unknown) =>
-            this.eventManager.emit(
-              'relayDisconnected',
-              detail ? { error: toWalletError(detail) } : {}
-            ),
-          // Relay transport recovered — pair with `relayDisconnected` (same
-          // sdkSessionId) to measure the dead window.
-          () => this.eventManager.emit('relayReconnected', undefined)
+            })
         )
       )
     }