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

package/src/__mocks__/secureStorage.ts

@@ -0,0 +1,87 @@
+/**
+ * Mock SecureStorage for testing
+ * 
+ * Supports identifier parameter for multi-wallet testing
+ */
+
+// Internal storage to simulate per-identifier wallet storage
+const storage: Record<string, {
+  encryptionKey: string | null
+  encryptedSeed: string | null
+  encryptedEntropy: string | null
+}> = {}
+
+const getStorageKey = (identifier?: string): string => {
+  return identifier || 'default'
+}
+
+export const mockSecureStorage = {
+  authenticate: jest.fn(() => Promise.resolve(true)),
+  hasWallet: jest.fn((identifier?: string) => {
+    const key = getStorageKey(identifier)
+    const wallet = storage[key]
+    return Promise.resolve(wallet !== undefined && wallet.encryptionKey !== null)
+  }),
+  setEncryptionKey: jest.fn((key: string, identifier?: string) => {
+    const storageKey = getStorageKey(identifier)
+    if (!storage[storageKey]) {
+      storage[storageKey] = { encryptionKey: null, encryptedSeed: null, encryptedEntropy: null }
+    }
+    storage[storageKey].encryptionKey = key
+    return Promise.resolve()
+  }),
+  getEncryptionKey: jest.fn((identifier?: string) => {
+    const storageKey = getStorageKey(identifier)
+    return Promise.resolve(storage[storageKey]?.encryptionKey || null)
+  }),
+  setEncryptedSeed: jest.fn((seed: string, identifier?: string) => {
+    const storageKey = getStorageKey(identifier)
+    if (!storage[storageKey]) {
+      storage[storageKey] = { encryptionKey: null, encryptedSeed: null, encryptedEntropy: null }
+    }
+    storage[storageKey].encryptedSeed = seed
+    return Promise.resolve()
+  }),
+  getEncryptedSeed: jest.fn((identifier?: string) => {
+    const storageKey = getStorageKey(identifier)
+    return Promise.resolve(storage[storageKey]?.encryptedSeed || null)
+  }),
+  setEncryptedEntropy: jest.fn((entropy: string, identifier?: string) => {
+    const storageKey = getStorageKey(identifier)
+    if (!storage[storageKey]) {
+      storage[storageKey] = { encryptionKey: null, encryptedSeed: null, encryptedEntropy: null }
+    }
+    storage[storageKey].encryptedEntropy = entropy
+    return Promise.resolve()
+  }),
+  getEncryptedEntropy: jest.fn((identifier?: string) => {
+    const storageKey = getStorageKey(identifier)
+    return Promise.resolve(storage[storageKey]?.encryptedEntropy || null)
+  }),
+  getAllEncrypted: jest.fn((identifier?: string) => {
+    const storageKey = getStorageKey(identifier)
+    const wallet = storage[storageKey]
+    return Promise.resolve({
+      encryptedSeed: wallet?.encryptedSeed || null,
+      encryptedEntropy: wallet?.encryptedEntropy || null,
+      encryptionKey: wallet?.encryptionKey || null,
+    })
+  }),
+  clearAll: jest.fn(() => {
+    Object.keys(storage).forEach(key => delete storage[key])
+    return Promise.resolve()
+  }),
+  isBiometricAvailable: jest.fn(() => Promise.resolve(true)),
+  deleteWallet: jest.fn((identifier?: string) => {
+    const storageKey = getStorageKey(identifier)
+    delete storage[storageKey]
+    return Promise.resolve()
+  }),
+  cleanup: jest.fn(),
+  // Helper method to clear storage between tests
+  _clearStorage: () => {
+    Object.keys(storage).forEach(key => delete storage[key])
+  },
+}
+
+export default mockSecureStorage

package/src/__tests__/hooks/useBalance.test.ts

@@ -0,0 +1,286 @@
+/**
+ * Tests for useBalance hook
+ *
+ * Tests balance hook logic with TanStack Query integration
+ */
+
+import { balanceQueryKeys } from '../../hooks/useBalance'
+import { AccountService } from '../../services/accountService'
+import { BalanceService } from '../../services/balanceService'
+import { getWorkletStore } from '../../store/workletStore'
+import { getWalletStore } from '../../store/walletStore'
+import { convertBalanceToString } from '../../utils/balanceUtils'
+import { NATIVE_TOKEN_KEY } from '../../utils/constants'
+
+// Mock TanStack Query
+jest.mock('@tanstack/react-query', () => ({
+  useQuery: jest.fn(),
+  useMutation: jest.fn(),
+  useQueryClient: jest.fn(),
+}))
+
+// Mock stores and services
+jest.mock('../../store/workletStore', () => ({
+  getWorkletStore: jest.fn(),
+}))
+
+jest.mock('../../store/walletStore', () => ({
+  getWalletStore: jest.fn(),
+}))
+
+jest.mock('../../services/accountService', () => ({
+  AccountService: {
+    callAccountMethod: jest.fn(),
+  },
+}))
+
+jest.mock('../../services/balanceService', () => ({
+  BalanceService: {
+    updateBalance: jest.fn(),
+    updateLastBalanceUpdate: jest.fn(),
+    getBalance: jest.fn(),
+  },
+}))
+
+jest.mock('../../utils/balanceUtils', () => ({
+  convertBalanceToString: jest.fn((val) => String(val)),
+}))
+
+jest.mock('../../utils/storeHelpers', () => ({
+  resolveWalletId: jest.fn((id) => id || 'default-wallet'),
+}))
+
+jest.mock('../../utils/validation', () => ({
+  validateWalletParams: jest.fn(),
+}))
+
+jest.mock('../../utils/logger', () => ({
+  log: jest.fn(),
+  logError: jest.fn(),
+}))
+
+describe('useBalance', () => {
+  let mockWorkletStore: any
+  let mockWalletStore: any
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    mockWorkletStore = {
+      getState: jest.fn(() => ({
+        isInitialized: true,
+      })),
+    }
+
+    mockWalletStore = {
+      getState: jest.fn(() => ({
+        activeWalletId: 'test-wallet-1',
+      })),
+    }
+    ;(getWorkletStore as jest.Mock).mockReturnValue(mockWorkletStore)
+    ;(getWalletStore as jest.Mock).mockReturnValue(mockWalletStore)
+  })
+
+  describe('balanceQueryKeys', () => {
+    it('should create correct query keys', () => {
+      expect(balanceQueryKeys.all).toEqual(['balances'])
+
+      const walletKey = balanceQueryKeys.byWallet('wallet-1', 0)
+      expect(walletKey).toEqual(['balances', 'wallet', 'wallet-1', 0])
+
+      const networkKey = balanceQueryKeys.byNetwork('ethereum')
+      expect(networkKey).toEqual(['balances', 'network', 'ethereum'])
+
+      const walletNetworkKey = balanceQueryKeys.byWalletAndNetwork(
+        'wallet-1',
+        0,
+        'ethereum',
+      )
+      expect(walletNetworkKey).toEqual([
+        'balances',
+        'wallet',
+        'wallet-1',
+        0,
+        'network',
+        'ethereum',
+      ])
+
+      const nativeTokenKey = balanceQueryKeys.byToken(
+        'wallet-1',
+        0,
+        'ethereum',
+        null,
+      )
+      expect(nativeTokenKey).toEqual([
+        'balances',
+        'wallet',
+        'wallet-1',
+        0,
+        'network',
+        'ethereum',
+        'token',
+        NATIVE_TOKEN_KEY,
+      ])
+
+      const tokenKey = balanceQueryKeys.byToken(
+        'wallet-1',
+        0,
+        'ethereum',
+        '0x123',
+      )
+      expect(tokenKey).toEqual([
+        'balances',
+        'wallet',
+        'wallet-1',
+        0,
+        'network',
+        'ethereum',
+        'token',
+        '0x123',
+      ])
+    })
+  })
+
+  describe('fetchBalance function (tested via hook)', () => {
+    it('should handle wallet not initialized', async () => {
+      mockWorkletStore.getState.mockReturnValue({ isInitialized: false })
+
+      // Import after mocks are set up
+      const { useBalance } = await import('../../hooks/useBalance')
+      const { useQuery } = await import('@tanstack/react-query')
+
+      const mockUseQuery = useQuery as jest.Mock
+      mockUseQuery.mockReturnValue({
+        data: {
+          success: false,
+          network: 'ethereum',
+          accountIndex: 0,
+          tokenAddress: null,
+          balance: null,
+          error: 'Wallet not initialized',
+        },
+        isLoading: false,
+        error: null,
+      })
+
+      // The hook would be called in a React component, but we can test the query function
+      expect(mockUseQuery).toBeDefined()
+    })
+
+    it('should fetch native balance successfully', async () => {
+      const mockBalance = '1000000000000000000'
+      ;(AccountService.callAccountMethod as jest.Mock).mockResolvedValue(
+        mockBalance,
+      )
+      ;(convertBalanceToString as jest.Mock).mockReturnValue(mockBalance)
+
+      const { useQuery } = await import('@tanstack/react-query')
+      const mockUseQuery = useQuery as jest.Mock
+
+      // Simulate query function call
+      const queryFn = mockUseQuery.mock.calls[0]?.[0]?.queryFn
+      if (queryFn) {
+        const result = await queryFn()
+        expect(result.success).toBe(true)
+        expect(result.balance).toBe(mockBalance)
+        expect(AccountService.callAccountMethod).toHaveBeenCalled()
+        expect(BalanceService.updateBalance).toHaveBeenCalled()
+      }
+    })
+
+    it('should fetch token balance successfully', async () => {
+      const mockBalance = '2000000000000000000'
+      const tokenAddress = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+      ;(AccountService.callAccountMethod as jest.Mock).mockResolvedValue(
+        mockBalance,
+      )
+      ;(convertBalanceToString as jest.Mock).mockReturnValue(mockBalance)
+
+      const { useQuery } = await import('@tanstack/react-query')
+      const mockUseQuery = useQuery as jest.Mock
+
+      // Simulate query function call
+      const queryFn = mockUseQuery.mock.calls[0]?.[0]?.queryFn
+      if (queryFn) {
+        const result = await queryFn()
+        expect(result.success).toBe(true)
+        expect(result.balance).toBe(mockBalance)
+        expect(AccountService.callAccountMethod).toHaveBeenCalledWith(
+          'ethereum',
+          0,
+          'getTokenBalance',
+          tokenAddress,
+        )
+      }
+    })
+
+    it('should handle fetch errors', async () => {
+      const error = new Error('Network error')
+      ;(AccountService.callAccountMethod as jest.Mock).mockRejectedValue(error)
+
+      const { useQuery } = await import('@tanstack/react-query')
+      const mockUseQuery = useQuery as jest.Mock
+
+      // Simulate query function call
+      const queryFn = mockUseQuery.mock.calls[0]?.[0]?.queryFn
+      if (queryFn) {
+        const result = await queryFn()
+        expect(result.success).toBe(false)
+        expect(result.error).toBe('Network error')
+        expect(result.balance).toBeNull()
+      }
+    })
+  })
+
+  describe('useBalancesForWallet', () => {
+    it('should build query keys for all tokens', async () => {
+      const tokenConfigs = {
+        ethereum: {
+          native: { address: null, symbol: 'ETH', decimals: 18 },
+          tokens: [{ address: '0x123', symbol: 'USDC', decimals: 6 }],
+        },
+      }
+
+      const { useQuery } = await import('@tanstack/react-query')
+      const mockUseQuery = useQuery as jest.Mock
+      mockUseQuery.mockReturnValue({
+        data: [],
+        isLoading: false,
+        error: null,
+      })
+
+      // Test that query keys are built correctly
+      // This would be tested in a React component, but we verify the structure
+      expect(mockUseQuery).toBeDefined()
+    })
+  })
+
+  describe('useRefreshBalance', () => {
+    it('should invalidate queries correctly', async () => {
+      // Since we can't actually call React hooks in Node environment,
+      // we verify that the hook exports exist and the query key functions work
+      const { useRefreshBalance, balanceQueryKeys } = await import(
+        '../../hooks/useBalance'
+      )
+
+      // Verify the hook is exported
+      expect(typeof useRefreshBalance).toBe('function')
+
+      // Verify query keys can be used for invalidation
+      const allKeys = balanceQueryKeys.all
+      const walletKeys = balanceQueryKeys.byWallet('wallet-1', 0)
+      const networkKeys = balanceQueryKeys.byNetwork('ethereum')
+      const tokenKeys = balanceQueryKeys.byToken(
+        'wallet-1',
+        0,
+        'ethereum',
+        null,
+      )
+
+      expect(allKeys).toEqual(['balances'])
+      expect(walletKeys).toEqual(['balances', 'wallet', 'wallet-1', 0])
+      expect(networkKeys).toEqual(['balances', 'network', 'ethereum'])
+      expect(tokenKeys).toContain('balances')
+    })
+  })
+})

package/src/__tests__/hooks/useWallet.test.ts

@@ -0,0 +1,122 @@
+/**
+ * Tests for useWallet hook
+ * 
+ * Tests wallet hook logic without React rendering
+ */
+
+import { getWorkletStore } from '../../store/workletStore'
+import { getWalletStore } from '../../store/walletStore'
+import { AddressService } from '../../services/addressService'
+import { AccountService } from '../../services/accountService'
+import { BalanceService } from '../../services/balanceService'
+
+// Mock stores and services
+jest.mock('../../store/workletStore', () => ({
+  getWorkletStore: jest.fn(),
+}))
+
+jest.mock('../../store/walletStore', () => ({
+  getWalletStore: jest.fn(),
+}))
+
+jest.mock('../../services/addressService', () => ({
+  AddressService: {
+    getAddress: jest.fn(),
+  },
+}))
+
+jest.mock('../../services/accountService', () => ({
+  AccountService: {
+    callAccountMethod: jest.fn(),
+  },
+}))
+
+jest.mock('../../services/balanceService', () => ({
+  BalanceService: {
+    updateBalance: jest.fn(),
+    getBalance: jest.fn(),
+    getBalancesForWallet: jest.fn(),
+    setBalanceLoading: jest.fn(),
+    isBalanceLoading: jest.fn(),
+    updateLastBalanceUpdate: jest.fn(),
+    getLastBalanceUpdate: jest.fn(),
+    clearBalances: jest.fn(),
+  },
+}))
+
+describe('useWallet', () => {
+  let mockWorkletStore: any
+  let mockWalletStore: any
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    mockWorkletStore = jest.fn((selector: any) => {
+      const state = {
+        isInitialized: true,
+      }
+      return selector ? selector(state) : state
+    })
+
+    mockWalletStore = jest.fn((selector: any) => {
+      const state = {
+        addresses: {
+          ethereum: {
+            0: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+          },
+        },
+        walletLoading: {},
+        balances: {
+          ethereum: {
+            0: {
+              native: '1000000000000000000',
+            },
+          },
+        },
+        balanceLoading: {},
+        lastBalanceUpdate: {
+          ethereum: {
+            0: 1234567890,
+          },
+        },
+      }
+      return selector ? selector(state) : state
+    })
+
+    ;(getWorkletStore as jest.Mock).mockReturnValue(mockWorkletStore)
+    ;(getWalletStore as jest.Mock).mockReturnValue(mockWalletStore)
+  })
+
+  it('should call services correctly', () => {
+    // Test that the hook calls the correct services
+    // Since we can't easily test React hooks in Node, we verify the service calls
+    
+    const mockAddress = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0'
+    ;(AddressService.getAddress as jest.Mock).mockResolvedValue(mockAddress)
+
+    // Verify service methods are callable
+    expect(typeof AddressService.getAddress).toBe('function')
+    expect(typeof AccountService.callAccountMethod).toBe('function')
+    expect(typeof BalanceService.updateBalance).toBe('function')
+    expect(typeof BalanceService.getBalance).toBe('function')
+    expect(typeof BalanceService.getBalancesForWallet).toBe('function')
+    expect(typeof BalanceService.setBalanceLoading).toBe('function')
+    expect(typeof BalanceService.isBalanceLoading).toBe('function')
+    expect(typeof BalanceService.updateLastBalanceUpdate).toBe('function')
+    expect(typeof BalanceService.getLastBalanceUpdate).toBe('function')
+    expect(typeof BalanceService.clearBalances).toBe('function')
+  })
+
+  it('should have correct store structure', () => {
+    // Verify stores return expected structure
+    expect(getWorkletStore).toBeDefined()
+    expect(getWalletStore).toBeDefined()
+    
+    const workletStore = getWorkletStore()
+    const walletStore = getWalletStore()
+    
+    expect(workletStore).toBeDefined()
+    expect(walletStore).toBeDefined()
+  })
+})
+