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

package/src/hooks/useRedemptions.ts

@@ -1,129 +1,196 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
+import { useTransactionSigner } from './useTransactionSigner';
+import type { TransactionSigningResult } from './useTransactionSigner';
+import type { 
+  RedemptionCreateRequestDTO, 
+  RedemptionDTO, 
+  RedemptionRedeemDTO, 
+  RedemptionRedeemRequestResponseDTO,
+  RedemptionTypeDTO,
+  TokenUnitCreateRequestDTO
+} from '@explorins/pers-shared';
 
 export const useRedemptions = () => {
-  const { redemptions, isInitialized, isAuthenticated } = usePersSDK();
+  const { sdk, isInitialized, isAuthenticated } = usePersSDK();
+  const { signTransaction, isSignerAvailable } = useTransactionSigner();
 
-  // Admin method: Create new redemption offers
-  const createRedemption = useCallback(async (redemptionData: any) => {
-    if (!isInitialized) {
+  const getActiveRedemptions = useCallback(async (): Promise<RedemptionDTO[]> => {
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
-    if (!redemptions?.createRedemption) {
-      throw new Error('createRedemption method not available - admin access required');
-    }
     
     try {
-      console.log('🔄 Creating redemption offer with data:', redemptionData);
-      const result = await redemptions.createRedemption(redemptionData);
-      console.log('✅ Redemption offer created successfully:', result);
+      const result = await sdk.redemptions.getActiveRedemptions();
+      console.log('Active redemptions fetched successfully:', result);
       return result;
     } catch (error) {
-      console.error('❌ Failed to create redemption offer:', error);
+      console.error('Failed to fetch active redemptions:', error);
       throw error;
     }
-  }, [redemptions]);
+  }, [sdk, isInitialized]);
 
-  const getActiveRedemptions = useCallback(async () => {
-    if (!isInitialized) {
+  const getUserRedemptions = useCallback(async (): Promise<RedemptionRedeemDTO[]> => {
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
-    if (!redemptions?.getActiveRedemptions) {
-      console.warn('getActiveRedemptions method not available');
+    if (!isAuthenticated) {
+      console.warn('SDK not authenticated. getUserRedemptions requires authentication.');
       return [];
     }
     
     try {
-      const result = await redemptions.getActiveRedemptions();
-      console.log('✅ Active redemptions fetched successfully:', result);
+      const result = await sdk.redemptions.getUserRedemptions();
+      console.log('User redemptions fetched successfully:', result);
       return result;
     } catch (error) {
-      console.error('❌ Failed to fetch active redemptions:', error);
+      console.error('Failed to fetch user redemptions:', error);
       throw error;
     }
-  }, [redemptions]);
+  }, [sdk, isInitialized, isAuthenticated]);
 
-  const getUserRedeems = useCallback(async () => {
-    if (!isInitialized) {
+  const redeemOffer = useCallback(async (redemptionId: string): Promise<RedemptionRedeemRequestResponseDTO> => {
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
     if (!isAuthenticated) {
-      console.warn('SDK not authenticated. getUserRedeems requires authentication.');
-      return [];
+      throw new Error('SDK not authenticated. redeemOffer requires authentication.');
     }
-    if (!redemptions?.getUserRedeems) {
-      console.warn('getUserRedeems method not available');
-      return [];
+    
+    try {
+      console.log('Redeeming redemption:', redemptionId);
+      const result = await sdk.redemptions.redeemOffer(redemptionId);
+      
+      // 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 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');
+      }
+      
+      // Return original result if no signing was required
+      return result;
+    } catch (error) {
+      console.error('Failed to redeem redemption:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized, isAuthenticated, signTransaction, isSignerAvailable]);
+
+  // Admin methods
+  const createRedemption = useCallback(async (redemptionData: RedemptionCreateRequestDTO): Promise<RedemptionDTO> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
     }
     
     try {
-      const result = await redemptions.getUserRedeems();
-      console.log('✅ User redemptions fetched successfully:', result);
+      console.log('Creating redemption offer with data:', redemptionData);
+      const result = await sdk.redemptions.createRedemption(redemptionData);
+      console.log('Redemption offer created successfully:', result);
       return result;
     } catch (error) {
-      console.error('❌ Failed to fetch user redemptions:', error);
+      console.error('Failed to create redemption offer:', error);
       throw error;
     }
-  }, [isInitialized, isAuthenticated, redemptions]);
+  }, [sdk, isInitialized]);
 
-  const redeemRedemption = useCallback(async (redemptionId: string) => {
-    if (!isInitialized) {
+  const getAllRedemptions = useCallback(async (active?: boolean): Promise<RedemptionDTO[]> => {
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
-    if (!isAuthenticated) {
-      throw new Error('SDK not authenticated. redeemRedemption requires authentication.');
+    
+    try {
+      const result = await sdk.redemptions.getAllRedemptions(active);
+      console.log('All redemptions fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch all redemptions:', error);
+      throw error;
     }
-    if (!redemptions?.redeemRedemption) {
-      throw new Error('redeemRedemption method not available');
+  }, [sdk, isInitialized]);
+
+  const getRedemptionTypes = useCallback(async (): Promise<RedemptionTypeDTO[]> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
     }
     
     try {
-      console.log('🔄 Redeeming redemption:', redemptionId);
-      const result = await redemptions.redeemRedemption(redemptionId);
-      
-      // React Native specific: Handle signature URLs for redemptions
-      if (result?.actionable?.actionUrl) {
-        try {
-          const { Linking } = require('react-native');
-          console.log('🔗 Opening redemption signature URL:', result.actionable.actionUrl);
-          await Linking.openURL(result.actionable.actionUrl);
-        } catch (linkingError) {
-          console.error('❌ Failed to open redemption signature URL:', linkingError);
-        }
-      }
-      
-      console.log('✅ Redemption processed successfully:', result);
+      const result = await sdk.redemptions.getRedemptionTypes();
+      console.log('Redemption types fetched successfully:', result);
       return result;
     } catch (error) {
-      console.error('❌ Failed to redeem redemption:', error);
+      console.error('Failed to fetch redemption types:', error);
       throw error;
     }
-  }, [isInitialized, isAuthenticated, redemptions]);
+  }, [sdk, isInitialized]);
 
-  const getRedemptionById = useCallback(async (redemptionId: string) => {
-    if (!isInitialized) {
+  const updateRedemption = useCallback(async (redemptionId: string, redemptionData: RedemptionCreateRequestDTO): Promise<RedemptionDTO> => {
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
-    if (!redemptions?.getRedemptionById) {
-      throw new Error('getRedemptionById method not available');
+    
+    try {
+      const result = await sdk.redemptions.updateRedemption(redemptionId, redemptionData);
+      console.log('Redemption updated successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to update redemption:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const toggleRedemptionStatus = useCallback(async (redemptionId: string): Promise<RedemptionDTO> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
     }
     
     try {
-      const result = await redemptions.getRedemptionById(redemptionId);
-      console.log('✅ Redemption fetched successfully:', result);
+      const result = await sdk.redemptions.toggleRedemptionStatus(redemptionId);
+      console.log('Redemption status toggled successfully:', result);
       return result;
     } catch (error) {
-      console.error('❌ Failed to fetch redemption:', error);
+      console.error('Failed to toggle redemption status:', error);
       throw error;
     }
-  }, [redemptions]);
+  }, [sdk, isInitialized]);
 
   return {
-    createRedemption,
     getActiveRedemptions,
-    getUserRedeems,
-    redeemRedemption,
-    getRedemptionById,
-    isAvailable: isInitialized && !!redemptions,
+    getUserRedemptions,
+    redeemOffer,
+    getRedemptionTypes,
+    createRedemption,
+    getAllRedemptions,
+    updateRedemption,
+    toggleRedemptionStatus,
+    isAvailable: isInitialized && !!sdk?.redemptions,
   };
-};
+};
+
+export type RedemptionHook = ReturnType<typeof useRedemptions>;

package/src/hooks/useTenants.ts

@@ -0,0 +1,77 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+import type { TenantPublicDTO, TenantClientConfigDTO, AdminDTO } from '@explorins/pers-shared';
+
+export const useTenants = () => {
+  const { sdk, isInitialized } = usePersSDK();
+
+  const getTenantInfo = useCallback(async (): Promise<TenantPublicDTO> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.tenants.getTenantInfo();
+      console.log('Tenant info fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch tenant info:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const getClientConfig = useCallback(async (): Promise<TenantClientConfigDTO> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.tenants.getClientConfig();
+      console.log('Client config fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch client config:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const getLoginToken = useCallback(async (): Promise<string> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.tenants.getLoginToken();
+      console.log('Login token fetched successfully');
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch login token:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const getAdmins = useCallback(async (): Promise<AdminDTO[]> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.tenants.getAdmins();
+      console.log('Admins fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch admins:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  return {
+    getTenantInfo,
+    getClientConfig,
+    getLoginToken,
+    getAdmins,
+    isAvailable: isInitialized && !!sdk?.tenants,
+  };
+};
+
+export type TenantHook = ReturnType<typeof useTenants>;

package/src/hooks/useTokens.ts

@@ -1,53 +1,221 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
+import type { TokenDTO } from '@explorins/pers-shared';
 
+/**
+ * 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.');
   }
 
-  const getTokens = useCallback(async () => {
-    if (!isInitialized) {
+  /**
+   * 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 (): Promise<TokenDTO[]> => {
+    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 (): Promise<TokenDTO> => {
+    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.getActiveCreditToken();
+      console.log('Active credit token fetched successfully:', result);
       return result;
     } catch (error) {
-      console.error('❌ Failed to fetch tokens:', error);
+      console.error('Failed to fetch active credit token:', error);
       throw error;
     }
-  }, [tokens]);
+  }, [sdk, isInitialized]);
 
-  const getTokenById = useCallback(async (tokenId: string) => {
-    if (!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 (): Promise<TokenDTO[]> => {
+    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.getRewardTokens();
+      console.log('Reward tokens fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch reward tokens:', error);
+      throw error;
+    }
+  }, [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 (): Promise<any> => {
+    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.getTokenTypes();
+      console.log('Token types fetched successfully:', result);
       return result;
     } catch (error) {
-      console.error('❌ Failed to fetch token:', error);
+      console.error('Failed to fetch token types:', error);
       throw error;
     }
-  }, [tokens]);
+  }, [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 (): Promise<TokenDTO[]> => {
+    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: string, contractTokenId?: string | null): Promise<TokenDTO> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      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 by contract:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
 
   return {
     getTokens,
-    getTokenById,
-    isAvailable: isInitialized && !!tokens,
+    getActiveCreditToken,
+    getRewardTokens,
+    getTokenTypes,
+    getStatusTokens,
+    getTokenByContract,
+    isAvailable: isInitialized && !!sdk?.tokens,
   };
-};
+};
+
+export type TokenHook = ReturnType<typeof useTokens>;