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

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()
       })

package/src/universal-wallet-connector.observability.test.ts

@@ -26,10 +26,10 @@ const reattachLifecycleMock = vi.fn()
 const switchNetworkMock = vi.fn()
 const sendTransactionMock = vi.fn()
 const getWalletCapabilitiesMock = vi.fn()
-// Captures the positional args the façade passes to the WalletConnect connector
-// (config, networkRpcMap, onRelayError, onInitError) so a test can invoke the
-// detached-error sinks and assert the emitted telemetry — this is the only place
-// the sink→event wiring (and its arg order) is exercised.
+// Captures the args the façade passes to the WalletConnect connector
+// (config, networkRpcMap, telemetryObserver) so a test can invoke the relay
+// telemetry sinks and assert the emitted event — this is the only place the
+// sink→bus wiring is exercised.
 const wcConnectorCapture: { args: unknown[] } = { args: [] }
 
 const connectedSession: Session = {
@@ -187,10 +187,14 @@ describe('UniversalWalletConnector — observability wiring', () => {
       walletConnectConfig: { projectId: 'test' }
     })
 
-    // The façade passes the connector (config, networkRpcMap, onRelayError,
-    // onInitError). Grabbing arg[3] and firing it guards both the wiring and the
-    // positional arg order — a swap with onRelayError would surface the wrong event.
-    const onInitError = wcConnectorCapture.args[3] as (e: unknown) => void
+    // The façade passes the connector (config, networkRpcMap, telemetryObserver).
+    // Grabbing the observer's onInitError sink and firing it guards the wiring;
+    // the named field can't be confused with onRelayError the way a positional
+    // arg could (the reason #3350 moved to a typed options object).
+    const telemetryObserver = wcConnectorCapture.args[2] as {
+      onInitError: (e: unknown) => void
+    }
+    const onInitError = telemetryObserver.onInitError
     expect(typeof onInitError).toBe('function')
     onInitError(
       new Error(
@@ -207,6 +211,48 @@ describe('UniversalWalletConnector — observability wiring', () => {
     expect(JSON.stringify(initError)).not.toContain('0xAbC123')
   })
 
+  it('wires the relay observer sinks → each emits its own telemetry event to the observer', () => {
+    // The whole point of #3350: a single typed observer whose named sinks map
+    // 1:1 to bus events. Fire each and assert the right event lands — this is
+    // the connector→bus lambda wiring, previously only covered end-to-end.
+    const events: UWCTelemetryEvent[] = []
+    const observer: UWCObserver = { onEvent: e => events.push(e) }
+    new UniversalWalletConnector({
+      networks,
+      wallets,
+      observer,
+      walletConnectConfig: { projectId: 'test' }
+    })
+
+    const telemetryObserver = wcConnectorCapture.args[2] as {
+      onRelayError: (e: unknown) => void
+      onRelayDisconnect: () => void
+      onRelayReconnect: () => void
+    }
+
+    telemetryObserver.onRelayError(
+      new Error(
+        'WebSocket closed abnormally 0xAbC1230000000000000000000000000000000000'
+      )
+    )
+    telemetryObserver.onRelayDisconnect()
+    telemetryObserver.onRelayReconnect()
+
+    const relayError = events.find(e => e.name === 'relayError')
+    expect(relayError).toBeDefined()
+    expect(relayError!.connectionMode).toBe('walletConnect')
+    // Same egress scrubbing as every other error record.
+    expect(JSON.stringify(relayError)).not.toContain('0xAbC123')
+
+    const dropped = events.find(e => e.name === 'relayDisconnected')
+    expect(dropped).toBeDefined()
+    expect(dropped!.connectionMode).toBe('walletConnect')
+
+    const recovered = events.find(e => e.name === 'relayReconnected')
+    expect(recovered).toBeDefined()
+    expect(recovered!.connectionMode).toBe('walletConnect')
+  })
+
   it('stamps a consumer-supplied correlationId (string) as its own field', async () => {
     const events: UWCTelemetryEvent[] = []
     const uwc = new UniversalWalletConnector({

package/src/universal-wallet-connector.ts

@@ -314,18 +314,28 @@ export class UniversalWalletConnector {
         new WalletConnectConnector(
           configuredWalletConnectConfig,
           this.networkRpcMap,
-          // Surface relay-socket failures (e.g. code 3000 JWT clock skew) that are
-          // detached from the connect handoff, as a telemetry event.
-          (error: unknown) =>
-            this.eventManager.emit('relayError', {
-              error: toWalletError(error)
-            }),
-          // Surface a failed SignClient.init as its own signal — otherwise it has no
-          // dedicated telemetry and only appears as a generic connect failure.
-          (error: unknown) =>
-            this.eventManager.emit('walletConnectInitError', {
-              error: toWalletError(error)
-            })
+          {
+            // Surface relay-socket failures (e.g. code 3000 JWT clock skew) that are
+            // detached from the connect handoff, as a telemetry event.
+            onRelayError: (error: unknown) =>
+              this.eventManager.emit('relayError', {
+                error: toWalletError(error)
+              }),
+            // Surface a failed SignClient.init as its own signal — otherwise it has no
+            // dedicated telemetry and only appears as a generic connect failure.
+            onInitError: (error: unknown) =>
+              this.eventManager.emit('walletConnectInitError', {
+                error: toWalletError(error)
+              }),
+            // Relay transport dropped (once per outage) — the FACT is the signal; the
+            // relayer carries no payload, so emit the bare event (CARE-263).
+            onRelayDisconnect: () =>
+              this.eventManager.emit('relayDisconnected', undefined),
+            // Relay transport recovered — pair with `relayDisconnected` (same
+            // sdkSessionId) to measure the dead window.
+            onRelayReconnect: () =>
+              this.eventManager.emit('relayReconnected', undefined)
+          }
         )
       )
     }

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.2.3'
+export const UWC_CORE_VERSION = '1.3.0'