@explorins/pers-sdk-react-native 1.5.13 → 1.5.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@explorins/pers-sdk-react-native",
-  "version": "1.5.13",
+  "version": "1.5.15",
   "description": "React Native SDK for PERS Platform - Tourism Loyalty System with Manager Pattern Architecture",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/hooks/useTransactionSigner.ts

@@ -1,9 +1,8 @@
 import { useCallback, useState, useRef, useEffect } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
-import type { UserDTO, AdminDTO } from '@explorins/pers-shared';
 
 // Dynamic import the signer SDK to avoid build issues with static dependencies
-let createPersSignerSDK: ((config: PersSignerConfig) => Promise<any>) | null = null;
+let createPersSignerSDK: ((config: PersSignerConfig) => Promise<PersSignerSDKInstance>) | null = null;
 try {
   const signerModule = require('@explorins/pers-signer/react-native');
   createPersSignerSDK = signerModule.createPersSignerSDK;
@@ -13,25 +12,22 @@ try {
   console.warn('[useTransactionSigner] Real blockchain signing will not be available');
 }
 
+// Simplified configuration matching web frontend
 interface PersSignerConfig {
-  tenantId?: string;              // Multi-tenant identifier
   ethersProviderUrl?: string;     // Custom blockchain provider
-  // webAuthnProvider: WebAuthnProvider; // Platform-specific WebAuthn provider
-  // Optional overrides for advanced use cases
-  apiUrl?: string;                // Override default signer API URL (defaults to signer-api.pers.ninja)
-  relyingPartyName?: string;      // Override default relying party name (defaults to 'PERS Signer')
 }
 
+// Simplified SDK interface matching web frontend
 interface PersSignerSDKInstance {
-  authenticateUser: (userInfo: SignerUserInfo) => Promise<SignerAuthenticatedUser>;
-  signPersTransaction: (user: SignerAuthenticatedUser, jwt: string) => Promise<SigningResult>;
+  authenticateWithJWT: (searchParams: URLSearchParams) => Promise<AuthenticationResult | null>;
+  authenticateUser: (identifier: string) => Promise<SignerAuthenticatedUser>;
+  signPersTransaction: (user: SignerAuthenticatedUser, transactionId: string) => Promise<SigningResult>;
 }
 
-interface SignerUserInfo {
-  identifier: string;
-  email?: string;
-  id?: string;
-  persAccessToken?: string;
+// Types matching web frontend
+interface AuthenticationResult {
+  user: SignerAuthenticatedUser;
+  isExpired: boolean;
 }
 
 interface SignerAuthenticatedUser {
@@ -43,37 +39,9 @@ interface SignerAuthenticatedUser {
 interface SigningResult {
   success: boolean;
   transactionHash?: string;
-  signature?: string;
   error?: string;
 }
 
-/**
- * Utility to decode JWT and extract user information
- * This will be used to extract user data for the signer
- */
-const extractUserInfoFromJWT = async (jwt: string): Promise<{ userId?: string; email?: string; sub?: string }> => {
-  try {
-    // Dynamically import jwt-decode to avoid bundling issues
-    const { jwtDecode } = await import('jwt-decode');
-    const decoded = jwtDecode<{ 
-      sub?: string; 
-      email?: string; 
-      user_id?: string;
-      userId?: string;
-      uid?: string;
-    }>(jwt);
-    
-    return {
-      userId: decoded.user_id || decoded.userId || decoded.uid || decoded.sub,
-      email: decoded.email,
-      sub: decoded.sub
-    };
-  } catch (error) {
-    console.warn('[useTransactionSigner] Failed to decode JWT:', error);
-    return {};
-  }
-};
-
 // Define our own result type that's compatible with both SDK and our usage
 interface TransactionSigningResult {
   success: boolean;
@@ -88,24 +56,17 @@ const DEFAULT_ETHERS_PROVIDER = "https://sepolia.infura.io/v3/2781b4b5242343d5b0
 /**
  * React Native hook for blockchain transaction signing using PERS Signer SDK
  * 
- * Provides WebAuthn-based transaction signing capabilities integrated with PERS ecosystem.
- * Automatically handles user authentication and transaction signing workflows.
+ * Simplified interface matching web frontend - uses high-level SDK methods
+ * that handle all complexity internally (tenant setup, project keys, etc.).
  * 
  * @example
  * ```typescript
  * function TransactionComponent() {
- *   const { signTransaction, initializeSigner, isSignerAvailable } = useTransactionSigner();
+ *   const { signTransactionWithJWT, isSignerAvailable } = useTransactionSigner();
  *   
- *   useEffect(() => {
- *     initializeSigner({
- *       tenantId: 'my-tenant',
- *       ethersProviderUrl: 'https://sepolia.infura.io/v3/...'
- *     });
- *   }, []);
- *   
- *   const handleSign = async () => {
+ *   const handleSign = async (jwtFromRedemption: string) => {
  *     try {
- *       const result = await signTransaction('transaction-id-123');
+ *       const result = await signTransactionWithJWT(jwtFromRedemption);
  *       if (result.success) {
  *         console.log('Transaction signed:', result.transactionHash);
  *       }
@@ -123,294 +84,163 @@ const DEFAULT_ETHERS_PROVIDER = "https://sepolia.infura.io/v3/2781b4b5242343d5b0
  * ```
  */
 export const useTransactionSigner = () => {
-  const { sdk, isInitialized, isAuthenticated, user, authProvider } = usePersSDK();
+  const { isInitialized, isAuthenticated, user } = usePersSDK();
   const [isSignerInitialized, setIsSignerInitialized] = useState(false);
   const signerSDKRef = useRef<PersSignerSDKInstance | null>(null);
 
-  // Auto-initialize signer when user is authenticated and real SDK is available
+  // Auto-initialize signer SDK when PERS SDK is ready
   useEffect(() => {
-    console.log('[useTransactionSigner] useEffect triggered:', {
-      isInitialized,
-      isAuthenticated,
-      hasUser: !!user,
-      isSignerInitialized,
-      hasSDK: !!sdk,
-      hasAuthProvider: !!authProvider,
-      hasCreatePersSignerSDK: !!createPersSignerSDK
-    });
+    console.log('[useTransactionSigner] Auto-initializing signer SDK...');
     
-    if (isInitialized && isAuthenticated && user && !isSignerInitialized && sdk && authProvider) {
-      console.log('[useTransactionSigner] Auto-initializing PERS transaction signer...');
-      
-      // Async auto-initialization function
-      const autoInitialize = async () => {
-        try {
-          // Get configuration from the PERS SDK
-          const sdkConfig = (sdk as any).config || {};
-          console.log('[useTransactionSigner] SDK config:', sdkConfig);
-          
-          // Try to extract tenantId from JWT token if available
-          let tenantIdFromJWT: string | undefined;
-          let authToken: string | null | undefined;
-          if (authProvider.getToken) {
-            try {
-              authToken = await authProvider.getToken();
-              if (authToken) {
-                // Decode JWT to get tenant information
-                const tokenParts = authToken.split('.');
-                if (tokenParts.length >= 2) {
-                  const payload = JSON.parse(atob(tokenParts[1]));
-                  console.log('[useTransactionSigner] JWT payload decoded:', payload);
-                  
-                  // Look for tenant ID in various possible fields
-                  tenantIdFromJWT = payload.tenantId || payload.tenant_id || payload.tenant;
-                  if (tenantIdFromJWT) {
-                    console.log('[useTransactionSigner] Found tenant ID in JWT:', tenantIdFromJWT);
-                  }
-                }
-              }
-            } catch (e) {
-              console.warn('[useTransactionSigner] Failed to decode JWT for tenant ID:', e);
-            }
-          }
-          
-          // For React Native, we should get tenantId from JWT, then user/auth context, then config
-          const userTenantId = (user as any).tenantId || (user as any).tenant_id;
-          const configTenantId = sdkConfig.tenantId || 'vq-demo';
-          const tenantId = tenantIdFromJWT || userTenantId || configTenantId;
-          
-          console.log('[useTransactionSigner] Extracted tenant ID:', tenantId, 'from JWT:', tenantIdFromJWT, 'user:', userTenantId, 'or config:', configTenantId);
-          
-          // Don't use apiProjectKey since we'll get it via tenant initialization
-          await initializeSigner({
-            tenantId: tenantId,
-            ethersProviderUrl: DEFAULT_ETHERS_PROVIDER
-          });
-        } catch (error) {
-          console.error('[useTransactionSigner] Auto-initialization failed:', error);
-        }
-      };
-      
-      autoInitialize();
-    }
-  }, [isInitialized, isAuthenticated, user, isSignerInitialized, sdk, authProvider]);
-
-  /**
-   * Initialize the blockchain signer with configuration
-   * 
-   * @param config - Signer configuration options
-   * @param config.tenantId - Multi-tenant identifier for the signer
-   * @param config.projectKey - PERS project API key for authentication
-   * @param config.ethersProviderUrl - Custom blockchain provider URL
-   * 
-   * @example
-   * ```typescript
-   * await initializeSigner({
-   *   tenantId: 'my-tenant-id',
-   *   projectKey: 'your-pers-api-key',
-   *   ethersProviderUrl: 'https://sepolia.infura.io/v3/your-key'
-   * });
-   * ```
-   */
-  const initializeSigner = useCallback(async (config?: { 
-    tenantId?: string;
-    projectKey?: string;
-    ethersProviderUrl?: string;
-  }) => {
-    if (!createPersSignerSDK) {
-      throw new Error('PERS Signer SDK not available. Please ensure dependencies are properly installed.');
-    }
+    const initializeSignerSDK = async () => {
+      if (!createPersSignerSDK) {
+        console.warn('[useTransactionSigner] Signer SDK not available');
+        return;
+      }
 
-    try {
-      console.log('[useTransactionSigner] Initializing PERS transaction signer...');
-      
-      // Configure the PERS service before creating SDK
-      if (config?.projectKey) {
-        console.log('[useTransactionSigner] Configuring PERS service with project key:', config.projectKey);
-        try {
-          // Import and configure the PERS service
-          const { PersService } = await import('@explorins/pers-signer/react-native');
-          console.log('[useTransactionSigner] PersService imported successfully');
-          (PersService as any).configure({
-            projectKey: config.projectKey
-          });
-          console.log('[useTransactionSigner] PERS service configured with project key');
-          
-          // Verify configuration
-          const persConfig = (PersService as any).getConfig();
-          console.log('[useTransactionSigner] PERS service config after configuration:', persConfig);
-        } catch (configError) {
-          console.error('[useTransactionSigner] Failed to configure PERS service:', configError);
-        }
-      } else if (config?.tenantId) {
-        console.log('[useTransactionSigner] No project key provided, will initialize tenant with tenantId:', config.tenantId);
-        try {
-          // Import and initialize tenant environment to get project key
-          const { PersService } = await import('@explorins/pers-signer/react-native');
-          console.log('[useTransactionSigner] Initializing tenant for tenantId:', config.tenantId);
-          
-          // We need to set the auth token first for tenant initialization
-          let authToken: string | null | undefined;
-          if (authProvider) {
-            try {
-              authToken = await authProvider.getToken();
-              if (authToken) {
-                console.log('[useTransactionSigner] Setting auth token for tenant initialization');
-                (PersService as any).configure({
-                  token: authToken
-                });
-              }
-            } catch (tokenError) {
-              console.warn('[useTransactionSigner] Could not get auth token for tenant initialization:', tokenError);
-            }
-          }
-          
-          await (PersService as any).initializeTenant(config.tenantId, authToken);
-          console.log('[useTransactionSigner] Tenant initialized successfully');
-          
-          // Get tenant data to extract project key manually
-          try {
-            const tenantData = await (PersService as any).getTenantById(config.tenantId, authToken);
-            console.log('[useTransactionSigner] Tenant data retrieved:', tenantData);
-            
-            // Extract and set project key manually if initializeTenant didn't set it
-            const projectKey = tenantData.projectApiKey || tenantData.projectKey || tenantData.apiKey;
-            if (projectKey) {
-              console.log('[useTransactionSigner] Setting project key manually:', projectKey);
-              (PersService as any).configure({
-                token: authToken,
-                projectKey: projectKey
-              });
-            } else {
-              console.warn('[useTransactionSigner] No project key found in tenant data:', tenantData);
-            }
-          } catch (tenantError) {
-            console.error('[useTransactionSigner] Failed to retrieve tenant data for project key:', tenantError);
-          }
-          
-          // Verify configuration
-          const persConfig = (PersService as any).getConfig();
-          console.log('[useTransactionSigner] PERS service config after tenant initialization:', persConfig);
-        } catch (configError) {
-          console.error('[useTransactionSigner] Failed to initialize tenant:', configError);
-        }
+      try {
+        console.log('[useTransactionSigner] Creating PERS Signer SDK...');
+        const signerSDK = await createPersSignerSDK({
+          ethersProviderUrl: DEFAULT_ETHERS_PROVIDER
+        });
+        
+        signerSDKRef.current = signerSDK;
+        setIsSignerInitialized(true);
+        console.log('[useTransactionSigner] PERS Signer SDK initialized successfully');
+        
+      } catch (error) {
+        console.error('[useTransactionSigner] Failed to initialize signer SDK:', error);
       }
-      
-      const signerSDK = await createPersSignerSDK({
-        tenantId: config?.tenantId,
-        ethersProviderUrl: config?.ethersProviderUrl || DEFAULT_ETHERS_PROVIDER
-      });
-      
-      signerSDKRef.current = signerSDK;
-      setIsSignerInitialized(true);
-      console.log('[useTransactionSigner] PERS Signer SDK initialized successfully');
-      
-    } catch (error) {
-      console.error('[useTransactionSigner] Failed to initialize transaction signer:', error);
-      throw new Error(`Signer initialization failed: ${error}`);
+    };
+    
+    if (!isSignerInitialized) {
+      initializeSignerSDK();
     }
-  }, [authProvider]);
+  }, [isSignerInitialized]);
 
   /**
-   * Sign a blockchain transaction using WebAuthn authentication
-   * 
-   * @param jwt - JWT token containing transaction information and user context
-   * @returns Promise resolving to signing result with transaction hash
+   * Sign a blockchain transaction using JWT token (matching web frontend pattern)
    * 
-   * @throws {Error} When SDK not initialized, user not authenticated, or signer not initialized
+   * This method replicates the web frontend flow:
+   * 1. Extract transaction info from JWT
+   * 2. Authenticate user with WebAuthn 
+   * 3. Sign transaction with authenticated user
    * 
-   * @example
-   * ```typescript
-   * try {
-   *   const result = await signTransaction(jwtToken);
-   *   if (result.success) {
-   *     console.log('Signed transaction hash:', result.transactionHash);
-   *   } else {
-   *     console.error('Signing failed:', result.error);
-   *   }
-   * } catch (error) {
-   *   console.error('Signing error:', error);
-   * }
-   * ```
+   * @param jwt - JWT token from redemption flow containing transaction ID
+   * @returns Promise resolving to signing result with transaction hash
    */
-  const signTransaction = useCallback(async (jwt: string): Promise<TransactionSigningResult> => {
-    if (!isInitialized || !sdk) {
-      throw new Error('SDK not initialized. Call initialize() first.');
-    }
-    if (!isAuthenticated || !user) {
-      throw new Error('User must be authenticated to sign transactions.');
-    }
+  const signTransactionWithJWT = useCallback(async (jwt: string): Promise<TransactionSigningResult> => {
     if (!isSignerInitialized || !signerSDKRef.current) {
-      throw new Error('Transaction signer not initialized. Call initializeSigner() first.');
+      throw new Error('Transaction signer not initialized');
     }
     if (!createPersSignerSDK) {
       throw new Error('PERS Signer SDK not available. Blockchain signing is not supported.');
     }
 
     try {
-      console.log('[useTransactionSigner] Extracting user info from JWT for transaction signing...');
+      console.log('[useTransactionSigner] Starting JWT-based transaction signing...');
       
-      // Extract user information from JWT
-      const jwtUserInfo = await extractUserInfoFromJWT(jwt);
+      // Create URLSearchParams from JWT token (matching web frontend)
+      const searchParams = new URLSearchParams();
+      searchParams.set('jwt', jwt);
       
-      // Create user info for signer, prioritizing current user data
-      const currentUser = user as UserDTO;
-      const signerUserInfo: SignerUserInfo = {
-        identifier: currentUser.email || currentUser.id || jwtUserInfo.userId || jwtUserInfo.sub || `user-${Date.now()}`,
-        email: currentUser.email || jwtUserInfo.email,
-        id: currentUser.id || jwtUserInfo.userId
-      };
+      // Step 1: Authenticate with JWT (handles tenant setup, project keys automatically)
+      console.log('[useTransactionSigner] Authenticating with JWT...');
+      const authResult = await signerSDKRef.current.authenticateWithJWT(searchParams);
       
-      // Get PERS access token from the auth provider
-      console.log('[useTransactionSigner] Auth provider found:', !!authProvider);
-      const persAccessToken = authProvider ? await authProvider.getToken() : '';
-      console.log('[useTransactionSigner] PERS access token extracted:', persAccessToken ? 'Token found' : 'No token');
+      if (!authResult) {
+        throw new Error('JWT authentication failed - no valid token found');
+      }
       
-      // Authenticate user with blockchain signer and pass PERS token
-      console.log('[useTransactionSigner] Authenticating user with signer:', signerUserInfo.identifier);
-      const signerUser = await signerSDKRef.current.authenticateUser({
-        ...signerUserInfo,
-        persAccessToken: persAccessToken || undefined
-      });
+      if (authResult.isExpired) {
+        throw new Error('JWT token is expired');
+      }
       
-      // Sign the PERS transaction using JWT
-      console.log('[useTransactionSigner] Signing PERS transaction with JWT containing transaction data');
-      const result = await signerSDKRef.current.signPersTransaction(signerUser, jwt);
+      console.log('[useTransactionSigner] JWT authentication successful:', authResult.user.identifier);
       
-      // Convert PERS SDK result to our format
-      const convertedResult: TransactionSigningResult = {
-        success: result.success || false,
-        transactionHash: result.transactionHash,
-        signature: result.signature,
-        error: result.error
-      };
+      // Step 2: Extract transaction ID from JWT
+      const jwtParts = jwt.split('.');
+      if (jwtParts.length !== 3) {
+        throw new Error('Invalid JWT token format');
+      }
       
-      if (convertedResult.success) {
-        console.log('[useTransactionSigner] Transaction signed successfully:', convertedResult.transactionHash);
-      } else {
-        console.warn('[useTransactionSigner] Transaction signing completed with warnings:', convertedResult.error);
+      const payload = JSON.parse(atob(jwtParts[1]));
+      const transactionId = payload.transactionId;
+      
+      if (!transactionId) {
+        throw new Error('No transaction ID found in JWT token');
       }
       
-      return convertedResult;
+      console.log('[useTransactionSigner] Found transaction ID:', transactionId);
+      
+      // Step 3: Sign transaction using authenticated user
+      console.log('[useTransactionSigner] Signing transaction...');
+      const signingResult = await signerSDKRef.current.signPersTransaction(
+        authResult.user, 
+        transactionId
+      );
+      
+      console.log('[useTransactionSigner] Transaction signing result:', signingResult);
+      
+      return {
+        success: signingResult.success,
+        transactionHash: signingResult.transactionHash,
+        error: signingResult.error
+      };
+      
     } catch (error) {
-      console.error('[useTransactionSigner] Failed to sign transaction:', error);
+      console.error('[useTransactionSigner] JWT transaction signing failed:', error);
       return {
         success: false,
         error: `Transaction signing failed: ${error}`
       };
     }
-  }, [sdk, isInitialized, isAuthenticated, user, isSignerInitialized]);
+  }, [isSignerInitialized]);
+
+  /**
+   * Manual user authentication (fallback method)
+   */
+  const authenticateUser = useCallback(async (identifier: string): Promise<SignerAuthenticatedUser | null> => {
+    if (!isSignerInitialized || !signerSDKRef.current) {
+      throw new Error('Transaction signer not initialized');
+    }
+
+    try {
+      console.log('[useTransactionSigner] Manual user authentication:', identifier);
+      const user = await signerSDKRef.current.authenticateUser(identifier);
+      console.log('[useTransactionSigner] Manual authentication successful');
+      return user;
+    } catch (error) {
+      console.error('[useTransactionSigner] Manual authentication failed:', error);
+      return null;
+    }
+  }, [isSignerInitialized]);
+
+  /**
+   * Legacy method for backward compatibility
+   * @deprecated Use signTransactionWithJWT instead
+   */
+  const signTransaction = useCallback(async (jwt: string): Promise<TransactionSigningResult> => {
+    console.warn('[useTransactionSigner] signTransaction is deprecated, use signTransactionWithJWT');
+    return signTransactionWithJWT(jwt);
+  }, [signTransactionWithJWT]);
 
   return {
     /**
-     * Sign a blockchain transaction with WebAuthn authentication
+     * Sign a blockchain transaction using JWT token (recommended method)
+     */
+    signTransactionWithJWT,
+    
+    /**
+     * Legacy transaction signing method
+     * @deprecated Use signTransactionWithJWT instead
      */
     signTransaction,
     
     /**
-     * Initialize the transaction signer with configuration
+     * Manual user authentication (for advanced use cases)
      */
-    initializeSigner,
+    authenticateUser,
     
     /**
      * Whether the transaction signer has been initialized
@@ -420,7 +250,7 @@ export const useTransactionSigner = () => {
     /**
      * Whether transaction signing is available (all requirements met)
      */
-    isSignerAvailable: isInitialized && isAuthenticated && isSignerInitialized,
+    isSignerAvailable: isSignerInitialized && !!createPersSignerSDK,
   };
 };
 
@@ -432,4 +262,4 @@ export type TransactionSignerHook = ReturnType<typeof useTransactionSigner>;
 /**
  * Export the transaction signing result type for external usage
  */
-export type { TransactionSigningResult };
+export type { TransactionSigningResult, SignerAuthenticatedUser, AuthenticationResult };