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

package/src/__tests__/store/workletStore.test.ts

@@ -0,0 +1,329 @@
+/**
+ * Tests for workletStore
+ */
+
+import { 
+  createWorkletStore, 
+  getWorkletStore, 
+  resetWorkletStore, 
+  getCachedCredentials,
+  setCachedCredentials,
+  clearCredentialsCache,
+  clearAllSensitiveData
+} from '../../store/workletStore'
+
+describe('workletStore', () => {
+  beforeEach(() => {
+    resetWorkletStore()
+    jest.clearAllMocks()
+    jest.useFakeTimers()
+  })
+
+  afterEach(() => {
+    resetWorkletStore()
+    jest.useRealTimers()
+  })
+
+  describe('createWorkletStore', () => {
+    it('should create a worklet store instance', () => {
+      const store = createWorkletStore()
+      expect(store).toBeDefined()
+      expect(typeof store.getState).toBe('function')
+    })
+
+    it('should return the same instance on subsequent calls', () => {
+      const store1 = createWorkletStore()
+      const store2 = createWorkletStore()
+      expect(store1).toBe(store2)
+    })
+
+    it('should initialize with default state', () => {
+      const store = createWorkletStore()
+      const state = store.getState()
+      
+      expect(state.worklet).toBe(null)
+      expect(state.hrpc).toBe(null)
+      expect(state.ipc).toBe(null)
+      expect(state.isWorkletStarted).toBe(false)
+      expect(state.isInitialized).toBe(false)
+      expect(state.isLoading).toBe(false)
+      expect(state.error).toBe(null)
+      expect(state.encryptedSeed).toBe(null)
+      expect(state.encryptionKey).toBe(null)
+      expect(state.networkConfigs).toBe(null)
+      expect(state.workletStartResult).toBe(null)
+      expect(state.wdkInitResult).toBe(null)
+      expect(state.credentialsCache).toEqual({})
+      expect(state.credentialsCacheTTL).toBe(5 * 60 * 1000)
+    })
+  })
+
+  describe('getWorkletStore', () => {
+    it('should return a worklet store instance', () => {
+      const store = getWorkletStore()
+      expect(store).toBeDefined()
+      expect(typeof store.getState).toBe('function')
+    })
+
+    it('should return the same instance as createWorkletStore', () => {
+      const store1 = createWorkletStore()
+      const store2 = getWorkletStore()
+      expect(store1).toBe(store2)
+    })
+  })
+
+  describe('resetWorkletStore', () => {
+    it('should reset the store instance', () => {
+      const store1 = createWorkletStore()
+      resetWorkletStore()
+      const store2 = createWorkletStore()
+      
+      // After reset, a new instance should be created
+      expect(store1).not.toBe(store2)
+    })
+  })
+
+  describe('clearSensitiveData', () => {
+    it('should clear encrypted seed and encryption key', () => {
+      const store = createWorkletStore()
+      
+      store.setState({
+        encryptedSeed: 'encrypted-seed',
+        encryptionKey: 'encryption-key',
+      })
+
+      clearAllSensitiveData()
+
+      const state = store.getState()
+      expect(state.encryptedSeed).toBe(null)
+      expect(state.encryptionKey).toBe(null)
+    })
+
+    it('should not affect other state', () => {
+      const store = createWorkletStore()
+      
+      store.setState({
+        isWorkletStarted: true,
+        encryptedSeed: 'encrypted-seed',
+        encryptionKey: 'encryption-key',
+      })
+
+      clearAllSensitiveData()
+
+      const state = store.getState()
+      expect(state.isWorkletStarted).toBe(true)
+      expect(state.encryptedSeed).toBe(null)
+      expect(state.encryptionKey).toBe(null)
+    })
+  })
+
+  describe('store state management', () => {
+    it('should allow state updates', () => {
+      const store = createWorkletStore()
+      
+      store.setState({
+        isWorkletStarted: true,
+        isLoading: true,
+      })
+
+      const state = store.getState()
+      expect(state.isWorkletStarted).toBe(true)
+      expect(state.isLoading).toBe(true)
+    })
+  })
+
+  describe('getCachedCredentials', () => {
+    it('should return null for non-existent identifier', () => {
+      const result = getCachedCredentials('non-existent')
+      expect(result).toBe(null)
+    })
+
+    it('should return cached credentials when valid', () => {
+      const identifier = 'test-wallet'
+      const credentials = {
+        encryptionKey: 'key-123',
+        encryptedSeed: 'seed-123',
+        expiresAt: Date.now() + 10000
+      }
+      
+      setCachedCredentials(identifier, credentials)
+      const result = getCachedCredentials(identifier)
+      
+      expect(result).not.toBe(null)
+      expect(result?.encryptionKey).toBe('key-123')
+      expect(result?.encryptedSeed).toBe('seed-123')
+    })
+
+    it('should return null for expired credentials', () => {
+      const identifier = 'expired-wallet'
+      const store = getWorkletStore()
+      const currentTime = 1000000
+      jest.setSystemTime(currentTime)
+      
+      // Set credentials first
+      setCachedCredentials(identifier, {
+        encryptionKey: 'key-123',
+      })
+      
+      // Manually set expired time in the store (bypassing setCachedCredentials which always sets future time)
+      store.setState({
+        credentialsCache: {
+          ...store.getState().credentialsCache,
+          [identifier]: {
+            encryptionKey: 'key-123',
+            expiresAt: currentTime - 1000, // Expired (1 second in the past)
+          },
+        },
+      })
+      
+      const result = getCachedCredentials(identifier)
+      
+      expect(result).toBe(null)
+    })
+
+    it('should remove expired credentials from cache', () => {
+      const identifier = 'expired-wallet'
+      const store = getWorkletStore()
+      const currentTime = 1000000
+      jest.setSystemTime(currentTime)
+      
+      // Set credentials first
+      setCachedCredentials(identifier, {
+        encryptionKey: 'key-123',
+      })
+      
+      // Manually set expired time in the store (bypassing setCachedCredentials which always sets future time)
+      store.setState({
+        credentialsCache: {
+          ...store.getState().credentialsCache,
+          [identifier]: {
+            encryptionKey: 'key-123',
+            expiresAt: currentTime - 1000, // Expired (1 second in the past)
+          },
+        },
+      })
+      
+      getCachedCredentials(identifier)
+      
+      const state = store.getState()
+      expect(state.credentialsCache[identifier]).toBeUndefined()
+    })
+  })
+
+  describe('setCachedCredentials', () => {
+    it('should set credentials with expiration', () => {
+      const identifier = 'test-wallet'
+      const credentials = {
+        encryptionKey: 'key-123',
+        encryptedSeed: 'seed-123'
+      }
+      
+      setCachedCredentials(identifier, credentials)
+      const result = getCachedCredentials(identifier)
+      
+      expect(result).not.toBe(null)
+      expect(result?.encryptionKey).toBe('key-123')
+      expect(result?.encryptedSeed).toBe('seed-123')
+      expect(result?.expiresAt).toBeGreaterThan(Date.now())
+    })
+
+    it('should merge with existing credentials', () => {
+      const identifier = 'test-wallet'
+      
+      setCachedCredentials(identifier, { encryptionKey: 'key-123' })
+      setCachedCredentials(identifier, { encryptedSeed: 'seed-123' })
+      
+      const result = getCachedCredentials(identifier)
+      expect(result?.encryptionKey).toBe('key-123')
+      expect(result?.encryptedSeed).toBe('seed-123')
+    })
+
+    it('should update expiration on each set', () => {
+      const identifier = 'test-wallet'
+      
+      setCachedCredentials(identifier, { encryptionKey: 'key-123' })
+      const firstExpiry = getCachedCredentials(identifier)?.expiresAt
+      
+      // Advance time
+      jest.advanceTimersByTime(100)
+      
+      setCachedCredentials(identifier, { encryptedSeed: 'seed-123' })
+      const secondExpiry = getCachedCredentials(identifier)?.expiresAt
+      
+      expect(secondExpiry).toBeGreaterThan(firstExpiry!)
+    })
+  })
+
+  describe('clearCredentialsCache', () => {
+    it('should clear specific wallet credentials', () => {
+      const identifier1 = 'wallet-1'
+      const identifier2 = 'wallet-2'
+      
+      setCachedCredentials(identifier1, { encryptionKey: 'key-1' })
+      setCachedCredentials(identifier2, { encryptionKey: 'key-2' })
+      
+      clearCredentialsCache(identifier1)
+      
+      expect(getCachedCredentials(identifier1)).toBe(null)
+      expect(getCachedCredentials(identifier2)).not.toBe(null)
+    })
+
+    it('should clear all credentials when no identifier provided', () => {
+      const identifier1 = 'wallet-1'
+      const identifier2 = 'wallet-2'
+      
+      setCachedCredentials(identifier1, { encryptionKey: 'key-1' })
+      setCachedCredentials(identifier2, { encryptionKey: 'key-2' })
+      
+      clearCredentialsCache()
+      
+      expect(getCachedCredentials(identifier1)).toBe(null)
+      expect(getCachedCredentials(identifier2)).toBe(null)
+    })
+  })
+
+  describe('clearAllSensitiveData', () => {
+    it('should clear encrypted seed and encryption key', () => {
+      const store = createWorkletStore()
+      
+      store.setState({
+        encryptedSeed: 'encrypted-seed',
+        encryptionKey: 'encryption-key',
+      })
+
+      clearAllSensitiveData()
+
+      const state = store.getState()
+      expect(state.encryptedSeed).toBe(null)
+      expect(state.encryptionKey).toBe(null)
+    })
+
+    it('should clear credentials cache', () => {
+      const identifier = 'test-wallet'
+      
+      setCachedCredentials(identifier, { encryptionKey: 'key-123' })
+      clearAllSensitiveData()
+      
+      expect(getCachedCredentials(identifier)).toBe(null)
+    })
+
+    it('should clear both active credentials and cache', () => {
+      const store = createWorkletStore()
+      const identifier = 'test-wallet'
+      
+      store.setState({
+        encryptedSeed: 'encrypted-seed',
+        encryptionKey: 'encryption-key',
+      })
+      setCachedCredentials(identifier, { encryptionKey: 'key-123' })
+      
+      clearAllSensitiveData()
+      
+      const state = store.getState()
+      expect(state.encryptedSeed).toBe(null)
+      expect(state.encryptionKey).toBe(null)
+      expect(getCachedCredentials(identifier)).toBe(null)
+    })
+  })
+})
+

package/src/__tests__/types/hrpc.test.ts

@@ -0,0 +1,125 @@
+/**
+ * Tests for HRPC type guards
+ */
+
+import { isExtendedHRPC, asExtendedHRPC } from '../../types/hrpc'
+import type { HRPC } from '@spacesops/pear-wrk-wdk'
+
+describe('hrpc', () => {
+  describe('isExtendedHRPC', () => {
+    it('should return true for HRPC with all extended methods', () => {
+      const hrpc = {
+        callMethod: jest.fn(),
+        initializeWDK: jest.fn(),
+        generateEntropyAndEncrypt: jest.fn(),
+        getMnemonicFromEntropy: jest.fn(),
+        getSeedAndEntropyFromMnemonic: jest.fn(),
+      } as unknown as HRPC
+
+      expect(isExtendedHRPC(hrpc)).toBe(true)
+    })
+
+    it('should return false for HRPC without initializeWDK', () => {
+      const hrpc = {
+        callMethod: jest.fn(),
+        generateEntropyAndEncrypt: jest.fn(),
+        getMnemonicFromEntropy: jest.fn(),
+        getSeedAndEntropyFromMnemonic: jest.fn(),
+      } as unknown as HRPC
+
+      expect(isExtendedHRPC(hrpc)).toBe(false)
+    })
+
+    it('should return false for HRPC without generateEntropyAndEncrypt', () => {
+      const hrpc = {
+        callMethod: jest.fn(),
+        initializeWDK: jest.fn(),
+        getMnemonicFromEntropy: jest.fn(),
+        getSeedAndEntropyFromMnemonic: jest.fn(),
+      } as unknown as HRPC
+
+      expect(isExtendedHRPC(hrpc)).toBe(false)
+    })
+
+    it('should return false for HRPC without getMnemonicFromEntropy', () => {
+      const hrpc = {
+        callMethod: jest.fn(),
+        initializeWDK: jest.fn(),
+        generateEntropyAndEncrypt: jest.fn(),
+        getSeedAndEntropyFromMnemonic: jest.fn(),
+      } as unknown as HRPC
+
+      expect(isExtendedHRPC(hrpc)).toBe(false)
+    })
+
+    it('should return false for HRPC without getSeedAndEntropyFromMnemonic', () => {
+      const hrpc = {
+        callMethod: jest.fn(),
+        initializeWDK: jest.fn(),
+        generateEntropyAndEncrypt: jest.fn(),
+        getMnemonicFromEntropy: jest.fn(),
+      } as unknown as HRPC
+
+      expect(isExtendedHRPC(hrpc)).toBe(false)
+    })
+
+    it('should return false for HRPC with non-function methods', () => {
+      const hrpc = {
+        callMethod: jest.fn(),
+        initializeWDK: 'not a function',
+        generateEntropyAndEncrypt: jest.fn(),
+        getMnemonicFromEntropy: jest.fn(),
+        getSeedAndEntropyFromMnemonic: jest.fn(),
+      } as unknown as HRPC
+
+      expect(isExtendedHRPC(hrpc)).toBe(false)
+    })
+
+    it('should return false for basic HRPC', () => {
+      const hrpc = {
+        callMethod: jest.fn(),
+      } as unknown as HRPC
+
+      expect(isExtendedHRPC(hrpc)).toBe(false)
+    })
+  })
+
+  describe('asExtendedHRPC', () => {
+    it('should return HRPC when it has all extended methods', () => {
+      const hrpc = {
+        callMethod: jest.fn(),
+        initializeWDK: jest.fn(),
+        generateEntropyAndEncrypt: jest.fn(),
+        getMnemonicFromEntropy: jest.fn(),
+        getSeedAndEntropyFromMnemonic: jest.fn(),
+      } as unknown as HRPC
+
+      const result = asExtendedHRPC(hrpc)
+      expect(result).toBe(hrpc)
+    })
+
+    it('should throw error when HRPC does not have required methods', () => {
+      const hrpc = {
+        callMethod: jest.fn(),
+      } as unknown as HRPC
+
+      expect(() => asExtendedHRPC(hrpc)).toThrow(
+        'HRPC instance does not have required extended methods'
+      )
+    })
+
+    it('should throw error when HRPC is missing initializeWDK', () => {
+      const hrpc = {
+        callMethod: jest.fn(),
+        generateEntropyAndEncrypt: jest.fn(),
+        getMnemonicFromEntropy: jest.fn(),
+        getSeedAndEntropyFromMnemonic: jest.fn(),
+      } as unknown as HRPC
+
+      expect(() => asExtendedHRPC(hrpc)).toThrow(
+        'HRPC instance does not have required extended methods'
+      )
+    })
+  })
+})
+

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

@@ -0,0 +1,151 @@
+/**
+ * Tests for balance utility functions
+ */
+
+import { convertBalanceToString, formatBalance, convertBigIntToString } from '../../utils/balanceUtils'
+
+describe('balanceUtils', () => {
+  describe('convertBalanceToString', () => {
+    it('should convert BigInt to string', () => {
+      expect(convertBalanceToString(BigInt(100))).toBe('100')
+      expect(convertBalanceToString(BigInt('1000000000000000000'))).toBe('1000000000000000000')
+    })
+
+    it('should return string as-is', () => {
+      expect(convertBalanceToString('100')).toBe('100')
+      expect(convertBalanceToString('0')).toBe('0')
+    })
+
+    it('should convert number to string', () => {
+      expect(convertBalanceToString(100)).toBe('100')
+      expect(convertBalanceToString(0)).toBe('0')
+    })
+
+    it('should convert other types to string', () => {
+      expect(convertBalanceToString(null)).toBe('null')
+      expect(convertBalanceToString(undefined)).toBe('undefined')
+      expect(convertBalanceToString(true)).toBe('true')
+    })
+  })
+
+  describe('formatBalance', () => {
+    it('should format balance with 18 decimals', () => {
+      expect(formatBalance('1000000000000000000', 18)).toBe('1')
+      expect(formatBalance('1500000000000000000', 18)).toBe('1.5')
+      expect(formatBalance('100000000000000000', 18)).toBe('0.1')
+      expect(formatBalance('123456789000000000', 18)).toBe('0.123456789')
+    })
+
+    it('should format balance with 6 decimals', () => {
+      expect(formatBalance('1000000', 6)).toBe('1')
+      expect(formatBalance('1500000', 6)).toBe('1.5')
+      expect(formatBalance('1000001', 6)).toBe('1.000001')
+    })
+
+    it('should handle zero balance', () => {
+      expect(formatBalance('0', 18)).toBe('0')
+      expect(formatBalance(null, 18)).toBe('0')
+      expect(formatBalance('null', 18)).toBe('0')
+    })
+
+    it('should remove trailing zeros', () => {
+      expect(formatBalance('1000000000000000000', 18)).toBe('1')
+      expect(formatBalance('10000000000000000000', 18)).toBe('10')
+    })
+
+    it('should handle large balances', () => {
+      expect(formatBalance('1000000000000000000000', 18)).toBe('1000')
+      expect(formatBalance('1000000000000000000000000', 18)).toBe('1000000')
+    })
+
+    it('should handle invalid balance gracefully', () => {
+      expect(formatBalance('invalid', 18)).toBe('invalid')
+      expect(formatBalance('', 18)).toBe('0')
+    })
+  })
+
+  describe('convertBigIntToString', () => {
+    it('should convert BigInt to string', () => {
+      expect(convertBigIntToString(BigInt(100))).toBe('100')
+      expect(convertBigIntToString(BigInt('1000000000000000000'))).toBe('1000000000000000000')
+    })
+
+    it('should convert BigInt in arrays', () => {
+      const input = [BigInt(100), BigInt(200), 'string', 42]
+      const result = convertBigIntToString(input)
+      expect(result).toEqual(['100', '200', 'string', 42])
+    })
+
+    it('should convert BigInt in nested arrays', () => {
+      const input = [[BigInt(100)], [BigInt(200), 'test']]
+      const result = convertBigIntToString(input)
+      expect(result).toEqual([['100'], ['200', 'test']])
+    })
+
+    it('should convert BigInt in objects', () => {
+      const input = {
+        balance: BigInt(100),
+        amount: BigInt(200),
+        name: 'test',
+        count: 42,
+      }
+      const result = convertBigIntToString(input)
+      expect(result).toEqual({
+        balance: '100',
+        amount: '200',
+        name: 'test',
+        count: 42,
+      })
+    })
+
+    it('should convert BigInt in nested objects', () => {
+      const input = {
+        data: {
+          balance: BigInt(100),
+          nested: {
+            amount: BigInt(200),
+          },
+        },
+      }
+      const result = convertBigIntToString(input)
+      expect(result).toEqual({
+        data: {
+          balance: '100',
+          nested: {
+            amount: '200',
+          },
+        },
+      })
+    })
+
+    it('should convert BigInt in mixed arrays and objects', () => {
+      const input = {
+        balances: [BigInt(100), BigInt(200)],
+        data: {
+          amounts: [BigInt(300), BigInt(400)],
+        },
+      }
+      const result = convertBigIntToString(input)
+      expect(result).toEqual({
+        balances: ['100', '200'],
+        data: {
+          amounts: ['300', '400'],
+        },
+      })
+    })
+
+    it('should return primitives as-is', () => {
+      expect(convertBigIntToString('string')).toBe('string')
+      expect(convertBigIntToString(42)).toBe(42)
+      expect(convertBigIntToString(null)).toBe(null)
+      expect(convertBigIntToString(undefined)).toBe(undefined)
+      expect(convertBigIntToString(true)).toBe(true)
+      expect(convertBigIntToString(false)).toBe(false)
+    })
+
+    it('should handle empty arrays and objects', () => {
+      expect(convertBigIntToString([])).toEqual([])
+      expect(convertBigIntToString({})).toEqual({})
+    })
+  })
+})