@spacesops/wdk-react-native-core 1.0.0-beta.40

package/src/__tests__/services/accountService.test.ts

@@ -0,0 +1,337 @@
+/**
+ * Tests for AccountService
+ * 
+ * Tests account method calls through the worklet
+ */
+
+import { AccountService } from '../../services/accountService'
+import { getWorkletStore } from '../../store/workletStore'
+
+// Mock stores
+jest.mock('../../store/workletStore', () => ({
+  getWorkletStore: jest.fn(),
+}))
+
+describe('AccountService', () => {
+  let mockWorkletStore: any
+  let mockHRPC: any
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    // Setup mock HRPC
+    mockHRPC = {
+      callMethod: jest.fn(),
+    }
+
+    // Setup mock worklet store
+    mockWorkletStore = {
+      getState: jest.fn(() => ({
+        isInitialized: true,
+        hrpc: mockHRPC,
+      })),
+    }
+
+    // Setup store mocks
+    ;(getWorkletStore as jest.Mock).mockReturnValue(mockWorkletStore)
+  })
+
+  describe('callAccountMethod', () => {
+    it('should call method and return result', async () => {
+      const mockResult = '1000000000000000000'
+      mockHRPC.callMethod.mockResolvedValue({
+        result: JSON.stringify(mockResult),
+      })
+
+      const result = await AccountService.callAccountMethod(
+        'ethereum',
+        0,
+        'getBalance'
+      )
+
+      expect(result).toBe(mockResult)
+      expect(mockHRPC.callMethod).toHaveBeenCalledWith({
+        methodName: 'getBalance',
+        network: 'ethereum',
+        accountIndex: 0,
+        args: null,
+      })
+    })
+
+    it('should handle method with arguments', async () => {
+      const mockArgs = { message: 'Hello World' }
+      const mockResult = { signature: '0x123' }
+      mockHRPC.callMethod.mockResolvedValue({
+        result: JSON.stringify(mockResult),
+      })
+
+      const result = await AccountService.callAccountMethod(
+        'ethereum',
+        0,
+        'signMessage',
+        mockArgs
+      )
+
+      expect(result).toEqual(mockResult)
+      expect(mockHRPC.callMethod).toHaveBeenCalledWith({
+        methodName: 'signMessage',
+        network: 'ethereum',
+        accountIndex: 0,
+        args: JSON.stringify(mockArgs),
+      })
+    })
+
+    it('should convert BigInt values to strings', async () => {
+      // getBalance returns a string, not an object
+      const mockResult = '1000000000000000000'
+      mockHRPC.callMethod.mockResolvedValue({
+        result: JSON.stringify(mockResult),
+      })
+
+      const result = await AccountService.callAccountMethod(
+        'ethereum',
+        0,
+        'getBalance'
+      )
+
+      expect(result).toBe('1000000000000000000')
+    })
+
+    it('should convert BigInt in nested objects', async () => {
+      // Test with signMessage which can return an object
+      const mockResult = {
+        data: {
+          balance: BigInt('1000000000000000000'),
+          nested: {
+            amount: BigInt('2000000000000000000'),
+          },
+        },
+      }
+      const jsonString = JSON.stringify(
+        mockResult,
+        (_, value) => (typeof value === 'bigint' ? value.toString() : value)
+      )
+      mockHRPC.callMethod.mockResolvedValue({
+        result: jsonString,
+      })
+
+      const result = await AccountService.callAccountMethod(
+        'ethereum',
+        0,
+        'signMessage',
+        { message: 'test' }
+      )
+
+      expect(result).toEqual({
+        data: {
+          balance: '1000000000000000000',
+          nested: {
+            amount: '2000000000000000000',
+          },
+        },
+      })
+    })
+
+    it('should convert BigInt in arrays', async () => {
+      // Test with signTransaction which can return an object with arrays
+      const mockResult = {
+        balances: ['1000000000000000000', '2000000000000000000'],
+      }
+      // Simulate BigInt in response by using a custom replacer
+      const jsonString = JSON.stringify(
+        {
+          balances: [BigInt('1000000000000000000'), BigInt('2000000000000000000')],
+        },
+        (_, value) => (typeof value === 'bigint' ? value.toString() : value)
+      )
+      mockHRPC.callMethod.mockResolvedValue({
+        result: jsonString,
+      })
+
+      const result = await AccountService.callAccountMethod(
+        'ethereum',
+        0,
+        'signTransaction',
+        { transaction: {} }
+      )
+
+      expect(result).toEqual({
+        balances: ['1000000000000000000', '2000000000000000000'],
+      })
+    })
+
+    it('should validate methodName', async () => {
+      await expect(
+        AccountService.callAccountMethod('ethereum', 0, '', null)
+      ).rejects.toThrow('methodName must be a non-empty string')
+
+      await expect(
+        AccountService.callAccountMethod('ethereum', 0, '   ', null)
+      ).rejects.toThrow('methodName must be a non-empty string')
+    })
+
+    it('should accept various method names', async () => {
+      const methods = [
+        'getAddress',
+        'getBalance',
+        'getTokenBalance',
+        'signMessage',
+        'signTransaction',
+        'sendTransaction',
+      ]
+
+      for (const method of methods) {
+        // getBalance and getTokenBalance return strings, others can return objects
+        const mockResult = (method === 'getBalance' || method === 'getTokenBalance')
+          ? '1000000000000000000'
+          : { success: true }
+        mockHRPC.callMethod.mockResolvedValue({
+          result: JSON.stringify(mockResult),
+        })
+
+        await expect(
+          AccountService.callAccountMethod('ethereum', 0, method, null)
+        ).resolves.toBeDefined()
+      }
+    })
+
+    it('should use safeStringify for args', async () => {
+      const mockArgs = { test: 'value' }
+      mockHRPC.callMethod.mockResolvedValue({
+        result: JSON.stringify({ success: true }),
+      })
+
+      await AccountService.callAccountMethod(
+        'ethereum',
+        0,
+        'signMessage',
+        mockArgs
+      )
+
+      expect(mockHRPC.callMethod).toHaveBeenCalledWith({
+        methodName: 'signMessage',
+        network: 'ethereum',
+        accountIndex: 0,
+        args: JSON.stringify(mockArgs),
+      })
+    })
+
+    it('should reject circular references in args', async () => {
+      const circular: any = { a: 1 }
+      circular.self = circular
+
+      await expect(
+        AccountService.callAccountMethod('ethereum', 0, 'signMessage', circular)
+      ).rejects.toThrow('circular references')
+    })
+
+    it('should validate balance response format', async () => {
+      mockHRPC.callMethod.mockResolvedValue({
+        result: JSON.stringify('invalid-balance-format'),
+      })
+
+      await expect(
+        AccountService.callAccountMethod('ethereum', 0, 'getBalance', null)
+      ).rejects.toThrow('Invalid balance format')
+    })
+
+    it('should accept valid balance response format', async () => {
+      mockHRPC.callMethod.mockResolvedValue({
+        result: JSON.stringify('1000000000000000000'),
+      })
+
+      const result = await AccountService.callAccountMethod(
+        'ethereum',
+        0,
+        'getBalance',
+        null
+      )
+
+      expect(result).toBe('1000000000000000000')
+    })
+
+    it('should validate network name', async () => {
+      await expect(
+        AccountService.callAccountMethod('', 0, 'getBalance', null)
+      ).rejects.toThrow(/network.*non-empty|Network name must contain only|String must contain at least 1 character/)
+    })
+
+    it('should validate account index', async () => {
+      await expect(
+        AccountService.callAccountMethod('ethereum', -1, 'getBalance', null)
+      ).rejects.toThrow(/accountIndex.*non-negative|Number must be greater than or equal to 0/)
+    })
+
+    it('should throw error if WDK not initialized', async () => {
+      mockWorkletStore.getState = jest.fn(() => ({
+        isInitialized: false,
+        hrpc: null,
+      }))
+
+      await expect(
+        AccountService.callAccountMethod('ethereum', 0, 'getBalance', null)
+      ).rejects.toThrow('WDK not initialized')
+    })
+
+    it('should throw error if HRPC not available', async () => {
+      mockWorkletStore.getState = jest.fn(() => ({
+        isInitialized: true,
+        hrpc: null,
+      }))
+
+      await expect(
+        AccountService.callAccountMethod('ethereum', 0, 'getBalance', null)
+      ).rejects.toThrow('WDK not initialized')
+    })
+
+    it('should throw error if method returns no result', async () => {
+      // workletResponseSchema requires result to be a string, so we need to mock a response that fails schema validation
+      mockHRPC.callMethod.mockResolvedValue({
+        result: null,
+      })
+
+      await expect(
+        AccountService.callAccountMethod('ethereum', 0, 'getBalance', null)
+      ).rejects.toThrow(/Method getBalance returned no result|Expected string/)
+    })
+
+    it('should throw error if result is null', async () => {
+      mockHRPC.callMethod.mockResolvedValue({
+        result: JSON.stringify(null),
+      })
+
+      await expect(
+        AccountService.callAccountMethod('ethereum', 0, 'getBalance', null)
+      ).rejects.toThrow('Parsed result is null or undefined')
+    })
+
+    it('should throw error if result is null', async () => {
+      mockHRPC.callMethod.mockResolvedValue({
+        result: JSON.stringify(null),
+      })
+
+      await expect(
+        AccountService.callAccountMethod('ethereum', 0, 'getBalance', null)
+      ).rejects.toThrow('Parsed result is null or undefined')
+    })
+
+    it('should throw error if JSON parsing fails', async () => {
+      mockHRPC.callMethod.mockResolvedValue({
+        result: 'invalid json',
+      })
+
+      await expect(
+        AccountService.callAccountMethod('ethereum', 0, 'getBalance', null)
+      ).rejects.toThrow('Failed to parse result from getBalance')
+    })
+
+    it('should handle worklet call errors', async () => {
+      mockHRPC.callMethod.mockRejectedValue(new Error('Worklet error'))
+
+      await expect(
+        AccountService.callAccountMethod('ethereum', 0, 'getBalance', null)
+      ).rejects.toThrow()
+    })
+  })
+})
+

package/src/__tests__/services/addressService.test.ts

@@ -0,0 +1,312 @@
+/**
+ * Tests for AddressService
+ * 
+ * Tests address retrieval functionality
+ */
+
+import { AddressService } from '../../services/addressService'
+import { getWorkletStore } from '../../store/workletStore'
+import { getWalletStore } from '../../store/walletStore'
+
+// Mock stores
+jest.mock('../../store/workletStore', () => ({
+  getWorkletStore: jest.fn(),
+}))
+
+jest.mock('../../store/walletStore', () => ({
+  getWalletStore: jest.fn(),
+}))
+
+describe('AddressService', () => {
+  let mockWorkletStore: any
+  let mockWalletStore: any
+  let mockHRPC: any
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    // Setup mock HRPC
+    mockHRPC = {
+      callMethod: jest.fn(),
+    }
+
+    // Setup mock worklet store
+    mockWorkletStore = {
+      getState: jest.fn(() => ({
+        isInitialized: true,
+        hrpc: mockHRPC,
+        isWorkletStarted: true,
+      })),
+    }
+
+    // Setup mock wallet store
+    mockWalletStore = {
+      getState: jest.fn(() => ({
+        addresses: {},
+        walletLoading: {},
+        activeWalletId: 'test-wallet-1',
+      })),
+      setState: jest.fn(),
+    }
+
+    // Setup store mocks
+    ;(getWorkletStore as jest.Mock).mockReturnValue(mockWorkletStore)
+    ;(getWalletStore as jest.Mock).mockReturnValue(mockWalletStore)
+  })
+
+  describe('getAddress', () => {
+    it('should get address from worklet and cache it', async () => {
+      const mockAddress = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+      mockHRPC.callMethod.mockResolvedValue({
+        result: JSON.stringify(mockAddress),
+      })
+
+      const address = await AddressService.getAddress('ethereum', 0)
+
+      expect(address).toBe(mockAddress)
+      expect(mockHRPC.callMethod).toHaveBeenCalledWith({
+        methodName: 'getAddress',
+        network: 'ethereum',
+        accountIndex: 0,
+        args: null,
+      })
+
+      // Verify address was cached
+      expect(mockWalletStore.setState).toHaveBeenCalledWith(
+        expect.any(Function)
+      )
+
+      // Verify the state update function
+      const setStateCall = mockWalletStore.setState.mock.calls.find(
+        (call: any[]) => {
+          const stateUpdater = call[0]
+          if (typeof stateUpdater === 'function') {
+            const prevState = {
+              addresses: {},
+              walletLoading: {},
+              activeWalletId: 'test-wallet-1',
+            }
+            const newState = stateUpdater(prevState)
+            return newState.addresses?.['test-wallet-1']?.ethereum?.[0] === mockAddress
+          }
+          return false
+        }
+      )
+      expect(setStateCall).toBeDefined()
+    })
+
+    it('should return cached address if available', async () => {
+      const cachedAddress = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+      mockWalletStore.getState = jest.fn(() => ({
+        addresses: {
+          'test-wallet-1': {
+            ethereum: {
+              0: cachedAddress,
+            },
+          },
+        },
+        walletLoading: {},
+        activeWalletId: 'test-wallet-1',
+      }))
+
+      const address = await AddressService.getAddress('ethereum', 0)
+
+      expect(address).toBe(cachedAddress)
+      // Should not call HRPC if cached
+      expect(mockHRPC.callMethod).not.toHaveBeenCalled()
+    })
+
+    it('should handle different networks', async () => {
+      const ethereumAddress = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+      const polygonAddress = '0x842d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+
+      mockHRPC.callMethod
+        .mockResolvedValueOnce({
+          result: JSON.stringify(ethereumAddress),
+        })
+        .mockResolvedValueOnce({
+          result: JSON.stringify(polygonAddress),
+        })
+
+      const ethAddr = await AddressService.getAddress('ethereum', 0)
+      const polyAddr = await AddressService.getAddress('polygon', 0)
+
+      expect(ethAddr).toBe(ethereumAddress)
+      expect(polyAddr).toBe(polygonAddress)
+      expect(mockHRPC.callMethod).toHaveBeenCalledTimes(2)
+    })
+
+    it('should handle different account indices', async () => {
+      const address0 = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+      const address1 = '0x842d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+
+      mockHRPC.callMethod
+        .mockResolvedValueOnce({
+          result: JSON.stringify(address0),
+        })
+        .mockResolvedValueOnce({
+          result: JSON.stringify(address1),
+        })
+
+      const addr0 = await AddressService.getAddress('ethereum', 0)
+      const addr1 = await AddressService.getAddress('ethereum', 1)
+
+      expect(addr0).toBe(address0)
+      expect(addr1).toBe(address1)
+      expect(mockHRPC.callMethod).toHaveBeenCalledWith(
+        expect.objectContaining({
+          network: 'ethereum',
+          accountIndex: 0,
+        })
+      )
+      expect(mockHRPC.callMethod).toHaveBeenCalledWith(
+        expect.objectContaining({
+          network: 'ethereum',
+          accountIndex: 1,
+        })
+      )
+    })
+
+    it('should throw error if WDK not initialized', async () => {
+      mockWorkletStore.getState = jest.fn(() => ({
+        isInitialized: false,
+        hrpc: null,
+      }))
+      mockWalletStore.getState = jest.fn(() => ({
+        addresses: {},
+        walletLoading: {},
+        activeWalletId: 'test-wallet-1',
+      }))
+
+      await expect(AddressService.getAddress('ethereum', 0)).rejects.toThrow(
+        'WDK not initialized'
+      )
+    })
+
+    it('should throw error if HRPC not available', async () => {
+      mockWorkletStore.getState = jest.fn(() => ({
+        isInitialized: true,
+        hrpc: null,
+      }))
+      mockWalletStore.getState = jest.fn(() => ({
+        addresses: {},
+        walletLoading: {},
+        activeWalletId: 'test-wallet-1',
+      }))
+
+      await expect(AddressService.getAddress('ethereum', 0)).rejects.toThrow(
+        'WDK not initialized'
+      )
+    })
+
+    it('should throw error if worklet call fails', async () => {
+      mockHRPC.callMethod.mockRejectedValue(new Error('Worklet error'))
+
+      await expect(AddressService.getAddress('ethereum', 0)).rejects.toThrow()
+    })
+
+    it('should throw error if worklet returns no result', async () => {
+      mockHRPC.callMethod.mockResolvedValue({
+        result: null,
+      })
+      mockWalletStore.getState = jest.fn(() => ({
+        addresses: {},
+        walletLoading: {},
+        activeWalletId: 'test-wallet-1',
+      }))
+
+      await expect(AddressService.getAddress('ethereum', 0)).rejects.toThrow(
+        /Failed to get address|Expected string/
+      )
+    })
+
+    it('should validate network name', async () => {
+      await expect(AddressService.getAddress('', 0)).rejects.toThrow(
+        /network.*non-empty|Network name must contain only|String must contain at least 1 character/
+      )
+    })
+
+    it('should validate account index', async () => {
+      await expect(AddressService.getAddress('ethereum', -1)).rejects.toThrow(
+        /accountIndex.*non-negative|Number must be greater than or equal to 0/
+      )
+    })
+
+    it('should handle all networks from the configuration', async () => {
+      const networks = ['ethereum', 'polygon', 'arbitrum', 'sepolia', 'plasma', 'spark']
+      // Use valid Ethereum address for most networks, Spark address for spark
+      const mockEthereumAddress = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+      const mockSparkAddress = 'spark1abcdefghijklmnopqrstuvwxyz123456'
+
+      for (const network of networks) {
+        const mockAddress = network === 'spark' ? mockSparkAddress : mockEthereumAddress
+        mockHRPC.callMethod.mockResolvedValueOnce({
+          result: JSON.stringify(mockAddress),
+        })
+        
+        const address = await AddressService.getAddress(network, 0)
+        expect(address).toBe(mockAddress)
+        expect(mockHRPC.callMethod).toHaveBeenCalledWith(
+          expect.objectContaining({
+            network,
+            accountIndex: 0,
+          })
+        )
+      }
+
+      expect(mockHRPC.callMethod).toHaveBeenCalledTimes(networks.length)
+    })
+
+    it('should set loading state during address fetch', async () => {
+      const mockAddress = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+      mockHRPC.callMethod.mockResolvedValue({
+        result: JSON.stringify(mockAddress),
+      })
+
+      await AddressService.getAddress('ethereum', 0)
+
+      // Verify loading state was set to true, then false
+      const setStateCalls = mockWalletStore.setState.mock.calls
+      expect(setStateCalls.length).toBeGreaterThan(0)
+
+      // Track state changes - start with initial state
+      let currentState: any = { 
+        walletLoading: {}, 
+        addresses: {},
+        balanceLoading: {},
+        lastBalanceUpdate: {},
+        balances: {},
+        activeWalletId: 'test-wallet-1',
+      }
+      let loadingWasSetToTrue = false
+      let loadingWasSetToFalse = false
+
+      for (const call of setStateCalls) {
+        const stateUpdater = call[0]
+        if (typeof stateUpdater === 'function') {
+          // Ensure all required state properties exist
+          const prevState = {
+            walletLoading: currentState.walletLoading || {},
+            addresses: currentState.addresses || {},
+            balanceLoading: currentState.balanceLoading || {},
+            lastBalanceUpdate: currentState.lastBalanceUpdate || {},
+            balances: currentState.balances || {},
+            activeWalletId: currentState.activeWalletId || 'test-wallet-1',
+          }
+          currentState = { ...prevState, ...stateUpdater(prevState) }
+          // Loading state is now per-wallet: walletLoading[walletId][loadingKey]
+          if (currentState.walletLoading?.['test-wallet-1']?.['ethereum-0'] === true) {
+            loadingWasSetToTrue = true
+          }
+          if (currentState.walletLoading?.['test-wallet-1']?.['ethereum-0'] === false) {
+            loadingWasSetToFalse = true
+          }
+        }
+      }
+
+      expect(loadingWasSetToTrue).toBe(true)
+      expect(loadingWasSetToFalse).toBe(true)
+    })
+  })
+})
+