@meshconnect/uwc-core 1.1.0 → 1.1.1-snapshot.2e0528b

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> = []
 
   constructor(
     private networks: Network[],
@@ -154,6 +160,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). */
@@ -161,7 +172,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 +192,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 +224,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.
@@ -213,6 +291,8 @@ export class ConnectionService {
   teardownLifecycle(): void {
     this.lifecycleTeardown?.()
     this.lifecycleTeardown = undefined
+    for (const teardown of this.secondaryAccountSyncTeardowns) teardown()
+    this.secondaryAccountSyncTeardowns = []
   }
 
   /**
@@ -237,13 +317,95 @@ 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(
     connector: Connector,
     network: Network,
@@ -420,14 +582,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'