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

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

@@ -1,265 +0,0 @@
-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)
-  })
-})

package/src/utils/id.test.ts

@@ -1,15 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { generateId } from './id'
-
-describe('generateId', () => {
-  it('produces unique values', () => {
-    const ids = new Set(Array.from({ length: 1000 }, () => generateId()))
-    expect(ids.size).toBe(1000)
-  })
-
-  it('produces a non-empty string', () => {
-    const id = generateId()
-    expect(typeof id).toBe('string')
-    expect(id.length).toBeGreaterThan(0)
-  })
-})

package/src/utils/id.ts

@@ -1,48 +0,0 @@
-/**
- * Generate a correlation id (RFC-4122 v4 when available).
- *
- * Used for the per-instance `sdkSessionId` and per-handoff `handoffId` — both are
- * opaque correlation tokens, never derived from wallet data (no address, no key).
- * Prefers the native `crypto.randomUUID()` (browsers + Node ≥ 16); falls back to a
- * `crypto.getRandomValues`-backed v4, and finally to a timestamp + monotonic
- * counter only in environments that expose neither. Correlation ids need to be
- * collision-resistant enough to pair a start event with its terminal — NOT
- * cryptographically unpredictable — so the last-resort branch uses no PRNG.
- */
-// Monotonic counter for the no-crypto fallback: guarantees per-process uniqueness
-// without any pseudo-random generator (correlation ids need uniqueness, not
-// unpredictability — and a counter is strictly more collision-resistant here).
-let fallbackCounter = 0
-
-export function generateId(): string {
-  const c = typeof globalThis !== 'undefined' ? globalThis.crypto : undefined
-
-  if (c?.randomUUID) {
-    return c.randomUUID()
-  }
-
-  if (c?.getRandomValues) {
-    const bytes = c.getRandomValues(new Uint8Array(16))
-    // Set the version (4) and variant (10xx) bits per RFC 4122 §4.4.
-    bytes[6] = (bytes[6]! & 0x0f) | 0x40
-    bytes[8] = (bytes[8]! & 0x3f) | 0x80
-    const hex = Array.from(bytes, b => b.toString(16).padStart(2, '0'))
-    return (
-      hex.slice(0, 4).join('') +
-      '-' +
-      hex.slice(4, 6).join('') +
-      '-' +
-      hex.slice(6, 8).join('') +
-      '-' +
-      hex.slice(8, 10).join('') +
-      '-' +
-      hex.slice(10, 16).join('')
-    )
-  }
-
-  // Last-resort fallback (no Web Crypto). Timestamp + monotonic counter keeps
-  // ids unique within the process without a PRNG. Sufficient for correlation.
-  return (
-    'uwc-' + Date.now().toString(36) + '-' + (fallbackCounter++).toString(36)
-  )
-}

package/src/utils/to-wallet-error.ts

@@ -1,36 +0,0 @@
-import { WalletConnectorError, type WalletError } from '@meshconnect/uwc-types'
-
-/** Normalize any thrown value into the PII-light `WalletError` shape. */
-export function toWalletError(error: unknown): WalletError {
-  if (error instanceof WalletConnectorError) {
-    return { type: error.type, message: error.message }
-  }
-  return {
-    type: 'unknown',
-    message: error instanceof Error ? error.message : String(error)
-  }
-}
-
-/**
- * Whether a thrown value is an explicit user rejection. Connectors usually wrap
- * these as `WalletConnectorError{type:'rejected'}`, but a raw EIP-1193 reject
- * (code `4001`) or ethers' `ACTION_REJECTED` can also reach the façade.
- */
-export function isUserRejection(error: unknown): boolean {
-  if (error instanceof WalletConnectorError) return error.type === 'rejected'
-  const code = (error as { code?: unknown } | null | undefined)?.code
-  return code === 4001 || code === 'ACTION_REJECTED'
-}
-
-/**
- * Whether a thrown value is an intentional cancellation (AbortSignal / fetch
- * abort). Matched by `name` rather than `instanceof Error` because a real abort is
- * a `DOMException`, which is not an `Error` subclass in every runtime.
- */
-export function isAbortError(error: unknown): boolean {
-  return (
-    typeof error === 'object' &&
-    error !== null &&
-    (error as { name?: unknown }).name === 'AbortError'
-  )
-}