@meshconnect/uwc-core 1.0.3 → 1.1.0

package/src/services/signature-service.ts

@@ -3,86 +3,83 @@ import type {
   Connector,
   ExtensionInjectedProvider,
   IntegratedBrowserInjectedProvider,
-  WalletConnectProvider,
   SupportedProvider,
   SignatureType,
   EIP712TypedData
 } from '@meshconnect/uwc-types'
 import type { SessionManager } from '../managers/session-manager'
+import type { EventManager } from '../managers/event-manager'
 import type { ServiceOptions } from './connection-service'
+import {
+  instrumentHandoff,
+  sessionHandoffContext
+} from '../observability/instrument-handoff'
+import { resolveSessionProvider } from '../utils/resolve-session-provider'
+import {
+  validateWalletSession,
+  getSessionConnector
+} from '../utils/validate-wallet-session'
 
 /**
- * Service for handling signature operations across different connector types
+ * Service for handling signature operations across different connector types.
+ *
+ * Owns the WHOLE wallet-boundary op — validation (session guards, connector
+ * capability, provider resolution) BEFORE the funnel, then the instrumented
+ * connector call — the same layering as ConnectionService / NetworkSwitchService,
+ * so a pre-wallet failure never emits an `awaitingWallet`/terminal pair.
  */
 export class SignatureService {
   constructor(
     private sessionManager: SessionManager,
-    private connectors: Map<ConnectionMode, Connector>
+    private connectors: Map<ConnectionMode, Connector>,
+    private usingIntegratedBrowser: boolean,
+    private eventManager: EventManager,
+    // Observational wallet-response deadline for the handoff timeout marker.
+    private walletResponseTimeoutMs: number
   ) {}
 
   /**
    * Sign a message with the currently connected wallet
    * @param message The message to sign
-   * @param provider The wallet provider to use for signing (required for injected connector)
    * @param options Optional cancellation signal
    * @returns A promise that resolves to the signature
    */
   async signMessage(
     message: string,
-    provider?: SupportedProvider,
     options?: ServiceOptions
   ): Promise<SignatureType> {
     options?.signal?.throwIfAborted()
-    const session = this.sessionManager.getSession()
+    const session = validateWalletSession(this.sessionManager, {
+      requireAddress: true
+    })
 
-    if (!session.connectionMode) {
-      throw new Error('No active connection')
-    }
-
-    if (!session.activeAddress) {
-      throw new Error('No active wallet address')
-    }
-
-    // Get the appropriate connector
-    const connector = this.connectors.get(session.connectionMode)
-    if (!connector) {
-      throw new Error(
-        `No connector found for connection mode: ${session.connectionMode}`
-      )
-    }
-
-    // Check if the connector supports signing
+    const connector = getSessionConnector(this.connectors, session)
     if (!connector.signMessage) {
       throw new Error(`Connector does not support message signing`)
     }
 
-    // Call the connector's signMessage method with the appropriate provider
-    let signature: SignatureType
-    if (session.connectionMode === 'injected') {
-      if (!provider) {
-        throw new Error('Provider is required for injected connector')
-      }
-      signature = await connector.signMessage(
-        message,
-        provider as
-          | ExtensionInjectedProvider
-          | IntegratedBrowserInjectedProvider
-      )
-    } else if (session.connectionMode === 'tonConnect') {
-      signature = await connector.signMessage(message)
-    } else if (session.connectionMode === 'walletConnect') {
-      if (!provider) {
-        throw new Error('Provider is required for WalletConnect connector')
-      }
-      signature = await connector.signMessage(
-        message,
-        provider as WalletConnectProvider
-      )
-    } else {
-      // For other connectors that might not need the provider
-      signature = await connector.signMessage(message)
-    }
+    // Validation, not wallet work — a missing provider must not enter the funnel.
+    // undefined only for tonConnect, whose connector resolves its own provider.
+    const provider = resolveSessionProvider(
+      session,
+      this.usingIntegratedBrowser
+    )
 
+    const signature = await instrumentHandoff(
+      {
+        eventManager: this.eventManager,
+        timeoutMs: this.walletResponseTimeoutMs,
+        signal: options?.signal
+      },
+      sessionHandoffContext('signMessage', session),
+      // tonConnect resolves undefined and keeps its message-only call shape.
+      () =>
+        provider === undefined
+          ? connector.signMessage!(message)
+          : connector.signMessage!(message, provider)
+    )
+    // AFTER the funnel: the wallet settled, so its truthful terminal is already
+    // recorded; an abort that raced completion still rejects the caller here.
     options?.signal?.throwIfAborted()
     return signature
   }
@@ -91,52 +88,45 @@ export class SignatureService {
    * Sign EIP-712 typed structured data with the currently connected wallet.
    * EVM-only (eip155); routes by connection mode. Throws for tonConnect.
    * @param typedData The EIP-712 typed data to sign
-   * @param provider The wallet provider (required for the injected connector)
    * @returns A promise that resolves to the 65-byte hex signature
    */
-  async signTypedData(
-    typedData: EIP712TypedData,
-    provider?: SupportedProvider
-  ): Promise<string> {
-    const session = this.sessionManager.getSession()
-
-    if (!session.connectionMode) {
-      throw new Error('No active connection')
+  async signTypedData(typedData: EIP712TypedData): Promise<string> {
+    const session = validateWalletSession(this.sessionManager, {
+      requireAddress: true
+    })
+
+    const connector = getSessionConnector(this.connectors, session)
+    // TON first: TonConnectConnector has no signTypedData, so the capability
+    // guard would otherwise shadow this branch with the generic message.
+    if (session.connectionMode === 'tonConnect') {
+      throw new Error('signTypedData is not supported for TON wallets')
     }
-
-    if (!session.activeAddress) {
-      throw new Error('No active wallet address')
-    }
-
-    const connector = this.connectors.get(session.connectionMode)
-    if (!connector) {
-      throw new Error(
-        `No connector found for connection mode: ${session.connectionMode}`
-      )
-    }
-
     if (!connector.signTypedData) {
       throw new Error(`Connector does not support typed data signing`)
     }
 
+    // Only the injected path resolves (and validates) a provider — WalletConnect
+    // resolves its own inside the connector.
+    let provider: SupportedProvider | undefined
     if (session.connectionMode === 'injected') {
-      if (!provider) {
-        throw new Error('Provider is required for injected connector')
-      }
-      return await connector.signTypedData(
-        typedData,
-        provider as
-          | ExtensionInjectedProvider
-          | IntegratedBrowserInjectedProvider
-      )
-    }
-
-    if (session.connectionMode === 'walletConnect') {
-      return await connector.signTypedData(typedData)
+      provider = resolveSessionProvider(session, this.usingIntegratedBrowser)
     }
 
-    throw new Error(
-      `signTypedData is not supported for connection mode: ${session.connectionMode}`
+    return await instrumentHandoff(
+      {
+        eventManager: this.eventManager,
+        timeoutMs: this.walletResponseTimeoutMs
+      },
+      sessionHandoffContext('signTypedData', session),
+      () =>
+        session.connectionMode === 'injected'
+          ? connector.signTypedData!(
+              typedData,
+              provider as
+                | ExtensionInjectedProvider
+                | IntegratedBrowserInjectedProvider
+            )
+          : connector.signTypedData!(typedData)
     )
   }
 }

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

@@ -1,20 +1,65 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest'
 import { TransactionService } from './transaction-service'
 import { SessionManager } from '../managers/session-manager'
+import { EventManager } from '../managers/event-manager'
 import type {
   ConnectionMode,
   Connector,
-  TransactionRequest
+  TransactionRequest,
+  WalletMetadata
 } from '../../../types/src'
 
-describe('TransactionService', () => {
+// Same layering contract as SignatureService: the service owns validation
+// (session guards, connector capability, provider resolution) BEFORE the
+// funnel, then the instrumented connector call.
+
+const injectedWallet = {
+  id: 'metamask',
+  name: 'MetaMask',
+  extensionInjectedProvider: { supportedNetworkIds: ['eip155:1'] }
+} as unknown as WalletMetadata
+
+const walletWithoutProviders = {
+  id: 'metamask',
+  name: 'MetaMask'
+} as unknown as WalletMetadata
+
+const request: TransactionRequest = {
+  to: '0x456',
+  value: BigInt('1000000000000000000'),
+  from: '0x123'
+} as unknown as TransactionRequest
+
+describe('TransactionService.sendTransaction', () => {
   let transactionService: TransactionService
   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(),
@@ -32,59 +77,82 @@ describe('TransactionService', () => {
     connectors = new Map()
     connectors.set('injected', mockConnector)
 
-    transactionService = new TransactionService(sessionManager, connectors)
+    transactionService = new TransactionService(
+      sessionManager,
+      connectors,
+      false,
+      eventManager,
+      60_000
+    )
   })
 
-  it('should initialize with provided parameters', () => {
-    expect(transactionService).toBeDefined()
+  it('throws "No active wallet" first on an empty session (public façade message)', async () => {
+    await expect(transactionService.sendTransaction(request)).rejects.toThrow(
+      'No active wallet'
+    )
+    expect(events).toEqual([])
   })
 
-  it('should throw error when no active connection', async () => {
-    const request: TransactionRequest = {
-      to: '0x456',
-      value: BigInt('1000000000000000000'),
-      from: '0x123'
-    }
+  it('records walletSucceeded when an abort races completion (the tx already broadcast)', async () => {
+    // The transaction went OUT — suppressing the terminal would under-count
+    // real sends; the abort still rejects the caller, after the terminal.
+    connectSession()
+    const controller = new AbortController()
+    vi.mocked(mockConnector.sendTransaction!).mockImplementation(async () => {
+      controller.abort()
+      return { hash: '0xtxhash' } as never
+    })
 
-    await expect(transactionService.sendTransaction(request)).rejects.toThrow(
-      'No active connection'
-    )
+    await expect(
+      transactionService.sendTransaction(request, {
+        signal: controller.signal
+      })
+    ).rejects.toMatchObject({ name: 'AbortError' })
+    expect(events).toEqual(['awaitingWallet', 'walletSucceeded'])
   })
 
-  it('should throw error when no active address', async () => {
-    sessionManager.updateSession({
-      connectionMode: 'injected'
+  it('rejects with a CUSTOM abort reason after broadcast — success terminal, no spurious failure', async () => {
+    connectSession()
+    const controller = new AbortController()
+    vi.mocked(mockConnector.sendTransaction!).mockImplementation(async () => {
+      controller.abort(new Error('nav away'))
+      return { hash: '0xtxhash' } as never
     })
 
-    const request: TransactionRequest = {
-      to: '0x456',
-      value: BigInt('1000000000000000000'),
-      from: '0x123'
-    }
+    await expect(
+      transactionService.sendTransaction(request, {
+        signal: controller.signal
+      })
+    ).rejects.toThrow('nav away')
+    expect(events).toEqual(['awaitingWallet', 'walletSucceeded'])
+  })
+
+  it('throws when no active address', async () => {
+    sessionManager.updateSession({
+      connectionMode: 'injected',
+      activeWallet: injectedWallet
+    })
 
     await expect(transactionService.sendTransaction(request)).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'
     })
 
-    const request: TransactionRequest = {
-      to: '0x456',
-      value: BigInt('1000000000000000000'),
-      from: '0x123'
-    }
-
     await expect(transactionService.sendTransaction(request)).rejects.toThrow(
       'No connector found for connection mode: unknown'
     )
+    expect(events).toEqual([])
   })
 
-  it('should throw error when connector does not support transactions', async () => {
+  it('throws when connector does not support transactions', async () => {
     const connectorWithoutTx = {
       connect: vi.fn(),
       disconnect: vi.fn(),
@@ -92,37 +160,29 @@ describe('TransactionService', () => {
       switchNetwork: vi.fn()
     }
     connectors.set('injected', connectorWithoutTx)
+    connectSession()
 
-    sessionManager.updateSession({
-      connectionMode: 'injected',
-      activeAddress: '0x123'
-    })
+    await expect(transactionService.sendTransaction(request)).rejects.toThrow(
+      'Connector does not support transactions'
+    )
+    expect(events).toEqual([])
+  })
 
-    const request: TransactionRequest = {
-      to: '0x456',
-      value: BigInt('1000000000000000000'),
-      from: '0x123'
-    }
+  it('a missing provider fails BEFORE the funnel (validation, not a wallet outcome)', async () => {
+    connectSession('injected', walletWithoutProviders)
 
     await expect(transactionService.sendTransaction(request)).rejects.toThrow(
-      'Connector does not support transactions'
+      'No provider available for the active wallet'
     )
+    expect(events).toEqual([])
+    expect(mockConnector.sendTransaction).not.toHaveBeenCalled()
   })
 
-  it('should send transaction successfully', async () => {
-    sessionManager.updateSession({
-      connectionMode: 'injected',
-      activeAddress: '0x123'
-    })
+  it('sends and emits awaitingWallet → walletSucceeded around the wallet call', async () => {
+    connectSession()
 
-    const request: TransactionRequest = {
-      to: '0x456',
-      value: BigInt('1000000000000000000'),
-      from: '0x123'
-    }
+    const result = await transactionService.sendTransaction(request)
 
-    const provider = {} as any
-    const result = await transactionService.sendTransaction(request, provider)
     expect(result).toEqual({
       hash: '0xtxhash',
       from: '0x123',
@@ -131,33 +191,174 @@ describe('TransactionService', () => {
     })
     expect(mockConnector.sendTransaction).toHaveBeenCalledWith(
       request,
-      provider
+      injectedWallet.extensionInjectedProvider
     )
+    expect(events).toEqual(['awaitingWallet', 'walletSucceeded'])
   })
 
-  it('should send transaction with provider', async () => {
+  it('a user rejection closes the handoff as walletRejected', async () => {
+    connectSession()
+    vi.mocked(mockConnector.sendTransaction!).mockRejectedValueOnce({
+      code: 4001
+    })
+
+    await expect(transactionService.sendTransaction(request)).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 transactionService.sendTransaction(request)
+
+    expect(mockConnector.sendTransaction).toHaveBeenCalledWith(request)
+    expect(events).toEqual(['awaitingWallet', 'walletSucceeded'])
+  })
+})
+
+describe('TransactionService.signSolanaTransactionBytes', () => {
+  let transactionService: TransactionService
+  let sessionManager: SessionManager
+  let eventManager: EventManager
+  let mockConnector: Connector
+  let connectors: Map<ConnectionMode, Connector>
+  let events: string[]
+
+  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(),
+      disconnect: vi.fn(),
+      signMessage: vi.fn(),
+      sendTransaction: vi.fn(),
+      switchNetwork: vi.fn(),
+      signSolanaTransactionBytes: vi.fn().mockResolvedValue(new Uint8Array([9]))
+    }
+
+    connectors = new Map()
+    connectors.set('injected', mockConnector)
+
+    transactionService = new TransactionService(
+      sessionManager,
+      connectors,
+      false,
+      eventManager,
+      60_000
+    )
+  })
+
+  it('throws "No active wallet" on an empty session', async () => {
+    await expect(
+      transactionService.signSolanaTransactionBytes(new Uint8Array([1]))
+    ).rejects.toThrow('No active wallet')
+    expect(events).toEqual([])
+  })
+
+  it('throws "No active connection" when the session has no connectionMode', async () => {
+    sessionManager.updateSession({ activeWallet: injectedWallet })
+
+    await expect(
+      transactionService.signSolanaTransactionBytes(new Uint8Array([1]))
+    ).rejects.toThrow('No active connection')
+    expect(events).toEqual([])
+  })
+
+  it('throws "not supported" when connectionMode maps to no registered connector', async () => {
     sessionManager.updateSession({
-      connectionMode: 'injected',
+      connectionMode: 'walletConnect',
+      activeWallet: injectedWallet,
       activeAddress: '0x123'
     })
 
-    const request: TransactionRequest = {
-      to: '0x456',
-      value: BigInt('1000000000000000000'),
-      from: '0x123'
+    await expect(
+      transactionService.signSolanaTransactionBytes(new Uint8Array([1]))
+    ).rejects.toThrow(
+      'signSolanaTransaction is not supported for connection mode "walletConnect"'
+    )
+    expect(events).toEqual([])
+  })
+
+  it('routes serializedTx to the walletConnect connector when active', async () => {
+    const SIGNED_TX = new Uint8Array([6, 7, 8])
+    const wcConnector = {
+      connect: vi.fn(),
+      disconnect: vi.fn(),
+      switchNetwork: vi.fn(),
+      signSolanaTransactionBytes: vi.fn().mockResolvedValue(SIGNED_TX)
     }
+    connectors.set('walletConnect', wcConnector)
+    sessionManager.updateSession({
+      connectionMode: 'walletConnect',
+      activeWallet: injectedWallet,
+      activeAddress: '0x123'
+    })
+    const bytes = new Uint8Array([1, 2, 3])
 
-    const provider = {} as any
-    const result = await transactionService.sendTransaction(request, provider)
-    expect(result).toEqual({
-      hash: '0xtxhash',
-      from: '0x123',
-      to: '0x456',
-      value: '1000000000000000000'
+    const result = await transactionService.signSolanaTransactionBytes(bytes)
+
+    expect(wcConnector.signSolanaTransactionBytes).toHaveBeenCalledWith(bytes)
+    expect(result).toBe(SIGNED_TX)
+    expect(events).toEqual(['awaitingWallet', 'walletSucceeded'])
+  })
+
+  it('INVARIANT: connector.sendTransaction is never called on the sign-only path', async () => {
+    sessionManager.updateSession({
+      connectionMode: 'injected',
+      activeWallet: injectedWallet,
+      activeAddress: '0x123'
     })
-    expect(mockConnector.sendTransaction).toHaveBeenCalledWith(
-      request,
-      provider
+
+    await transactionService.signSolanaTransactionBytes(new Uint8Array([1]))
+
+    expect(mockConnector.sendTransaction).not.toHaveBeenCalled()
+  })
+
+  it('throws the façade message when the connector lacks the capability, outside the funnel', async () => {
+    const connectorWithoutSolana = {
+      connect: vi.fn(),
+      disconnect: vi.fn(),
+      switchNetwork: vi.fn()
+    }
+    connectors.set('injected', connectorWithoutSolana)
+    sessionManager.updateSession({
+      connectionMode: 'injected',
+      activeWallet: injectedWallet,
+      activeAddress: '0x123'
+    })
+
+    await expect(
+      transactionService.signSolanaTransactionBytes(new Uint8Array([1]))
+    ).rejects.toThrow(
+      'signSolanaTransaction is not supported for connection mode "injected"'
     )
+    expect(events).toEqual([])
+  })
+
+  it('signs (never broadcasts) inside the funnel', async () => {
+    sessionManager.updateSession({
+      connectionMode: 'injected',
+      activeWallet: injectedWallet,
+      activeAddress: '0x123'
+    })
+    const bytes = new Uint8Array([1, 2, 3])
+
+    const signed = await transactionService.signSolanaTransactionBytes(bytes)
+
+    expect(signed).toEqual(new Uint8Array([9]))
+    expect(mockConnector.signSolanaTransactionBytes).toHaveBeenCalledWith(bytes)
+    expect(events).toEqual(['awaitingWallet', 'walletSucceeded'])
   })
 })