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

package/dist/hooks/useTransactions.js

@@ -1,78 +1,188 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
+/**
+ * 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 const useTransactions = () => {
-    const { transactions, isInitialized, isAuthenticated } = usePersSDK();
+    const { sdk, isInitialized, isAuthenticated } = usePersSDK();
     if (!isAuthenticated && isInitialized) {
         console.warn('SDK not authenticated. Some transaction operations may fail.');
     }
+    /**
+     * Creates a new transaction in the system
+     *
+     * Automatically handles signature URLs by opening them in the device's browser.
+     * The transaction may require user approval through external wallet applications.
+     *
+     * @param request - Transaction request data including amount, recipient, etc.
+     * @returns Promise resolving to transaction response with potential actionable items
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { createTransaction } = useTransactions();
+     * const request = {
+     *   amount: '100',
+     *   recipient: '0x123...',
+     *   tokenId: 'token-123'
+     * };
+     * const result = await createTransaction(request);
+     * console.log('Transaction created:', result);
+     * ```
+     */
     const createTransaction = useCallback(async (request) => {
-        if (!isInitialized) {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!transactions?.createTransaction) {
-            throw new Error('createTransaction method not available');
-        }
         try {
-            console.log('🔄 Creating transaction with request:', request);
-            const result = await transactions.createTransaction(request);
-            // React Native specific: 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);
-                }
-            }
-            console.log('✅ Transaction created successfully:', result);
+            const result = await sdk.transactions.createTransaction(request);
+            // Cross-platform: Dont handle signature URLs here, leave to caller
+            console.log('Transaction created successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to create transaction:', error);
+            console.error('Failed to create transaction:', error);
             throw error;
         }
-    }, [transactions]);
+    }, [sdk, isInitialized]);
+    /**
+     * Retrieves a specific transaction by its ID
+     *
+     * @param transactionId - Unique identifier of the transaction
+     * @returns Promise resolving to transaction data or null if not found
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getTransactionById } = useTransactions();
+     * const transaction = await getTransactionById('txn-123');
+     * console.log('Transaction details:', transaction);
+     * ```
+     */
     const getTransactionById = useCallback(async (transactionId) => {
-        if (!isInitialized) {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!transactions?.getTransactionById) {
-            throw new Error('getTransactionById method not available');
+        try {
+            const result = await sdk.transactions.getTransactionById(transactionId);
+            console.log('Transaction fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch transaction:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    /**
+     * Retrieves transaction history for the authenticated user, filtered by type
+     *
+     * @param type - Transaction type filter (defaults to 'all')
+     * @returns Promise resolving to array of user's transactions
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getUserTransactionHistory } = useTransactions();
+     * const transactions = await getUserTransactionHistory('credit');
+     * console.log('Credit transactions:', transactions);
+     * ```
+     */
+    const getUserTransactionHistory = useCallback(async (type = 'all') => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await transactions.getTransactionById(transactionId);
-            console.log('✅ Transaction fetched successfully:', result);
+            const result = await sdk.transactions.getUserTransactionHistory(type);
+            console.log('Transaction history fetched successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to fetch transaction:', error);
+            console.error('Failed to fetch transaction history:', error);
             throw error;
         }
-    }, [transactions]);
-    const getTransactionHistory = useCallback(async (filters) => {
-        if (!isInitialized) {
+    }, [sdk, isInitialized]);
+    const getTenantTransactions = useCallback(async () => {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!transactions?.getTransactionHistory) {
-            console.warn('getTransactionHistory method not available');
-            return [];
+        try {
+            const result = await sdk.transactions.getTenantTransactions();
+            console.log('Tenant transactions fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch tenant transactions:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const getPaginatedTransactions = useCallback(async (params) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.transactions.getPaginatedTransactions(params);
+            console.log('Paginated transactions fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch paginated transactions:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const exportTransactionsCSV = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await transactions.getTransactionHistory(filters);
-            console.log('✅ Transaction history fetched successfully:', result);
+            const result = await sdk.transactions.exportTransactionsCSV();
+            console.log('Transactions CSV exported successfully');
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to fetch transaction history:', error);
+            console.error('Failed to export transactions CSV:', error);
             throw error;
         }
-    }, [transactions]);
+    }, [sdk, isInitialized]);
     return {
         createTransaction,
         getTransactionById,
-        getTransactionHistory,
-        isAvailable: isInitialized && !!transactions,
+        getUserTransactionHistory,
+        getTenantTransactions,
+        getPaginatedTransactions,
+        exportTransactionsCSV,
+        isAvailable: isInitialized && !!sdk?.transactions,
     };
 };

package/dist/hooks/useUserStatus.d.ts

@@ -0,0 +1,9 @@
+import type { UserStatusTypeDTO } from '@explorins/pers-shared';
+export declare const useUserStatus: () => {
+    getUserStatusTypes: () => Promise<UserStatusTypeDTO[]>;
+    getEarnedUserStatus: () => Promise<UserStatusTypeDTO[]>;
+    createUserStatusType: (userStatusType: UserStatusTypeDTO) => Promise<UserStatusTypeDTO>;
+    isAvailable: boolean;
+};
+export type UserStatusHook = ReturnType<typeof useUserStatus>;
+//# sourceMappingURL=useUserStatus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useUserStatus.d.ts","sourceRoot":"","sources":["../../src/hooks/useUserStatus.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,eAAO,MAAM,aAAa;8BAGyB,QAAQ,iBAAiB,EAAE,CAAC;+BAe3B,QAAQ,iBAAiB,EAAE,CAAC;2CAmBd,iBAAiB,KAAG,QAAQ,iBAAiB,CAAC;;CAqB/G,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/hooks/useUserStatus.js

@@ -0,0 +1,57 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+export const useUserStatus = () => {
+    const { sdk, isInitialized, isAuthenticated } = usePersSDK();
+    const getUserStatusTypes = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.userStatus.getUserStatusTypes();
+            console.log('User status types fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch user status types:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const getEarnedUserStatus = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!isAuthenticated) {
+            throw new Error('SDK not authenticated. getEarnedUserStatus requires authentication.');
+        }
+        try {
+            const result = await sdk.userStatus.getEarnedUserStatus();
+            console.log('Earned user status fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch earned user status:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized, isAuthenticated]);
+    // Admin methods
+    const createUserStatusType = useCallback(async (userStatusType) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.userStatus.createUserStatusType(userStatusType);
+            console.log('User status type created successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to create user status type:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    return {
+        getUserStatusTypes,
+        getEarnedUserStatus,
+        createUserStatusType,
+        isAvailable: isInitialized && !!sdk?.userStatus,
+    };
+};

package/dist/hooks/useUsers.d.ts

@@ -0,0 +1,17 @@
+import type { UserDTO, UserCreateRequestDTO } from '@explorins/pers-shared';
+import type { UserPublicProfileDTO } from '@explorins/pers-sdk/user';
+export declare const useUsers: () => {
+    getCurrentUser: () => Promise<UserDTO>;
+    updateCurrentUser: (userData: UserCreateRequestDTO) => Promise<UserDTO>;
+    getUserById: (userId: string) => Promise<UserDTO>;
+    getAllUsersPublic: (filter?: {
+        key: string;
+        value: string;
+    }) => Promise<UserPublicProfileDTO[]>;
+    getAllUsers: () => Promise<UserDTO[]>;
+    updateUser: (userId: string, userData: UserCreateRequestDTO) => Promise<UserDTO>;
+    toggleUserStatus: (user: UserDTO) => Promise<UserDTO>;
+    isAvailable: boolean;
+};
+export type UserHook = ReturnType<typeof useUsers>;
+//# sourceMappingURL=useUsers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useUsers.d.ts","sourceRoot":"","sources":["../../src/hooks/useUsers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC5E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE,eAAO,MAAM,QAAQ;0BAG0B,QAAQ,OAAO,CAAC;kCAkBN,oBAAoB,KAAG,QAAQ,OAAO,CAAC;0BAkB/C,MAAM,KAAG,QAAQ,OAAO,CAAC;iCAelB;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,KAAG,QAAQ,oBAAoB,EAAE,CAAC;uBAgB5E,QAAQ,OAAO,EAAE,CAAC;yBAed,MAAM,YAAY,oBAAoB,KAAG,QAAQ,OAAO,CAAC;6BAerD,OAAO,KAAG,QAAQ,OAAO,CAAC;;CAyB7E,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC"}

package/dist/hooks/useUsers.js

@@ -0,0 +1,120 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+export const useUsers = () => {
+    const { sdk, isInitialized, isAuthenticated } = usePersSDK();
+    const getCurrentUser = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!isAuthenticated) {
+            throw new Error('SDK not authenticated. getCurrentUser requires authentication.');
+        }
+        try {
+            const result = await sdk.users.getCurrentUser();
+            console.log('Current user fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch current user:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized, isAuthenticated]);
+    const updateCurrentUser = useCallback(async (userData) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!isAuthenticated) {
+            throw new Error('SDK not authenticated. updateCurrentUser requires authentication.');
+        }
+        try {
+            const result = await sdk.users.updateCurrentUser(userData);
+            console.log('Current user updated successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to update current user:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized, isAuthenticated]);
+    const getUserById = useCallback(async (userId) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.users.getUserById(userId);
+            console.log('User fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch user:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const getAllUsersPublic = useCallback(async (filter) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.users.getAllUsersPublic(filter);
+            console.log('Public users fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch public users:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    // Admin methods
+    const getAllUsers = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.users.getAllUsers();
+            console.log('All users fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch all users:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const updateUser = useCallback(async (userId, userData) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.users.updateUser(userId, userData);
+            console.log('User updated successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to update user:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const toggleUserStatus = useCallback(async (user) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.users.toggleUserStatus(user);
+            console.log('User status toggled successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to toggle user status:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    return {
+        getCurrentUser,
+        updateCurrentUser,
+        getUserById,
+        getAllUsersPublic,
+        getAllUsers,
+        updateUser,
+        toggleUserStatus,
+        isAvailable: isInitialized && !!sdk?.users,
+    };
+};

package/dist/hooks/useWeb3.d.ts

@@ -1,11 +1,74 @@
+import type { TokenBalance, TokenBalanceRequest, TokenCollectionRequest, TokenCollection, TokenMetadata } from '@explorins/pers-sdk/web3';
+import type { ChainData } from '@explorins/pers-sdk/web3-chain';
+interface WalletInfo {
+    address: string | null;
+    isConnected: boolean;
+}
+/**
+ * React hook for Web3 operations in the PERS SDK
+ *
+ * Provides comprehensive Web3 functionality including token balance queries,
+ * metadata retrieval, collection management, IPFS resolution, and blockchain
+ * explorer integration. Supports multi-chain operations and wallet management.
+ *
+ * @returns Web3 hook with methods for blockchain operations
+ *
+ * @example
+ * ```typescript
+ * function Web3Component() {
+ *   const {
+ *     getTokenBalance,
+ *     getTokenMetadata,
+ *     getWalletInfo,
+ *     accountAddress
+ *   } = useWeb3();
+ *
+ *   const loadTokenData = async () => {
+ *     try {
+ *       if (!accountAddress) {
+ *         console.log('No wallet connected');
+ *         return;
+ *       }
+ *
+ *       const balance = await getTokenBalance({
+ *         walletAddress: accountAddress,
+ *         contractAddress: '0x123...',
+ *         chainId: 1
+ *       });
+ *
+ *       console.log('Token balance:', balance);
+ *     } catch (error) {
+ *       console.error('Failed to load token data:', error);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {accountAddress ? (
+ *         <div>
+ *           <p>Wallet: {accountAddress}</p>
+ *           <button onClick={loadTokenData}>Load Tokens</button>
+ *         </div>
+ *       ) : (
+ *         <p>No wallet connected</p>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
 export declare const useWeb3: () => {
-    getTokenBalance: (request: any) => Promise<any>;
-    getTokenCollection: (request: any) => Promise<any>;
-    getWalletInfo: () => Promise<{
-        address: string;
-        isConnected: boolean;
-    } | null>;
+    getTokenBalance: (request: TokenBalanceRequest) => Promise<TokenBalance>;
+    getTokenMetadata: (request: TokenBalanceRequest) => Promise<TokenMetadata | null>;
+    getTokenCollection: (request: TokenCollectionRequest) => Promise<TokenCollection>;
+    resolveIPFSUrl: (url: string, chainId: number) => Promise<string>;
+    fetchAndProcessMetadata: (tokenUri: string, chainId: number) => Promise<TokenMetadata | null>;
+    getChainDataById: (chainId: number) => Promise<ChainData | null>;
+    getExplorerUrl: (chainId: number, address: string, type: 'address' | 'tx') => Promise<string>;
+    getWalletInfo: () => Promise<WalletInfo | null>;
     accountAddress: string | null;
     isAvailable: boolean;
 };
+export type Web3Hook = ReturnType<typeof useWeb3>;
+export {};
 //# sourceMappingURL=useWeb3.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useWeb3.d.ts","sourceRoot":"","sources":["../../src/hooks/useWeb3.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,OAAO;+BAOkC,GAAG;kCAkBA,GAAG;;;;;;;CAyC3D,CAAC"}
+{"version":3,"file":"useWeb3.d.ts","sourceRoot":"","sources":["../../src/hooks/useWeb3.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,YAAY,EACZ,mBAAmB,EACnB,sBAAsB,EACtB,eAAe,EACf,aAAa,EACd,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAEhE,UAAU,UAAU;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,WAAW,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,OAAO;+BA0BkC,mBAAmB,KAAG,QAAQ,YAAY,CAAC;gCAmC1C,mBAAmB,KAAG,QAAQ,aAAa,GAAG,IAAI,CAAC;kCAejD,sBAAsB,KAAG,QAAQ,eAAe,CAAC;0BAezD,MAAM,WAAW,MAAM,KAAG,QAAQ,MAAM,CAAC;wCAe3B,MAAM,WAAW,MAAM,KAAG,QAAQ,aAAa,GAAG,IAAI,CAAC;gCAe/D,MAAM,KAAG,QAAQ,SAAS,GAAG,IAAI,CAAC;8BAepC,MAAM,WAAW,MAAM,QAAQ,SAAS,GAAG,IAAI,KAAG,QAAQ,MAAM,CAAC;yBAexE,QAAQ,UAAU,GAAG,IAAI,CAAC;;;CA2BvE,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC"}