@explorins/pers-sdk-react-native 1.5.18 → 1.5.20

package/dist/hooks/index.d.ts

@@ -14,5 +14,5 @@ export { useFiles } from './useFiles';
 export { useAnalytics } from './useAnalytics';
 export { useDonations } from './useDonations';
 export type { RawUserData } from './useAuth';
-export type { TransactionSignerHook, TransactionSigningResult } from './useTransactionSigner';
+export type { TransactionSignerHook, SubmissionResult, AuthenticatedUser, TransactionSigningResult } from './useTransactionSigner';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,YAAY,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,YAAY,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/hooks/useAuth.d.ts

@@ -51,7 +51,7 @@ export declare const useAuth: () => {
     checkIsAuthenticated: () => Promise<boolean>;
     refreshTokens: (refreshToken?: string) => Promise<import("@explorins/pers-shared").SessionAuthResponseDTO>;
     clearAuth: () => Promise<void>;
-    hasValidAuth: () => boolean;
+    hasValidAuth: () => Promise<boolean>;
 };
 export type AuthHook = ReturnType<typeof useAuth>;
 //# sourceMappingURL=useAuth.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useAuth.d.ts","sourceRoot":"","sources":["../../src/hooks/useAuth.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAG/F,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,OAAO;;;;;sBA2ByB,MAAM,aAAY,MAAM,GAAG,OAAO,KAAY,QAAQ,6BAA6B,CAAC;oCA8CtE,WAAW,KAAG,QAAQ,IAAI,CAAC;kBA+C/C,QAAQ,IAAI,CAAC;;0BA8BL,QAAQ,OAAO,CAAC;gCAmBV,QAAQ,OAAO,CAAC;mCAqBX,MAAM;qBAmBtB,QAAQ,IAAI,CAAC;wBAoBhB,OAAO;CAyB7C,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC"}
+{"version":3,"file":"useAuth.d.ts","sourceRoot":"","sources":["../../src/hooks/useAuth.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAG/F,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,OAAO;;;;;sBA2ByB,MAAM,aAAY,MAAM,GAAG,OAAO,KAAY,QAAQ,6BAA6B,CAAC;oCA8CtE,WAAW,KAAG,QAAQ,IAAI,CAAC;kBA+C/C,QAAQ,IAAI,CAAC;;0BA8BL,QAAQ,OAAO,CAAC;gCAmBV,QAAQ,OAAO,CAAC;mCAqBX,MAAM;qBAmBtB,QAAQ,IAAI,CAAC;wBAoBV,QAAQ,OAAO,CAAC;CAyB5D,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC"}

package/dist/hooks/useAuth.js

@@ -61,7 +61,7 @@ export const useAuth = () => {
         try {
             console.log(`Logging in as ${userType}...`);
             // Set token in auth provider
-            await authProvider.setToken(jwtToken);
+            await authProvider.setAccessToken(jwtToken);
             // Perform login using the manager
             const result = await sdk.auth.loginWithToken(jwtToken, userType);
             const userData = result.user || result.admin;
@@ -100,11 +100,11 @@ export const useAuth = () => {
         }
         try {
             console.log('Logging in with raw user data...');
-            // Use the raw data login from the API client directly
-            const result = await sdk.api().loginUserWithRawData(rawUserData);
+            // Use the raw data login from the auth manager
+            const result = await sdk.auth.loginWithRawData(rawUserData);
             // Set token from result
             if (result.accessToken) {
-                await authProvider.setToken(result.accessToken);
+                await authProvider.setAccessToken(result.accessToken);
             }
             const userData = result.user;
             if (userData) {
@@ -139,7 +139,7 @@ export const useAuth = () => {
         try {
             console.log('Logging out...');
             if (authProvider) {
-                await authProvider.setToken(null);
+                await authProvider.clearTokens();
             }
             setAuthenticationState(null, null, false);
             console.log('Logout successful');
@@ -237,11 +237,11 @@ export const useAuth = () => {
      * console.log('Auth is valid:', isValid);
      * ```
      */
-    const hasValidAuth = useCallback(() => {
+    const hasValidAuth = useCallback(async () => {
         if (!sdk) {
             return false;
         }
-        return sdk.auth.hasValidAuth();
+        return await sdk.auth.hasValidAuth();
     }, [sdk]);
     return {
         // State

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

@@ -1 +1 @@
-{"version":3,"file":"useRedemptions.d.ts","sourceRoot":"","sources":["../../src/hooks/useRedemptions.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,0BAA0B,EAC1B,aAAa,EACb,mBAAmB,EACnB,kCAAkC,EAClC,iBAAiB,EAElB,MAAM,wBAAwB,CAAC;AAEhC,eAAO,MAAM,cAAc;gCAI0B,QAAQ,aAAa,EAAE,CAAC;8BAe1B,QAAQ,mBAAmB,EAAE,CAAC;gCAmB1B,MAAM,KAAG,QAAQ,kCAAkC,CAAC;8BAsFxD,QAAQ,iBAAiB,EAAE,CAAC;uCA/BjB,0BAA0B,KAAG,QAAQ,aAAa,CAAC;iCAgBzD,OAAO,KAAG,QAAQ,aAAa,EAAE,CAAC;qCA8B9B,MAAM,kBAAkB,0BAA0B,KAAG,QAAQ,aAAa,CAAC;2CAerE,MAAM,KAAG,QAAQ,aAAa,CAAC;;CA0BhG,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC"}
+{"version":3,"file":"useRedemptions.d.ts","sourceRoot":"","sources":["../../src/hooks/useRedemptions.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,0BAA0B,EAC1B,aAAa,EACb,mBAAmB,EACnB,kCAAkC,EAClC,iBAAiB,EAClB,MAAM,wBAAwB,CAAC;AAEhC,eAAO,MAAM,cAAc;gCAI0B,QAAQ,aAAa,EAAE,CAAC;8BAe1B,QAAQ,mBAAmB,EAAE,CAAC;gCAmB1B,MAAM,KAAG,QAAQ,kCAAkC,CAAC;8BAsFxD,QAAQ,iBAAiB,EAAE,CAAC;uCA/BjB,0BAA0B,KAAG,QAAQ,aAAa,CAAC;iCAgBzD,OAAO,KAAG,QAAQ,aAAa,EAAE,CAAC;qCA8B9B,MAAM,kBAAkB,0BAA0B,KAAG,QAAQ,aAAa,CAAC;2CAerE,MAAM,KAAG,QAAQ,aAAa,CAAC;;CA0BhG,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/hooks/useRedemptions.js

@@ -3,7 +3,7 @@ import { usePersSDK } from '../providers/PersSDKProvider';
 import { useTransactionSigner } from './useTransactionSigner';
 export const useRedemptions = () => {
     const { sdk, isInitialized, isAuthenticated } = usePersSDK();
-    const { signTransaction, isSignerAvailable } = useTransactionSigner();
+    const { signAndSubmitTransactionWithJWT, isSignerAvailable } = useTransactionSigner();
     const getActiveRedemptions = useCallback(async () => {
         if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
@@ -52,7 +52,7 @@ export const useRedemptions = () => {
             if (txToken && isSignerAvailable) {
                 console.log('Transaction requires blockchain signing, processing with WebAuthn signer...');
                 try {
-                    const signingResult = await signTransaction(txToken);
+                    const signingResult = await signAndSubmitTransactionWithJWT(txToken);
                     console.log('Blockchain signing result:', signingResult);
                     if (signingResult.success) {
                         console.log('Transaction signed successfully:', signingResult.transactionHash);
@@ -60,7 +60,7 @@ export const useRedemptions = () => {
                         return {
                             ...result,
                             transactionHash: signingResult.transactionHash,
-                            signature: signingResult.signature,
+                            // signature: signingResult.signature,
                             isSigned: true,
                             signedAt: new Date().toISOString()
                         };
@@ -86,7 +86,7 @@ export const useRedemptions = () => {
             console.error('Failed to redeem redemption:', error);
             throw error;
         }
-    }, [sdk, isInitialized, isAuthenticated, signTransaction, isSignerAvailable]);
+    }, [sdk, isInitialized, isAuthenticated, signAndSubmitTransactionWithJWT, isSignerAvailable]);
     // Admin methods
     const createRedemption = useCallback(async (redemptionData) => {
         if (!isInitialized || !sdk) {

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

@@ -1 +1 @@
-{"version":3,"file":"useTenants.d.ts","sourceRoot":"","sources":["../../src/hooks/useTenants.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAE/F,eAAO,MAAM,UAAU;yBAGuB,QAAQ,eAAe,CAAC;2BAetB,QAAQ,qBAAqB,CAAC;yBAehC,QAAQ,MAAM,CAAC;qBAenB,QAAQ,QAAQ,EAAE,CAAC;;CAsB5D,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC"}
+{"version":3,"file":"useTenants.d.ts","sourceRoot":"","sources":["../../src/hooks/useTenants.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAE/F,eAAO,MAAM,UAAU;yBAGuB,QAAQ,eAAe,CAAC;2BActB,QAAQ,qBAAqB,CAAC;yBAehC,QAAQ,MAAM,CAAC;qBAenB,QAAQ,QAAQ,EAAE,CAAC;;CAsB5D,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/hooks/useTenants.js

@@ -8,7 +8,6 @@ export const useTenants = () => {
         }
         try {
             const result = await sdk.tenants.getTenantInfo();
-            console.log('Tenant info fetched successfully:', result);
             return result;
         }
         catch (error) {

package/dist/hooks/useTransactionSigner.d.ts

@@ -1,77 +1,210 @@
-interface AuthenticationResult {
-    user: SignerAuthenticatedUser;
-    isExpired: boolean;
-}
-interface SignerAuthenticatedUser {
-    identifier: string;
-    signerAuthToken: string;
-    persAccessToken: string;
-}
-interface TransactionSigningResult {
-    success: boolean;
-    transactionHash?: string;
-    signature?: string;
-    error?: string;
+type SubmissionResult = import('@explorins/pers-signer/react-native').SubmissionResult;
+type AuthenticatedUser = import('@explorins/pers-signer/react-native').AuthenticatedUser;
+type TransactionSigningResult = import('@explorins/pers-signer/react-native').TransactionSigningResult;
+/**
+ * Return interface for the useTransactionSigner hook
+ *
+ * Provides secure transaction signing capabilities for EVM blockchain interactions
+ * and error handling for React Native applications.
+ *
+ * @interface TransactionSignerHook
+ * @property {Function} signAndSubmitTransactionWithJWT - Main method to sign and submit transactions
+ * @property {boolean} isSignerInitialized - Whether the signer SDK has been initialized
+ * @property {boolean} isSignerAvailable - Whether signing functionality is fully available
+ */
+interface TransactionSignerHook {
+    signAndSubmitTransactionWithJWT: (jwt: string) => Promise<SubmissionResult>;
+    isSignerInitialized: boolean;
+    isSignerAvailable: boolean;
 }
 /**
  * React Native hook for blockchain transaction signing using PERS Signer SDK
  *
- * Simplified interface matching web frontend - uses high-level SDK methods
- * that handle all complexity internally (tenant setup, project keys, etc.).
+ * This hook provides a complete blockchain transaction signing solution for React Native
+ * applications, integrating with the PERS ecosystem for tourism loyalty and reward systems.
+ * It automatically handles WebAuthn authentication, transaction preparation, signing, and
+ * blockchain submission in a single convenient interface.
+ *
+ * **Features:**
+ * - Automatic WebAuthn provider initialization for React Native
+ * - 5-minute authentication caching to reduce repeated logins
+ * - Complete transaction lifecycle management (sign + submit)
+ * - Comprehensive error handling with detailed error messages
+ * - Real-time status monitoring for UI feedback
+ * - Automatic retry logic for network failures
+ *
+ * **Underlying SDK Methods:**
+ * The hook uses the PERS Signer SDK which provides 5 core methods:
+ * 1. `loginUser(jwtToken)` - Authenticate user with 5-minute caching
+ * 2. `signTransaction(signingData, jwtToken)` - Sign transactions with auto-login
+ * 3. `submitTransaction(signingResult, jwtToken)` - Submit signed transactions
+ * 4. `signPersTransaction(jwtToken)` - Legacy one-liner for backward compatibility
+ * 5. `signAndSubmitPersTransaction(jwtToken)` - Complete sign + submit flow (used by this hook)
+ *
+ * **Security:**
+ * - WebAuthn-based secure authentication (no passwords stored)
+ * - JWT token validation and expiration checking
+ * - Secure transaction signing using device biometrics/PIN
+ * - No sensitive data stored locally
+ *
+ * @returns {TransactionSignerHook} Hook interface with signing methods and status
  *
  * @example
+ * **Basic Usage:**
  * ```typescript
- * function TransactionComponent() {
- *   const { signTransactionWithJWT, isSignerAvailable } = useTransactionSigner();
+ * import { useTransactionSigner } from '@explorins/pers-sdk-react-native';
+ *
+ * function TransactionScreen() {
+ *   const {
+ *     signAndSubmitTransactionWithJWT,
+ *     isSignerAvailable,
+ *     isSignerInitialized
+ *   } = useTransactionSigner();
  *
  *   const handleSign = async (jwtFromRedemption: string) => {
+ *     if (!isSignerAvailable) {
+ *       console.error('Signer not available');
+ *       return;
+ *     }
+ *
  *     try {
- *       const result = await signTransactionWithJWT(jwtFromRedemption);
+ *       const result = await signAndSubmitTransactionWithJWT(jwtFromRedemption);
  *       if (result.success) {
- *         console.log('Transaction signed:', result.transactionHash);
+ *         console.log('Transaction completed:', result.transactionHash);
+ *         // Handle successful transaction
+ *         if (result.shouldRedirect && result.redirectUrl) {
+ *           // Navigate to success page or external URL
+ *         }
  *       }
  *     } catch (error) {
- *       console.error('Signing failed:', error);
+ *       console.error('Transaction failed:', error.message);
+ *       // Handle error (show user-friendly message)
  *     }
  *   };
  *
  *   return (
- *     <button onClick={handleSign} disabled={!isSignerAvailable}>
- *       Sign Transaction
- *     </button>
+ *     <View style={styles.container}>
+ *       <TouchableOpacity
+ *         onPress={() => handleSign(redeemJWT)}
+ *         disabled={!isSignerAvailable}
+ *         style={[styles.button, !isSignerAvailable && styles.disabled]}
+ *       >
+ *         <Text style={styles.buttonText}>
+ *           {isSignerInitialized ? 'Sign Transaction' : 'Initializing...'}
+ *         </Text>
+ *       </TouchableOpacity>
+ *     </View>
  *   );
  * }
  * ```
+ *
+ * @example
+ * **Advanced Usage with Error Handling:**
+ * ```typescript
+ * function AdvancedTransactionComponent() {
+ *   const [isLoading, setIsLoading] = useState(false);
+ *   const [error, setError] = useState<string | null>(null);
+ *   const { signAndSubmitTransactionWithJWT, isSignerAvailable } = useTransactionSigner();
+ *
+ *   const handleTransaction = async (jwt: string) => {
+ *     setIsLoading(true);
+ *     setError(null);
+ *
+ *     try {
+ *       const result = await signAndSubmitTransactionWithJWT(jwt);
+ *
+ *       if (result.success) {
+ *         // Success handling
+ *         Alert.alert(
+ *           'Success',
+ *           `Transaction completed!\nHash: ${result.transactionHash}`
+ *         );
+ *       } else {
+ *         throw new Error(result.error || 'Transaction failed');
+ *       }
+ *     } catch (err) {
+ *       const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+ *       setError(errorMessage);
+ *
+ *       // Different error handling based on error type
+ *       if (errorMessage.includes('expired')) {
+ *         Alert.alert('Session Expired', 'Please log in again');
+ *       } else if (errorMessage.includes('network')) {
+ *         Alert.alert('Network Error', 'Please check your connection');
+ *       } else {
+ *         Alert.alert('Transaction Failed', errorMessage);
+ *       }
+ *     } finally {
+ *       setIsLoading(false);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <View>
+ *       {error && (
+ *         <Text style={styles.errorText}>{error}</Text>
+ *       )}
+ *       <TouchableOpacity
+ *         onPress={() => handleTransaction(jwtToken)}
+ *         disabled={!isSignerAvailable || isLoading}
+ *       >
+ *         <Text>
+ *           {isLoading ? 'Processing...' : 'Sign & Submit Transaction'}
+ *         </Text>
+ *       </TouchableOpacity>
+ *     </View>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * **Integration with PERS SDK:**
+ * ```typescript
+ * import { usePersSDK } from '@explorins/pers-sdk-react-native';
+ * import { useTransactionSigner } from '@explorins/pers-sdk-react-native';
+ *
+ * function RedemptionFlow() {
+ *   const { user, redeemTokens } = usePersSDK();
+ *   const { signAndSubmitTransactionWithJWT } = useTransactionSigner();
+ *
+ *   const handleRedemption = async (tokenAmount: number) => {
+ *     try {
+ *       // Step 1: Create redemption with PERS SDK
+ *       const redemption = await redeemTokens({
+ *         tokenAmount,
+ *         destinationAddress: user?.walletAddress
+ *       });
+ *
+ *       // Step 2: Sign and submit transaction
+ *       const txResult = await signAndSubmitTransactionWithJWT(redemption.jwtToken);
+ *
+ *       if (txResult.success) {
+ *         console.log('Redemption completed:', txResult.transactionHash);
+ *       }
+ *     } catch (error) {
+ *       console.error('Redemption failed:', error);
+ *     }
+ *   };
+ * }
+ * ```
+ *
+ * @see {@link SubmissionResult} for transaction result structure
+ * @see {@link TransactionSigningResult} for signing result details
+ * @see {@link AuthenticatedUser} for user authentication data
+ *
+ * @since 1.5.0
  */
-export declare const useTransactionSigner: () => {
-    /**
-     * Sign a blockchain transaction using JWT token (recommended method)
-     */
-    signTransactionWithJWT: (jwt: string) => Promise<TransactionSigningResult>;
-    /**
-     * Legacy transaction signing method
-     * @deprecated Use signTransactionWithJWT instead
-     */
-    signTransaction: (jwt: string) => Promise<TransactionSigningResult>;
-    /**
-     * Manual user authentication (for advanced use cases)
-     */
-    authenticateUser: (identifier: string) => Promise<SignerAuthenticatedUser | null>;
-    /**
-     * 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 declare const useTransactionSigner: () => TransactionSignerHook;
 /**
- * Export the transaction signing result type for external usage
+ * Type exports for external usage
+ *
+ * These types are re-exported from the PERS Signer SDK for convenience
+ * when working with transaction signing in React Native applications.
+ *
+ * @see {@link SubmissionResult} - Complete transaction submission result
+ * @see {@link AuthenticatedUser} - User authentication data structure
+ * @see {@link TransactionSigningResult} - Transaction signing result details
+ * @see {@link TransactionSignerHook} - Hook return interface
  */
-export type { TransactionSigningResult, SignerAuthenticatedUser, AuthenticationResult };
+export type { SubmissionResult, AuthenticatedUser, TransactionSigningResult, TransactionSignerHook };
 //# sourceMappingURL=useTransactionSigner.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useTransactionSigner.d.ts","sourceRoot":"","sources":["../../src/hooks/useTransactionSigner.ts"],"names":[],"mappings":"AA2BA,UAAU,oBAAoB;IAC5B,IAAI,EAAE,uBAAuB,CAAC;IAC9B,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,UAAU,uBAAuB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;CACzB;AASD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,oBAAoB;IA+I7B;;OAEG;kCAnGkD,MAAM,KAAG,QAAQ,wBAAwB,CAAC;IAsG/F;;;OAGG;2BAd2C,MAAM,KAAG,QAAQ,wBAAwB,CAAC;IAiBxF;;OAEG;mCAvCmD,MAAM,KAAG,QAAQ,uBAAuB,GAAG,IAAI,CAAC;IA0CtG;;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,uBAAuB,EAAE,oBAAoB,EAAE,CAAC"}
+{"version":3,"file":"useTransactionSigner.d.ts","sourceRoot":"","sources":["../../src/hooks/useTransactionSigner.ts"],"names":[],"mappings":"AAMA,KAAK,gBAAgB,GAAG,OAAO,qCAAqC,EAAE,gBAAgB,CAAC;AACvF,KAAK,iBAAiB,GAAG,OAAO,qCAAqC,EAAE,iBAAiB,CAAC;AACzF,KAAK,wBAAwB,GAAG,OAAO,qCAAqC,EAAE,wBAAwB,CAAC;AAcvG;;;;;;;;;;GAUG;AACH,UAAU,qBAAqB;IAC7B,+BAA+B,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC5E,mBAAmB,EAAE,OAAO,CAAC;IAC7B,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgLG;AACH,eAAO,MAAM,oBAAoB,QAAO,qBA4LvC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,CAAC"}