@sip-protocol/react-native 0.1.0

package/src/hooks/use-scan-payments.ts

@@ -0,0 +1,288 @@
+/**
+ * useScanPayments - Mobile-optimized payment scanning hook
+ *
+ * Scans for incoming stealth payments using viewing key.
+ *
+ * @example
+ * ```tsx
+ * import { useScanPayments } from '@sip-protocol/react-native'
+ *
+ * function InboxScreen() {
+ *   const { payments, isScanning, scan, claim } = useScanPayments({
+ *     connection,
+ *     provider: heliusProvider,
+ *   })
+ *
+ *   useEffect(() => {
+ *     // Load keys from keychain and scan
+ *     loadKeysAndScan()
+ *   }, [])
+ *
+ *   return (
+ *     <FlatList
+ *       data={payments}
+ *       renderItem={({ item }) => (
+ *         <PaymentCard
+ *           payment={item}
+ *           onClaim={() => claim(item.signature)}
+ *         />
+ *       )}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+
+import { useState, useCallback, useRef } from 'react'
+
+/**
+ * Solana connection interface (subset of @solana/web3.js Connection)
+ */
+export interface SolanaConnection {
+  getAccountInfo(publicKey: unknown): Promise<unknown>
+  getSignaturesForAddress(address: unknown, options?: unknown): Promise<unknown[]>
+  getTransaction(signature: string, options?: unknown): Promise<unknown>
+}
+
+/**
+ * Scanned payment result from SDK
+ */
+interface SDKPaymentResult {
+  signature: string
+  stealthAddress: string
+  ephemeralPublicKey: string
+  mint: string
+  amount: bigint
+  timestamp?: number
+}
+
+/**
+ * Scanned payment info
+ */
+export interface ScannedPayment {
+  /** Transaction signature */
+  signature: string
+  /** Stealth address that received the payment */
+  stealthAddress: string
+  /** Ephemeral public key */
+  ephemeralPublicKey: string
+  /** Token mint address */
+  mint: string
+  /** Amount in smallest units */
+  amount: bigint
+  /** Block timestamp */
+  timestamp: number
+  /** Whether this payment has been claimed */
+  claimed: boolean
+}
+
+/**
+ * Scan status
+ */
+export type ScanStatus = 'idle' | 'scanning' | 'claiming' | 'error'
+
+/**
+ * Hook parameters
+ */
+export interface UseScanPaymentsParams {
+  /** Solana connection */
+  connection: SolanaConnection
+  /** RPC provider (Helius recommended) */
+  provider?: unknown
+}
+
+/**
+ * Hook return type
+ */
+export interface UseScanPaymentsReturn {
+  /** Scanned payments */
+  payments: ScannedPayment[]
+  /** Current status */
+  status: ScanStatus
+  /** Error if any */
+  error: Error | null
+  /** Whether scanning is in progress */
+  isScanning: boolean
+  /** Scan for payments */
+  scan: (viewingPrivateKey: string, spendingPublicKey: string) => Promise<void>
+  /** Claim a specific payment */
+  claim: (signature: string, spendingPrivateKey: string, destinationAddress: string) => Promise<string | null>
+  /** Claim all unclaimed payments */
+  claimAll: (spendingPrivateKey: string, destinationAddress: string) => Promise<string[]>
+  /** Clear payments */
+  clear: () => void
+}
+
+/**
+ * Mobile payment scanning hook
+ */
+export function useScanPayments(params: UseScanPaymentsParams): UseScanPaymentsReturn {
+  const { connection } = params
+
+  const [payments, setPayments] = useState<ScannedPayment[]>([])
+  const [status, setStatus] = useState<ScanStatus>('idle')
+  const [error, setError] = useState<Error | null>(null)
+  const scanningRef = useRef(false)
+
+  const scan = useCallback(
+    async (viewingPrivateKey: string, spendingPublicKey: string) => {
+      if (scanningRef.current) return
+      scanningRef.current = true
+
+      try {
+        setStatus('scanning')
+        setError(null)
+
+        // Dynamic import with runtime check
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const sdk: any = await import('@sip-protocol/sdk')
+
+        if (!sdk.scanForPayments) {
+          throw new Error(
+            'scanForPayments not available. Install @sip-protocol/sdk with Solana support.'
+          )
+        }
+
+        const scanForPayments = sdk.scanForPayments as (params: {
+          connection: unknown
+          viewingPrivateKey: string
+          spendingPublicKey: string
+        }) => Promise<SDKPaymentResult[]>
+
+        const result = await scanForPayments({
+          connection,
+          viewingPrivateKey,
+          spendingPublicKey,
+        })
+
+        // Map to our payment type
+        const scannedPayments: ScannedPayment[] = result.map((p: SDKPaymentResult) => ({
+          signature: p.signature,
+          stealthAddress: p.stealthAddress,
+          ephemeralPublicKey: p.ephemeralPublicKey,
+          mint: p.mint,
+          amount: p.amount,
+          timestamp: p.timestamp ?? Date.now(),
+          claimed: false,
+        }))
+
+        setPayments((prev) => {
+          // Merge with existing, avoiding duplicates
+          const existingSigs = new Set(prev.map((p) => p.signature))
+          const newPayments = scannedPayments.filter((p) => !existingSigs.has(p.signature))
+          return [...prev, ...newPayments]
+        })
+
+        setStatus('idle')
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error('Scan failed')
+        setError(error)
+        setStatus('error')
+      } finally {
+        scanningRef.current = false
+      }
+    },
+    [connection]
+  )
+
+  const claim = useCallback(
+    async (
+      signature: string,
+      spendingPrivateKey: string,
+      destinationAddress: string
+    ): Promise<string | null> => {
+      try {
+        setStatus('claiming')
+        setError(null)
+
+        const payment = payments.find((p) => p.signature === signature)
+        if (!payment) {
+          throw new Error('Payment not found')
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const sdk: any = await import('@sip-protocol/sdk')
+        const { PublicKey } = await import('@solana/web3.js')
+
+        if (!sdk.claimStealthPayment) {
+          throw new Error(
+            'claimStealthPayment not available. Install @sip-protocol/sdk with Solana support.'
+          )
+        }
+
+        const claimStealthPayment = sdk.claimStealthPayment as (params: {
+          connection: unknown
+          stealthAddress: string
+          ephemeralPublicKey: string
+          viewingPrivateKey: string
+          spendingPrivateKey: string
+          destinationAddress: unknown
+          mint: unknown
+        }) => Promise<{ signature: string }>
+
+        const result = await claimStealthPayment({
+          connection,
+          stealthAddress: payment.stealthAddress,
+          ephemeralPublicKey: payment.ephemeralPublicKey,
+          viewingPrivateKey: '', // Not needed for claiming
+          spendingPrivateKey,
+          destinationAddress: new PublicKey(destinationAddress),
+          mint: new PublicKey(payment.mint),
+        })
+
+        // Mark as claimed
+        setPayments((prev) =>
+          prev.map((p) =>
+            p.signature === signature ? { ...p, claimed: true } : p
+          )
+        )
+
+        setStatus('idle')
+        return result.signature
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error('Claim failed')
+        setError(error)
+        setStatus('error')
+        return null
+      }
+    },
+    [connection, payments]
+  )
+
+  const claimAll = useCallback(
+    async (
+      spendingPrivateKey: string,
+      destinationAddress: string
+    ): Promise<string[]> => {
+      const unclaimedPayments = payments.filter((p) => !p.claimed)
+      const signatures: string[] = []
+
+      for (const payment of unclaimedPayments) {
+        const sig = await claim(payment.signature, spendingPrivateKey, destinationAddress)
+        if (sig) {
+          signatures.push(sig)
+        }
+      }
+
+      return signatures
+    },
+    [payments, claim]
+  )
+
+  const clear = useCallback(() => {
+    setPayments([])
+    setError(null)
+    setStatus('idle')
+  }, [])
+
+  return {
+    payments,
+    status,
+    error,
+    isScanning: status === 'scanning',
+    scan,
+    claim,
+    claimAll,
+    clear,
+  }
+}

package/src/hooks/use-stealth-address.ts

@@ -0,0 +1,329 @@
+/**
+ * useStealthAddress - Mobile-optimized stealth address hook
+ *
+ * React Native version with secure storage and native clipboard support.
+ *
+ * @example
+ * ```tsx
+ * import { useStealthAddress } from '@sip-protocol/react-native'
+ *
+ * function ReceiveScreen() {
+ *   const {
+ *     metaAddress,
+ *     stealthAddress,
+ *     isGenerating,
+ *     regenerate,
+ *     copyToClipboard,
+ *     saveToKeychain,
+ *   } = useStealthAddress('solana')
+ *
+ *   return (
+ *     <View>
+ *       <Text>Share: {metaAddress}</Text>
+ *       <TouchableOpacity onPress={copyToClipboard}>
+ *         <Text>Copy</Text>
+ *       </TouchableOpacity>
+ *       <TouchableOpacity onPress={saveToKeychain}>
+ *         <Text>Save Securely</Text>
+ *       </TouchableOpacity>
+ *     </View>
+ *   )
+ * }
+ * ```
+ */
+
+import { useState, useEffect, useCallback } from 'react'
+import { copyToClipboard as nativeCopyToClipboard } from '../utils/clipboard'
+import { SecureStorage } from '../storage/secure-storage'
+
+/**
+ * Supported chain IDs (matches @sip-protocol/types ChainId)
+ */
+export type SupportedChainId =
+  | 'ethereum'
+  | 'solana'
+  | 'near'
+  | 'bitcoin'
+  | 'polygon'
+  | 'arbitrum'
+  | 'optimism'
+  | 'base'
+  | 'bsc'
+  | 'avalanche'
+  | 'cosmos'
+  | 'aptos'
+  | 'sui'
+  | 'polkadot'
+  | 'tezos'
+
+/**
+ * Stealth meta-address structure from SDK
+ */
+interface StealthMetaAddressResult {
+  metaAddress: {
+    chain: string
+    spendingKey: string
+    viewingKey: string
+  }
+  spendingPrivateKey: string
+  viewingPrivateKey: string
+}
+
+/**
+ * Stealth address generation result from SDK
+ */
+interface StealthAddressResult {
+  stealthAddress: {
+    address: string
+  }
+  ephemeralPublicKey: string
+}
+
+/**
+ * Options for useStealthAddress hook
+ */
+export interface UseStealthAddressOptions {
+  /** Auto-save to secure storage on generation */
+  autoSave?: boolean
+  /** Require biometrics to access stored keys */
+  requireBiometrics?: boolean
+  /** Wallet identifier for storage (default: 'default') */
+  walletId?: string
+}
+
+/**
+ * Return type for useStealthAddress hook
+ */
+export interface UseStealthAddressReturn {
+  /** Encoded meta-address for sharing */
+  metaAddress: string | null
+  /** One-time stealth address */
+  stealthAddress: string | null
+  /** Spending private key (for claiming) */
+  spendingPrivateKey: string | null
+  /** Viewing private key (for scanning) */
+  viewingPrivateKey: string | null
+  /** Whether generation is in progress */
+  isGenerating: boolean
+  /** Error if any occurred */
+  error: Error | null
+  /** Generate a new stealth address */
+  regenerate: () => void
+  /** Copy stealth address to clipboard */
+  copyToClipboard: () => Promise<boolean>
+  /** Save keys to secure storage */
+  saveToKeychain: () => Promise<boolean>
+  /** Load keys from secure storage */
+  loadFromKeychain: () => Promise<boolean>
+  /** Clear error state */
+  clearError: () => void
+}
+
+/**
+ * Mobile-optimized stealth address hook
+ *
+ * @param chain - Target blockchain
+ * @param options - Hook options
+ */
+export function useStealthAddress(
+  chain: SupportedChainId,
+  options: UseStealthAddressOptions = {}
+): UseStealthAddressReturn {
+  const { autoSave = false, requireBiometrics = false, walletId = 'default' } = options
+
+  const [metaAddress, setMetaAddress] = useState<string | null>(null)
+  const [stealthAddress, setStealthAddress] = useState<string | null>(null)
+  const [spendingPrivateKey, setSpendingPrivateKey] = useState<string | null>(null)
+  const [viewingPrivateKey, setViewingPrivateKey] = useState<string | null>(null)
+  const [isGenerating, setIsGenerating] = useState<boolean>(false)
+  const [error, setError] = useState<Error | null>(null)
+
+  // Generate keys on mount
+  useEffect(() => {
+    let cancelled = false
+
+    const generate = async () => {
+      setIsGenerating(true)
+
+      try {
+        // Dynamic import SDK functions
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const sdk: any = await import('@sip-protocol/sdk')
+
+        // Generate meta-address with keys (handles Ed25519 vs secp256k1 internally)
+        const generateStealthMetaAddress = sdk.generateStealthMetaAddress as (
+          chain: string
+        ) => StealthMetaAddressResult
+
+        const metaAddressData = generateStealthMetaAddress(chain)
+
+        if (cancelled) return
+
+        const encodeStealthMetaAddress = sdk.encodeStealthMetaAddress as (
+          metaAddress: { chain: string; spendingKey: string; viewingKey: string }
+        ) => string
+
+        const encoded = encodeStealthMetaAddress(metaAddressData.metaAddress)
+        setMetaAddress(encoded)
+        setSpendingPrivateKey(metaAddressData.spendingPrivateKey)
+        setViewingPrivateKey(metaAddressData.viewingPrivateKey)
+
+        // Generate initial stealth address
+        const generateStealthAddress = sdk.generateStealthAddress as (
+          metaAddress: { chain: string; spendingKey: string; viewingKey: string }
+        ) => StealthAddressResult
+
+        const stealthData = generateStealthAddress(metaAddressData.metaAddress)
+
+        if (cancelled) return
+        setStealthAddress(stealthData.stealthAddress.address)
+        setError(null)
+
+        // Auto-save if enabled
+        if (autoSave && !cancelled) {
+          await SecureStorage.setSpendingKey(walletId, metaAddressData.spendingPrivateKey, {
+            requireBiometrics,
+          })
+          await SecureStorage.setViewingKey(walletId, metaAddressData.viewingPrivateKey, {
+            requireBiometrics,
+          })
+          await SecureStorage.setMetaAddress(walletId, encoded, { requireBiometrics })
+        }
+      } catch (err) {
+        if (cancelled) return
+        const error = err instanceof Error ? err : new Error('Failed to generate stealth addresses')
+        setError(error)
+        setMetaAddress(null)
+        setStealthAddress(null)
+        setSpendingPrivateKey(null)
+        setViewingPrivateKey(null)
+      } finally {
+        if (!cancelled) {
+          setIsGenerating(false)
+        }
+      }
+    }
+
+    generate()
+
+    return () => {
+      cancelled = true
+    }
+  }, [chain, autoSave, requireBiometrics, walletId])
+
+  // Regenerate stealth address
+  const regenerate = useCallback(() => {
+    if (!metaAddress) return
+
+    setIsGenerating(true)
+
+    // Use setTimeout to avoid blocking UI
+    setTimeout(async () => {
+      try {
+        const parts = metaAddress.split(':')
+        if (parts.length < 4) {
+          throw new Error('Invalid meta-address format')
+        }
+
+        const [, chainId, spendingKey, viewingKey] = parts
+        const metaAddressObj = {
+          chain: chainId,
+          spendingKey: spendingKey.startsWith('0x') ? spendingKey : `0x${spendingKey}`,
+          viewingKey: viewingKey.startsWith('0x') ? viewingKey : `0x${viewingKey}`,
+        }
+
+        // Dynamic import SDK
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const sdk: any = await import('@sip-protocol/sdk')
+        const generateStealthAddress = sdk.generateStealthAddress as (
+          metaAddress: { chain: string; spendingKey: string; viewingKey: string }
+        ) => StealthAddressResult
+
+        const stealthData = generateStealthAddress(metaAddressObj)
+
+        setStealthAddress(stealthData.stealthAddress.address)
+        setError(null)
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error('Failed to regenerate stealth address')
+        setError(error)
+      } finally {
+        setIsGenerating(false)
+      }
+    }, 0)
+  }, [metaAddress])
+
+  // Copy to clipboard (native)
+  const copyToClipboard = useCallback(async (): Promise<boolean> => {
+    if (!stealthAddress) return false
+    const success = await nativeCopyToClipboard(stealthAddress)
+    if (!success) {
+      setError(new Error('Failed to copy to clipboard'))
+    } else {
+      setError(null)
+    }
+    return success
+  }, [stealthAddress])
+
+  // Save to secure storage
+  const saveToKeychain = useCallback(async (): Promise<boolean> => {
+    if (!spendingPrivateKey || !viewingPrivateKey || !metaAddress) {
+      setError(new Error('No keys to save'))
+      return false
+    }
+
+    try {
+      await SecureStorage.setSpendingKey(walletId, spendingPrivateKey, { requireBiometrics })
+      await SecureStorage.setViewingKey(walletId, viewingPrivateKey, { requireBiometrics })
+      await SecureStorage.setMetaAddress(walletId, metaAddress, { requireBiometrics })
+      setError(null)
+      return true
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error('Failed to save to keychain')
+      setError(error)
+      return false
+    }
+  }, [spendingPrivateKey, viewingPrivateKey, metaAddress, walletId, requireBiometrics])
+
+  // Load from secure storage
+  const loadFromKeychain = useCallback(async (): Promise<boolean> => {
+    try {
+      const storedMeta = await SecureStorage.getMetaAddress(walletId, { requireBiometrics })
+      const storedSpending = await SecureStorage.getSpendingKey(walletId, { requireBiometrics })
+      const storedViewing = await SecureStorage.getViewingKey(walletId, { requireBiometrics })
+
+      if (!storedMeta || !storedSpending || !storedViewing) {
+        setError(new Error('No keys found in keychain'))
+        return false
+      }
+
+      setMetaAddress(storedMeta)
+      setSpendingPrivateKey(storedSpending)
+      setViewingPrivateKey(storedViewing)
+      setError(null)
+      return true
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error('Failed to load from keychain')
+      setError(error)
+      return false
+    }
+  }, [walletId, requireBiometrics])
+
+  // Clear error
+  const clearError = useCallback(() => {
+    setError(null)
+  }, [])
+
+  return {
+    metaAddress,
+    stealthAddress,
+    spendingPrivateKey,
+    viewingPrivateKey,
+    isGenerating,
+    error,
+    regenerate,
+    copyToClipboard,
+    saveToKeychain,
+    loadFromKeychain,
+    clearError,
+  }
+}