@meshconnect/uwc-core 1.0.0 → 1.0.1-snapshot.c7e65ce

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

@@ -0,0 +1,265 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import type {
+  Network,
+  WalletMetadata,
+  Logger,
+  Session
+} from '@meshconnect/uwc-types'
+import { UniversalWalletConnector } from './universal-wallet-connector'
+import type { UWCObserver, UWCTelemetryEvent } from './observability/telemetry'
+
+// Mock connectors + services so the façade resolves deterministically, but leave
+// the EventManager + logger + observability wiring REAL so this exercises the
+// actual end-to-end observer path through the public API.
+//
+// connect()/switchNetwork() instrumentation now lives INSIDE their services
+// (after validation) — covered by the service tests. Here we use signMessage,
+// which stays instrumented at the façade, to exercise the observer end-to-end.
+const signMessageMock = vi.fn()
+
+const connectedSession: Session = {
+  connectionMode: 'injected',
+  activeNetwork: {
+    internalId: 1,
+    id: 'eip155:1',
+    namespace: 'eip155',
+    name: 'Ethereum',
+    logoUrl: '',
+    nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+    networkType: 'evm'
+  },
+  activeWalletCapabilities: null,
+  activeNetworkWalletCapabilities: null,
+  activeAddress: '0xabc',
+  publicKey: null,
+  availableNetworks: [],
+  activeWallet: {
+    id: 'metamask',
+    name: 'MetaMask',
+    extensionInjectedProvider: {}
+  } as unknown as WalletMetadata,
+  availableAddresses: []
+}
+
+vi.mock('@meshconnect/uwc-injected-connector', () => ({
+  InjectedConnector: vi.fn().mockImplementation(function () {
+    return { getAvailableWallets: vi.fn().mockResolvedValue([]) }
+  })
+}))
+vi.mock('@meshconnect/uwc-wallet-connect-connector', () => ({
+  WalletConnectConnector: vi.fn().mockImplementation(function () {
+    return { getAvailableWallets: vi.fn().mockResolvedValue([]) }
+  })
+}))
+vi.mock('@meshconnect/uwc-ton-connector', () => ({
+  TonConnectConnector: vi.fn().mockImplementation(function () {
+    return { getAvailableWallets: vi.fn().mockResolvedValue([]) }
+  })
+}))
+vi.mock('./managers/session-manager', () => ({
+  SessionManager: vi.fn().mockImplementation(function () {
+    return { getSession: () => connectedSession, updateSession: vi.fn() }
+  })
+}))
+vi.mock('./services/connection-service', () => ({
+  ConnectionService: vi.fn().mockImplementation(function () {
+    return {
+      connect: vi.fn().mockResolvedValue(undefined),
+      disconnect: vi.fn().mockResolvedValue(undefined),
+      getWallets: vi.fn().mockReturnValue([]),
+      getNetworks: vi.fn().mockReturnValue([]),
+      getConnectionURI: vi.fn(),
+      updateWallets: vi.fn()
+    }
+  })
+}))
+vi.mock('./services/network-switch-service', () => ({
+  NetworkSwitchService: vi.fn().mockImplementation(function () {
+    return { switchNetwork: vi.fn(), getLoadingState: vi.fn() }
+  })
+}))
+vi.mock('./services/signature-service', () => ({
+  SignatureService: vi.fn().mockImplementation(function () {
+    return { signMessage: signMessageMock, signTypedData: vi.fn() }
+  })
+}))
+vi.mock('./services/transaction-service', () => ({
+  TransactionService: vi.fn().mockImplementation(function () {
+    return { sendTransaction: vi.fn() }
+  })
+}))
+vi.mock('./services/wallet-capabilities-service', () => ({
+  WalletCapabilitiesService: vi.fn().mockImplementation(function () {
+    return { getWalletCapabilities: vi.fn() }
+  })
+}))
+
+const networks = [
+  {
+    internalId: 1,
+    id: 'eip155:1',
+    namespace: 'eip155',
+    name: 'Ethereum',
+    logoUrl: '',
+    nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+    networkType: 'evm'
+  }
+] as unknown as Network[]
+
+const wallets = [
+  { id: 'metamask', name: 'MetaMask' }
+] as unknown as WalletMetadata[]
+
+describe('UniversalWalletConnector — observability wiring', () => {
+  beforeEach(() => {
+    UniversalWalletConnector.resetInstance()
+    signMessageMock.mockReset()
+    signMessageMock.mockResolvedValue({ type: 'standard', signature: '0xsig' })
+  })
+
+  it('forwards a sign handoff to observer.onEvent (awaitingWallet → walletSucceeded)', async () => {
+    const events: UWCTelemetryEvent[] = []
+    const observer: UWCObserver = { onEvent: e => events.push(e) }
+    const uwc = new UniversalWalletConnector({ networks, wallets, observer })
+
+    await uwc.signMessage('hello')
+
+    const names = events.map(e => e.name)
+    expect(names).toContain('awaitingWallet')
+    expect(names).toContain('walletSucceeded')
+
+    const awaiting = events.find(e => e.name === 'awaitingWallet')!
+    const succeeded = events.find(e => e.name === 'walletSucceeded')!
+    // Same correlation id pairs start↔terminal, and the per-instance session id
+    // is stamped on every record.
+    expect(awaiting.handoffId).toBe(succeeded.handoffId)
+    expect(awaiting.sdkSessionId).toBe(succeeded.sdkSessionId)
+    expect(awaiting.operation).toBe('signMessage')
+    expect(signMessageMock).toHaveBeenCalledOnce()
+  })
+
+  it('stamps a consumer-supplied correlationId (string) on every record', async () => {
+    const events: UWCTelemetryEvent[] = []
+    const uwc = new UniversalWalletConnector({
+      networks,
+      wallets,
+      observer: { onEvent: e => events.push(e) },
+      correlationId: 'link-123'
+    })
+
+    await uwc.signMessage('hello')
+
+    expect(events.length).toBeGreaterThan(0)
+    expect(events.every(e => e.sdkSessionId === 'link-123')).toBe(true)
+  })
+
+  it('resolves a correlationId getter per-event (dynamic id)', async () => {
+    let id = 'a'
+    const events: UWCTelemetryEvent[] = []
+    const uwc = new UniversalWalletConnector({
+      networks,
+      wallets,
+      observer: { onEvent: e => events.push(e) },
+      correlationId: () => id
+    })
+
+    await uwc.signMessage('one')
+    id = 'b'
+    await uwc.signMessage('two')
+
+    const ids = new Set(events.map(e => e.sdkSessionId))
+    expect(ids.has('a')).toBe(true)
+    expect(ids.has('b')).toBe(true)
+  })
+
+  it('falls back to the generated id when the correlationId getter throws', async () => {
+    const events: UWCTelemetryEvent[] = []
+    const uwc = new UniversalWalletConnector({
+      networks,
+      wallets,
+      observer: { onEvent: e => events.push(e) },
+      correlationId: () => {
+        throw new Error('not ready')
+      }
+    })
+
+    await uwc.signMessage('hello')
+
+    expect(events.length).toBeGreaterThan(0)
+    // A stable, non-empty fallback id is stamped — never a throw.
+    expect(
+      events.every(
+        e => typeof e.sdkSessionId === 'string' && e.sdkSessionId.length > 0
+      )
+    ).toBe(true)
+  })
+
+  it('emits walletFailed when the underlying op throws', async () => {
+    signMessageMock.mockRejectedValueOnce(new Error('relay down'))
+    const events: UWCTelemetryEvent[] = []
+    const uwc = new UniversalWalletConnector({
+      networks,
+      wallets,
+      observer: { onEvent: e => events.push(e) }
+    })
+
+    await expect(uwc.signMessage('hello')).rejects.toThrow('relay down')
+    const failed = events.find(e => e.name === 'walletFailed')
+    expect(failed?.error?.message).toBe('relay down')
+    // The back-compat `error` event still fires too.
+    expect(events.some(e => e.name === 'error')).toBe(true)
+  })
+
+  it('an aborted op emits awaitingWallet with no terminal and no error', async () => {
+    // A DOMException AbortError is an intentional cancellation, not a wallet
+    // outcome: instrumentHandoff emits no terminal, and emitError must skip it
+    // too (both paths share isAbortError).
+    signMessageMock.mockRejectedValueOnce(
+      new DOMException('Aborted', 'AbortError')
+    )
+    const events: UWCTelemetryEvent[] = []
+    const uwc = new UniversalWalletConnector({
+      networks,
+      wallets,
+      observer: { onEvent: e => events.push(e) }
+    })
+
+    await expect(uwc.signMessage('hello')).rejects.toThrow()
+
+    const names = events.map(e => e.name)
+    expect(names).toContain('awaitingWallet')
+    expect(names).not.toContain('walletSucceeded')
+    expect(names).not.toContain('walletRejected')
+    expect(names).not.toContain('walletFailed')
+    expect(names).not.toContain('error')
+  })
+
+  it('routes a custom logger as the sink and the multi-instance warning through it', () => {
+    const calls: string[] = []
+    const logger: Logger = {
+      debug: () => {},
+      info: () => {},
+      warn: () => {},
+      error: msg => calls.push(msg)
+    }
+    // First instance is fine; the SECOND triggers the multi-instance warning,
+    // which must travel through the injected logger, not raw console.
+    new UniversalWalletConnector({ networks, wallets, logger })
+    new UniversalWalletConnector({ networks, wallets, logger })
+
+    expect(calls.some(m => m.includes('Multiple instances'))).toBe(true)
+  })
+
+  it('dispose() stops further observer delivery', async () => {
+    const events: UWCTelemetryEvent[] = []
+    const uwc = new UniversalWalletConnector({
+      networks,
+      wallets,
+      observer: { onEvent: e => events.push(e) }
+    })
+    uwc.dispose()
+    events.length = 0
+    await uwc.signMessage('hello')
+    expect(events).toHaveLength(0)
+  })
+})