@meshconnect/uwc-core 1.1.0 → 1.1.1-snapshot.7a97a0f

package/src/services/connection-service.ts

@@ -161,7 +161,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
@@ -181,6 +181,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 {
@@ -203,6 +213,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.
@@ -237,10 +304,15 @@ 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()
+      }
     )
   }
 
@@ -420,14 +492,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/version.ts

@@ -1,2 +1,2 @@
 // Generated from package.json by scripts/generate-version.mjs — do not edit.
-export const UWC_CORE_VERSION = '1.1.0'
+export const UWC_CORE_VERSION = '1.1.1'