@meshconnect/uwc-core 1.0.3 → 1.1.0

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

@@ -12,6 +12,7 @@ import type {
 import type { SessionManager } from '../managers/session-manager'
 import type { EventManager } from '../managers/event-manager'
 import type { ServiceOptions } from './connection-service'
+import { instrumentHandoff } from '../observability/instrument-handoff'
 
 export class NetworkSwitchService {
   private isLoading = false
@@ -22,7 +23,9 @@ export class NetworkSwitchService {
     private sessionManager: SessionManager,
     private connectors: Map<ConnectionMode, Connector>,
     private usingIntegratedBrowser: boolean,
-    private eventManager: EventManager
+    private eventManager: EventManager,
+    // Observational wallet-response deadline for the handoff timeout marker.
+    private walletResponseTimeoutMs: number
   ) {}
 
   getLoadingState() {
@@ -61,7 +64,13 @@ export class NetworkSwitchService {
       throw new Error('No connection mode found in session')
     }
 
-    // Get the provider for the current connection mode
+    // Get the provider for the current connection mode.
+    // NOTE: deliberately NOT `resolveSessionProvider` (utils) — this
+    // pre-existing dispatch groups `tonConnect` with `injected` (a TON switch
+    // only proceeds when the wallet also carries injected-provider metadata,
+    // whose `supportedNetworkIds` gate below relies on), while the shared
+    // helper yields undefined for TON. Unifying them changes TON switch
+    // behaviour and needs its own change.
     let provider: SupportedProvider | undefined
 
     if (
@@ -106,6 +115,10 @@ export class NetworkSwitchService {
       session.activeNetwork
     )
 
+    // A no-op switch (target chain already active) still hands off to the wallet
+    // on some connectors; flag it so the funnel can separate it from real switches.
+    const targetAlreadyActive = networkId === session.activeNetwork?.id
+
     try {
       // Set loading states
       this.isLoading = true
@@ -115,28 +128,47 @@ export class NetworkSwitchService {
         isWaitingForUserApproval: requiresApproval
       })
 
-      // Perform the network switch and get the new address
-      // Pass the appropriate provider based on connection mode
-      let result
-      if (
-        (session.connectionMode === 'injected' ||
-          session.connectionMode === 'tonConnect') &&
-        provider
-      ) {
-        result = await activeConnector.switchNetwork(
-          network,
-          provider as
-            | ExtensionInjectedProvider
-            | IntegratedBrowserInjectedProvider
-        )
-      } else if (session.connectionMode === 'walletConnect' && provider) {
-        result = await activeConnector.switchNetwork(
-          network,
-          provider as WalletConnectProvider
-        )
-      } else {
-        result = await activeConnector.switchNetwork(network)
-      }
+      // Perform the network switch and get the new address. Instrument the
+      // wallet hand-off HERE — after validation + the `networkSwitching` emit —
+      // so `awaitingWallet` marks the real wallet boundary; pre-wallet validation
+      // failures throw above and never enter the funnel.
+      // Pass the appropriate provider based on connection mode.
+      const result = await instrumentHandoff(
+        {
+          eventManager: this.eventManager,
+          timeoutMs: this.walletResponseTimeoutMs,
+          signal: options?.signal
+        },
+        {
+          operation: 'switchNetwork',
+          connectionMode: session.connectionMode,
+          walletId: currentWallet.id,
+          namespace: network.namespace,
+          chainId: network.id,
+          targetAlreadyActive
+        },
+        async () => {
+          if (
+            (session.connectionMode === 'injected' ||
+              session.connectionMode === 'tonConnect') &&
+            provider
+          ) {
+            return await activeConnector.switchNetwork(
+              network,
+              provider as
+                | ExtensionInjectedProvider
+                | IntegratedBrowserInjectedProvider
+            )
+          } else if (session.connectionMode === 'walletConnect' && provider) {
+            return await activeConnector.switchNetwork(
+              network,
+              provider as WalletConnectProvider
+            )
+          } else {
+            return await activeConnector.switchNetwork(network)
+          }
+        }
+      )
 
       options?.signal?.throwIfAborted()
 

package/src/services/signature-service.test.ts

@@ -1,16 +1,59 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest'
 import { SignatureService } from './signature-service'
 import { SessionManager } from '../managers/session-manager'
-import type { ConnectionMode, Connector } from '../../../types/src'
-
-describe('SignatureService', () => {
+import { EventManager } from '../managers/event-manager'
+import type {
+  ConnectionMode,
+  Connector,
+  WalletMetadata
+} from '../../../types/src'
+
+// The service owns the whole wallet-boundary op: validation (session guards,
+// connector capability, provider resolution) BEFORE the funnel, then the
+// instrumented connector call — same layering as ConnectionService /
+// NetworkSwitchService. The façade only delegates + emits `error`.
+
+const injectedWallet = {
+  id: 'metamask',
+  name: 'MetaMask',
+  extensionInjectedProvider: { supportedNetworkIds: ['eip155:1'] }
+} as unknown as WalletMetadata
+
+const walletWithoutProviders = {
+  id: 'metamask',
+  name: 'MetaMask'
+} as unknown as WalletMetadata
+
+describe('SignatureService.signMessage', () => {
   let signatureService: SignatureService
   let sessionManager: SessionManager
+  let eventManager: EventManager
   let mockConnector: Connector
   let connectors: Map<ConnectionMode, Connector>
+  let events: string[]
+
+  const connectSession = (
+    mode: ConnectionMode = 'injected',
+    wallet: WalletMetadata = injectedWallet
+  ) =>
+    sessionManager.updateSession({
+      connectionMode: mode,
+      activeWallet: wallet,
+      activeAddress: '0x123'
+    })
 
   beforeEach(() => {
     sessionManager = new SessionManager()
+    eventManager = new EventManager()
+    events = []
+    for (const name of [
+      'awaitingWallet',
+      'walletSucceeded',
+      'walletRejected',
+      'walletFailed'
+    ] as const) {
+      eventManager.on(name, () => events.push(name))
+    }
 
     mockConnector = {
       connect: vi.fn(),
@@ -23,41 +66,78 @@ describe('SignatureService', () => {
     connectors = new Map()
     connectors.set('injected', mockConnector)
 
-    signatureService = new SignatureService(sessionManager, connectors)
-  })
-
-  it('should initialize with provided parameters', () => {
-    expect(signatureService).toBeDefined()
+    signatureService = new SignatureService(
+      sessionManager,
+      connectors,
+      false,
+      eventManager,
+      60_000
+    )
   })
 
-  it('should throw error when no active connection', async () => {
+  it('throws "No active wallet" first on an empty session (public façade message)', async () => {
     await expect(signatureService.signMessage('test message')).rejects.toThrow(
-      'No active connection'
+      'No active wallet'
     )
+    expect(events).toEqual([])
+  })
+
+  it('records walletSucceeded when an abort races completion (the wallet settled first)', async () => {
+    // The signature EXISTS — the funnel must record the wallet's truthful
+    // outcome; the abort still rejects the caller, after the terminal.
+    connectSession()
+    const controller = new AbortController()
+    vi.mocked(mockConnector.signMessage!).mockImplementation(async () => {
+      controller.abort()
+      return '0xsig' as never
+    })
+
+    await expect(
+      signatureService.signMessage('m', { signal: controller.signal })
+    ).rejects.toMatchObject({ name: 'AbortError' })
+    expect(events).toEqual(['awaitingWallet', 'walletSucceeded'])
+  })
+
+  it('rejects with a CUSTOM abort reason after the wallet settled — success terminal, no spurious failure', async () => {
+    connectSession()
+    const controller = new AbortController()
+    vi.mocked(mockConnector.signMessage!).mockImplementation(async () => {
+      controller.abort(new Error('nav away'))
+      return '0xsig' as never
+    })
+
+    await expect(
+      signatureService.signMessage('m', { signal: controller.signal })
+    ).rejects.toThrow('nav away')
+    expect(events).toEqual(['awaitingWallet', 'walletSucceeded'])
   })
 
-  it('should throw error when no active address', async () => {
+  it('throws when no active address', async () => {
     sessionManager.updateSession({
-      connectionMode: 'injected'
+      connectionMode: 'injected',
+      activeWallet: injectedWallet
     })
 
     await expect(signatureService.signMessage('test message')).rejects.toThrow(
       'No active wallet address'
     )
+    expect(events).toEqual([])
   })
 
-  it('should throw error when connector not found', async () => {
+  it('throws when connector not found', async () => {
     sessionManager.updateSession({
       connectionMode: 'unknown' as ConnectionMode,
+      activeWallet: injectedWallet,
       activeAddress: '0x123'
     })
 
     await expect(signatureService.signMessage('test message')).rejects.toThrow(
       'No connector found for connection mode: unknown'
     )
+    expect(events).toEqual([])
   })
 
-  it('should throw error when connector does not support signing', async () => {
+  it('throws when connector does not support signing', async () => {
     const connectorWithoutSign = {
       connect: vi.fn(),
       disconnect: vi.fn(),
@@ -65,53 +145,66 @@ describe('SignatureService', () => {
       switchNetwork: vi.fn()
     }
     connectors.set('injected', connectorWithoutSign)
-
-    sessionManager.updateSession({
-      connectionMode: 'injected',
-      activeAddress: '0x123'
-    })
+    connectSession()
 
     await expect(signatureService.signMessage('test message')).rejects.toThrow(
       'Connector does not support message signing'
     )
+    expect(events).toEqual([])
   })
 
-  it('should sign message successfully', async () => {
-    sessionManager.updateSession({
-      connectionMode: 'injected',
-      activeAddress: '0x123'
-    })
+  it('a missing provider fails BEFORE the funnel (validation, not a wallet outcome)', async () => {
+    connectSession('injected', walletWithoutProviders)
 
-    const provider = {} as any
-    const result = await signatureService.signMessage('test message', provider)
-    expect(result).toBe('0xsignature')
-    expect(mockConnector.signMessage).toHaveBeenCalledWith(
-      'test message',
-      provider
+    await expect(signatureService.signMessage('test message')).rejects.toThrow(
+      'No provider available for the active wallet'
     )
+    expect(events).toEqual([])
+    expect(mockConnector.signMessage).not.toHaveBeenCalled()
   })
 
-  it('should sign message with provider', async () => {
-    sessionManager.updateSession({
-      connectionMode: 'injected',
-      activeAddress: '0x123'
-    })
+  it('signs and emits awaitingWallet → walletSucceeded around the wallet call', async () => {
+    connectSession()
+
+    const result = await signatureService.signMessage('test message')
 
-    const provider = {} as any
-    const result = await signatureService.signMessage('test message', provider)
     expect(result).toBe('0xsignature')
+    // The resolved session provider is threaded to the connector.
     expect(mockConnector.signMessage).toHaveBeenCalledWith(
       'test message',
-      provider
+      injectedWallet.extensionInjectedProvider
     )
+    expect(events).toEqual(['awaitingWallet', 'walletSucceeded'])
+  })
+
+  it('a user rejection closes the handoff as walletRejected', async () => {
+    connectSession()
+    vi.mocked(mockConnector.signMessage!).mockRejectedValueOnce({ code: 4001 })
+
+    await expect(signatureService.signMessage('test message')).rejects.toEqual({
+      code: 4001
+    })
+    expect(events).toEqual(['awaitingWallet', 'walletRejected'])
+  })
+
+  it('tonConnect enters the funnel with the connector resolving its own provider', async () => {
+    connectors.set('tonConnect', mockConnector)
+    connectSession('tonConnect', walletWithoutProviders)
+
+    await signatureService.signMessage('hello')
+
+    expect(mockConnector.signMessage).toHaveBeenCalledWith('hello')
+    expect(events).toEqual(['awaitingWallet', 'walletSucceeded'])
   })
 })
 
 describe('SignatureService.signTypedData', () => {
   let signatureService: SignatureService
   let sessionManager: SessionManager
+  let eventManager: EventManager
   let mockConnector: Connector
   let connectors: Map<ConnectionMode, Connector>
+  let events: string[]
 
   const typedData = {
     domain: {
@@ -143,6 +236,15 @@ describe('SignatureService.signTypedData', () => {
 
   beforeEach(() => {
     sessionManager = new SessionManager()
+    eventManager = new EventManager()
+    events = []
+    for (const name of [
+      'awaitingWallet',
+      'walletSucceeded',
+      'walletFailed'
+    ] as const) {
+      eventManager.on(name, () => events.push(name))
+    }
 
     mockConnector = {
       connect: vi.fn(),
@@ -156,33 +258,23 @@ describe('SignatureService.signTypedData', () => {
     connectors = new Map()
     connectors.set('injected', mockConnector)
 
-    signatureService = new SignatureService(sessionManager, connectors)
-  })
-
-  it('should throw when no active connection', async () => {
-    await expect(signatureService.signTypedData(typedData)).rejects.toThrow(
-      'No active connection'
+    signatureService = new SignatureService(
+      sessionManager,
+      connectors,
+      false,
+      eventManager,
+      60_000
     )
   })
 
-  it('should throw when no active address', async () => {
-    sessionManager.updateSession({ connectionMode: 'injected' })
-    await expect(signatureService.signTypedData(typedData)).rejects.toThrow(
-      'No active wallet address'
-    )
-  })
-
-  it('should throw when connector not found', async () => {
-    sessionManager.updateSession({
-      connectionMode: 'unknown' as ConnectionMode,
-      activeAddress: '0x123'
-    })
+  it('throws "No active wallet" first on an empty session', async () => {
     await expect(signatureService.signTypedData(typedData)).rejects.toThrow(
-      'No connector found for connection mode: unknown'
+      'No active wallet'
     )
+    expect(events).toEqual([])
   })
 
-  it('should throw when connector does not support signTypedData', async () => {
+  it('throws when connector does not support signTypedData', async () => {
     const connectorWithoutTypedData = {
       connect: vi.fn(),
       disconnect: vi.fn(),
@@ -192,56 +284,69 @@ describe('SignatureService.signTypedData', () => {
     connectors.set('injected', connectorWithoutTypedData)
     sessionManager.updateSession({
       connectionMode: 'injected',
+      activeWallet: injectedWallet,
       activeAddress: '0x123'
     })
     await expect(signatureService.signTypedData(typedData)).rejects.toThrow(
       'Connector does not support typed data signing'
     )
+    expect(events).toEqual([])
+  })
+
+  it('throws the façade message for TON, outside the funnel', async () => {
+    // Shape of the real TonConnectConnector: NO signTypedData. The TON branch
+    // must win over the generic capability guard, not be shadowed by it.
+    const tonConnector = { ...mockConnector }
+    delete (tonConnector as { signTypedData?: unknown }).signTypedData
+    connectors.set('tonConnect', tonConnector)
+    sessionManager.updateSession({
+      connectionMode: 'tonConnect',
+      activeWallet: injectedWallet,
+      activeAddress: '0x123'
+    })
+    await expect(signatureService.signTypedData(typedData)).rejects.toThrow(
+      'signTypedData is not supported for TON wallets'
+    )
+    expect(events).toEqual([])
   })
 
-  it('should throw when injected mode has no provider', async () => {
+  it('a missing injected provider fails BEFORE the funnel', async () => {
     sessionManager.updateSession({
       connectionMode: 'injected',
+      activeWallet: walletWithoutProviders,
       activeAddress: '0x123'
     })
     await expect(signatureService.signTypedData(typedData)).rejects.toThrow(
-      'Provider is required for injected connector'
+      'No provider available for the active wallet'
     )
+    expect(events).toEqual([])
   })
 
-  it('should sign typed data via injected connector', async () => {
+  it('signs via the injected connector inside the funnel', async () => {
     sessionManager.updateSession({
       connectionMode: 'injected',
+      activeWallet: injectedWallet,
       activeAddress: '0x123'
     })
-    const provider = {} as any
-    const result = await signatureService.signTypedData(typedData, provider)
+    const result = await signatureService.signTypedData(typedData)
     expect(result).toBe('0xtypedsig')
     expect(mockConnector.signTypedData).toHaveBeenCalledWith(
       typedData,
-      provider
+      injectedWallet.extensionInjectedProvider
     )
+    expect(events).toEqual(['awaitingWallet', 'walletSucceeded'])
   })
 
-  it('should sign typed data via walletConnect connector without provider', async () => {
+  it('signs via walletConnect with no provider (connector resolves its own)', async () => {
     connectors.set('walletConnect', mockConnector)
     sessionManager.updateSession({
       connectionMode: 'walletConnect',
+      activeWallet: walletWithoutProviders,
       activeAddress: '0x123'
     })
     const result = await signatureService.signTypedData(typedData)
     expect(result).toBe('0xtypedsig')
     expect(mockConnector.signTypedData).toHaveBeenCalledWith(typedData)
-  })
-
-  it('should throw for tonConnect mode', async () => {
-    connectors.set('tonConnect', mockConnector)
-    sessionManager.updateSession({
-      connectionMode: 'tonConnect',
-      activeAddress: '0x123'
-    })
-    await expect(signatureService.signTypedData(typedData)).rejects.toThrow(
-      'signTypedData is not supported for connection mode: tonConnect'
-    )
+    expect(events).toEqual(['awaitingWallet', 'walletSucceeded'])
   })
 })