@meshconnect/uwc-core 0.2.13 → 0.2.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meshconnect/uwc-core",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "description": "Core functionality for Universal Wallet Connector",
   "type": "module",
   "main": "dist/index.js",
@@ -16,10 +16,10 @@
     "src"
   ],
   "dependencies": {
+    "@meshconnect/uwc-injected-connector": "0.2.9",
+    "@meshconnect/uwc-types": "0.2.6",
     "@meshconnect/uwc-bridge-child": "0.0.3",
-    "@meshconnect/uwc-types": "0.2.5",
-    "@meshconnect/uwc-injected-connector": "0.2.8",
-    "@meshconnect/uwc-wallet-connect-connector": "0.2.8"
+    "@meshconnect/uwc-wallet-connect-connector": "0.2.9"
   },
   "devDependencies": {
     "typescript": "^5.9.2"

package/src/managers/event-manager.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { EventManager } from './event-manager'
+
+describe('EventManager', () => {
+  let eventManager: EventManager
+
+  beforeEach(() => {
+    eventManager = new EventManager()
+  })
+  it('should subscribe and notify listeners', () => {
+    let eventReceived = false
+
+    const unsubscribe = eventManager.subscribe(() => {
+      eventReceived = true
+    })
+
+    eventManager.notify()
+
+    expect(eventReceived).toBe(true)
+
+    unsubscribe()
+    eventReceived = false
+
+    eventManager.notify()
+
+    expect(eventReceived).toBe(false)
+  })
+
+  it('should handle multiple subscribers', () => {
+    let subscriber1Called = false
+    let subscriber2Called = false
+
+    const unsubscribe1 = eventManager.subscribe(() => {
+      subscriber1Called = true
+    })
+
+    const unsubscribe2 = eventManager.subscribe(() => {
+      subscriber2Called = true
+    })
+
+    eventManager.notify()
+
+    expect(subscriber1Called).toBe(true)
+    expect(subscriber2Called).toBe(true)
+
+    unsubscribe1()
+    unsubscribe2()
+  })
+
+  it('should track listener count', () => {
+    expect(eventManager.getListenerCount()).toBe(0)
+
+    const unsubscribe1 = eventManager.subscribe(() => {})
+    expect(eventManager.getListenerCount()).toBe(1)
+
+    const unsubscribe2 = eventManager.subscribe(() => {})
+    expect(eventManager.getListenerCount()).toBe(2)
+
+    unsubscribe1()
+    expect(eventManager.getListenerCount()).toBe(1)
+
+    unsubscribe2()
+    expect(eventManager.getListenerCount()).toBe(0)
+  })
+
+  it('should clear all listeners', () => {
+    eventManager.subscribe(() => {})
+    eventManager.subscribe(() => {})
+    expect(eventManager.getListenerCount()).toBe(2)
+
+    eventManager.clearAllListeners()
+    expect(eventManager.getListenerCount()).toBe(0)
+  })
+})

package/src/managers/session-manager.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { SessionManager } from './session-manager'
+import type { Network } from '../../../types/src'
+
+describe('SessionManager', () => {
+  let sessionManager: SessionManager
+
+  beforeEach(() => {
+    sessionManager = new SessionManager()
+  })
+
+  it('should initialize with empty session', () => {
+    const session = sessionManager.getSession()
+    expect(session.connectionMode).toBeNull()
+    expect(session.activeWallet).toBeNull()
+    expect(session.activeNetwork).toBeNull()
+    expect(session.activeAddress).toBeNull()
+    expect(session.availableNetworks).toEqual([])
+    expect(session.availableAddresses).toEqual([])
+  })
+
+  it('should update session correctly', () => {
+    const updates = {
+      connectionMode: 'injected' as const,
+      activeAddress: '0x1234567890abcdef',
+      availableNetworks: [
+        {
+          id: 'eip155:1',
+          internalId: 1,
+          name: 'Ethereum Mainnet',
+          namespace: 'eip155',
+          logoUrl:
+            'https://ethereum.org/static/6b935ac0e619424734bc5a3b11026273/6ed5f/eth-diamond-black.png',
+          rpcUrls: {
+            default: {
+              http: ['https://mainnet.infura.io/v3/test']
+            }
+          },
+          blockExplorers: {
+            default: {
+              name: 'Etherscan',
+              url: 'https://etherscan.io'
+            }
+          },
+          networkType: 'evm',
+          nativeCurrency: {
+            name: 'Ether',
+            symbol: 'ETH',
+            decimals: 18
+          }
+        }
+      ]
+    }
+
+    sessionManager.updateSession(updates)
+    const session = sessionManager.getSession()
+
+    expect(session.connectionMode).toBe('injected')
+    expect(session.activeAddress).toBe('0x1234567890abcdef')
+    expect(session.availableNetworks).toHaveLength(1)
+    expect(session.availableNetworks[0].name).toBe('Ethereum Mainnet')
+  })
+
+  it('should clear session correctly', () => {
+    // First update the session
+    sessionManager.updateSession({
+      connectionMode: 'injected',
+      activeAddress: '0x1234567890abcdef'
+    })
+
+    // Then clear it
+    sessionManager.clearSession()
+    const session = sessionManager.getSession()
+
+    expect(session.connectionMode).toBeNull()
+    expect(session.activeWallet).toBeNull()
+    expect(session.activeNetwork).toBeNull()
+    expect(session.activeAddress).toBeNull()
+    expect(session.availableNetworks).toEqual([])
+    expect(session.availableAddresses).toEqual([])
+  })
+
+  it('should set individual properties', () => {
+    const network: Network = {
+      id: 'eip155:1',
+      internalId: 1,
+      name: 'Ethereum Mainnet',
+      namespace: 'eip155',
+      logoUrl:
+        'https://ethereum.org/static/6b935ac0e619424734bc5a3b11026273/6ed5f/eth-diamond-black.png',
+      rpcUrls: {
+        default: {
+          http: ['https://mainnet.infura.io/v3/test']
+        }
+      },
+      blockExplorers: {
+        default: {
+          name: 'Etherscan',
+          url: 'https://etherscan.io'
+        }
+      },
+      networkType: 'evm',
+      nativeCurrency: {
+        name: 'Ether',
+        symbol: 'ETH',
+        decimals: 18
+      }
+    }
+
+    sessionManager.setActiveNetwork(network)
+    sessionManager.setActiveAddress('0xabcdef1234567890')
+    sessionManager.setAvailableNetworks([network])
+
+    const session = sessionManager.getSession()
+    expect(session.activeNetwork).toEqual(network)
+    expect(session.activeAddress).toBe('0xabcdef1234567890')
+    expect(session.availableNetworks).toEqual([network])
+  })
+})

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

@@ -0,0 +1,151 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { ConnectionService } from './connection-service'
+import { SessionManager } from '../managers/session-manager'
+import { EventManager } from '../managers/event-manager'
+import type {
+  Network,
+  WalletMetadata,
+  ConnectionMode,
+  Connector
+} from '../../../types/src'
+
+describe('ConnectionService', () => {
+  let connectionService: ConnectionService
+  let sessionManager: SessionManager
+  let eventManager: EventManager
+  let mockConnector: Connector
+  let networks: Network[]
+  let wallets: WalletMetadata[]
+  let connectors: Map<ConnectionMode, Connector>
+
+  beforeEach(() => {
+    sessionManager = new SessionManager()
+    eventManager = new EventManager()
+
+    networks = [
+      {
+        id: 'eip155:1',
+        internalId: 1,
+        name: 'Ethereum Mainnet',
+        namespace: 'eip155',
+        logoUrl:
+          'https://ethereum.org/static/6b935ac0e619424734bc5a3b11026273/6ed5f/eth-diamond-black.png',
+        rpcUrls: {
+          default: {
+            http: ['https://mainnet.infura.io/v3/test']
+          }
+        },
+        blockExplorers: {
+          default: {
+            name: 'Etherscan',
+            url: 'https://etherscan.io'
+          }
+        },
+        networkType: 'evm',
+        nativeCurrency: {
+          name: 'Ether',
+          symbol: 'ETH',
+          decimals: 18
+        }
+      }
+    ]
+
+    wallets = [
+      {
+        id: 'metamask',
+        name: 'MetaMask',
+        metadata: {
+          icon: 'data:image/svg+xml;base64,test',
+          downloadUrl: 'https://metamask.io',
+          supportedChains: ['eip155:1']
+        },
+        extensionInjectedProvider: {} as any,
+        walletConnectProvider: {} as any
+      }
+    ]
+
+    mockConnector = {
+      connect: vi.fn(),
+      disconnect: vi.fn(),
+      signMessage: vi.fn(),
+      sendTransaction: vi.fn(),
+      switchNetwork: vi.fn()
+    }
+
+    connectors = new Map()
+    connectors.set('injected', mockConnector)
+
+    connectionService = new ConnectionService(
+      networks,
+      wallets,
+      sessionManager,
+      connectors,
+      false,
+      eventManager
+    )
+  })
+
+  it('should initialize with provided parameters', () => {
+    expect(connectionService).toBeDefined()
+  })
+
+  it('should find wallet by id', () => {
+    const wallet = connectionService['findWallet']('metamask')
+    expect(wallet).toEqual(wallets[0])
+  })
+
+  it('should throw error for unknown wallet', () => {
+    expect(() => {
+      connectionService['findWallet']('unknown')
+    }).toThrow("Wallet with id 'unknown' not found")
+  })
+
+  it('should validate network exists', () => {
+    const mockProvider = {
+      supportedNetworkIds: ['eip155:1']
+    }
+    const network = connectionService['validateAndDetermineNetwork'](
+      'eip155:1',
+      mockProvider as any
+    )
+    expect(network).toEqual(networks[0])
+  })
+
+  it('should throw error for unknown network', () => {
+    const mockProvider = {
+      supportedNetworkIds: ['eip155:1']
+    }
+    expect(() => {
+      connectionService['validateAndDetermineNetwork'](
+        'eip155:999',
+        mockProvider as any
+      )
+    }).toThrow('Network eip155:999 is not in the configured networks')
+  })
+
+  it('should get connector by mode', () => {
+    const connector = connectionService['getConnector']('injected')
+    expect(connector).toBe(mockConnector)
+  })
+
+  it('should throw error for unknown connector mode', () => {
+    expect(() => {
+      connectionService['getConnector']('unknown' as ConnectionMode)
+    }).toThrow('No connector found for connection mode: unknown')
+  })
+
+  it('should get provider for injected mode', () => {
+    const wallet = wallets[0]
+    const provider = connectionService['getProviderForMode'](wallet, 'injected')
+    expect(provider).toBeDefined()
+  })
+
+  it('should get provider for walletConnect mode', () => {
+    const wallet = wallets[0]
+    const provider = connectionService['getProviderForMode'](
+      wallet,
+      'walletConnect'
+    )
+    expect(provider).toBeDefined()
+  })
+})

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

@@ -0,0 +1,187 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { NetworkSwitchService } from './network-switch-service'
+import { SessionManager } from '../managers/session-manager'
+import { EventManager } from '../managers/event-manager'
+import type { Network, ConnectionMode, Connector } from '../../../types/src'
+
+describe('NetworkSwitchService', () => {
+  let networkSwitchService: NetworkSwitchService
+  let sessionManager: SessionManager
+  let eventManager: EventManager
+  let mockConnector: Connector
+  let networks: Network[]
+  let connectors: Map<ConnectionMode, Connector>
+
+  beforeEach(() => {
+    sessionManager = new SessionManager()
+    eventManager = new EventManager()
+
+    networks = [
+      {
+        id: 'eip155:1',
+        internalId: 1,
+        name: 'Ethereum Mainnet',
+        namespace: 'eip155',
+        logoUrl:
+          'https://ethereum.org/static/6b935ac0e619424734bc5a3b11026273/6ed5f/eth-diamond-black.png',
+        rpcUrls: {
+          default: {
+            http: ['https://mainnet.infura.io/v3/test']
+          }
+        },
+        blockExplorers: {
+          default: {
+            name: 'Etherscan',
+            url: 'https://etherscan.io'
+          }
+        },
+        networkType: 'evm',
+        nativeCurrency: {
+          name: 'Ether',
+          symbol: 'ETH',
+          decimals: 18
+        }
+      },
+      {
+        id: 'eip155:137',
+        internalId: 137,
+        name: 'Polygon',
+        namespace: 'eip155',
+        logoUrl: 'https://polygon.technology/static/polygon-logo.png',
+        rpcUrls: {
+          default: {
+            http: ['https://polygon-rpc.com']
+          }
+        },
+        blockExplorers: {
+          default: {
+            name: 'Polygonscan',
+            url: 'https://polygonscan.com'
+          }
+        },
+        networkType: 'evm',
+        nativeCurrency: {
+          name: 'MATIC',
+          symbol: 'MATIC',
+          decimals: 18
+        }
+      }
+    ]
+
+    mockConnector = {
+      connect: vi.fn(),
+      disconnect: vi.fn(),
+      signMessage: vi.fn(),
+      sendTransaction: vi.fn(),
+      switchNetwork: vi.fn()
+    }
+
+    connectors = new Map()
+    connectors.set('injected', mockConnector)
+
+    networkSwitchService = new NetworkSwitchService(
+      networks,
+      sessionManager,
+      connectors,
+      false,
+      eventManager
+    )
+  })
+
+  it('should initialize with provided parameters', () => {
+    expect(networkSwitchService).toBeDefined()
+  })
+
+  it('should return loading state', () => {
+    const state = networkSwitchService.getLoadingState()
+    expect(state).toEqual({
+      isLoading: false,
+      isWaitingForUserApproval: false
+    })
+  })
+
+  it('should throw error when no active connection', async () => {
+    await expect(
+      networkSwitchService.switchNetwork('eip155:1')
+    ).rejects.toThrow('No active wallet found in session')
+  })
+
+  it('should throw error for unknown network', async () => {
+    sessionManager.updateSession({
+      connectionMode: 'injected',
+      activeWallet: {
+        id: 'metamask',
+        name: 'MetaMask',
+        metadata: {
+          icon: 'test',
+          downloadUrl: 'test',
+          supportedChains: ['eip155:1']
+        }
+      }
+    })
+
+    await expect(
+      networkSwitchService.switchNetwork('eip155:999')
+    ).rejects.toThrow("Network with id 'eip155:999' not found")
+  })
+
+  it('should throw error when no active wallet', async () => {
+    sessionManager.updateSession({
+      connectionMode: 'injected'
+    })
+
+    await expect(
+      networkSwitchService.switchNetwork('eip155:1')
+    ).rejects.toThrow('No active wallet found in session')
+  })
+
+  it('should throw error when wallet does not support network', async () => {
+    sessionManager.updateSession({
+      connectionMode: 'injected',
+      activeWallet: {
+        id: 'metamask',
+        name: 'MetaMask',
+        metadata: {
+          icon: 'test',
+          downloadUrl: 'test',
+          supportedChains: ['eip155:1']
+        }
+      }
+    })
+
+    await expect(
+      networkSwitchService.switchNetwork('eip155:137')
+    ).rejects.toThrow(
+      "Wallet 'metamask' does not have a provider for injected mode"
+    )
+  })
+
+  it('should throw error when connector does not support network switching', async () => {
+    const connectorWithoutSwitch = {
+      connect: vi.fn(),
+      disconnect: vi.fn(),
+      signMessage: vi.fn(),
+      sendTransaction: vi.fn()
+    }
+    connectors.set('injected', connectorWithoutSwitch)
+
+    sessionManager.updateSession({
+      connectionMode: 'injected',
+      activeWallet: {
+        id: 'metamask',
+        name: 'MetaMask',
+        metadata: {
+          icon: 'test',
+          downloadUrl: 'test',
+          supportedChains: ['eip155:1']
+        }
+      }
+    })
+
+    await expect(
+      networkSwitchService.switchNetwork('eip155:1')
+    ).rejects.toThrow(
+      "Wallet 'metamask' does not have a provider for injected mode"
+    )
+  })
+})

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

@@ -0,0 +1,108 @@
+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', () => {
+  let signatureService: SignatureService
+  let sessionManager: SessionManager
+  let mockConnector: Connector
+  let connectors: Map<ConnectionMode, Connector>
+
+  beforeEach(() => {
+    sessionManager = new SessionManager()
+
+    mockConnector = {
+      connect: vi.fn(),
+      disconnect: vi.fn(),
+      signMessage: vi.fn().mockResolvedValue('0xsignature'),
+      sendTransaction: vi.fn(),
+      switchNetwork: vi.fn()
+    }
+
+    connectors = new Map()
+    connectors.set('injected', mockConnector)
+
+    signatureService = new SignatureService(sessionManager, connectors)
+  })
+
+  it('should initialize with provided parameters', () => {
+    expect(signatureService).toBeDefined()
+  })
+
+  it('should throw error when no active connection', async () => {
+    await expect(signatureService.signMessage('test message')).rejects.toThrow(
+      'No active connection'
+    )
+  })
+
+  it('should throw error when no active address', async () => {
+    sessionManager.updateSession({
+      connectionMode: 'injected'
+    })
+
+    await expect(signatureService.signMessage('test message')).rejects.toThrow(
+      'No active wallet address'
+    )
+  })
+
+  it('should throw error when connector not found', async () => {
+    sessionManager.updateSession({
+      connectionMode: 'unknown' as ConnectionMode,
+      activeAddress: '0x123'
+    })
+
+    await expect(signatureService.signMessage('test message')).rejects.toThrow(
+      'No connector found for connection mode: unknown'
+    )
+  })
+
+  it('should throw error when connector does not support signing', async () => {
+    const connectorWithoutSign = {
+      connect: vi.fn(),
+      disconnect: vi.fn(),
+      sendTransaction: vi.fn(),
+      switchNetwork: vi.fn()
+    }
+    connectors.set('injected', connectorWithoutSign)
+
+    sessionManager.updateSession({
+      connectionMode: 'injected',
+      activeAddress: '0x123'
+    })
+
+    await expect(signatureService.signMessage('test message')).rejects.toThrow(
+      'Connector does not support message signing'
+    )
+  })
+
+  it('should sign message successfully', async () => {
+    sessionManager.updateSession({
+      connectionMode: 'injected',
+      activeAddress: '0x123'
+    })
+
+    const provider = {} as any
+    const result = await signatureService.signMessage('test message', provider)
+    expect(result).toBe('0xsignature')
+    expect(mockConnector.signMessage).toHaveBeenCalledWith(
+      'test message',
+      provider
+    )
+  })
+
+  it('should sign message with provider', async () => {
+    sessionManager.updateSession({
+      connectionMode: 'injected',
+      activeAddress: '0x123'
+    })
+
+    const provider = {} as any
+    const result = await signatureService.signMessage('test message', provider)
+    expect(result).toBe('0xsignature')
+    expect(mockConnector.signMessage).toHaveBeenCalledWith(
+      'test message',
+      provider
+    )
+  })
+})