@meshconnect/uwc-core 1.2.3 → 1.3.0-snapshot.3412d21

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

@@ -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)
+          }
         )
       )
     }
@@ -697,6 +707,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.2.3'
+export const UWC_CORE_VERSION = '1.3.0'