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

package/src/services/connection-service.ts

@@ -26,12 +26,6 @@ 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
@@ -206,11 +200,6 @@ 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). */
@@ -218,7 +207,7 @@ export class ConnectionService {
     connectionMode: ConnectionMode,
     walletId: string,
     namespace: Namespace,
-    initialSwitch?: { chainId: NetworkId; address?: string; at: number }
+    initialSwitch?: { chainId: NetworkId; at: number }
   ): void {
     this.teardownLifecycle()
     const connector = this.activeConnector
@@ -238,16 +227,6 @@ 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 {
@@ -270,63 +249,6 @@ 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.
@@ -337,8 +259,6 @@ export class ConnectionService {
   teardownLifecycle(): void {
     this.lifecycleTeardown?.()
     this.lifecycleTeardown = undefined
-    for (const teardown of this.secondaryAccountSyncTeardowns) teardown()
-    this.secondaryAccountSyncTeardowns = []
   }
 
   /**
@@ -363,93 +283,11 @@ export class ConnectionService {
       session.connectionMode,
       session.activeWallet.id,
       session.activeNetwork.namespace,
-      // 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()
-      }
+      // 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() }
     )
-    // 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(
@@ -648,32 +486,14 @@ export class ConnectionService {
         await this.activeConnector.disconnect()
       }
     } finally {
-      this.finishDisconnect()
+      this.activeConnector = null
+      this.sessionManager.clearSession()
+      const session = this.sessionManager.getSession()
+      this.eventManager.emit('disconnected', undefined)
+      this.eventManager.emit('sessionChanged', { session })
     }
   }
 
-  /**
-   * 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,37 +234,4 @@ 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,10 +188,7 @@ export class NetworkSwitchService {
         })
       })
 
-      this.eventManager.emit('networkSwitched', {
-        network,
-        address: result.address
-      })
+      this.eventManager.emit('networkSwitched', { network })
       this.eventManager.emit('sessionChanged', {
         session: this.sessionManager.getSession()
       })