@tetherto/wdk-react-native-secure-storage 1.0.0-beta.1

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@tetherto/wdk-react-native-secure-storage",
+  "version": "1.0.0-beta.1",
+  "description": "Secure storage abstractions for React Native - provides secure storage for sensitive data (encrypted seeds, keys) using react-native-keychain",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "react-native": "src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "react-native": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tetherto/wdk-react-native-secure-storage.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tetherto/wdk-react-native-secure-storage/issues"
+  },
+  "homepage": "https://github.com/tetherto/wdk-react-native-secure-storage#readme",
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "prepublishOnly": "npm run build && npm run test",
+    "prepack": "npm run build",
+    "prepare": "npm run build"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE",
+    "tsconfig.json"
+  ],
+  "keywords": [
+    "wallet",
+    "react-native",
+    "secure-storage",
+    "react-native-keychain",
+    "keychain"
+  ],
+  "author": "Tetherto",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "expo-crypto": "^15.0.8",
+    "expo-local-authentication": "~17.0.8",
+    "react-native-keychain": "^10.0.0"
+  },
+  "peerDependencies": {
+    "react-native": ">=0.70.0"
+  },
+  "devDependencies": {
+    "@jest/test-sequencer": "^30.2.0",
+    "@types/jest": "^29.5.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.50.0",
+    "jest": "^29.5.0",
+    "prettier": "^3.0.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.3.3"
+  }
+}

package/src/__tests__/__mocks__/expo-crypto.ts

@@ -0,0 +1,35 @@
+/**
+ * Mock for expo-crypto
+ * Used in tests to simulate cryptographic operations
+ */
+
+export enum CryptoDigestAlgorithm {
+  SHA256 = 'SHA256',
+  SHA384 = 'SHA384',
+  SHA512 = 'SHA512',
+}
+
+/**
+ * Mock digestStringAsync function
+ * Returns a deterministic hash based on input string
+ * For testing purposes, uses a simple hash to ensure consistency
+ */
+export async function digestStringAsync(
+  _algorithm: CryptoDigestAlgorithm,
+  data: string
+): Promise<string> {
+  // Simple deterministic hash for testing (not cryptographically secure, but consistent)
+  let hash = 0
+  for (let i = 0; i < data.length; i++) {
+    const char = data.charCodeAt(i)
+    hash = ((hash << 5) - hash) + char
+    hash = hash & hash // Convert to 32-bit integer
+  }
+  
+  // Convert to hex string (64 chars for SHA-256)
+  const hex = Math.abs(hash).toString(16).padStart(8, '0')
+  // Repeat to get 64 characters (SHA-256 length)
+  return (hex.repeat(8)).substring(0, 64)
+}
+
+

package/src/__tests__/__mocks__/expo-local-authentication.ts

@@ -0,0 +1,40 @@
+/**
+ * Mock for expo-local-authentication
+ * Used in tests to simulate authentication operations
+ */
+
+let mockIsEnrolled = true
+let mockHasHardware = true
+let mockAuthenticateResult = { success: true }
+
+export function isEnrolledAsync(): Promise<boolean> {
+  return Promise.resolve(mockIsEnrolled)
+}
+
+export function hasHardwareAsync(): Promise<boolean> {
+  return Promise.resolve(mockHasHardware)
+}
+
+export function authenticateAsync(options?: {
+  promptMessage?: string
+  cancelLabel?: string
+  disableDeviceFallback?: boolean
+}): Promise<{ success: boolean }> {
+  return Promise.resolve(mockAuthenticateResult)
+}
+
+// Helpers for tests to control mock behavior
+export function __setMockIsEnrolled(value: boolean): void {
+  mockIsEnrolled = value
+}
+
+export function __setMockHasHardware(value: boolean): void {
+  mockHasHardware = value
+}
+
+export function __setMockAuthenticateResult(value: { success: boolean }): void {
+  mockAuthenticateResult = value
+}
+
+
+

package/src/__tests__/__mocks__/react-native-keychain.ts

@@ -0,0 +1,60 @@
+/**
+ * Mock for react-native-keychain
+ * Used in tests to simulate keychain operations
+ */
+
+export const ACCESSIBLE = {
+  WHEN_UNLOCKED: 'WHEN_UNLOCKED',
+  WHEN_UNLOCKED_THIS_DEVICE_ONLY: 'WHEN_UNLOCKED_THIS_DEVICE_ONLY',
+}
+
+export const ACCESS_CONTROL = {
+  BIOMETRY_ANY_OR_DEVICE_PASSCODE: 'BIOMETRY_ANY_OR_DEVICE_PASSCODE',
+}
+
+let mockStorage: Map<string, { username: string; password: string }> = new Map()
+
+export function setGenericPassword(
+  username: string,
+  password: string,
+  options?: { service?: string }
+): Promise<{ service: string; storage: string } | false> {
+  const service = options?.service || 'default'
+  mockStorage.set(service, { username, password })
+  return Promise.resolve({ service, storage: 'keychain' })
+}
+
+export function getGenericPassword(options?: { service?: string }): Promise<
+  | {
+      service: string
+      username: string
+      password: string
+      storage: string
+    }
+  | false
+> {
+  const service = options?.service || 'default'
+  const stored = mockStorage.get(service)
+  if (stored) {
+    return Promise.resolve({
+      service,
+      username: stored.username,
+      password: stored.password,
+      storage: 'keychain',
+    })
+  }
+  return Promise.resolve(false)
+}
+
+export function resetGenericPassword(options?: { service?: string }): Promise<boolean> {
+  const service = options?.service || 'default'
+  mockStorage.delete(service)
+  return Promise.resolve(true)
+}
+
+// Helper for tests to reset mock storage
+export function __resetMockStorage(): void {
+  mockStorage.clear()
+}
+
+

package/src/__tests__/errors.test.ts

@@ -0,0 +1,78 @@
+import {
+  SecureStorageError,
+  KeychainError,
+  KeychainWriteError,
+  KeychainReadError,
+  AuthenticationError,
+  ValidationError,
+  TimeoutError,
+} from '../errors'
+
+describe('errors', () => {
+  describe('SecureStorageError', () => {
+    it('should create error with message and code', () => {
+      const error = new SecureStorageError('Test error', 'TEST_CODE')
+      expect(error.message).toBe('Test error')
+      expect(error.code).toBe('TEST_CODE')
+      expect(error.name).toBe('SecureStorageError')
+    })
+
+    it('should include cause error', () => {
+      const cause = new Error('Original error')
+      const error = new SecureStorageError('Test error', 'TEST_CODE', cause)
+      expect(error.cause).toBe(cause)
+    })
+  })
+
+  describe('KeychainError', () => {
+    it('should create keychain error', () => {
+      const error = new KeychainError('Keychain failed')
+      expect(error.message).toBe('Keychain failed')
+      expect(error.code).toBe('KEYCHAIN_ERROR')
+      expect(error.name).toBe('KeychainError')
+    })
+  })
+
+  describe('KeychainWriteError', () => {
+    it('should create write error', () => {
+      const error = new KeychainWriteError('Write failed')
+      expect(error.code).toBe('KEYCHAIN_WRITE_ERROR')
+      expect(error.name).toBe('KeychainWriteError')
+    })
+  })
+
+  describe('KeychainReadError', () => {
+    it('should create read error', () => {
+      const error = new KeychainReadError('Read failed')
+      expect(error.code).toBe('KEYCHAIN_READ_ERROR')
+      expect(error.name).toBe('KeychainReadError')
+    })
+  })
+
+  describe('AuthenticationError', () => {
+    it('should create authentication error', () => {
+      const error = new AuthenticationError('Auth failed')
+      expect(error.code).toBe('AUTHENTICATION_ERROR')
+      expect(error.name).toBe('AuthenticationError')
+    })
+  })
+
+  describe('ValidationError', () => {
+    it('should create validation error', () => {
+      const error = new ValidationError('Invalid input')
+      expect(error.code).toBe('VALIDATION_ERROR')
+      expect(error.name).toBe('ValidationError')
+    })
+  })
+
+  describe('TimeoutError', () => {
+    it('should create timeout error', () => {
+      const error = new TimeoutError('Operation timed out')
+      expect(error.code).toBe('TIMEOUT_ERROR')
+      expect(error.name).toBe('TimeoutError')
+    })
+  })
+})
+
+
+

package/src/__tests__/logger.test.ts

@@ -0,0 +1,131 @@
+import { defaultLogger, LogLevel } from '../logger'
+
+describe('logger', () => {
+  let consoleErrorSpy: jest.SpyInstance
+  let consoleWarnSpy: jest.SpyInstance
+  let consoleLogSpy: jest.SpyInstance
+
+  beforeEach(() => {
+    // Spy on console methods
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
+    consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation()
+    consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
+  })
+
+  afterEach(() => {
+    // Restore console methods
+    consoleErrorSpy.mockRestore()
+    consoleWarnSpy.mockRestore()
+    consoleLogSpy.mockRestore()
+    // Reset logger level to default (ERROR)
+    defaultLogger.setLevel(LogLevel.ERROR)
+  })
+
+  describe('defaultLogger', () => {
+    it('should set log level', () => {
+      defaultLogger.setLevel(LogLevel.DEBUG)
+      expect(() => defaultLogger.setLevel(LogLevel.INFO)).not.toThrow()
+    })
+
+    it('should log error messages', () => {
+      defaultLogger.setLevel(LogLevel.ERROR)
+      const error = new Error('Test error')
+      defaultLogger.error('Error message', error, { context: 'test' })
+      
+      expect(consoleErrorSpy).toHaveBeenCalledTimes(1)
+      const logCall = consoleErrorSpy.mock.calls[0][0]
+      expect(logCall).toContain('Error message')
+      expect(JSON.parse(logCall)).toMatchObject({
+        level: LogLevel.ERROR,
+        message: 'Error message',
+      })
+    })
+
+    it('should log warn messages when level is WARN or lower', () => {
+      defaultLogger.setLevel(LogLevel.WARN)
+      defaultLogger.warn('Warning message', { context: 'test' })
+      
+      expect(consoleWarnSpy).toHaveBeenCalledTimes(1)
+      const logCall = consoleWarnSpy.mock.calls[0][0]
+      expect(JSON.parse(logCall)).toMatchObject({
+        level: LogLevel.WARN,
+        message: 'Warning message',
+      })
+    })
+
+    it('should log info messages when level is INFO or lower', () => {
+      defaultLogger.setLevel(LogLevel.INFO)
+      defaultLogger.info('Info message', { context: 'test' })
+      
+      expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+      const logCall = consoleLogSpy.mock.calls[0][0]
+      expect(JSON.parse(logCall)).toMatchObject({
+        level: LogLevel.INFO,
+        message: 'Info message',
+      })
+    })
+
+    it('should log debug messages when level is DEBUG', () => {
+      defaultLogger.setLevel(LogLevel.DEBUG)
+      defaultLogger.debug('Debug message', { context: 'test' })
+      
+      expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+      const logCall = consoleLogSpy.mock.calls[0][0]
+      expect(JSON.parse(logCall)).toMatchObject({
+        level: LogLevel.DEBUG,
+        message: 'Debug message',
+      })
+    })
+
+    it('should not log messages below minimum level', () => {
+      defaultLogger.setLevel(LogLevel.ERROR)
+      
+      defaultLogger.debug('Debug message')
+      defaultLogger.info('Info message')
+      defaultLogger.warn('Warning message')
+      
+      expect(consoleLogSpy).not.toHaveBeenCalled()
+      expect(consoleWarnSpy).not.toHaveBeenCalled()
+      
+      // Error should still be logged
+      defaultLogger.error('Error message')
+      expect(consoleErrorSpy).toHaveBeenCalledTimes(1)
+    })
+
+    it('should include context in log entries', () => {
+      defaultLogger.setLevel(LogLevel.DEBUG)
+      defaultLogger.info('Test message', { key: 'value', number: 123 })
+      
+      const logCall = consoleLogSpy.mock.calls[0][0]
+      const entry = JSON.parse(logCall)
+      expect(entry.context).toEqual({ key: 'value', number: 123 })
+    })
+
+    it('should include error in log entries', () => {
+      defaultLogger.setLevel(LogLevel.ERROR)
+      const error = new Error('Test error')
+      error.stack = 'Error stack trace'
+      
+      defaultLogger.error('Error message', error)
+      
+      const logCall = consoleErrorSpy.mock.calls[0][0]
+      const entry = JSON.parse(logCall)
+      expect(entry.error).toBeDefined()
+    })
+
+    it('should include timestamp in log entries', () => {
+      defaultLogger.setLevel(LogLevel.DEBUG)
+      const beforeTime = Date.now()
+      
+      defaultLogger.info('Test message')
+      
+      const logCall = consoleLogSpy.mock.calls[0][0]
+      const entry = JSON.parse(logCall)
+      const afterTime = Date.now()
+      
+      expect(entry.timestamp).toBeGreaterThanOrEqual(beforeTime)
+      expect(entry.timestamp).toBeLessThanOrEqual(afterTime)
+    })
+  })
+})
+