@meshconnect/uwc-core 1.3.0 → 1.4.0-snapshot.103d25f

package/src/services/connection-service.ts

@@ -139,7 +139,8 @@ export class ConnectionService {
                 network,
                 provider,
                 connectionMode,
-                signal
+                signal,
+                wallet.name
               ),
               signal
             )
@@ -189,7 +190,11 @@ export class ConnectionService {
       availableNetworks: this.networks.filter(n =>
         provider.supportedNetworkIds.includes(n.id)
       ),
-      availableAddresses: filteredAvailableAddresses
+      availableAddresses: filteredAvailableAddresses,
+      // Connection provenance for observability — set definitively on every
+      // connect so a fresh pairing clears any prior reused flag (MFS-642). Rides
+      // `connected` + every later operation handoff via sessionHandoffContext.
+      reused: result.reused === true
     })
 
     const session = this.sessionManager.getSession()
@@ -295,9 +300,17 @@ export class ConnectionService {
     network: Network,
     provider: SupportedProvider,
     connectionMode: ConnectionMode,
-    signal?: AbortSignal
+    signal?: AbortSignal,
+    // Passed to the connector as ConnectOptions.walletName so the WalletConnect
+    // connector can confirm a reused session belongs to the selected wallet
+    // (MFS-642). Ignored by connectors without session reuse.
+    walletName?: string
   ): Promise<ConnectorResult> {
-    const connectPromise = connector.connect(network, provider)
+    const connectPromise = connector.connect(
+      network,
+      provider,
+      walletName ? { walletName } : undefined
+    )
 
     let pollingStopped = false
     let emittedUri: string | undefined

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

@@ -145,7 +145,8 @@ export class NetworkSwitchService {
           walletId: currentWallet.id,
           namespace: network.namespace,
           chainId: network.id,
-          targetAlreadyActive
+          targetAlreadyActive,
+          reused: session.reused
         },
         async () => {
           if (

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

@@ -14,7 +14,8 @@ const mockInjectedConnector = {
 
 const mockWalletConnectConnector = {
   getAvailableWallets: vi.fn().mockResolvedValue([]),
-  signSolanaTransactionBytes: vi.fn()
+  signSolanaTransactionBytes: vi.fn(),
+  beginPairing: vi.fn()
 }
 
 // tonConnect deliberately omits signSolanaTransactionBytes so the router's
@@ -695,4 +696,80 @@ describe('UniversalWalletConnector', () => {
       ).rejects.toThrow('No active wallet')
     })
   })
+
+  describe('beginPairing (WalletConnect pre-warm)', () => {
+    // Wallets exposing a WalletConnect provider, so the union of their networks
+    // is non-empty and beginPairing has something to pair.
+    const walletsWithWc: WalletMetadata[] = [
+      {
+        id: 'rainbow',
+        name: 'Rainbow',
+        metadata: {},
+        walletConnectProvider: {
+          supportedNetworkIds: ['eip155:1', 'eip155:137'],
+          deeplinks: { universal: 'https://rnbwapp.com', native: 'rainbow://' }
+        }
+      },
+      {
+        id: 'trust',
+        name: 'Trust',
+        metadata: {},
+        walletConnectProvider: {
+          supportedNetworkIds: ['eip155:137', 'eip155:8453'],
+          deeplinks: {
+            universal: 'https://link.trustwallet.com',
+            native: 'trust://'
+          }
+        }
+      }
+    ]
+
+    it('returns undefined when WalletConnect is not configured', async () => {
+      const uwc = new UniversalWalletConnector(mockNetworks, walletsWithWc)
+      await expect(uwc.beginPairing()).resolves.toBeUndefined()
+      expect(mockWalletConnectConnector.beginPairing).not.toHaveBeenCalled()
+    })
+
+    it('returns undefined when no wallet exposes a WalletConnect provider', async () => {
+      // WC configured, but mockWallets carries only an injected provider — nothing to pair.
+      const uwc = new UniversalWalletConnector(
+        mockNetworks,
+        mockWallets,
+        false,
+        mockWalletConnectConfig
+      )
+      await expect(uwc.beginPairing()).resolves.toBeUndefined()
+      expect(mockWalletConnectConnector.beginPairing).not.toHaveBeenCalled()
+    })
+
+    it('delegates to the connector with the deduped union of wallet networks', async () => {
+      mockWalletConnectConnector.beginPairing.mockResolvedValueOnce(
+        'wc:union@2'
+      )
+      const uwc = new UniversalWalletConnector(
+        mockNetworks,
+        walletsWithWc,
+        false,
+        mockWalletConnectConfig
+      )
+      const uri = await uwc.beginPairing()
+      expect(uri).toBe('wc:union@2')
+      expect(mockWalletConnectConnector.beginPairing).toHaveBeenCalledWith({
+        supportedNetworkIds: ['eip155:1', 'eip155:137', 'eip155:8453']
+      })
+    })
+
+    it('never throws: resolves undefined if the connector rejects', async () => {
+      mockWalletConnectConnector.beginPairing.mockRejectedValueOnce(
+        new Error('relay down')
+      )
+      const uwc = new UniversalWalletConnector(
+        mockNetworks,
+        walletsWithWc,
+        false,
+        mockWalletConnectConfig
+      )
+      await expect(uwc.beginPairing()).resolves.toBeUndefined()
+    })
+  })
 })

package/src/universal-wallet-connector.ts

@@ -334,7 +334,20 @@ export class UniversalWalletConnector {
             // Relay transport recovered — pair with `relayDisconnected` (same
             // sdkSessionId) to measure the dead window.
             onRelayReconnect: () =>
-              this.eventManager.emit('relayReconnected', undefined)
+              this.eventManager.emit('relayReconnected', undefined),
+            // Relay/subscription health captured just before a wallet request is
+            // published — the CARE-263 delivery signal for a reused session whose
+            // transport went stale (correlate with the sign terminal).
+            onRelayHealthProbe: probe =>
+              this.eventManager.emit('relayHealthProbe', probe),
+            // Outbound request handed to the relay, with its JSON-RPC id — the
+            // correlation key for wallet-side duplicate-prompt triage.
+            onRequestPublished: info =>
+              this.eventManager.emit('wcRequestPublished', info),
+            // A published request hit its WC TTL unanswered — the terminal
+            // counterpart to the probe ("wallet never surfaced the prompt").
+            onRequestExpired: info =>
+              this.eventManager.emit('wcRequestExpired', info)
           }
         )
       )
@@ -707,6 +720,41 @@ export class UniversalWalletConnector {
     }
   }
 
+  /**
+   * Pre-generate a WalletConnect pairing ahead of the user's tap. Warms the relay
+   * (opens the socket even on a cold, topic-less client) and returns a URI the app
+   * can deep-link inside the tap gesture, so the first tap opens the wallet
+   * reliably; a subsequent `connect()` adopts the same pairing. Built against the
+   * UNION of every WalletConnect wallet's networks so the single pairing serves
+   * whichever wallet the user picks (optionalNamespaces let a wallet approve only
+   * its supported subset). Best-effort: resolves `undefined` when WalletConnect is
+   * not configured or there is nothing to pair, and never throws into the caller.
+   */
+  async beginPairing(): Promise<string | undefined> {
+    try {
+      const connector = this.connectors.get('walletConnect')
+      if (!connector?.beginPairing) {
+        return undefined
+      }
+
+      const supportedNetworkIds = [
+        ...new Set(
+          this.wallets.flatMap(
+            wallet => wallet.walletConnectProvider?.supportedNetworkIds ?? []
+          )
+        )
+      ]
+      if (supportedNetworkIds.length === 0) {
+        return undefined
+      }
+
+      return await connector.beginPairing({ supportedNetworkIds })
+    } catch {
+      // Best-effort pre-warm — never surface a pairing failure to the caller.
+      return undefined
+    }
+  }
+
   getConnectionURI(): string | undefined {
     return this.connectionService.getConnectionURI()
   }

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.3.0'
+export const UWC_CORE_VERSION = '1.4.0'