toss-expo-sdk 0.1.2 → 1.0.2

package/src/hooks/useOfflineBLETransactions.ts

@@ -0,0 +1,438 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { Device } from 'react-native-ble-plx';
+import { Connection } from '@solana/web3.js';
+import type { SolanaIntent } from '../intent';
+import type {
+  OfflineTransaction,
+  NonceAccountCacheEntry,
+} from '../types/nonceAccount';
+import type { TossUser } from '../types/tossUser';
+import { BLETransactionHandler } from '../client/BLETransactionHandler';
+import { NonceAccountManager } from '../client/NonceAccountManager';
+import { AuthService } from '../services/authService';
+
+/**
+ * State for BLE transaction transmission
+ */
+export interface BLETransmissionState {
+  isTransmitting: boolean;
+  progress: {
+    sentFragments: number;
+    totalFragments: number;
+    messageId?: string;
+  };
+  error?: string;
+  lastSent?: {
+    messageId: string;
+    timestamp: number;
+  };
+}
+
+/**
+ * State for offline transaction preparation
+ */
+export interface OfflineTransactionState {
+  isPreparing: boolean;
+  transaction?: OfflineTransaction;
+  error?: string;
+  isReady: boolean;
+}
+
+/**
+ * useOfflineTransaction Hook
+ * Manages offline transaction creation with nonce accounts
+ * Handles biometric protection and secure storage
+ */
+export function useOfflineTransaction(user: TossUser, connection: Connection) {
+  const [state, setState] = useState<OfflineTransactionState>({
+    isPreparing: false,
+    isReady: false,
+  });
+  const nonceManagerRef = useRef<NonceAccountManager | null>(null);
+
+  // Initialize nonce manager
+  useEffect(() => {
+    nonceManagerRef.current = new NonceAccountManager(connection);
+
+    // Cleanup expired cache periodically
+    const interval = setInterval(
+      () => {
+        nonceManagerRef.current?.cleanupExpiredCache();
+      },
+      5 * 60 * 1000
+    ); // Every 5 minutes
+
+    return () => clearInterval(interval);
+  }, [connection]);
+
+  /**
+   * Create offline transaction with nonce account
+   * Requires biometric verification if enabled
+   */
+  const createOfflineTransaction = useCallback(
+    async (
+      instructions: any[], // TransactionInstruction[]
+      metadata?: { description?: string; tags?: string[] }
+    ): Promise<OfflineTransaction | null> => {
+      if (!user.nonceAccount) {
+        setState((prev) => ({
+          ...prev,
+          error: 'User does not have nonce account configured',
+        }));
+        return null;
+      }
+
+      setState((prev) => ({
+        ...prev,
+        isPreparing: true,
+        error: undefined,
+      }));
+
+      try {
+        // Verify nonce account access (requires biometric if enabled)
+        if (user.security.nonceAccountRequiresBiometric) {
+          const hasAccess = await AuthService.verifyNonceAccountAccess(
+            user.userId
+          );
+          if (!hasAccess) {
+            throw new Error('Biometric verification failed');
+          }
+        }
+
+        // Get cached nonce account or retrieve from storage
+        const nonceManager = nonceManagerRef.current!;
+        let nonceAccountData = nonceManager.getCachedNonceAccount(user.userId);
+
+        let nonceAccountInfo: NonceAccountCacheEntry | null = null;
+        if (nonceAccountData) {
+          nonceAccountInfo = nonceAccountData;
+        } else {
+          const retrievedInfo = await nonceManager.getNonceAccountSecure(
+            user.userId
+          );
+          if (retrievedInfo) {
+            nonceAccountInfo = nonceManager.getCachedNonceAccount(user.userId);
+          }
+        }
+
+        if (!nonceAccountInfo) {
+          throw new Error('Failed to retrieve nonce account information');
+        }
+
+        // Validate nonce account
+        if (!nonceManager.isNonceAccountValid(nonceAccountInfo.accountInfo)) {
+          throw new Error('Nonce account is no longer valid');
+        }
+
+        // Prepare offline transaction
+        const transaction = await nonceManager.prepareOfflineTransaction(
+          user,
+          instructions,
+          nonceAccountInfo.accountInfo
+        );
+
+        transaction.metadata = metadata || {};
+
+        setState((prev) => ({
+          ...prev,
+          transaction,
+          isReady: true,
+          isPreparing: false,
+        }));
+
+        return transaction;
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        setState((prev) => ({
+          ...prev,
+          error: errorMessage,
+          isPreparing: false,
+          isReady: false,
+        }));
+        return null;
+      }
+    },
+    [user]
+  );
+
+  /**
+   * Clear current offline transaction
+   */
+  const clearTransaction = useCallback(() => {
+    setState({
+      isPreparing: false,
+      isReady: false,
+    });
+  }, []);
+
+  return {
+    ...state,
+    createOfflineTransaction,
+    clearTransaction,
+    nonceManager: nonceManagerRef.current,
+  };
+}
+
+/**
+ * useBLETransactionTransmission Hook
+ * Handles secure BLE transmission of fragmented transactions
+ * with Noise Protocol encryption
+ */
+export function useBLETransactionTransmission(
+  platform: 'android' | 'ios' = 'android'
+) {
+  const [state, setState] = useState<BLETransmissionState>({
+    isTransmitting: false,
+    progress: {
+      sentFragments: 0,
+      totalFragments: 0,
+    },
+  });
+
+  const bleHandlerRef = useRef(new BLETransactionHandler(platform));
+
+  /**
+   * Send transaction over BLE with fragmentation
+   */
+  const sendTransactionBLE = useCallback(
+    async (
+      device: Device,
+      transaction: OfflineTransaction | SolanaIntent,
+      sendFn: (
+        deviceId: string,
+        characteristicUUID: string,
+        data: Buffer
+      ) => Promise<void>,
+      noiseEncryptFn?: (data: Uint8Array) => Promise<any>,
+      isIntent: boolean = false
+    ): Promise<boolean> => {
+      setState((prev) => ({
+        ...prev,
+        isTransmitting: true,
+        error: undefined,
+      }));
+
+      try {
+        const bleHandler = bleHandlerRef.current;
+        const result = await bleHandler.sendFragmentedTransactionBLE(
+          device,
+          transaction,
+          sendFn,
+          noiseEncryptFn,
+          isIntent
+        );
+
+        if (!result.success) {
+          const failedCount = result.failedFragments.length;
+          throw new Error(
+            `Failed to send ${failedCount} fragment(s): ${result.failedFragments.join(', ')}`
+          );
+        }
+
+        setState((prev) => ({
+          ...prev,
+          isTransmitting: false,
+          progress: {
+            sentFragments: result.sentFragments,
+            totalFragments:
+              result.sentFragments + result.failedFragments.length,
+            messageId: result.messageId,
+          },
+          lastSent: {
+            messageId: result.messageId,
+            timestamp: Date.now(),
+          },
+        }));
+
+        return true;
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        setState((prev) => ({
+          ...prev,
+          isTransmitting: false,
+          error: errorMessage,
+        }));
+        return false;
+      }
+    },
+    []
+  );
+
+  /**
+   * Receive fragmented transaction
+   */
+  const receiveTransactionFragment = useCallback(
+    async (
+      fragment: any, // BLEFragment
+      noiseDecryptFn?: (encrypted: any) => Promise<Uint8Array>
+    ): Promise<{
+      complete: boolean;
+      transaction?: OfflineTransaction | SolanaIntent;
+      progress: { received: number; total: number };
+    }> => {
+      try {
+        const bleHandler = bleHandlerRef.current;
+        const result = await bleHandler.receiveFragmentedMessage(
+          fragment,
+          noiseDecryptFn
+        );
+
+        setState((prev) => ({
+          ...prev,
+          progress: {
+            sentFragments: result.progress.received,
+            totalFragments: result.progress.total,
+            messageId: fragment.messageId,
+          },
+        }));
+
+        return result;
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        setState((prev) => ({
+          ...prev,
+          error: errorMessage,
+        }));
+
+        return {
+          complete: false,
+          progress: { received: 0, total: 0 },
+        };
+      }
+    },
+    []
+  );
+
+  const getMTUConfig = useCallback(() => {
+    return bleHandlerRef.current.getMTUConfig();
+  }, []);
+
+  const setMTUConfig = useCallback((config: Partial<any>) => {
+    bleHandlerRef.current.setMTUConfig(config);
+  }, []);
+
+  return {
+    ...state,
+    sendTransactionBLE,
+    receiveTransactionFragment,
+    getMTUConfig,
+    setMTUConfig,
+  };
+}
+
+/**
+ * useNonceAccountManagement Hook
+ * Manages nonce account lifecycle: creation, renewal, revocation
+ */
+export function useNonceAccountManagement(
+  user: TossUser,
+  connection: Connection
+) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | undefined>();
+  const nonceManagerRef = useRef(new NonceAccountManager(connection));
+
+  /**
+   * Create nonce account with biometric protection
+   */
+  const createNonceAccount = useCallback(
+    async (userKeypair: any) => {
+      setIsLoading(true);
+      setError(undefined);
+
+      try {
+        const updatedUser = await AuthService.createSecureNonceAccount(
+          user,
+          connection,
+          userKeypair
+        );
+
+        return updatedUser;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        setError(errorMessage);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [user, connection]
+  );
+
+  /**
+   * Renew nonce account (refresh from blockchain)
+   */
+  const renewNonceAccount = useCallback(async () => {
+    if (!user.nonceAccount) {
+      setError('No nonce account to renew');
+      return null;
+    }
+
+    setIsLoading(true);
+    setError(undefined);
+
+    try {
+      const updated = await nonceManagerRef.current.renewNonceAccount(
+        user.userId,
+        user.nonceAccount.address
+      );
+
+      return updated;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      return null;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [user.userId, user.nonceAccount]);
+
+  /**
+   * Revoke nonce account
+   */
+  const revokeNonceAccount = useCallback(async () => {
+    setIsLoading(true);
+    setError(undefined);
+
+    try {
+      const updatedUser = await AuthService.revokeNonceAccount(
+        user.userId,
+        user
+      );
+
+      return updatedUser;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      return null;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [user]);
+
+  const isNonceAccountValid = useCallback(() => {
+    if (!user.nonceAccount) {
+      return false;
+    }
+
+    const cached = nonceManagerRef.current.getCachedNonceAccount(user.userId);
+    if (cached) {
+      return nonceManagerRef.current.isNonceAccountValid(cached.accountInfo);
+    }
+
+    return user.nonceAccount.status === 'active';
+  }, [user.userId, user.nonceAccount]);
+
+  return {
+    isLoading,
+    error,
+    createNonceAccount,
+    renewNonceAccount,
+    revokeNonceAccount,
+    isNonceAccountValid,
+    hasNonceAccount: !!user.nonceAccount,
+  };
+}

package/src/index.tsx

@@ -3,10 +3,39 @@ export {
   createIntent,
   createUserIntent,
   createSignedIntent,
+  createOfflineIntent,
   type SolanaIntent,
   type IntentStatus,
 } from './intent';
 
+// Nonce Account Management (for offline transactions)
+export { NonceAccountManager } from './client/NonceAccountManager';
+export type {
+  NonceAccountInfo,
+  NonceAccountCacheEntry,
+  CreateNonceAccountOptions,
+  OfflineTransaction,
+} from './types/nonceAccount';
+
+// BLE Transaction Handling (fragmentation & Noise encryption)
+export { BLETransactionHandler } from './client/BLETransactionHandler';
+export type {
+  BLEFragment,
+  EncryptedBLEMessage,
+  BLEMTUConfig,
+} from './client/BLETransactionHandler';
+
+// Custom Hooks for Offline BLE Transactions
+export {
+  useOfflineTransaction,
+  useBLETransactionTransmission,
+  useNonceAccountManagement,
+} from './hooks/useOfflineBLETransactions';
+export type {
+  BLETransmissionState,
+  OfflineTransactionState,
+} from './hooks/useOfflineBLETransactions';
+
 // Intent management
 export {
   verifyIntentSignature,
@@ -24,8 +53,15 @@ export {
   clearPendingIntents,
 } from './storage';
 
-// Transport methods
-export { startTossScan, requestBLEPermissions } from './ble';
+// Transport methods (enhanced with fragmentation)
+export {
+  startTossScan,
+  requestBLEPermissions,
+  sendOfflineTransactionFragmented,
+  receiveOfflineTransactionFragment,
+  getBLEMTUConfig,
+  setBLEMTUConfig,
+} from './ble';
 export { initNFC, readNFCUser, writeUserToNFC, writeIntentToNFC } from './nfc';
 export { QRScanner } from './qr';
 
@@ -34,10 +70,8 @@ export { TossClient, type TossConfig } from './client/TossClient';
 export type { TossUser } from './types/tossUser';
 export { WalletProvider, useWallet } from './contexts/WalletContext';
 
-// Create client instance
-import { TossClient } from './client/TossClient';
-export const createClient = TossClient.createClient;
-
+// Authentication Service (enhanced with nonce accounts)
+export { AuthService } from './services/authService';
 // Sync and settlement
 export { syncToChain, checkSyncStatus, type SyncResult } from './sync';
 
@@ -67,3 +101,15 @@ export {
   type IntentExchangeRequest,
   type IntentExchangeResponse,
 } from './discovery';
+
+// Compression utilities
+export {
+  compressMetadata,
+  decompressMetadata,
+  compressIntentMetadata,
+  decompressIntentMetadata,
+  estimateCompressionSavings,
+} from './utils/compression';
+
+// WiFi Direct transport
+export { WiFiDirectTransport, SmartTransportSelector } from './wifi';