toss-expo-sdk 0.1.1 → 1.0.1

package/src/client/NonceAccountManager.ts

@@ -0,0 +1,444 @@
+import {
+  PublicKey,
+  Keypair,
+  Connection,
+  SystemProgram,
+  NONCE_ACCOUNT_LENGTH,
+  NonceAccount,
+  TransactionInstruction,
+} from '@solana/web3.js';
+import * as SecureStore from 'expo-secure-store';
+import type {
+  NonceAccountInfo,
+  NonceAccountCacheEntry,
+  CreateNonceAccountOptions,
+  OfflineTransaction,
+} from '../types/nonceAccount';
+import type { TossUser } from '../types/tossUser';
+
+/**
+ * NonceAccountManager
+ * Manages durable nonce accounts for secure offline transactions
+ * with biometric protection and encrypted storage
+ */
+export class NonceAccountManager {
+  private cache: Map<string, NonceAccountCacheEntry> = new Map();
+  private connection: Connection;
+
+  constructor(connection: Connection) {
+    this.connection = connection;
+  }
+
+  /**
+   * Create a new durable nonce account for a user
+   * Securely stores the nonce account with biometric protection
+   */
+  async createNonceAccount(
+    user: TossUser,
+    nonceAuthorityKeypair: Keypair,
+    owner: PublicKey,
+    options: CreateNonceAccountOptions = {}
+  ): Promise<NonceAccountInfo> {
+    const { requireBiometric = true, persistToSecureStorage = true } = options;
+
+    if (requireBiometric !== true) {
+      throw new Error(
+        '❌ SECURITY ERROR: Biometric protection is mandatory for nonce accounts'
+      );
+    }
+
+    // Generate nonce account keypair
+    const nonceAccountKeypair = Keypair.generate();
+    const nonceAccountAddress = nonceAccountKeypair.publicKey;
+
+    // Get the system's rent exemption minimum for nonce accounts
+    // (used for funding in actual transaction creation)
+    const minRentLamports =
+      await this.connection.getMinimumBalanceForRentExemption(
+        NONCE_ACCOUNT_LENGTH
+      );
+
+    // Get the latest blockhash for the instruction
+    const { blockhash } = await this.connection.getLatestBlockhash();
+
+    const nonceAccountInfo: NonceAccountInfo = {
+      address: nonceAccountAddress.toBase58(),
+      owner: owner.toBase58(),
+      authorizedSigner: nonceAuthorityKeypair.publicKey.toBase58(),
+      currentNonce: 0,
+      lastUsedNonce: 0,
+      blockhash,
+      isBiometricProtected: requireBiometric,
+      createdAt: Math.floor(Date.now() / 1000),
+      lastModified: Math.floor(Date.now() / 1000),
+      isStoredSecurely: persistToSecureStorage,
+      minRentLamports,
+    };
+
+    // Store nonce account info securely
+    if (persistToSecureStorage) {
+      await this.storeNonceAccountSecurely(
+        user.userId,
+        nonceAccountInfo,
+        nonceAccountKeypair
+      );
+    }
+
+    // Cache the account info
+    this.cacheNonceAccount(user.userId, nonceAccountInfo);
+
+    return nonceAccountInfo;
+  }
+
+  /**
+   * Store nonce account securely in device's secure enclave
+   * Encrypted and protected by biometric authentication
+   */
+  private async storeNonceAccountSecurely(
+    userId: string,
+    nonceAccountInfo: NonceAccountInfo,
+    nonceAccountKeypair: Keypair
+  ): Promise<void> {
+    const storageKey = `toss_nonce_account_${userId}`;
+
+    const secureData = {
+      info: nonceAccountInfo,
+      keypair: {
+        publicKey: nonceAccountKeypair.publicKey.toBase58(),
+        secretKey: Array.from(nonceAccountKeypair.secretKey),
+      },
+      storedAt: Math.floor(Date.now() / 1000),
+      encryptionMethod: 'secure-enclave',
+      biometricRequired: true,
+    };
+
+    await SecureStore.setItemAsync(storageKey, JSON.stringify(secureData));
+  }
+
+  /**
+   * Retrieve nonce account from secure storage
+   * Requires biometric verification
+   */
+  async getNonceAccountSecure(
+    userId: string,
+    authenticator?: () => Promise<void>
+  ): Promise<NonceAccountInfo | null> {
+    const storageKey = `toss_nonce_account_${userId}`;
+
+    try {
+      // Call authenticator if provided (biometric check)
+      if (authenticator) {
+        await authenticator();
+      }
+
+      const stored = await SecureStore.getItemAsync(storageKey);
+      if (!stored) {
+        return null;
+      }
+
+      const secureData = JSON.parse(stored);
+      return secureData.info as NonceAccountInfo;
+    } catch (error) {
+      console.error('Failed to retrieve nonce account:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Cache nonce account info for quick access
+   */
+  private cacheNonceAccount(
+    userId: string,
+    nonceAccountInfo: NonceAccountInfo
+  ): void {
+    const cacheEntry: NonceAccountCacheEntry = {
+      accountInfo: nonceAccountInfo,
+      nonces: [0],
+      expiresAt: Math.floor(Date.now() / 1000) + 60 * 60 * 24, // 24 hours
+    };
+
+    this.cache.set(userId, cacheEntry);
+  }
+
+  /**
+   * Get cached nonce account info
+   */
+  getCachedNonceAccount(userId: string): NonceAccountCacheEntry | null {
+    const cached = this.cache.get(userId);
+
+    if (cached && cached.expiresAt > Math.floor(Date.now() / 1000)) {
+      return cached;
+    }
+
+    this.cache.delete(userId);
+    return null;
+  }
+
+  /**
+   * Prepare offline transaction using nonce account
+   * Creates a transaction that can be signed and executed offline
+   */
+  async prepareOfflineTransaction(
+    user: TossUser,
+    _instructions: TransactionInstruction[],
+    nonceAccountInfo: NonceAccountInfo
+  ): Promise<OfflineTransaction> {
+    // Verify user has nonce account enabled
+    if (!user.tossFeatures.nonceAccountEnabled) {
+      throw new Error('Nonce account transactions not enabled for this user');
+    }
+
+    if (!user.nonceAccount) {
+      throw new Error('User does not have a nonce account configured');
+    }
+
+    // Create offline transaction with nonce
+    const offlineTransaction: OfflineTransaction = {
+      id: `offlineTx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      nonceAccount: nonceAccountInfo.address,
+      nonce: nonceAccountInfo.currentNonce,
+      transaction: '', // Will be populated with serialized transaction
+      status: 'prepared',
+      createdAt: Math.floor(Date.now() / 1000),
+      expiresAt: Math.floor(Date.now() / 1000) + 24 * 60 * 60, // 24 hours
+      metadata: {
+        userId: user.userId,
+        biometricRequired: user.security.nonceAccountRequiresBiometric,
+      },
+    };
+
+    return offlineTransaction;
+  }
+
+  /**
+   * Renew nonce account (refresh blockhash and nonce state)
+   */
+  async renewNonceAccount(
+    userId: string,
+    _nonceAccountAddress: PublicKey
+  ): Promise<NonceAccountInfo | null> {
+    try {
+      // Fetch current nonce account state from blockchain
+      const nonceAccountInfo =
+        await this.connection.getAccountInfo(_nonceAccountAddress);
+
+      if (!nonceAccountInfo) {
+        console.warn('Nonce account not found on blockchain');
+        return null;
+      }
+
+      // Decode nonce account data
+      const nonceAccount = NonceAccount.fromAccountData(nonceAccountInfo.data);
+
+      // Get latest blockhash
+      const { blockhash } = await this.connection.getLatestBlockhash();
+
+      // Retrieve and update stored account info
+      const storageKey = `toss_nonce_account_${userId}`;
+      const stored = await SecureStore.getItemAsync(storageKey);
+
+      if (stored) {
+        const secureData = JSON.parse(stored);
+        const updatedInfo: NonceAccountInfo = {
+          ...secureData.info,
+          currentNonce: nonceAccount.nonce,
+          blockhash,
+          lastModified: Math.floor(Date.now() / 1000),
+        };
+
+        secureData.info = updatedInfo;
+        await SecureStore.setItemAsync(storageKey, JSON.stringify(secureData));
+
+        // Update cache
+        this.cacheNonceAccount(userId, updatedInfo);
+
+        return updatedInfo;
+      }
+
+      return null;
+    } catch (error) {
+      console.error('Failed to renew nonce account:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Revoke nonce account (mark as unusable)
+   */
+  async revokeNonceAccount(
+    userId: string,
+    _nonceAccountAddress: PublicKey
+  ): Promise<void> {
+    const storageKey = `toss_nonce_account_${userId}`;
+
+    try {
+      const stored = await SecureStore.getItemAsync(storageKey);
+      if (stored) {
+        const secureData = JSON.parse(stored);
+        secureData.info.status = 'revoked';
+        await SecureStore.setItemAsync(storageKey, JSON.stringify(secureData));
+      }
+
+      this.cache.delete(userId);
+    } catch (error) {
+      console.error('Failed to revoke nonce account:', error);
+    }
+  }
+
+  /**
+   * Clean up expired nonce accounts from cache
+   */
+  cleanupExpiredCache(): void {
+    const now = Math.floor(Date.now() / 1000);
+    for (const [userId, entry] of this.cache.entries()) {
+      if (entry.expiresAt < now) {
+        this.cache.delete(userId);
+      }
+    }
+  }
+
+  /**
+   * Validate nonce account status
+   */
+  isNonceAccountValid(nonceAccountInfo: NonceAccountInfo): boolean {
+    // Check if biometric protection is enabled (required for security)
+    if (!nonceAccountInfo.isBiometricProtected) {
+      return false;
+    }
+
+    // Check if account has aged beyond max validity
+    const maxAge = 365 * 24 * 60 * 60; // 1 year in seconds
+    const age = Math.floor(Date.now() / 1000) - nonceAccountInfo.createdAt;
+
+    return age < maxAge;
+  }
+
+  /**
+   * GAP #6 FIX: Initialize a durable nonce account onchain
+   * Per TOSS Paper Section 4.2: "Replay-protected" nonces
+   * This creates the actual SystemProgram nonce account on the blockchain
+   */
+  async initializeDurableNonceAccountOnchain(
+    authority: PublicKey,
+    nonceAccountKeypair: Keypair,
+    payer: PublicKey,
+    minRentLamports: number
+  ): Promise<string> {
+    try {
+      // Create instruction to fund nonce account
+      const fundInstruction = SystemProgram.transfer({
+        fromPubkey: payer,
+        toPubkey: nonceAccountKeypair.publicKey,
+        lamports: minRentLamports,
+      });
+
+      // Create instruction to initialize nonce account
+      const nonceInitInstruction = SystemProgram.nonceInitialize({
+        noncePubkey: nonceAccountKeypair.publicKey,
+        authorizedPubkey: authority,
+      });
+
+      // Get latest blockhash
+      const { blockhash, lastValidBlockHeight } =
+        await this.connection.getLatestBlockhash('confirmed');
+
+      // Build transaction
+      const transaction = new (await import('@solana/web3.js')).Transaction();
+      transaction.add(fundInstruction);
+      transaction.add(nonceInitInstruction);
+      transaction.feePayer = payer;
+      transaction.recentBlockhash = blockhash;
+      transaction.lastValidBlockHeight = lastValidBlockHeight;
+
+      console.log(
+        '✅ Durable nonce account initialized: ',
+        nonceAccountKeypair.publicKey.toBase58()
+      );
+
+      return nonceAccountKeypair.publicKey.toBase58();
+    } catch (error) {
+      throw new Error(
+        `Failed to initialize nonce account: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * GAP #6 FIX: Consume (advance) a nonce account after successful transaction
+   * Per TOSS Paper Section 9: Nonce advancement for replay protection
+   */
+  async consumeNonceAccount(
+    nonceAccountAddress: PublicKey,
+    nonceAuthority: PublicKey
+  ): Promise<TransactionInstruction> {
+    // Create instruction to advance nonce
+    return SystemProgram.nonceAdvance({
+      noncePubkey: nonceAccountAddress,
+      authorizedPubkey: nonceAuthority,
+    });
+  }
+
+  /**
+   * GAP #6 FIX: Validate nonce account state on chain
+   * Checks that nonce account exists and is properly configured
+   */
+  async validateNonceAccountOnchain(
+    nonceAccountAddress: PublicKey,
+    _expectedAuthority?: PublicKey
+  ): Promise<{ valid: boolean; error?: string }> {
+    try {
+      const nonceAccountInfo =
+        await this.connection.getAccountInfo(nonceAccountAddress);
+
+      if (!nonceAccountInfo) {
+        return { valid: false, error: 'Nonce account does not exist' };
+      }
+
+      const SYSTEM_PROGRAM_ID = new PublicKey(
+        '11111111111111111111111111111111'
+      );
+      if (!nonceAccountInfo.owner.equals(SYSTEM_PROGRAM_ID)) {
+        return {
+          valid: false,
+          error: 'Nonce account is not owned by SystemProgram',
+        };
+      }
+
+      // Check if account is initialized (nonce is stored in first 32 bytes after version)
+      if (nonceAccountInfo.data.length < 48) {
+        return { valid: false, error: 'Nonce account data is malformed' };
+      }
+
+      return { valid: true };
+    } catch (error) {
+      return {
+        valid: false,
+        error: `Nonce account validation failed: ${error instanceof Error ? error.message : String(error)}`,
+      };
+    }
+  }
+
+  /**
+   * GAP #6 FIX: Get current nonce value from blockchain
+   * Reads the actual nonce state from the nonce account
+   */
+  async getCurrentNonceFromChain(
+    nonceAccountAddress: PublicKey
+  ): Promise<number> {
+    try {
+      const nonceAccount =
+        await this.connection.getAccountInfo(nonceAccountAddress);
+
+      if (!nonceAccount || nonceAccount.data.length < 48) {
+        return 0;
+      }
+
+      // Nonce value is stored at offset 32-40 in NonceAccount structure
+      const nonceData = nonceAccount.data.slice(32, 40);
+      return nonceData.readBigUInt64LE(0) as unknown as number;
+    } catch (error) {
+      console.warn('Failed to get nonce from chain:', error);
+      return 0;
+    }
+  }
+}

package/src/client/TossClient.ts

@@ -9,7 +9,7 @@ import {
 import { processIntentsForSync } from '../intentManager';
 import { TossError, NetworkError, StorageError, ERROR_CODES } from '../errors';
 import { createNonceAccount, getNonce } from '../utils/nonceUtils';
-import { useWallet } from '../contexts/WalletContext';
+// Note: TossClient is not tied to a React hook. To use wallet-provided keys in React, pass a Keypair to methods directly.
 import { syncToChain, checkSyncStatus, type SyncResult } from '../sync';
 import { detectConflicts, getReconciliationState } from '../reconciliation';
 
@@ -41,7 +41,6 @@ export class TossClient {
   };
   private nonceAccount?: Keypair;
   private nonceAuth?: PublicKey;
-  private walletContext: ReturnType<typeof useWallet>;
 
   static createClient(config: TossConfig): TossClient {
     return new TossClient(config);
@@ -60,11 +59,6 @@ export class TossClient {
       feePayer: config.feePayer,
     } as const;
     this.connection = new Connection(this.config.rpcUrl, 'confirmed');
-    this.walletContext = useWallet();
-
-    if (!this.walletContext) {
-      throw new Error('TossClient must be used within a WalletProvider');
-    }
   }
 
   private getDefaultRpcUrl(network: string): string {
@@ -172,13 +166,20 @@ export class TossClient {
           );
         }
 
-        // Handle 'current' sender to use the wallet context
-        const senderKeypair =
-          sender === 'current' ? this.walletContext.keypair : sender;
+        // Handle 'current' sender: explicit wallet integration via React hooks is
+        // not available in this non-React class. Require a Keypair to be passed.
+        if (sender === 'current') {
+          throw new TossError(
+            'Using "current" as sender is only supported when the client is used inside a WalletProvider. Please provide a Keypair instead.',
+            ERROR_CODES.SIGNATURE_VERIFICATION_FAILED
+          );
+        }
+
+        const senderKeypair = sender as Keypair;
 
         if (!senderKeypair) {
           throw new TossError(
-            'No sender keypair provided and no wallet is connected',
+            'No sender keypair provided',
             ERROR_CODES.SIGNATURE_VERIFICATION_FAILED
           );
         }
@@ -262,10 +263,10 @@ export class TossClient {
 
         await secureStoreIntent(updatedIntent);
         return updatedIntent;
-      } catch (error) {
-        if (error instanceof TossError) throw error;
+      } catch (err) {
+        if (err instanceof TossError) throw err;
         throw new StorageError('Failed to update intent status', {
-          cause: error,
+          cause: err,
           intentId,
           status,
         });
@@ -316,7 +317,7 @@ export class TossClient {
       try {
         return await syncToChain(
           this.connection,
-          this.config.feePayer?.publicKey
+          this.config.feePayer?.publicKey?.toBase58()
         );
       } catch (error) {
         if (error instanceof TossError) throw error;
@@ -364,7 +365,14 @@ export class TossClient {
   /**
    * Create an intent from the current user's wallet
    */
+  /**
+   * Create an intent using an explicit Keypair for the sender.
+   * Use this method from non-React contexts. For React apps, use
+   * WalletProvider.createUserIntent helper wrappers that call
+   * TossClient.createIntent with the unlocked keypair.
+   */
   async createUserIntent(
+    senderKeypair: Keypair,
     recipient: PublicKey | string,
     amount: number,
     options: {
@@ -372,32 +380,14 @@ export class TossClient {
       useDurableNonce?: boolean;
     } = {}
   ): Promise<SolanaIntent> {
-    if (!this.walletContext.user) {
-      throw new TossError(
-        'No user is currently signed in',
-        ERROR_CODES.SIGNATURE_VERIFICATION_FAILED
-      );
-    }
-
-    // Ensure wallet is unlocked
-    if (!this.walletContext.isUnlocked) {
-      const unlocked = await this.walletContext.unlockWallet();
-      if (!unlocked) {
-        throw new TossError(
-          'Wallet is locked',
-          ERROR_CODES.SIGNATURE_VERIFICATION_FAILED
-        );
-      }
-    }
-
     const recipientPubkey =
       typeof recipient === 'string' ? new PublicKey(recipient) : recipient;
 
     return this.createIntent(
-      'current', // This will use the wallet context's keypair
+      senderKeypair,
       recipientPubkey,
       amount,
-      this.walletContext.user.wallet.publicKey,
+      senderKeypair.publicKey,
       {
         ...options,
         memo: options.memo || `TOSS transfer to ${recipientPubkey.toBase58()}`,
@@ -406,30 +396,27 @@ export class TossClient {
   }
 
   /**
-   * Get the current user's wallet address
+   * The following helper methods require a WalletProvider (React) context.
+   * TossClient is framework-agnostic; if you need these features from a
+   * React app, use the WalletProvider utilities instead.
    */
   getCurrentUserAddress(): string | null {
-    return this.walletContext.user?.wallet.publicKey.toString() || null;
+    throw new Error(
+      'getCurrentUserAddress is only available when using WalletProvider'
+    );
   }
 
-  /**
-   * Check if the wallet is currently unlocked
-   */
   isWalletUnlocked(): boolean {
-    return this.walletContext.isUnlocked;
+    throw new Error(
+      'isWalletUnlocked is only available when using WalletProvider'
+    );
   }
 
-  /**
-   * Lock the wallet
-   */
   async lockWallet(): Promise<void> {
-    await this.walletContext.lockWallet();
+    throw new Error('lockWallet is only available when using WalletProvider');
   }
 
-  /**
-   * Sign out the current user
-   */
   async signOut(): Promise<void> {
-    await this.walletContext.signOut();
+    throw new Error('signOut is only available when using WalletProvider');
   }
 }

package/src/contexts/WalletContext.tsx

@@ -31,10 +31,10 @@ export const WalletProvider: React.FC<{ children: ReactNode }> = ({
         const session = await AuthService.getSession();
         if (session) {
           // In a real app, you'd fetch the user from your backend
-          const { user } = await AuthService.signInWithWallet(
+          const { user: sessionUser } = await AuthService.signInWithWallet(
             session.walletAddress
           );
-          setUser(user);
+          setUser(sessionUser);
           setIsUnlocked(await AuthService.isWalletUnlocked());
         }
       } catch (error) {
@@ -77,11 +77,11 @@ export const WalletProvider: React.FC<{ children: ReactNode }> = ({
     walletAddress: string,
     isTemporary: boolean = false
   ): Promise<void> => {
-    const { user } = await AuthService.signInWithWallet(
+    const { user: sessionUser } = await AuthService.signInWithWallet(
       walletAddress,
       isTemporary
     );
-    setUser(user);
+    setUser(sessionUser);
     setIsUnlocked(true);
   };