@explorins/pers-sdk-react-native 1.5.1 → 1.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@explorins/pers-sdk-react-native",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "React Native SDK for PERS Platform - Tourism Loyalty System with Manager Pattern Architecture",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,7 +15,9 @@
     "docs:serve": "npx http-server docs -p 8080",
     "prepublishOnly": "npm run clean && npm run build",
     "publish-version": "npm run clean && npm run build && npm version patch && npm publish",
-    "publish-with-docs": "npm run clean && npm run build && npm run docs && npm version patch && npm publish"
+    "publish-with-docs": "npm run clean && npm run build && npm run docs && npm version patch && npm publish",
+    "yalc:publish": "npm version patch --no-git-tag-version && npm run build && yalc publish",
+    "yalc:push": "npm version patch --no-git-tag-version && npm run build && yalc push"
   },
   "keywords": [
     "pers",
@@ -29,8 +31,11 @@
   "author": "eXplorins",
   "license": "MIT",
   "dependencies": {
+    "@dfns/sdk": "^0.8.1",
+    "@dfns/sdk-react-native": "^0.8.1",
     "@explorins/pers-sdk": "^1.6.3",
     "@explorins/pers-shared": "^2.1.40",
+    "@explorins/pers-signer": "^1.0.9",
     "@explorins/web3-ts": "^0.3.75",
     "@react-native-async-storage/async-storage": "^2.2.0",
     "buffer": "^6.0.3",
@@ -150,6 +155,7 @@
   "devDependencies": {
     "@react-native-async-storage/async-storage": "^1.19.0",
     "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@types/react": "^19.1.1",
     "@types/react-native": "^0.72.8",

package/src/hooks/index.ts

@@ -2,6 +2,7 @@
 export { useAuth } from './useAuth';
 export { useTokens } from './useTokens';
 export { useTransactions } from './useTransactions';
+export { useTransactionSigner } from './useTransactionSigner';
 export { useBusiness } from './useBusiness';
 export { useCampaigns } from './useCampaigns';
 export { useRedemptions } from './useRedemptions';
@@ -15,4 +16,5 @@ export { useAnalytics } from './useAnalytics';
 export { useDonations } from './useDonations';
 
 // Re-export auth-related types for convenience
-export type { RawUserData } from './useAuth';
+export type { RawUserData } from './useAuth';
+export type { TransactionSignerHook, TransactionSigningResult } from './useTransactionSigner';

package/src/hooks/useRedemptions.ts

@@ -1,5 +1,7 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
+import { useTransactionSigner } from './useTransactionSigner';
+import type { TransactionSigningResult } from './useTransactionSigner';
 import type { 
   RedemptionCreateRequestDTO, 
   RedemptionDTO, 
@@ -11,6 +13,7 @@ import type {
 
 export const useRedemptions = () => {
   const { sdk, isInitialized, isAuthenticated } = usePersSDK();
+  const { signTransaction, isSignerAvailable } = useTransactionSigner();
 
   const getActiveRedemptions = useCallback(async (): Promise<RedemptionDTO[]> => {
     if (!isInitialized || !sdk) {
@@ -58,24 +61,47 @@ export const useRedemptions = () => {
       console.log('Redeeming redemption:', redemptionId);
       const result = await sdk.redemptions.redeemOffer(redemptionId);
       
-      // Cross-platform: Handle signature URLs for redemptions
-      if (result?.senderTransaction?.actionable?.actionUrl) {
+      // Check if result has signing fields and sign transaction if required and signer is available
+      console.log('Redemption processed successfully:', result);
+
+
+      const txToken = result.senderTransaction?.actionable?.authToken;
+      if (txToken && isSignerAvailable) {
+        console.log('Transaction requires blockchain signing, processing with WebAuthn signer...');
+        
         try {
-          const { Linking } = require('react-native');
-          console.log('Opening signature URL:', result.senderTransaction.actionable.actionUrl);
-          await Linking.openURL(result.senderTransaction.actionable.actionUrl);
-        } catch (linkingError) {
-          console.error('Failed to open signature URL:', linkingError);
+          const signingResult: TransactionSigningResult = await signTransaction(txToken);
+          console.log('Blockchain signing result:', signingResult);
+          if (signingResult.success) {
+            console.log('Transaction signed successfully:', signingResult.transactionHash);
+            // Return enhanced result with signing information
+            return {
+              ...result,
+              transactionHash: signingResult.transactionHash,
+              signature: signingResult.signature,
+              isSigned: true,
+              signedAt: new Date().toISOString()
+            } as RedemptionRedeemRequestResponseDTO;
+          } else {
+            console.error('Transaction signing failed:', signingResult.error);
+            throw new Error(signingResult.error || 'Transaction signing failed');
+          }
+        } catch (signingError) {
+          console.error('Blockchain signing error:', signingError);
+          throw new Error(`Transaction signing failed: ${signingError}`);
         }
+      } else if (txToken && !isSignerAvailable) {
+        console.warn('Transaction requires signature but signer is not available');
+        throw new Error('Transaction requires signature but blockchain signer is not initialized');
       }
       
-      console.log('Redemption processed successfully:', result);
+      // Return original result if no signing was required
       return result;
     } catch (error) {
       console.error('Failed to redeem redemption:', error);
       throw error;
     }
-  }, [sdk, isInitialized, isAuthenticated]);
+  }, [sdk, isInitialized, isAuthenticated, signTransaction, isSignerAvailable]);
 
   // Admin methods
   const createRedemption = useCallback(async (redemptionData: RedemptionCreateRequestDTO): Promise<RedemptionDTO> => {

package/src/hooks/useTransactionSigner.ts

@@ -0,0 +1,287 @@
+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: any) => Promise<any>) | null = null;
+try {
+  const signerModule = require('@explorins/pers-signer/react-native');
+  createPersSignerSDK = signerModule.createPersSignerSDK;
+  console.log('[useTransactionSigner] PERS Signer SDK loaded successfully');
+} catch (error: unknown) {
+  console.warn('[useTransactionSigner] PERS Signer SDK not available:', (error as Error).message);
+  console.warn('[useTransactionSigner] Real blockchain signing will not be available');
+}
+
+interface PersSignerSDKInstance {
+  authenticateUser: (userInfo: SignerUserInfo) => Promise<SignerAuthenticatedUser>;
+  signPersTransaction: (user: SignerAuthenticatedUser, jwt: string) => Promise<SigningResult>;
+}
+
+interface SignerUserInfo {
+  identifier: string;
+  email?: string;
+  id?: string;
+}
+
+interface SignerAuthenticatedUser {
+  identifier: string;
+  signerAuthToken: string;
+  persAccessToken: string;
+}
+
+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;
+  transactionHash?: string;
+  signature?: string;
+  error?: string;
+}
+
+// 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.
+ * 
+ * @example
+ * ```typescript
+ * function TransactionComponent() {
+ *   const { signTransaction, initializeSigner, isSignerAvailable } = useTransactionSigner();
+ *   
+ *   useEffect(() => {
+ *     initializeSigner({
+ *       tenantId: 'my-tenant',
+ *       ethersProviderUrl: 'https://sepolia.infura.io/v3/...'
+ *     });
+ *   }, []);
+ *   
+ *   const handleSign = async () => {
+ *     try {
+ *       const result = await signTransaction('transaction-id-123');
+ *       if (result.success) {
+ *         console.log('Transaction signed:', result.transactionHash);
+ *       }
+ *     } catch (error) {
+ *       console.error('Signing failed:', error);
+ *     }
+ *   };
+ *   
+ *   return (
+ *     <button onClick={handleSign} disabled={!isSignerAvailable}>
+ *       Sign Transaction
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export const useTransactionSigner = () => {
+  const { sdk, 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
+  useEffect(() => {
+    if (isInitialized && isAuthenticated && user && !isSignerInitialized) {
+      console.log('[useTransactionSigner] Auto-initializing PERS transaction signer...');
+      initializeSigner({
+        tenantId: 'auto-tenant', // TODO: Get from SDK config or environment
+        ethersProviderUrl: DEFAULT_ETHERS_PROVIDER
+      }).catch((error) => {
+        console.error('[useTransactionSigner] Auto-initialization failed:', error);
+      });
+    }
+  }, [isInitialized, isAuthenticated, user, isSignerInitialized, createPersSignerSDK]);
+
+  /**
+   * Initialize the blockchain signer with configuration
+   * 
+   * @param config - Signer configuration options
+   * @param config.tenantId - Multi-tenant identifier for the signer
+   * @param config.ethersProviderUrl - Custom blockchain provider URL
+   * 
+   * @example
+   * ```typescript
+   * await initializeSigner({
+   *   tenantId: 'my-tenant-id',
+   *   ethersProviderUrl: 'https://sepolia.infura.io/v3/your-key'
+   * });
+   * ```
+   */
+  const initializeSigner = useCallback(async (config?: { 
+    tenantId?: string; 
+    ethersProviderUrl?: string;
+  }) => {
+    if (!createPersSignerSDK) {
+      throw new Error('PERS Signer SDK not available. Please ensure dependencies are properly installed.');
+    }
+
+    try {
+      console.log('[useTransactionSigner] Initializing PERS transaction signer...');
+      
+      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}`);
+    }
+  }, []);
+
+  /**
+   * 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
+   * 
+   * @throws {Error} When SDK not initialized, user not authenticated, or signer not initialized
+   * 
+   * @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);
+   * }
+   * ```
+   */
+  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.');
+    }
+    if (!isSignerInitialized || !signerSDKRef.current) {
+      throw new Error('Transaction signer not initialized. Call initializeSigner() first.');
+    }
+    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 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
+      };
+      
+      // Authenticate user with blockchain signer
+      console.log('[useTransactionSigner] Authenticating user with signer:', signerUserInfo.identifier);
+      const signerUser = await signerSDKRef.current.authenticateUser(signerUserInfo);
+      
+      // 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: TransactionSigningResult = {
+        success: result.success || false,
+        transactionHash: result.transactionHash,
+        signature: result.signature,
+        error: result.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);
+      return {
+        success: false,
+        error: `Transaction signing failed: ${error}`
+      };
+    }
+  }, [sdk, isInitialized, isAuthenticated, user, isSignerInitialized]);
+
+  return {
+    /**
+     * Sign a blockchain transaction with WebAuthn authentication
+     */
+    signTransaction,
+    
+    /**
+     * Initialize the transaction signer with configuration
+     */
+    initializeSigner,
+    
+    /**
+     * Whether the transaction signer has been initialized
+     */
+    isSignerInitialized,
+    
+    /**
+     * Whether transaction signing is available (all requirements met)
+     */
+    isSignerAvailable: isInitialized && isAuthenticated && isSignerInitialized,
+  };
+};
+
+/**
+ * Type definition for the transaction signer hook
+ */
+export type TransactionSignerHook = ReturnType<typeof useTransactionSigner>;
+
+/**
+ * Export the transaction signing result type for external usage
+ */
+export type { TransactionSigningResult };

package/src/hooks/useTransactions.ts

@@ -7,10 +7,6 @@ import type {
 } from '@explorins/pers-shared';
 import type { TransactionPaginationParams } from '@explorins/pers-sdk/transaction';
 
-interface TransactionFilters {
-  type?: string;
-}
-
 /**
  * React hook for transaction operations in the PERS SDK
  * 
@@ -82,19 +78,9 @@ export const useTransactions = () => {
     }
     
     try {
-      console.log('Creating transaction with request:', request);
       const result = await sdk.transactions.createTransaction(request);
       
-      // Cross-platform: Handle signature URLs
-      if (result?.actionable?.actionUrl) {
-        try {
-          const { Linking } = require('react-native');
-          console.log('Opening signature URL:', result.actionable.actionUrl);
-          await Linking.openURL(result.actionable.actionUrl);
-        } catch (linkingError) {
-          console.error('Failed to open signature URL:', linkingError);
-        }
-      }
+      // Cross-platform: Dont handle signature URLs here, leave to caller
       
       console.log('Transaction created successfully:', result);
       return result;

package/src/index.ts

@@ -20,6 +20,7 @@ export {
   useAuth,
   useTokens,
   useTransactions,
+  useTransactionSigner,
   useBusiness,
   useCampaigns,
   useRedemptions,