@meshconnect/uwc-core 0.2.13 → 0.2.15

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

@@ -0,0 +1,428 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest'
+import { UniversalWalletConnector } from './universal-wallet-connector'
+import type {
+  Network,
+  WalletMetadata,
+  WalletConnectConfig,
+  TransactionRequest
+} from '@meshconnect/uwc-types'
+
+const mockInjectedConnector = {
+  getAvailableWallets: vi.fn().mockResolvedValue([])
+}
+
+const mockWalletConnectConnector = {
+  getAvailableWallets: vi.fn().mockResolvedValue([])
+}
+
+const mockSessionManager = {
+  getSession: vi.fn().mockReturnValue({
+    connectionMode: null,
+    activeWallet: null,
+    activeNetwork: null,
+    activeAddress: null,
+    availableNetworks: [],
+    availableAddresses: [],
+    activeWalletCapabilities: null
+  })
+}
+
+const mockEventManager = {
+  subscribe: vi.fn().mockReturnValue(() => {}),
+  notify: vi.fn()
+}
+
+const mockConnectionService = {
+  getWallets: vi.fn().mockReturnValue([]),
+  getNetworks: vi.fn().mockReturnValue([]),
+  connect: vi.fn(),
+  disconnect: vi.fn(),
+  getConnectionURI: vi.fn(),
+  updateWallets: vi.fn()
+}
+
+const mockNetworkSwitchService = {
+  switchNetwork: vi.fn(),
+  getLoadingState: vi.fn().mockReturnValue(false)
+}
+
+const mockSignatureService = {
+  signMessage: vi.fn()
+}
+
+const mockTransactionService = {
+  sendTransaction: vi.fn()
+}
+
+// Mock the dependencies
+vi.mock('@meshconnect/uwc-injected-connector', () => ({
+  InjectedConnector: vi.fn(() => mockInjectedConnector)
+}))
+
+vi.mock('@meshconnect/uwc-wallet-connect-connector', () => ({
+  WalletConnectConnector: vi.fn(() => mockWalletConnectConnector)
+}))
+
+vi.mock('@meshconnect/uwc-bridge-child', () => ({
+  BridgeChild: vi.fn()
+}))
+
+vi.mock('./managers/session-manager', () => ({
+  SessionManager: vi.fn(() => mockSessionManager)
+}))
+
+vi.mock('./managers/event-manager', () => ({
+  EventManager: vi.fn(() => mockEventManager)
+}))
+
+vi.mock('./services/connection-service', () => ({
+  ConnectionService: vi.fn(() => mockConnectionService)
+}))
+
+vi.mock('./services/network-switch-service', () => ({
+  NetworkSwitchService: vi.fn(() => mockNetworkSwitchService)
+}))
+
+vi.mock('./services/signature-service', () => ({
+  SignatureService: vi.fn(() => mockSignatureService)
+}))
+
+vi.mock('./services/transaction-service', () => ({
+  TransactionService: vi.fn(() => mockTransactionService)
+}))
+
+vi.mock('./utils/network-rpc-utils', () => ({
+  createNetworkRpcMap: vi.fn().mockReturnValue(new Map())
+}))
+
+describe('UniversalWalletConnector', () => {
+  let mockNetworks: Network[]
+  let mockWallets: WalletMetadata[]
+  let mockWalletConnectConfig: WalletConnectConfig
+
+  beforeEach(() => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ;(UniversalWalletConnector as any).instanceCount = 0
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ;(UniversalWalletConnector as any).hasWarnedAboutMultipleInstances = false
+
+    mockNetworks = [
+      {
+        id: 'eip155:1',
+        internalId: 1,
+        name: 'Ethereum Mainnet',
+        namespace: 'eip155',
+        logoUrl: 'https://example.com/eth.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
+        }
+      }
+    ]
+
+    mockWallets = [
+      {
+        id: 'metamask',
+        name: 'MetaMask',
+        metadata: {},
+        extensionInjectedProvider: {
+          supportedNetworkIds: ['eip155:1'] as const,
+          namespaceMetaData: {
+            eip155: {
+              eip155Name: 'MetaMask',
+              injectedId: 'io.metamask',
+              supportsAddingNetworks: true,
+              requiresUserApprovalOnNetworkSwitch: false
+            }
+          },
+          requiresUserApprovalOnNamespaceSwitch: false
+        }
+      }
+    ]
+
+    mockWalletConnectConfig = {
+      projectId: 'test-project-id',
+      metadata: {
+        name: 'Test App',
+        description: 'Test App Description',
+        url: 'https://test.com',
+        icons: ['https://test.com/icon.png']
+      }
+    }
+
+    // Clear all mocks
+    vi.clearAllMocks()
+
+    // Reset mock return values for methods that are called in the constructor
+    mockInjectedConnector.getAvailableWallets.mockResolvedValue([])
+    mockWalletConnectConnector.getAvailableWallets.mockResolvedValue([])
+    mockConnectionService.getWallets.mockReturnValue(mockWallets)
+    mockConnectionService.getNetworks.mockReturnValue(mockNetworks)
+    mockSessionManager.getSession.mockReturnValue({
+      connectionMode: null,
+      activeWallet: null,
+      activeNetwork: null,
+      activeAddress: null,
+      availableNetworks: [],
+      availableAddresses: [],
+      activeWalletCapabilities: null
+    })
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe('constructor', () => {
+    it('should initialize with required parameters', () => {
+      const connector = new UniversalWalletConnector(mockNetworks, mockWallets)
+
+      expect(connector).toBeInstanceOf(UniversalWalletConnector)
+    })
+
+    it('should initialize with WalletConnect config when provided', () => {
+      const connector = new UniversalWalletConnector(
+        mockNetworks,
+        mockWallets,
+        false,
+        mockWalletConnectConfig
+      )
+
+      expect(connector).toBeInstanceOf(UniversalWalletConnector)
+    })
+
+    it('should throw error when networks are not provided', () => {
+      expect(() => {
+        // @ts-expect-error Testing error case with null networks
+        new UniversalWalletConnector(null, mockWallets)
+      }).toThrow(
+        'Universal Wallet Connector must be initialized with at least one network'
+      )
+    })
+
+    it('should throw error when wallets are not provided', () => {
+      expect(() => {
+        // @ts-expect-error Testing error case with null wallets
+        new UniversalWalletConnector(mockNetworks, null)
+      }).toThrow(
+        'Universal Wallet Connector must be initialized with at least one wallet'
+      )
+    })
+
+    it('should warn about multiple instances', () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+
+      new UniversalWalletConnector(mockNetworks, mockWallets)
+      new UniversalWalletConnector(mockNetworks, mockWallets)
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining(
+          'WARNING: Multiple instances of UniversalWalletConnector detected'
+        )
+      )
+
+      consoleSpy.mockRestore()
+    })
+  })
+
+  describe('isReady', () => {
+    it('should return true after detection is complete', async () => {
+      const connector = new UniversalWalletConnector(mockNetworks, mockWallets)
+
+      // Wait for async initialization to complete
+      await new Promise(resolve => setTimeout(resolve, 0))
+
+      expect(connector.isReady()).toBe(true)
+    })
+  })
+
+  describe('isConnectionModeAvailable', () => {
+    it('should return false for unknown wallet', () => {
+      const connector = new UniversalWalletConnector(mockNetworks, mockWallets)
+
+      expect(
+        connector.isConnectionModeAvailable('injected', 'unknown-wallet')
+      ).toBe(false)
+    })
+
+    it('should return false for WalletConnect when connector not available', () => {
+      const connector = new UniversalWalletConnector(mockNetworks, mockWallets)
+
+      expect(
+        connector.isConnectionModeAvailable('walletConnect', 'metamask')
+      ).toBe(false)
+    })
+
+    it('should return true for WalletConnect when connector and provider available', () => {
+      const walletWithWalletConnect = {
+        ...mockWallets[0],
+        walletConnectProvider: {
+          supportedNetworkIds: ['eip155:1'] as const,
+          deeplinks: {
+            universal: 'https://metamask.app',
+            native: 'metamask://'
+          }
+        }
+      } as WalletMetadata
+
+      const connector = new UniversalWalletConnector(
+        mockNetworks,
+        [walletWithWalletConnect],
+        false,
+        mockWalletConnectConfig
+      )
+
+      expect(
+        connector.isConnectionModeAvailable('walletConnect', 'metamask')
+      ).toBe(true)
+    })
+
+    it('should return false for injected when no provider', () => {
+      const walletWithoutProvider = {
+        ...mockWallets[0],
+        extensionInjectedProvider: undefined
+      }
+
+      const connector = new UniversalWalletConnector(mockNetworks, [
+        walletWithoutProvider
+      ])
+
+      expect(connector.isConnectionModeAvailable('injected', 'metamask')).toBe(
+        false
+      )
+    })
+
+    it('should return false for injected when no installed namespace', () => {
+      const walletWithoutInstalledNamespace = {
+        ...mockWallets[0],
+        extensionInjectedProvider: {
+          supportedNetworkIds: ['eip155:1'] as const,
+          namespaceMetaData: {
+            eip155: {
+              eip155Name: 'MetaMask',
+              injectedId: 'io.metamask',
+              supportsAddingNetworks: true,
+              requiresUserApprovalOnNetworkSwitch: false,
+              installed: false
+            }
+          },
+          requiresUserApprovalOnNamespaceSwitch: false
+        }
+      } as WalletMetadata
+
+      const connector = new UniversalWalletConnector(mockNetworks, [
+        walletWithoutInstalledNamespace
+      ])
+
+      expect(connector.isConnectionModeAvailable('injected', 'metamask')).toBe(
+        false
+      )
+    })
+
+    it('should return true for injected when namespace is installed', () => {
+      const walletWithInstalledNamespace = {
+        ...mockWallets[0],
+        extensionInjectedProvider: {
+          supportedNetworkIds: ['eip155:1'] as const,
+          namespaceMetaData: {
+            eip155: {
+              eip155Name: 'MetaMask',
+              injectedId: 'io.metamask',
+              supportsAddingNetworks: true,
+              requiresUserApprovalOnNetworkSwitch: false,
+              installed: true
+            }
+          },
+          requiresUserApprovalOnNamespaceSwitch: false
+        }
+      } as WalletMetadata
+
+      const connector = new UniversalWalletConnector(mockNetworks, [
+        walletWithInstalledNamespace
+      ])
+
+      expect(connector.isConnectionModeAvailable('injected', 'metamask')).toBe(
+        true
+      )
+    })
+
+    it('should return false for unknown connection mode', () => {
+      const connector = new UniversalWalletConnector(mockNetworks, mockWallets)
+
+      expect(
+        // @ts-expect-error Testing unknown connection mode
+        connector.isConnectionModeAvailable('unknown', 'metamask')
+      ).toBe(false)
+    })
+  })
+
+  describe('basic functionality', () => {
+    it('should have all required methods', () => {
+      const connector = new UniversalWalletConnector(mockNetworks, mockWallets)
+
+      expect(typeof connector.getSession).toBe('function')
+      expect(typeof connector.isReady).toBe('function')
+      expect(typeof connector.subscribe).toBe('function')
+      expect(typeof connector.getState).toBe('function')
+      expect(typeof connector.getWallets).toBe('function')
+      expect(typeof connector.getNetworks).toBe('function')
+      expect(typeof connector.connect).toBe('function')
+      expect(typeof connector.getConnectionURI).toBe('function')
+      expect(typeof connector.disconnect).toBe('function')
+      expect(typeof connector.switchNetwork).toBe('function')
+      expect(typeof connector.getNetworkSwitchLoadingState).toBe('function')
+      expect(typeof connector.signMessage).toBe('function')
+      expect(typeof connector.sendTransaction).toBe('function')
+      expect(typeof connector.isConnectionModeAvailable).toBe('function')
+      expect(typeof connector.getActiveWalletCapabilities).toBe('function')
+    })
+  })
+
+  describe('error handling', () => {
+    it('should handle signMessage errors gracefully', async () => {
+      const connector = new UniversalWalletConnector(mockNetworks, mockWallets)
+
+      // This should not throw an error, but should handle the case where session manager is not properly mocked
+      await expect(connector.signMessage('test')).rejects.toThrow()
+    })
+
+    it('should handle sendTransaction errors gracefully', async () => {
+      const connector = new UniversalWalletConnector(mockNetworks, mockWallets)
+
+      // This should not throw an error, but should handle the case where session manager is not properly mocked
+      await expect(
+        connector.sendTransaction({
+          to: '0x123',
+          value: '0x0',
+          data: '0x',
+          gas: '0x5208'
+        } as unknown as TransactionRequest)
+      ).rejects.toThrow()
+    })
+  })
+
+  describe('wallet detection', () => {
+    it('should handle wallet detection gracefully', async () => {
+      const connector = new UniversalWalletConnector(mockNetworks, mockWallets)
+
+      // Wait for async initialization to complete
+      await new Promise(resolve => setTimeout(resolve, 0))
+
+      // Should complete without throwing
+      expect(connector.isReady()).toBe(true)
+    })
+  })
+})