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

package/src/__tests__/utils/result.test.ts

@@ -0,0 +1,73 @@
+/**
+ * Tests for Result type utilities
+ */
+
+import { ok, err, toResult, toResultSync } from '../../utils/result'
+
+describe('result', () => {
+  describe('ok', () => {
+    it('should create a success result', () => {
+      const result = ok('test data')
+      expect(result.success).toBe(true)
+      expect(result.data).toBe('test data')
+      expect(result.error).toBeUndefined()
+    })
+  })
+
+  describe('err', () => {
+    it('should create an error result', () => {
+      const error = new Error('test error')
+      const result = err(error)
+      expect(result.success).toBe(false)
+      expect(result.error).toBe(error)
+      expect(result.data).toBeUndefined()
+    })
+  })
+
+  describe('toResult', () => {
+    it('should return ok result for successful async function', async () => {
+      const fn = async () => 'success'
+      const result = await toResult(fn)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data).toBe('success')
+      }
+    })
+
+    it('should return err result for failed async function', async () => {
+      const fn = async () => {
+        throw new Error('async error')
+      }
+      const result = await toResult(fn)
+      expect(result.success).toBe(false)
+      if (!result.success) {
+        expect(result.error).toBeInstanceOf(Error)
+        expect((result.error as Error).message).toBe('async error')
+      }
+    })
+  })
+
+  describe('toResultSync', () => {
+    it('should return ok result for successful sync function', () => {
+      const fn = () => 'success'
+      const result = toResultSync(fn)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data).toBe('success')
+      }
+    })
+
+    it('should return err result for failed sync function', () => {
+      const fn = () => {
+        throw new Error('sync error')
+      }
+      const result = toResultSync(fn)
+      expect(result.success).toBe(false)
+      if (!result.success) {
+        expect(result.error).toBeInstanceOf(Error)
+        expect((result.error as Error).message).toBe('sync error')
+      }
+    })
+  })
+})
+

package/src/__tests__/utils/schemas.test.ts

@@ -0,0 +1,82 @@
+/**
+ * Tests for Zod schemas
+ */
+
+import {
+  workletResponseSchema,
+  balanceResponseSchema,
+  accountMethodResponseSchema,
+} from '../../utils/schemas'
+
+describe('schemas', () => {
+  describe('workletResponseSchema', () => {
+    it('should validate valid worklet response', () => {
+      const valid = {
+        result: '{"data": "test"}',
+      }
+      expect(() => workletResponseSchema.parse(valid)).not.toThrow()
+    })
+
+    it('should validate worklet response with error', () => {
+      const valid = {
+        result: '{"data": "test"}',
+        error: 'Some error',
+      }
+      expect(() => workletResponseSchema.parse(valid)).not.toThrow()
+    })
+
+    it('should reject invalid worklet response', () => {
+      const invalid = {
+        result: null,
+      }
+      expect(() => workletResponseSchema.parse(invalid)).toThrow()
+    })
+
+    it('should require result field', () => {
+      const invalid = {}
+      expect(() => workletResponseSchema.parse(invalid)).toThrow()
+    })
+  })
+
+  describe('balanceResponseSchema', () => {
+    it('should validate numeric string', () => {
+      expect(() => balanceResponseSchema.parse('1000000000000000000')).not.toThrow()
+      expect(() => balanceResponseSchema.parse('0')).not.toThrow()
+      expect(() => balanceResponseSchema.parse('123456789')).not.toThrow()
+    })
+
+    it('should reject non-numeric strings', () => {
+      expect(() => balanceResponseSchema.parse('abc')).toThrow()
+      expect(() => balanceResponseSchema.parse('123.45')).toThrow()
+      expect(() => balanceResponseSchema.parse('-123')).toThrow()
+      expect(() => balanceResponseSchema.parse('')).toThrow()
+    })
+
+    it('should reject non-string values', () => {
+      expect(() => balanceResponseSchema.parse(123)).toThrow()
+      expect(() => balanceResponseSchema.parse(null)).toThrow()
+      expect(() => balanceResponseSchema.parse(undefined)).toThrow()
+    })
+  })
+
+  describe('accountMethodResponseSchema', () => {
+    it('should validate balance response', () => {
+      expect(() => accountMethodResponseSchema.parse('1000000000000000000')).not.toThrow()
+    })
+
+    it('should validate string response', () => {
+      expect(() => accountMethodResponseSchema.parse('0x1234567890123456789012345678901234567890')).not.toThrow()
+      expect(() => accountMethodResponseSchema.parse('some string')).not.toThrow()
+    })
+
+    it('should validate object response', () => {
+      expect(() => accountMethodResponseSchema.parse({ data: 'test' })).not.toThrow()
+      expect(() => accountMethodResponseSchema.parse({ nested: { value: 123 } })).not.toThrow()
+    })
+
+    it('should validate empty object', () => {
+      expect(() => accountMethodResponseSchema.parse({})).not.toThrow()
+    })
+  })
+})
+

package/src/__tests__/utils/storeHelpers.test.ts

@@ -0,0 +1,323 @@
+/**
+ * Tests for store helper utilities
+ */
+
+import {
+  requireInitialized,
+  requireExtendedHRPC,
+  isInitialized,
+  updateBalanceInState,
+  updateAddressInState,
+} from '../../utils/storeHelpers'
+import { getWorkletStore } from '../../store/workletStore'
+import { asExtendedHRPC } from '../../types/hrpc'
+
+// Mock stores
+jest.mock('../../store/workletStore', () => ({
+  getWorkletStore: jest.fn(),
+}))
+
+jest.mock('../../types/hrpc', () => ({
+  asExtendedHRPC: jest.fn(),
+}))
+
+describe('storeHelpers', () => {
+  let mockWorkletStore: any
+  let mockHRPC: any
+  let mockExtendedHRPC: any
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    mockHRPC = {
+      callMethod: jest.fn(),
+    }
+
+    mockExtendedHRPC = {
+      callMethod: jest.fn(),
+      initializeWDK: jest.fn(),
+    }
+
+    mockWorkletStore = {
+      getState: jest.fn(() => ({
+        isInitialized: true,
+        hrpc: mockHRPC,
+      })),
+    }
+
+    ;(getWorkletStore as jest.Mock).mockReturnValue(mockWorkletStore)
+    ;(asExtendedHRPC as jest.Mock).mockReturnValue(mockExtendedHRPC)
+  })
+
+  describe('requireInitialized', () => {
+    it('should return HRPC when initialized', () => {
+      const hrpc = requireInitialized()
+      expect(hrpc).toBe(mockHRPC)
+      expect(getWorkletStore).toHaveBeenCalled()
+    })
+
+    it('should throw error when not initialized', () => {
+      mockWorkletStore.getState = jest.fn(() => ({
+        isInitialized: false,
+        hrpc: null,
+      }))
+
+      expect(() => requireInitialized()).toThrow('WDK not initialized')
+    })
+
+    it('should throw error when HRPC is null', () => {
+      mockWorkletStore.getState = jest.fn(() => ({
+        isInitialized: true,
+        hrpc: null,
+      }))
+
+      expect(() => requireInitialized()).toThrow('WDK not initialized')
+    })
+  })
+
+  describe('requireExtendedHRPC', () => {
+    it('should return extended HRPC when initialized', () => {
+      const hrpc = requireExtendedHRPC()
+      expect(hrpc).toBe(mockExtendedHRPC)
+      expect(asExtendedHRPC).toHaveBeenCalledWith(mockHRPC)
+    })
+
+    it('should throw error when not initialized', () => {
+      mockWorkletStore.getState = jest.fn(() => ({
+        isInitialized: false,
+        hrpc: null,
+      }))
+
+      expect(() => requireExtendedHRPC()).toThrow('WDK not initialized')
+    })
+  })
+
+  describe('isInitialized', () => {
+    it('should return true when initialized', () => {
+      expect(isInitialized()).toBe(true)
+    })
+
+    it('should return false when not initialized', () => {
+      mockWorkletStore.getState = jest.fn(() => ({
+        isInitialized: false,
+        hrpc: null,
+      }))
+
+      expect(isInitialized()).toBe(false)
+    })
+
+    it('should return false when HRPC is null', () => {
+      mockWorkletStore.getState = jest.fn(() => ({
+        isInitialized: true,
+        hrpc: null,
+      }))
+
+      expect(isInitialized()).toBe(false)
+    })
+  })
+
+  describe('updateBalanceInState', () => {
+    it('should update balance in empty state', () => {
+      const prev = {
+        balances: {},
+      } as any
+
+      const result = updateBalanceInState(prev, 'wallet-1', 'ethereum', 0, 'native', '100')
+
+      expect(result.balances).toEqual({
+        'wallet-1': {
+          ethereum: {
+            0: {
+              native: '100',
+            },
+          },
+        },
+      })
+    })
+
+    it('should update balance in existing state', () => {
+      const prev = {
+        balances: {
+          'wallet-1': {
+            ethereum: {
+              0: {
+                native: '50',
+              },
+            },
+          },
+        },
+      } as any
+
+      const result = updateBalanceInState(prev, 'wallet-1', 'ethereum', 0, 'native', '100')
+
+      expect(result.balances?.['wallet-1']?.ethereum?.[0]?.native).toBe('100')
+    })
+
+    it('should add new network balance', () => {
+      const prev = {
+        balances: {
+          'wallet-1': {
+            polygon: {
+              0: {
+                native: '50',
+              },
+            },
+          },
+        },
+      } as any
+
+      const result = updateBalanceInState(prev, 'wallet-1', 'ethereum', 0, 'native', '100')
+
+      expect(result.balances?.['wallet-1']?.ethereum?.[0]?.native).toBe('100')
+      expect(result.balances?.['wallet-1']?.polygon?.[0]?.native).toBe('50')
+    })
+
+    it('should add new account balance', () => {
+      const prev = {
+        balances: {
+          'wallet-1': {
+            ethereum: {
+              0: {
+                native: '50',
+              },
+            },
+          },
+        },
+      } as any
+
+      const result = updateBalanceInState(prev, 'wallet-1', 'ethereum', 1, 'native', '200')
+
+      expect(result.balances?.['wallet-1']?.ethereum?.[0]?.native).toBe('50')
+      expect(result.balances?.['wallet-1']?.ethereum?.[1]?.native).toBe('200')
+    })
+
+    it('should add token balance', () => {
+      const prev = {
+        balances: {
+          'wallet-1': {
+            ethereum: {
+              0: {
+                native: '50',
+              },
+            },
+          },
+        },
+      } as any
+
+      const result = updateBalanceInState(
+        prev,
+        'wallet-1',
+        'ethereum',
+        0,
+        '0x123',
+        '1000'
+      )
+
+      expect(result.balances?.['wallet-1']?.ethereum?.[0]?.native).toBe('50')
+      expect(result.balances?.['wallet-1']?.ethereum?.[0]?.['0x123']).toBe('1000')
+    })
+  })
+
+  describe('updateAddressInState', () => {
+    it('should update address in empty state', () => {
+      const prev = {
+        addresses: {},
+      } as any
+
+      const result = updateAddressInState(
+        prev,
+        'wallet-1',
+        'ethereum',
+        0,
+        '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+      )
+
+      expect(result.addresses).toEqual({
+        'wallet-1': {
+          ethereum: {
+            0: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+          },
+        },
+      })
+    })
+
+    it('should update address in existing state', () => {
+      const prev = {
+        addresses: {
+          'wallet-1': {
+            ethereum: {
+              0: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+            },
+          },
+        },
+      } as any
+
+      const result = updateAddressInState(
+        prev,
+        'wallet-1',
+        'ethereum',
+        0,
+        '0x842d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+      )
+
+      expect(result.addresses?.['wallet-1']?.ethereum?.[0]).toBe(
+        '0x842d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+      )
+    })
+
+    it('should add new network address', () => {
+      const prev = {
+        addresses: {
+          'wallet-1': {
+            polygon: {
+              0: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+            },
+          },
+        },
+      } as any
+
+      const result = updateAddressInState(
+        prev,
+        'wallet-1',
+        'ethereum',
+        0,
+        '0x842d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+      )
+
+      expect(result.addresses?.['wallet-1']?.ethereum?.[0]).toBe(
+        '0x842d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+      )
+      expect(result.addresses?.['wallet-1']?.polygon?.[0]).toBe(
+        '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+      )
+    })
+
+    it('should add new account address', () => {
+      const prev = {
+        addresses: {
+          'wallet-1': {
+            ethereum: {
+              0: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+            },
+          },
+        },
+      } as any
+
+      const result = updateAddressInState(
+        prev,
+        'wallet-1',
+        'ethereum',
+        1,
+        '0x842d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+      )
+
+      expect(result.addresses?.['wallet-1']?.ethereum?.[0]).toBe(
+        '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+      )
+      expect(result.addresses?.['wallet-1']?.ethereum?.[1]).toBe(
+        '0x842d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+      )
+    })
+  })
+})
+

package/src/__tests__/utils/typeGuards.test.ts

@@ -0,0 +1,209 @@
+/**
+ * Tests for type guard utilities
+ */
+
+import {
+  isNetworkConfig,
+  isNetworkConfigs,
+  isTokenConfig,
+  isTokenConfigs,
+  isWalletAddresses,
+  isWalletBalances,
+  isEthereumAddress,
+  isValidAccountIndex,
+  isValidNetworkName,
+  isValidBalanceString,
+} from '../../utils/typeGuards'
+import type { NetworkConfig, NetworkConfigs, TokenConfig, TokenConfigs } from '../../types'
+
+describe('typeGuards', () => {
+  describe('isNetworkConfig', () => {
+    it('should return true for valid network config', () => {
+      const valid: NetworkConfig = {
+        chainId: 1,
+        blockchain: 'ethereum',
+      }
+      expect(isNetworkConfig(valid)).toBe(true)
+    })
+
+    it('should return false for invalid network config', () => {
+      expect(isNetworkConfig(null)).toBe(false)
+      expect(isNetworkConfig({})).toBe(false)
+      expect(isNetworkConfig({ chainId: '1', blockchain: 'ethereum' })).toBe(false)
+      expect(isNetworkConfig({ chainId: 1 })).toBe(false)
+      expect(isNetworkConfig({ blockchain: 'ethereum' })).toBe(false)
+    })
+  })
+
+  describe('isNetworkConfigs', () => {
+    it('should return true for valid network configs', () => {
+      const valid: NetworkConfigs = {
+        ethereum: {
+          chainId: 1,
+          blockchain: 'ethereum',
+        },
+      }
+      expect(isNetworkConfigs(valid)).toBe(true)
+    })
+
+    it('should return false for invalid network configs', () => {
+      expect(isNetworkConfigs(null)).toBe(false)
+      expect(isNetworkConfigs({})).toBe(false)
+      expect(isNetworkConfigs([])).toBe(false)
+      expect(isNetworkConfigs({ ethereum: null })).toBe(false)
+    })
+  })
+
+  describe('isTokenConfig', () => {
+    it('should return true for valid token config', () => {
+      const valid: TokenConfig = {
+        symbol: 'ETH',
+        name: 'Ethereum',
+        decimals: 18,
+        address: null,
+      }
+      expect(isTokenConfig(valid)).toBe(true)
+
+      const validWithAddress: TokenConfig = {
+        symbol: 'USDT',
+        name: 'Tether',
+        decimals: 6,
+        address: '0x1234567890123456789012345678901234567890',
+      }
+      expect(isTokenConfig(validWithAddress)).toBe(true)
+    })
+
+    it('should return false for invalid token config', () => {
+      expect(isTokenConfig(null)).toBe(false)
+      expect(isTokenConfig({})).toBe(false)
+      expect(isTokenConfig({ symbol: 'ETH' })).toBe(false)
+      expect(isTokenConfig({ symbol: 'ETH', name: 'Ethereum', decimals: '18' })).toBe(false)
+    })
+  })
+
+  describe('isTokenConfigs', () => {
+    it('should return true for valid token configs', () => {
+      const valid: TokenConfigs = {
+        ethereum: {
+          native: {
+            symbol: 'ETH',
+            name: 'Ethereum',
+            decimals: 18,
+            address: null,
+          },
+          tokens: [],
+        },
+      }
+      expect(isTokenConfigs(valid)).toBe(true)
+    })
+
+    it('should return false for invalid token configs', () => {
+      expect(isTokenConfigs(null)).toBe(false)
+      expect(isTokenConfigs({})).toBe(false)
+      expect(isTokenConfigs([])).toBe(false)
+    })
+  })
+
+  describe('isWalletAddresses', () => {
+    it('should return true for valid wallet addresses', () => {
+      const valid = {
+        ethereum: {
+          0: '0x1234567890123456789012345678901234567890',
+          1: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd',
+        },
+      }
+      expect(isWalletAddresses(valid)).toBe(true)
+    })
+
+    it('should return false for invalid wallet addresses', () => {
+      expect(isWalletAddresses(null)).toBe(false)
+      expect(isWalletAddresses({})).toBe(true) // Empty object is valid
+      expect(isWalletAddresses([])).toBe(false)
+      expect(isWalletAddresses({ ethereum: 'invalid' })).toBe(false)
+      expect(isWalletAddresses({ ethereum: { 0: 'invalid' } })).toBe(false)
+    })
+  })
+
+  describe('isWalletBalances', () => {
+    it('should return true for valid wallet balances', () => {
+      const valid = {
+        ethereum: {
+          0: {
+            '0x0000000000000000000000000000000000000000': '1000000000000000000',
+            '0x1234567890123456789012345678901234567890': '2000000000000000000',
+          },
+        },
+      }
+      expect(isWalletBalances(valid)).toBe(true)
+    })
+
+    it('should return false for invalid wallet balances', () => {
+      expect(isWalletBalances(null)).toBe(false)
+      expect(isWalletBalances({})).toBe(true) // Empty object is valid
+      expect(isWalletBalances([])).toBe(false)
+      expect(isWalletBalances({ ethereum: { 0: 'invalid' } })).toBe(false)
+    })
+  })
+
+  describe('isEthereumAddress', () => {
+    it('should return true for valid Ethereum addresses', () => {
+      expect(isEthereumAddress('0x1234567890123456789012345678901234567890')).toBe(true)
+      expect(isEthereumAddress('0xABCDEFabcdef1234567890123456789012345678')).toBe(true)
+    })
+
+    it('should return false for invalid Ethereum addresses', () => {
+      expect(isEthereumAddress('')).toBe(false)
+      expect(isEthereumAddress('0x123')).toBe(false)
+      expect(isEthereumAddress('1234567890123456789012345678901234567890')).toBe(false)
+      expect(isEthereumAddress(null)).toBe(false)
+      expect(isEthereumAddress(123)).toBe(false)
+    })
+  })
+
+  describe('isValidAccountIndex', () => {
+    it('should return true for valid account indices', () => {
+      expect(isValidAccountIndex(0)).toBe(true)
+      expect(isValidAccountIndex(1)).toBe(true)
+      expect(isValidAccountIndex(100)).toBe(true)
+    })
+
+    it('should return false for invalid account indices', () => {
+      expect(isValidAccountIndex(-1)).toBe(false)
+      expect(isValidAccountIndex(1.5)).toBe(false)
+      expect(isValidAccountIndex(NaN)).toBe(false)
+      expect(isValidAccountIndex(Infinity)).toBe(false)
+    })
+  })
+
+  describe('isValidNetworkName', () => {
+    it('should return true for valid network names', () => {
+      expect(isValidNetworkName('ethereum')).toBe(true)
+      expect(isValidNetworkName('polygon-mainnet')).toBe(true)
+      expect(isValidNetworkName('network_1')).toBe(true)
+    })
+
+    it('should return false for invalid network names', () => {
+      expect(isValidNetworkName('')).toBe(false)
+      expect(isValidNetworkName('  ')).toBe(false)
+      expect(isValidNetworkName('network with spaces')).toBe(false)
+      expect(isValidNetworkName('network@invalid')).toBe(false)
+    })
+  })
+
+  describe('isValidBalanceString', () => {
+    it('should return true for valid balance strings', () => {
+      expect(isValidBalanceString('0')).toBe(true)
+      expect(isValidBalanceString('100')).toBe(true)
+      expect(isValidBalanceString('100.5')).toBe(true)
+      expect(isValidBalanceString('-100')).toBe(true)
+    })
+
+    it('should return false for invalid balance strings', () => {
+      expect(isValidBalanceString('')).toBe(false)
+      expect(isValidBalanceString('abc')).toBe(false)
+      expect(isValidBalanceString('100.5.5')).toBe(false)
+      expect(isValidBalanceString('100a')).toBe(false)
+    })
+  })
+})
+