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

package/dist/index.js

@@ -30253,49 +30253,22 @@ catch (error) {
     console.warn('[useTransactionSigner] PERS Signer SDK not available:', error.message);
     console.warn('[useTransactionSigner] Real blockchain signing will not be available');
 }
-/**
- * Utility to decode JWT and extract user information
- * This will be used to extract user data for the signer
- */
-const extractUserInfoFromJWT = async (jwt) => {
-    try {
-        // Dynamically import jwt-decode to avoid bundling issues
-        const { jwtDecode } = await Promise.resolve().then(function () { return index; });
-        const decoded = jwtDecode(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 {};
-    }
-};
 // Constants - TODO: Move to environment config later
 const DEFAULT_ETHERS_PROVIDER = "https://sepolia.infura.io/v3/2781b4b5242343d5b0954c98f287b29e";
 /**
  * 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();
- *
- *   useEffect(() => {
- *     initializeSigner({
- *       tenantId: 'my-tenant',
- *       ethersProviderUrl: 'https://sepolia.infura.io/v3/...'
- *     });
- *   }, []);
+ *   const { signTransactionWithJWT, isSignerAvailable } = useTransactionSigner();
  *
- *   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);
  *       }
@@ -30313,268 +30286,136 @@ const DEFAULT_ETHERS_PROVIDER = "https://sepolia.infura.io/v3/2781b4b5242343d5b0
  * ```
  */
 const useTransactionSigner = () => {
-    const { sdk, isInitialized, isAuthenticated, user, authProvider } = usePersSDK();
+    const { isInitialized, isAuthenticated, user } = usePersSDK();
     const [isSignerInitialized, setIsSignerInitialized] = react.useState(false);
     const signerSDKRef = react.useRef(null);
-    // Auto-initialize signer when user is authenticated and real SDK is available
+    // Auto-initialize signer SDK when PERS SDK is ready
     react.useEffect(() => {
-        console.log('[useTransactionSigner] useEffect triggered:', {
-            isInitialized,
-            isAuthenticated,
-            hasUser: !!user,
-            isSignerInitialized,
-            hasSDK: !!sdk,
-            hasAuthProvider: !!authProvider,
-            hasCreatePersSignerSDK: !!createPersSignerSDK
-        });
-        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.config || {};
-                    console.log('[useTransactionSigner] SDK config:', sdkConfig);
-                    // Try to extract tenantId from JWT token if available
-                    let tenantIdFromJWT;
-                    let authToken;
-                    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.tenantId || user.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 = react.useCallback(async (config) => {
-        if (!createPersSignerSDK) {
-            throw new Error('PERS Signer SDK not available. Please ensure dependencies are properly installed.');
-        }
-        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 Promise.resolve().then(function () { return require('./react-native.esm-BtyCg4n1.js'); });
-                    console.log('[useTransactionSigner] PersService imported successfully');
-                    PersService.configure({
-                        projectKey: config.projectKey
-                    });
-                    console.log('[useTransactionSigner] PERS service configured with project key');
-                    // Verify configuration
-                    const persConfig = PersService.getConfig();
-                    console.log('[useTransactionSigner] PERS service config after configuration:', persConfig);
-                }
-                catch (configError) {
-                    console.error('[useTransactionSigner] Failed to configure PERS service:', configError);
-                }
+        console.log('[useTransactionSigner] Auto-initializing signer SDK...');
+        const initializeSignerSDK = async () => {
+            if (!createPersSignerSDK) {
+                console.warn('[useTransactionSigner] Signer SDK not available');
+                return;
             }
-            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 Promise.resolve().then(function () { return require('./react-native.esm-BtyCg4n1.js'); });
-                    console.log('[useTransactionSigner] Initializing tenant for tenantId:', config.tenantId);
-                    // We need to set the auth token first for tenant initialization
-                    let authToken;
-                    if (authProvider) {
-                        try {
-                            authToken = await authProvider.getToken();
-                            if (authToken) {
-                                console.log('[useTransactionSigner] Setting auth token for tenant initialization');
-                                PersService.configure({
-                                    token: authToken
-                                });
-                            }
-                        }
-                        catch (tokenError) {
-                            console.warn('[useTransactionSigner] Could not get auth token for tenant initialization:', tokenError);
-                        }
-                    }
-                    await PersService.initializeTenant(config.tenantId, authToken);
-                    console.log('[useTransactionSigner] Tenant initialized successfully');
-                    // Get tenant data to extract project key manually
-                    try {
-                        const tenantData = await PersService.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.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.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');
             }
-            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}`);
+            catch (error) {
+                console.error('[useTransactionSigner] Failed to initialize signer SDK:', 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 = react.useCallback(async (jwt) => {
-        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 = react.useCallback(async (jwt) => {
         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...');
-            // Extract user information from JWT
-            const jwtUserInfo = await extractUserInfoFromJWT(jwt);
-            // Create user info for signer, prioritizing current user data
-            const currentUser = user;
-            const signerUserInfo = {
-                identifier: currentUser.email || currentUser.id || jwtUserInfo.userId || jwtUserInfo.sub || `user-${Date.now()}`,
-                email: currentUser.email || jwtUserInfo.email,
-                id: currentUser.id || jwtUserInfo.userId
-            };
-            // 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');
-            // 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
-            });
-            // 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);
-            // Convert PERS SDK result to our format
-            const convertedResult = {
-                success: result.success || false,
-                transactionHash: result.transactionHash,
-                signature: result.signature,
-                error: result.error
+            console.log('[useTransactionSigner] Starting JWT-based transaction signing...');
+            // Create URLSearchParams from JWT token (matching web frontend)
+            const searchParams = new URLSearchParams();
+            searchParams.set('jwt', jwt);
+            // Step 1: Authenticate with JWT (handles tenant setup, project keys automatically)
+            console.log('[useTransactionSigner] Authenticating with JWT...');
+            const authResult = await signerSDKRef.current.authenticateWithJWT(searchParams);
+            if (!authResult) {
+                throw new Error('JWT authentication failed - no valid token found');
+            }
+            if (authResult.isExpired) {
+                throw new Error('JWT token is expired');
+            }
+            console.log('[useTransactionSigner] JWT authentication successful:', authResult.user.identifier);
+            // Step 2: Extract transaction ID from JWT
+            const jwtParts = jwt.split('.');
+            if (jwtParts.length !== 3) {
+                throw new Error('Invalid JWT token format');
+            }
+            const payload = JSON.parse(atob(jwtParts[1]));
+            const transactionId = payload.transactionId;
+            if (!transactionId) {
+                throw new Error('No transaction ID found in JWT token');
+            }
+            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
             };
-            if (convertedResult.success) {
-                console.log('[useTransactionSigner] Transaction signed successfully:', convertedResult.transactionHash);
-            }
-            else {
-                console.warn('[useTransactionSigner] Transaction signing completed with warnings:', convertedResult.error);
-            }
-            return convertedResult;
         }
         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 = react.useCallback(async (identifier) => {
+        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 = react.useCallback(async (jwt) => {
+        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
          */
@@ -30582,7 +30423,7 @@ const useTransactionSigner = () => {
         /**
          * Whether transaction signing is available (all requirements met)
          */
-        isSignerAvailable: isInitialized && isAuthenticated && isSignerInitialized,
+        isSignerAvailable: isSignerInitialized && !!createPersSignerSDK,
     };
 };