@explorins/pers-sdk-react-native 1.3.2 → 1.5.2

package/dist/hooks/useTokens.js

@@ -1,48 +1,209 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
+/**
+ * React hook for token operations in the PERS SDK
+ *
+ * Provides methods for fetching various types of tokens including credit, reward, and status tokens.
+ * Supports both general token queries and specific contract-based token retrieval.
+ *
+ * @returns Token hook with methods for token management
+ *
+ * @example
+ * ```typescript
+ * function TokensComponent() {
+ *   const { getTokens, getActiveCreditToken, getRewardTokens } = useTokens();
+ *
+ *   const loadTokens = async () => {
+ *     try {
+ *       const tokens = await getTokens();
+ *       const creditToken = await getActiveCreditToken();
+ *       console.log('Loaded tokens:', tokens);
+ *       console.log('Active credit token:', creditToken);
+ *     } catch (error) {
+ *       console.error('Failed to load tokens:', error);
+ *     }
+ *   };
+ *
+ *   return <button onClick={loadTokens}>Load Tokens</button>;
+ * }
+ * ```
+ */
 export const useTokens = () => {
-    const { tokens, isInitialized, isAuthenticated } = usePersSDK();
+    const { sdk, isInitialized, isAuthenticated } = usePersSDK();
     if (!isAuthenticated && isInitialized) {
         console.warn('SDK not authenticated. Some token operations may fail.');
     }
+    /**
+     * Retrieves all tokens available to the current user
+     *
+     * @returns Promise resolving to array of tokens
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getTokens } = useTokens();
+     * const tokens = await getTokens();
+     * console.log('Available tokens:', tokens);
+     * ```
+     */
     const getTokens = useCallback(async () => {
-        if (!isInitialized) {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!tokens?.getTokens) {
-            console.warn('getTokens method not available');
-            return [];
+        try {
+            const result = await sdk.tokens.getTokens();
+            console.log('Tokens fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch tokens:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    /**
+     * Retrieves the currently active credit token
+     *
+     * @returns Promise resolving to active credit token
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getActiveCreditToken } = useTokens();
+     * const creditToken = await getActiveCreditToken();
+     * console.log('Active credit token:', creditToken.name);
+     * ```
+     */
+    const getActiveCreditToken = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.tokens.getActiveCreditToken();
+            console.log('Active credit token fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch active credit token:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    /**
+     * Retrieves all reward tokens available in the system
+     *
+     * @returns Promise resolving to array of reward tokens
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getRewardTokens } = useTokens();
+     * const rewardTokens = await getRewardTokens();
+     * console.log('Reward tokens:', rewardTokens);
+     * ```
+     */
+    const getRewardTokens = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await tokens.getTokens();
-            console.log('✅ Tokens fetched successfully:', result);
+            const result = await sdk.tokens.getRewardTokens();
+            console.log('Reward tokens fetched successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to fetch tokens:', error);
+            console.error('Failed to fetch reward tokens:', error);
             throw error;
         }
-    }, [tokens]);
-    const getTokenById = useCallback(async (tokenId) => {
-        if (!isInitialized) {
+    }, [sdk, isInitialized]);
+    /**
+     * Retrieves all available token types in the system
+     *
+     * @returns Promise resolving to array of token types
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getTokenTypes } = useTokens();
+     * const types = await getTokenTypes();
+     * console.log('Token types:', types);
+     * ```
+     */
+    const getTokenTypes = useCallback(async () => {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!tokens?.getTokenById) {
-            throw new Error('getTokenById method not available');
+        try {
+            const result = await sdk.tokens.getTokenTypes();
+            console.log('Token types fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch token types:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    /**
+     * Retrieves all status tokens (tokens that represent user status/achievements)
+     *
+     * @returns Promise resolving to array of status tokens
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getStatusTokens } = useTokens();
+     * const statusTokens = await getStatusTokens();
+     * console.log('Status tokens:', statusTokens);
+     * ```
+     */
+    const getStatusTokens = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.tokens.getStatusTokens();
+            console.log('Status tokens fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch status tokens:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    /**
+     * Retrieves a specific token by its contract address and optional token ID
+     *
+     * @param contractAddress - The contract address of the token
+     * @param contractTokenId - Optional specific token ID within the contract
+     * @returns Promise resolving to the token data
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getTokenByContract } = useTokens();
+     * const token = await getTokenByContract('0x123...', 'token-1');
+     * console.log('Token from contract:', token);
+     * ```
+     */
+    const getTokenByContract = useCallback(async (contractAddress, contractTokenId) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await tokens.getTokenById(tokenId);
-            console.log('✅ Token fetched successfully:', result);
+            const result = await sdk.tokens.getTokenByContract(contractAddress, contractTokenId);
+            console.log('Token by contract fetched successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to fetch token:', error);
+            console.error('Failed to fetch token by contract:', error);
             throw error;
         }
-    }, [tokens]);
+    }, [sdk, isInitialized]);
     return {
         getTokens,
-        getTokenById,
-        isAvailable: isInitialized && !!tokens,
+        getActiveCreditToken,
+        getRewardTokens,
+        getTokenTypes,
+        getStatusTokens,
+        getTokenByContract,
+        isAvailable: isInitialized && !!sdk?.tokens,
     };
 };

package/dist/hooks/useTransactionSigner.d.ts

@@ -0,0 +1,73 @@
+interface TransactionSigningResult {
+    success: boolean;
+    transactionHash?: string;
+    signature?: string;
+    error?: string;
+}
+/**
+ * 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 declare const useTransactionSigner: () => {
+    /**
+     * Sign a blockchain transaction with WebAuthn authentication
+     */
+    signTransaction: (jwt: string) => Promise<TransactionSigningResult>;
+    /**
+     * Initialize the transaction signer with configuration
+     */
+    initializeSigner: (config?: {
+        tenantId?: string;
+        ethersProviderUrl?: string;
+    }) => Promise<void>;
+    /**
+     * Whether the transaction signer has been initialized
+     */
+    isSignerInitialized: boolean;
+    /**
+     * Whether transaction signing is available (all requirements met)
+     */
+    isSignerAvailable: boolean;
+};
+/**
+ * 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 };
+//# sourceMappingURL=useTransactionSigner.d.ts.map

package/dist/hooks/useTransactionSigner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTransactionSigner.d.ts","sourceRoot":"","sources":["../../src/hooks/useTransactionSigner.ts"],"names":[],"mappings":"AAmEA,UAAU,wBAAwB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,oBAAoB;IA8I7B;;OAEG;2BA/D2C,MAAM,KAAG,QAAQ,wBAAwB,CAAC;IAkExF;;OAEG;gCApHgD;QACnD,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B;IAoHC;;OAEG;;IAGH;;OAEG;;CAGN,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAE5E;;GAEG;AACH,YAAY,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/hooks/useTransactionSigner.js

@@ -0,0 +1,216 @@
+import { useCallback, useState, useRef, useEffect } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+// Dynamic import the signer SDK to avoid build issues with static dependencies
+let createPersSignerSDK = null;
+try {
+    const signerModule = require('@explorins/pers-signer/react-native');
+    createPersSignerSDK = signerModule.createPersSignerSDK;
+    console.log('[useTransactionSigner] PERS Signer SDK loaded successfully');
+}
+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 import('jwt-decode');
+        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.
+ *
+ * @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(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) => {
+        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) => {
+        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;
+            const 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 = {
+                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,
+    };
+};

package/dist/hooks/useTransactions.d.ts

@@ -1,7 +1,49 @@
+import type { TransactionRequestDTO, TransactionRequestResponseDTO, TransactionDTO } from '@explorins/pers-shared';
+import type { TransactionPaginationParams } from '@explorins/pers-sdk/transaction';
+/**
+ * React hook for transaction operations in the PERS SDK
+ *
+ * Provides comprehensive transaction management including creation, retrieval, history,
+ * and administrative operations. Supports pagination and CSV export functionality.
+ *
+ * @returns Transaction hook with methods for transaction management
+ *
+ * @example
+ * ```typescript
+ * function TransactionsComponent() {
+ *   const {
+ *     createTransaction,
+ *     getUserTransactionHistory
+ *   } = useTransactions();
+ *
+ *   const handleCreateTransaction = async (request) => {
+ *     try {
+ *       const result = await createTransaction(request);
+ *       console.log('Transaction created:', result);
+ *       // Handle signature URL if returned
+ *     } catch (error) {
+ *       console.error('Transaction failed:', error);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => handleCreateTransaction(transactionRequest)}>
+ *         Create Transaction
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
 export declare const useTransactions: () => {
-    createTransaction: (request: any) => Promise<any>;
-    getTransactionById: (transactionId: string) => Promise<any>;
-    getTransactionHistory: (filters?: any) => Promise<any>;
+    createTransaction: (request: TransactionRequestDTO) => Promise<TransactionRequestResponseDTO>;
+    getTransactionById: (transactionId: string) => Promise<TransactionDTO | null>;
+    getUserTransactionHistory: (type?: string) => Promise<TransactionDTO[]>;
+    getTenantTransactions: () => Promise<TransactionDTO[]>;
+    getPaginatedTransactions: (params: TransactionPaginationParams) => Promise<any>;
+    exportTransactionsCSV: () => Promise<Blob>;
     isAvailable: boolean;
 };
+export type TransactionHook = ReturnType<typeof useTransactions>;
 //# sourceMappingURL=useTransactions.d.ts.map

package/dist/hooks/useTransactions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTransactions.d.ts","sourceRoot":"","sources":["../../src/hooks/useTransactions.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe;iCAO4B,GAAG;wCA+BI,MAAM;sCAkBR,GAAG;;CAyB/D,CAAC"}
+{"version":3,"file":"useTransactions.d.ts","sourceRoot":"","sources":["../../src/hooks/useTransactions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,qBAAqB,EACrB,6BAA6B,EAC7B,cAAc,EACf,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAC;AAEnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,eAAe;iCA6B4B,qBAAqB,KAAG,QAAQ,6BAA6B,CAAC;wCAgCvD,MAAM,KAAG,QAAQ,cAAc,GAAG,IAAI,CAAC;uCA6BzC,MAAM,KAAW,QAAQ,cAAc,EAAE,CAAC;iCAejD,QAAQ,cAAc,EAAE,CAAC;uCAejB,2BAA2B,KAAG,QAAQ,GAAG,CAAC;iCAelD,QAAQ,IAAI,CAAC;;CAwBlE,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC"}