@explorins/pers-sdk-react-native 1.5.30 → 1.5.32

package/dist/index.js

@@ -32044,6 +32044,119 @@ class PersSDK {
     }
 }
 
+/**
+ * AsyncStorage Token Storage for React Native Mobile Platforms
+ *
+ * Bundler-agnostic AsyncStorage implementation for mobile platforms
+ */
+/**
+ * Bundler-agnostic AsyncStorage wrapper
+ * Handles different module resolution patterns across bundlers (Metro, Webpack, Rollup, etc.)
+ */
+class BundlerAgnosticAsyncStorage {
+    constructor(asyncStorageModule) {
+        // Try different import patterns to handle various bundlers
+        if (asyncStorageModule?.default?.getItem) {
+            // Metro/Webpack pattern: { default: { getItem, setItem, ... } }
+            this.storage = asyncStorageModule.default;
+        }
+        else if (asyncStorageModule?.getItem) {
+            // Direct export pattern: { getItem, setItem, ... }
+            this.storage = asyncStorageModule;
+        }
+        else if (typeof asyncStorageModule === 'function') {
+            // Function export pattern (some bundlers)
+            this.storage = asyncStorageModule();
+        }
+        else {
+            // Log the structure for debugging
+            console.error('[BundlerAgnosticAsyncStorage] Unknown AsyncStorage structure:', asyncStorageModule);
+            throw new Error('AsyncStorage methods not found. Expected structure with getItem/setItem methods. ' +
+                'Make sure @react-native-async-storage/async-storage is properly installed.');
+        }
+        // Validate that we have the required methods
+        const requiredMethods = ['getItem', 'setItem', 'removeItem', 'getAllKeys', 'multiRemove'];
+        const missingMethods = requiredMethods.filter(method => typeof this.storage[method] !== 'function');
+        if (missingMethods.length > 0) {
+            throw new Error(`AsyncStorage missing required methods: ${missingMethods.join(', ')}. ` +
+                'Ensure @react-native-async-storage/async-storage is properly installed and compatible.');
+        }
+    }
+    async getItem(key) {
+        return this.storage.getItem(key);
+    }
+    async setItem(key, value) {
+        return this.storage.setItem(key, value);
+    }
+    async removeItem(key) {
+        return this.storage.removeItem(key);
+    }
+    async getAllKeys() {
+        return this.storage.getAllKeys();
+    }
+    async multiRemove(keys) {
+        return this.storage.multiRemove(keys);
+    }
+}
+/**
+ * AsyncStorage implementation for mobile platforms
+ *
+ * This class is only used on mobile platforms (iOS/Android).
+ * Web platforms use LocalStorageTokenStorage from core SDK.
+ */
+class AsyncStorageTokenStorage {
+    constructor(keyPrefix = 'pers_tokens_') {
+        this.keyPrefix = keyPrefix;
+        try {
+            // Initialize bundler-agnostic AsyncStorage wrapper
+            this.asyncStorage = new BundlerAgnosticAsyncStorage(AsyncStorage);
+        }
+        catch (error) {
+            console.error('[AsyncStorageTokenStorage] Failed to initialize:', error);
+            throw new Error('Failed to initialize AsyncStorage. Make sure @react-native-async-storage/async-storage is installed and ' +
+                'this code is running on a React Native mobile platform (not web).');
+        }
+    }
+    async set(key, value) {
+        try {
+            await this.asyncStorage.setItem(`${this.keyPrefix}${key}`, value);
+        }
+        catch (error) {
+            console.error(`Failed to store token ${key}:`, error);
+            throw new Error(`Token storage failed: ${error}`);
+        }
+    }
+    async get(key) {
+        try {
+            return await this.asyncStorage.getItem(`${this.keyPrefix}${key}`);
+        }
+        catch (error) {
+            console.error(`Failed to retrieve token ${key}:`, error);
+            return null;
+        }
+    }
+    async remove(key) {
+        try {
+            await this.asyncStorage.removeItem(`${this.keyPrefix}${key}`);
+        }
+        catch (error) {
+            console.error(`Failed to remove token ${key}:`, error);
+        }
+    }
+    async clear() {
+        try {
+            const allKeys = await this.asyncStorage.getAllKeys();
+            const ourKeys = allKeys.filter(key => key.startsWith(this.keyPrefix));
+            if (ourKeys.length > 0) {
+                await this.asyncStorage.multiRemove(ourKeys);
+            }
+        }
+        catch (error) {
+            console.error('Failed to clear token storage:', error);
+        }
+    }
+}
+
 // Conditionally require Keychain to avoid Web bundler errors
 let Keychain;
 if (reactNative.Platform.OS !== 'web') {
@@ -32070,6 +32183,7 @@ class ReactNativeSecureStorage {
             AUTH_STORAGE_KEYS.REFRESH_TOKEN,
             AUTH_STORAGE_KEYS.PROVIDER_TOKEN
         ]);
+        this.fallbackStorage = new AsyncStorageTokenStorage(keyPrefix);
     }
     async set(key, value) {
         const prefixedKey = this.getKeyName(key);
@@ -32090,12 +32204,12 @@ class ReactNativeSecureStorage {
             catch (e) {
                 console.warn(`[ReactNativeSecureStorage] Keychain set failed for ${key}, falling back to AsyncStorage`, e);
                 // Fallback to AsyncStorage if Keychain fails
-                await AsyncStorage.setItem(prefixedKey, stringValue);
+                await this.fallbackStorage.set(key, stringValue);
             }
         }
         else {
             // Store standard config/metadata in AsyncStorage
-            await AsyncStorage.setItem(prefixedKey, stringValue);
+            await this.fallbackStorage.set(key, stringValue);
         }
     }
     async get(key) {
@@ -32115,7 +32229,7 @@ class ReactNativeSecureStorage {
             }
             // Fallback: Check AsyncStorage if not found in Keychain or Keychain failed
             try {
-                const val = await AsyncStorage.getItem(prefixedKey);
+                const val = await this.fallbackStorage.get(key);
                 return val ? this.tryParse(val) : null;
             }
             catch (e) {
@@ -32124,7 +32238,7 @@ class ReactNativeSecureStorage {
         }
         else {
             try {
-                const val = await AsyncStorage.getItem(prefixedKey);
+                const val = await this.fallbackStorage.get(key);
                 return val ? this.tryParse(val) : null;
             }
             catch (e) {
@@ -32145,10 +32259,10 @@ class ReactNativeSecureStorage {
                 console.warn(`[ReactNativeSecureStorage] Failed to reset keychain for ${key}`, e);
             }
             // Always remove from fallback storage too, just in case
-            await AsyncStorage.removeItem(prefixedKey);
+            await this.fallbackStorage.remove(key);
         }
         else {
-            await AsyncStorage.removeItem(prefixedKey);
+            await this.fallbackStorage.remove(key);
         }
     }
     async clear() {
@@ -32165,11 +32279,7 @@ class ReactNativeSecureStorage {
         }
         // Clear AsyncStorage keys related to PERS
         try {
-            const allKeys = await AsyncStorage.getAllKeys();
-            const ourKeys = allKeys.filter(k => k.startsWith(this.keyPrefix));
-            if (ourKeys.length > 0) {
-                await AsyncStorage.multiRemove(ourKeys);
-            }
+            await this.fallbackStorage.clear();
         }
         catch (e) {
             console.warn('[ReactNativeSecureStorage] Failed to clear AsyncStorage', e);
@@ -32225,6 +32335,10 @@ function createReactNativeAuthProvider(projectKey, config = {}) {
         enabled: dpop.enabled ?? true,
         cryptoProvider: dpop.cryptoProvider
     } : undefined;
+    // DEBUG LOGGING
+    if (debug) {
+        console.log('[ReactNativeAuthProvider] Creating provider with DPoP config:', JSON.stringify(dpopConfig));
+    }
     // Return DefaultAuthProvider configured with platform-appropriate storage
     return new DefaultAuthProvider({
         authType,
@@ -32234,119 +32348,6 @@ function createReactNativeAuthProvider(projectKey, config = {}) {
     });
 }
 
-/**
- * AsyncStorage Token Storage for React Native Mobile Platforms
- *
- * Bundler-agnostic AsyncStorage implementation for mobile platforms
- */
-/**
- * Bundler-agnostic AsyncStorage wrapper
- * Handles different module resolution patterns across bundlers (Metro, Webpack, Rollup, etc.)
- */
-class BundlerAgnosticAsyncStorage {
-    constructor(asyncStorageModule) {
-        // Try different import patterns to handle various bundlers
-        if (asyncStorageModule?.default?.getItem) {
-            // Metro/Webpack pattern: { default: { getItem, setItem, ... } }
-            this.storage = asyncStorageModule.default;
-        }
-        else if (asyncStorageModule?.getItem) {
-            // Direct export pattern: { getItem, setItem, ... }
-            this.storage = asyncStorageModule;
-        }
-        else if (typeof asyncStorageModule === 'function') {
-            // Function export pattern (some bundlers)
-            this.storage = asyncStorageModule();
-        }
-        else {
-            // Log the structure for debugging
-            console.error('[BundlerAgnosticAsyncStorage] Unknown AsyncStorage structure:', asyncStorageModule);
-            throw new Error('AsyncStorage methods not found. Expected structure with getItem/setItem methods. ' +
-                'Make sure @react-native-async-storage/async-storage is properly installed.');
-        }
-        // Validate that we have the required methods
-        const requiredMethods = ['getItem', 'setItem', 'removeItem', 'getAllKeys', 'multiRemove'];
-        const missingMethods = requiredMethods.filter(method => typeof this.storage[method] !== 'function');
-        if (missingMethods.length > 0) {
-            throw new Error(`AsyncStorage missing required methods: ${missingMethods.join(', ')}. ` +
-                'Ensure @react-native-async-storage/async-storage is properly installed and compatible.');
-        }
-    }
-    async getItem(key) {
-        return this.storage.getItem(key);
-    }
-    async setItem(key, value) {
-        return this.storage.setItem(key, value);
-    }
-    async removeItem(key) {
-        return this.storage.removeItem(key);
-    }
-    async getAllKeys() {
-        return this.storage.getAllKeys();
-    }
-    async multiRemove(keys) {
-        return this.storage.multiRemove(keys);
-    }
-}
-/**
- * AsyncStorage implementation for mobile platforms
- *
- * This class is only used on mobile platforms (iOS/Android).
- * Web platforms use LocalStorageTokenStorage from core SDK.
- */
-class AsyncStorageTokenStorage {
-    constructor(keyPrefix = 'pers_tokens_') {
-        this.keyPrefix = keyPrefix;
-        try {
-            // Initialize bundler-agnostic AsyncStorage wrapper
-            this.asyncStorage = new BundlerAgnosticAsyncStorage(AsyncStorage);
-        }
-        catch (error) {
-            console.error('[AsyncStorageTokenStorage] Failed to initialize:', error);
-            throw new Error('Failed to initialize AsyncStorage. Make sure @react-native-async-storage/async-storage is installed and ' +
-                'this code is running on a React Native mobile platform (not web).');
-        }
-    }
-    async set(key, value) {
-        try {
-            await this.asyncStorage.setItem(`${this.keyPrefix}${key}`, value);
-        }
-        catch (error) {
-            console.error(`Failed to store token ${key}:`, error);
-            throw new Error(`Token storage failed: ${error}`);
-        }
-    }
-    async get(key) {
-        try {
-            return await this.asyncStorage.getItem(`${this.keyPrefix}${key}`);
-        }
-        catch (error) {
-            console.error(`Failed to retrieve token ${key}:`, error);
-            return null;
-        }
-    }
-    async remove(key) {
-        try {
-            await this.asyncStorage.removeItem(`${this.keyPrefix}${key}`);
-        }
-        catch (error) {
-            console.error(`Failed to remove token ${key}:`, error);
-        }
-    }
-    async clear() {
-        try {
-            const allKeys = await this.asyncStorage.getAllKeys();
-            const ourKeys = allKeys.filter(key => key.startsWith(this.keyPrefix));
-            if (ourKeys.length > 0) {
-                await this.asyncStorage.multiRemove(ourKeys);
-            }
-        }
-        catch (error) {
-            console.error('Failed to clear token storage:', error);
-        }
-    }
-}
-
 // Conditionally require quick-crypto for Native platforms only
 let crypto$1;
 if (reactNative.Platform.OS !== 'web') {
@@ -32359,7 +32360,6 @@ if (reactNative.Platform.OS !== 'web') {
 }
 else {
     // on Web, we shouldn't be using this provider anyway (Core SDK has WebDPoPProvider)
-    // But to be safe, we can mock or throw
     crypto$1 = {
         generateKeyPair: () => { throw new Error('ReactNativeDPoPProvider not supported on Web'); }
     };
@@ -32368,26 +32368,39 @@ class ReactNativeDPoPProvider {
     /**
      * Generates a new key pair (ES256 recommended)
      *
-     * Note: options.extractable is ignored because for React Native Keychain storage,
-     * we MUST export the keys as JWK/strings. We rely on the Keychain encryption
-     * for security at rest (High Security), making the key "Extractable" in memory
-     * but protected by hardware encryption when stored.
+     * Uses WebCrypto API (crypto.subtle) for cross-platform compatibility.
+     * Falls back to Node.js crypto API on iOS if needed.
      */
     async generateKeyPair(options) {
-        // Generate P-256 Key Pair
+        // Try WebCrypto API first (works on both iOS and Android)
+        if (crypto$1.subtle) {
+            try {
+                const keyPair = await crypto$1.subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, true, // extractable - required for JWK export
+                ['sign', 'verify']);
+                const publicKeyJwk = await crypto$1.subtle.exportKey('jwk', keyPair.publicKey);
+                const privateKeyJwk = await crypto$1.subtle.exportKey('jwk', keyPair.privateKey);
+                return {
+                    publicKey: publicKeyJwk,
+                    privateKey: privateKeyJwk
+                };
+            }
+            catch (err) {
+                console.warn('[DPoP] WebCrypto API failed, trying Node.js crypto API', err);
+            }
+        }
+        // Fallback: Node.js crypto API (works on iOS)
         return new Promise((resolve, reject) => {
             crypto$1.generateKeyPair('ec', { namedCurve: 'P-256' }, (err, publicKey, privateKey) => {
                 if (err)
                     return reject(err);
-                // Export to JWK for SDK Compatibility
-                // We use 'export' because supportsObjects=false in our storage forces the SDK
-                // to expect serializable keys.
-                const pubJwk = publicKey.export({ format: 'jwk' });
-                const privJwk = privateKey.export({ format: 'jwk' });
-                resolve({
-                    publicKey: pubJwk,
-                    privateKey: privJwk
-                });
+                try {
+                    const pJwk = publicKey.export({ format: 'jwk' });
+                    const prJwk = privateKey.export({ format: 'jwk' });
+                    resolve({ publicKey: pJwk, privateKey: prJwk });
+                }
+                catch (exportErr) {
+                    reject(exportErr);
+                }
             });
         });
     }
@@ -32408,21 +32421,37 @@ class ReactNativeDPoPProvider {
         const b64Header = this.base64Url(JSON.stringify(header));
         const b64Payload = this.base64Url(JSON.stringify(finalPayload));
         const signingInput = `${b64Header}.${b64Payload}`;
-        // 4. Sign
+        // 4. Sign - try WebCrypto first, fallback to Node.js crypto
+        if (crypto$1.subtle) {
+            try {
+                const privateKey = await crypto$1.subtle.importKey('jwk', keyPair.privateKey, { name: 'ECDSA', namedCurve: 'P-256' }, false, ['sign']);
+                const signatureBuffer = await crypto$1.subtle.sign({ name: 'ECDSA', hash: 'SHA-256' }, privateKey, buffer.Buffer.from(signingInput));
+                // WebCrypto returns signature in IEEE P1363 format (r || s), which is what we need for JWT
+                return `${signingInput}.${this.base64UrlBuffer(buffer.Buffer.from(signatureBuffer))}`;
+            }
+            catch (err) {
+                console.warn('[DPoP] WebCrypto sign failed, trying Node.js crypto', err);
+            }
+        }
+        // Fallback: Node.js crypto API
         const sign = crypto$1.createSign('SHA256');
         sign.update(signingInput);
-        // sign.end() is not required/available in quick-crypto as it doesn't strictly follow stream interface
-        // Import private key back from JWK to sign
-        // The keyPair.privateKey is a JsonWebKey object because we exported it earlier.
-        // quick-crypto createPrivateKey expects jwk object if format is jwk
         const privateKeyObj = crypto$1.createPrivateKey({ key: keyPair.privateKey, format: 'jwk' });
         const signature = sign.sign(privateKeyObj);
-        // signature is a Buffer in quick-crypto
         return `${signingInput}.${this.base64UrlBuffer(signature)}`;
     }
     async hashAccessToken(accessToken) {
+        // Try WebCrypto first
+        if (crypto$1.subtle) {
+            try {
+                const hashBuffer = await crypto$1.subtle.digest('SHA-256', buffer.Buffer.from(accessToken));
+                return this.base64UrlBuffer(buffer.Buffer.from(hashBuffer));
+            }
+            catch (err) {
+                // Fallback to Node.js crypto
+            }
+        }
         const hash = crypto$1.createHash('sha256').update(accessToken).digest();
-        // digest returns Buffer in quick-crypto
         return this.base64UrlBuffer(hash);
     }
     // --- Helpers ---
@@ -32430,7 +32459,6 @@ class ReactNativeDPoPProvider {
         return this.base64UrlBuffer(buffer.Buffer.from(str));
     }
     base64UrlBuffer(buf) {
-        // Ensure we have a Buffer
         const buffer$1 = buffer.Buffer.isBuffer(buf) ? buf : buffer.Buffer.from(buf);
         return buffer$1.toString('base64')
             .replace(/=/g, '')
@@ -32544,7 +32572,6 @@ const PersSDKProvider = ({ children, config }) => {
     const [isInitialized, setIsInitialized] = react.useState(false);
     const [isAuthenticated, setIsAuthenticated] = react.useState(false);
     const [user, setUser] = react.useState(null);
-    const [accountAddress, setAccountAddress] = react.useState(null);
     const initialize = react.useCallback(async (config) => {
         // Prevent multiple initializations
         if (isInitialized || initializingRef.current) {
@@ -32554,8 +32581,7 @@ const PersSDKProvider = ({ children, config }) => {
         try {
             // Create HTTP client
             const httpClient = new ReactNativeHttpClient();
-            // Ensure DPoP is enabled by default for all platforms
-            const dpopConfig = config.dpop || {};
+            const dpopConfig = config.dpop ?? {};
             const isDpopEnabled = dpopConfig.enabled ?? true;
             // Prepare DPoP settings for Auth Provider
             const dpopSettings = {
@@ -32607,9 +32633,8 @@ const PersSDKProvider = ({ children, config }) => {
             });
         }
     }, [config, isInitialized, initialize]);
-    const setAuthenticationState = react.useCallback((user, accountAddress, isAuthenticated) => {
+    const setAuthenticationState = react.useCallback((user, isAuthenticated) => {
         setUser(user);
-        setAccountAddress(accountAddress);
         setIsAuthenticated(isAuthenticated);
     }, []);
     const refreshUserData = react.useCallback(async () => {
@@ -32625,7 +32650,7 @@ const PersSDKProvider = ({ children, config }) => {
             throw error;
         }
     }, [sdk, isAuthenticated, isInitialized]);
-    const contextValue = {
+    const contextValue = react.useMemo(() => ({
         // Main SDK instance
         sdk,
         // Manager shortcuts for convenience
@@ -32640,20 +32665,26 @@ const PersSDKProvider = ({ children, config }) => {
         tenants: sdk?.tenants || null,
         analytics: sdk?.analytics || null,
         donations: sdk?.donations || null,
-        // Legacy support (deprecated but kept for backward compatibility)
-        business: sdk?.businesses || null,
         // Platform-specific providers
         authProvider,
         // State
         isInitialized,
         isAuthenticated,
         user,
-        accountAddress,
         // Methods
         initialize,
         setAuthenticationState,
         refreshUserData,
-    };
+    }), [
+        sdk,
+        authProvider,
+        isInitialized,
+        isAuthenticated,
+        user,
+        initialize,
+        setAuthenticationState,
+        refreshUserData
+    ]);
     return (jsxRuntime.jsx(SDKContext.Provider, { value: contextValue, children: children }));
 };
 // Custom hook to use the SDK context
@@ -32703,7 +32734,7 @@ const usePersSDK = () => {
  * ```
  */
 const useAuth = () => {
-    const { sdk, authProvider, isInitialized, isAuthenticated, user, accountAddress, setAuthenticationState, refreshUserData } = usePersSDK();
+    const { sdk, authProvider, isInitialized, isAuthenticated, user, setAuthenticationState, refreshUserData } = usePersSDK();
     /**
      * Authenticates a user with a JWT token
      *
@@ -32724,18 +32755,13 @@ const useAuth = () => {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            console.log(`Logging in as ${userType}...`);
             // Set token in auth provider
             await authProvider.setAccessToken(jwtToken);
             // Perform login using the manager
             const result = await sdk.auth.loginWithToken(jwtToken, userType);
             const userData = result.user || result.admin;
             if (userData) {
-                const userAccountAddress = ('accountAddress' in userData && userData.accountAddress) ||
-                    ('wallets' in userData && userData.wallets?.[0]?.address) ||
-                    null;
-                setAuthenticationState(userData, userAccountAddress, true);
-                console.log('Login successful');
+                setAuthenticationState(userData, true);
                 return result;
             }
             else {
@@ -32764,7 +32790,6 @@ const useAuth = () => {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            console.log('Logging in with raw user data...');
             // Use the raw data login from the auth manager
             const result = await sdk.auth.loginWithRawData(rawUserData);
             // Set token from result
@@ -32773,11 +32798,7 @@ const useAuth = () => {
             }
             const userData = result.user;
             if (userData) {
-                const userAccountAddress = userData.accountAddress ||
-                    userData?.wallets?.[0]?.address ||
-                    null;
-                setAuthenticationState(userData, userAccountAddress, true);
-                console.log('Raw data login successful');
+                setAuthenticationState(userData, true);
             }
             else {
                 throw new Error('No user data returned from raw data login');
@@ -32802,12 +32823,10 @@ const useAuth = () => {
      */
     const logout = react.useCallback(async () => {
         try {
-            console.log('Logging out...');
             if (authProvider) {
                 await authProvider.clearTokens();
             }
-            setAuthenticationState(null, null, false);
-            console.log('Logout successful');
+            setAuthenticationState(null, false);
         }
         catch (error) {
             console.error('Logout failed:', error);
@@ -32888,7 +32907,7 @@ const useAuth = () => {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         await sdk.auth.clearAuth();
-        setAuthenticationState(null, null, false);
+        setAuthenticationState(null, false);
     }, [sdk, setAuthenticationState]);
     /**
      * Checks if the current authentication is valid (non-expired)
@@ -32913,7 +32932,6 @@ const useAuth = () => {
         isInitialized,
         isAuthenticated,
         user,
-        accountAddress,
         // Methods
         login,
         loginWithRawData,
@@ -32979,7 +32997,6 @@ const useTokens = () => {
         }
         try {
             const result = await sdk.tokens.getTokens();
-            console.log('Tokens fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33006,7 +33023,6 @@ const useTokens = () => {
         }
         try {
             const result = await sdk.tokens.getActiveCreditToken();
-            console.log('Active credit token fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33033,7 +33049,6 @@ const useTokens = () => {
         }
         try {
             const result = await sdk.tokens.getRewardTokens();
-            console.log('Reward tokens fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33060,7 +33075,6 @@ const useTokens = () => {
         }
         try {
             const result = await sdk.tokens.getTokenTypes();
-            console.log('Token types fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33087,7 +33101,6 @@ const useTokens = () => {
         }
         try {
             const result = await sdk.tokens.getStatusTokens();
-            console.log('Status tokens fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33116,7 +33129,6 @@ const useTokens = () => {
         }
         try {
             const result = await sdk.tokens.getTokenByContract(contractAddress, contractTokenId);
-            console.log('Token by contract fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33135,6 +33147,45 @@ const useTokens = () => {
     };
 };
 
+/**
+ * Transaction statuses that allow signing
+ */
+[exports.TransactionStatus.PENDING_SIGNATURE, exports.TransactionStatus.CREATED];
+
+/**
+ * Error codes for transaction signing operations
+ */
+var TransactionSigningErrorCode;
+(function (TransactionSigningErrorCode) {
+    TransactionSigningErrorCode["INVALID_TOKENS"] = "INVALID_TOKENS";
+    TransactionSigningErrorCode["TRANSACTION_NOT_FOUND"] = "TRANSACTION_NOT_FOUND";
+    TransactionSigningErrorCode["TRANSACTION_NOT_PENDING"] = "TRANSACTION_NOT_PENDING";
+    TransactionSigningErrorCode["WALLET_NOT_AVAILABLE"] = "WALLET_NOT_AVAILABLE";
+    TransactionSigningErrorCode["WEBAUTHN_OPERATION_IN_PROGRESS"] = "WEBAUTHN_OPERATION_IN_PROGRESS";
+    TransactionSigningErrorCode["SIGNING_CANCELLED"] = "SIGNING_CANCELLED";
+    TransactionSigningErrorCode["PERS_AUTH_FAILED"] = "PERS_AUTH_FAILED";
+    TransactionSigningErrorCode["AUTH_FAILED"] = "AUTH_FAILED";
+    TransactionSigningErrorCode["TRANSACTION_NOT_READY"] = "TRANSACTION_NOT_READY";
+    TransactionSigningErrorCode["SUBMISSION_FAILED"] = "SUBMISSION_FAILED";
+    TransactionSigningErrorCode["SERVER_ERROR"] = "SERVER_ERROR";
+    TransactionSigningErrorCode["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+})(TransactionSigningErrorCode || (TransactionSigningErrorCode = {}));
+
+/**
+ * Signing status types for type-safe status updates
+ * Using const pattern instead of enum for better bundling compatibility
+ */
+const SigningStatus = {
+    INITIALIZING: 'initializing',
+    AUTHENTICATING: 'authenticating',
+    PREPARING: 'preparing',
+    SIGNING: 'signing',
+    SUBMITTING: 'submitting',
+    COMPLETED: 'completed',
+    ERROR: 'error',
+    EXPIRED: 'expired'
+};
+
 // Dynamic import the signer SDK to avoid build issues with static dependencies
 let createPersSignerSDK = null;
 try {
@@ -33327,6 +33378,8 @@ const DEFAULT_ETHERS_PROVIDER = "https://sepolia.infura.io/v3/2781b4b5242343d5b0
 const useTransactionSigner = () => {
     // const { isInitialized, isAuthenticated, user } = usePersSDK();
     const [isSignerInitialized, setIsSignerInitialized] = react.useState(false);
+    const [currentStatus, setCurrentStatus] = react.useState(null);
+    const [statusMessage, setStatusMessage] = react.useState(null);
     const signerSDKRef = react.useRef(null);
     // Auto-initialize signer SDK when PERS SDK is ready
     react.useEffect(() => {
@@ -33375,6 +33428,7 @@ const useTransactionSigner = () => {
      *
      * @param {string} jwt - JWT token containing transaction ID and user information
      *   Must include: `transactionId`, `identifierEmail`, `tenantId`
+     * @param {StatusCallback} [onStatusUpdate] - Optional callback for real-time status updates
      * @returns {Promise<SubmissionResult>} Complete transaction result
      *
      * @throws {Error} 'Transaction signer not initialized' - Hook not ready
@@ -33397,6 +33451,15 @@ const useTransactionSigner = () => {
      * ```
      *
      * @example
+     * **With Status Updates:**
+     * ```typescript
+     * const result = await signAndSubmitTransactionWithJWT(jwtToken, (status, message) => {
+     *   console.log(`Status: ${status} - ${message}`);
+     *   setStatusText(message);
+     * });
+     * ```
+     *
+     * @example
      * **With Error Handling:**
      * ```typescript
      * try {
@@ -33431,20 +33494,30 @@ const useTransactionSigner = () => {
      *
      * @see {@link SubmissionResult} for detailed result structure
      */
-    const signAndSubmitTransactionWithJWT = react.useCallback(async (jwt) => {
+    const signAndSubmitTransactionWithJWT = react.useCallback(async (jwt, onStatusUpdate) => {
         if (!isSignerInitialized || !signerSDKRef.current) {
             throw new Error('Transaction signer not initialized');
         }
         if (!createPersSignerSDK) {
             throw new Error('PERS Signer SDK not available. Blockchain signing is not supported.');
         }
+        // Create status callback wrapper that updates both hook state and calls user callback
+        const statusCallback = {
+            onStatusUpdate: (status, message, data) => {
+                setCurrentStatus(status);
+                setStatusMessage(message);
+                onStatusUpdate?.(status, message, data);
+            }
+        };
         try {
             // Use the actual SDK method that handles the complete sign + submit flow
-            const submissionResult = await signerSDKRef.current.signAndSubmitPersTransaction(jwt);
+            const submissionResult = await signerSDKRef.current.signAndSubmitPersTransaction(jwt, statusCallback);
             return submissionResult;
         }
         catch (error) {
             console.error('[useTransactionSigner] JWT transaction signing failed:', error);
+            setCurrentStatus(SigningStatus.ERROR);
+            setStatusMessage(error instanceof Error ? error.message : 'Transaction failed');
             throw error; // Re-throw to maintain error handling upstream
         }
     }, [isSignerInitialized]);
@@ -33456,6 +33529,7 @@ const useTransactionSigner = () => {
          * from authentication to blockchain submission in a single call.
          *
          * @param {string} jwt - JWT token with transaction and user data
+         * @param {StatusCallback} [onStatusUpdate] - Optional callback for real-time status updates
          * @returns {Promise<SubmissionResult>} Transaction result with hash and status
          */
         signAndSubmitTransactionWithJWT,
@@ -33501,6 +33575,36 @@ const useTransactionSigner = () => {
          * ```
          */
         isSignerAvailable: isSignerInitialized && !!createPersSignerSDK,
+        /**
+         * Current signing status for UI feedback
+         *
+         * Tracks the current state of the signing process. Use this to show
+         * progress indicators or status messages during transaction signing.
+         *
+         * Possible values: 'initializing', 'authenticating', 'preparing',
+         * 'signing', 'submitting', 'completed', 'error', 'expired'
+         *
+         * @example
+         * ```typescript
+         * const { currentStatus, statusMessage } = useTransactionSigner();
+         *
+         * return (
+         *   <View>
+         *     {currentStatus && (
+         *       <Text>Status: {statusMessage}</Text>
+         *     )}
+         *   </View>
+         * );
+         * ```
+         */
+        currentStatus,
+        /**
+         * Human-readable status message
+         *
+         * Provides a user-friendly description of the current signing status.
+         * Updates in real-time as the transaction progresses.
+         */
+        statusMessage,
     };
 };
 
@@ -33542,7 +33646,7 @@ const useTransactionSigner = () => {
  */
 const useTransactions = () => {
     const { sdk, isInitialized, isAuthenticated } = usePersSDK();
-    const { signAndSubmitTransactionWithJWT, isSignerAvailable } = useTransactionSigner();
+    const { signAndSubmitTransactionWithJWT, isSignerAvailable, currentStatus, statusMessage } = useTransactionSigner();
     if (!isAuthenticated && isInitialized) {
         console.warn('SDK not authenticated. Some transaction operations may fail.');
     }
@@ -33564,29 +33668,29 @@ const useTransactions = () => {
      *   recipient: '0x123...',
      *   tokenId: 'token-123'
      * };
-     * const result = await createTransaction(request);
+     * const result = await createTransaction(request, (status, message) => {
+     *   console.log(`Status: ${status} - ${message}`);
+     * });
      * console.log('Transaction created:', result);
      * ```
      */
-    const createTransaction = react.useCallback(async (request) => {
+    const createTransaction = react.useCallback(async (request, onStatusUpdate) => {
         if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
             const result = await sdk.transactions.createTransaction(request);
-            console.log('Transaction created successfully:', result);
             // Check if transaction requires signing (contains actionable authToken)
             // Type assertion needed as TransactionRequestResponseDTO type may not include all dynamic properties
             const txToken = result?.actionable?.authToken;
             if (txToken) {
-                console.log('[useTransactions] Transaction requires signing, attempting automatic signature...');
                 try {
                     if (!isSignerAvailable) {
                         console.warn('[useTransactions] Transaction signer not available, skipping automatic signing');
                         return result;
                     }
                     // Automatically sign the transaction using the authToken
-                    const signingResult = await signAndSubmitTransactionWithJWT(txToken);
+                    const signingResult = await signAndSubmitTransactionWithJWT(txToken, onStatusUpdate);
                     if (signingResult.success) {
                         console.log('[useTransactions] Transaction signed successfully:', signingResult.transactionHash);
                         // Return the original result - the transaction is now signed and will be processed
@@ -33631,7 +33735,6 @@ const useTransactions = () => {
         }
         try {
             const result = await sdk.transactions.getTransactionById(transactionId);
-            console.log('Transaction fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33659,7 +33762,6 @@ const useTransactions = () => {
         }
         try {
             const result = await sdk.transactions.getUserTransactionHistory(role);
-            console.log('Transaction history fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33686,7 +33788,6 @@ const useTransactions = () => {
         }
         try {
             const result = await sdk.transactions.getPaginatedTransactions(params);
-            console.log('Paginated transactions fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33700,7 +33801,6 @@ const useTransactions = () => {
         }
         try {
             const result = await sdk.transactions.exportTransactionsCSV();
-            console.log('Transactions CSV exported successfully');
             return result;
         }
         catch (error) {
@@ -33716,6 +33816,9 @@ const useTransactions = () => {
         getPaginatedTransactions,
         exportTransactionsCSV,
         isAvailable: isInitialized && !!sdk?.transactions,
+        // Expose signing status for UI feedback
+        signingStatus: currentStatus,
+        signingStatusMessage: statusMessage,
     };
 };
 
@@ -33774,7 +33877,6 @@ const useBusiness = () => {
         }
         try {
             const result = await sdk.businesses.getActiveBusinesses();
-            console.log('Active businesses fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33801,7 +33903,6 @@ const useBusiness = () => {
         }
         try {
             const result = await sdk.businesses.getBusinessTypes();
-            console.log('Business types fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33815,7 +33916,6 @@ const useBusiness = () => {
         }
         try {
             const result = await sdk.businesses.getBusinessById(businessId);
-            console.log('Business fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33829,7 +33929,6 @@ const useBusiness = () => {
         }
         try {
             const result = await sdk.businesses.getBusinesses();
-            console.log('All businesses fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33843,7 +33942,6 @@ const useBusiness = () => {
         }
         try {
             const result = await sdk.businesses.getBusinessByAccount(accountAddress);
-            console.log('Business by account fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33857,7 +33955,6 @@ const useBusiness = () => {
         }
         try {
             const result = await sdk.businesses.getBusinessesByType(typeId);
-            console.log('Businesses by type fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33886,7 +33983,6 @@ const useBusiness = () => {
         }
         try {
             const result = await sdk.businesses.createBusiness(displayName);
-            console.log('Business created successfully:', result);
             return result;
         }
         catch (error) {
@@ -33900,7 +33996,6 @@ const useBusiness = () => {
         }
         try {
             const result = await sdk.businesses.updateBusiness(businessId, businessData);
-            console.log('Business updated successfully:', result);
             return result;
         }
         catch (error) {
@@ -33914,7 +34009,6 @@ const useBusiness = () => {
         }
         try {
             const result = await sdk.businesses.toggleBusinessStatus(businessId, toggleData);
-            console.log('Business status toggled successfully:', result);
             return result;
         }
         catch (error) {
@@ -33944,7 +34038,6 @@ const useCampaigns = () => {
         }
         try {
             const result = await sdk.campaigns.getActiveCampaigns();
-            console.log('Active campaigns fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33958,7 +34051,6 @@ const useCampaigns = () => {
         }
         try {
             const result = await sdk.campaigns.getCampaignById(campaignId);
-            console.log('Campaign fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33974,9 +34066,7 @@ const useCampaigns = () => {
             throw new Error('SDK not authenticated. claimCampaign requires authentication.');
         }
         try {
-            console.log('Claiming campaign with request:', request);
             const result = await sdk.campaigns.claimCampaign(request);
-            console.log('Campaign claimed successfully:', result);
             return result;
         }
         catch (error) {
@@ -33994,7 +34084,6 @@ const useCampaigns = () => {
         }
         try {
             const result = await sdk.campaigns.getUserClaims();
-            console.log('User claims fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34008,7 +34097,6 @@ const useCampaigns = () => {
         }
         try {
             const result = await sdk.campaigns.getCampaignTriggers();
-            console.log('Campaign triggers fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34023,7 +34111,6 @@ const useCampaigns = () => {
         }
         try {
             const result = await sdk.campaigns.getAllCampaigns(active);
-            console.log('All campaigns fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34037,7 +34124,6 @@ const useCampaigns = () => {
         }
         try {
             const result = await sdk.campaigns.getCampaignClaims();
-            console.log('Campaign claims fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34051,7 +34137,6 @@ const useCampaigns = () => {
         }
         try {
             const result = await sdk.campaigns.getCampaignClaimsByUserId(userId);
-            console.log('Campaign claims by user ID fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34065,7 +34150,6 @@ const useCampaigns = () => {
         }
         try {
             const result = await sdk.campaigns.getCampaignClaimsByBusinessId(businessId);
-            console.log('Campaign claims by business ID fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34089,14 +34173,13 @@ const useCampaigns = () => {
 
 const useRedemptions = () => {
     const { sdk, isInitialized, isAuthenticated } = usePersSDK();
-    const { signAndSubmitTransactionWithJWT, isSignerAvailable } = useTransactionSigner();
+    const { signAndSubmitTransactionWithJWT, isSignerAvailable, currentStatus, statusMessage } = useTransactionSigner();
     const getActiveRedemptions = react.useCallback(async () => {
         if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
             const result = await sdk.redemptions.getActiveRedemptions();
-            console.log('Active redemptions fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34114,7 +34197,6 @@ const useRedemptions = () => {
         }
         try {
             const result = await sdk.redemptions.getUserRedemptions();
-            console.log('User redemptions fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34122,7 +34204,7 @@ const useRedemptions = () => {
             throw error;
         }
     }, [sdk, isInitialized, isAuthenticated]);
-    const redeem = react.useCallback(async (redemptionId) => {
+    const redeem = react.useCallback(async (redemptionId, onStatusUpdate) => {
         if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
@@ -34130,18 +34212,12 @@ const useRedemptions = () => {
             throw new Error('SDK not authenticated. redeem requires authentication.');
         }
         try {
-            console.log('Redeeming redemption:', redemptionId);
             const result = await sdk.redemptions.redeem(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 = await signAndSubmitTransactionWithJWT(txToken);
-                    console.log('Blockchain signing result:', signingResult);
+                    const signingResult = await signAndSubmitTransactionWithJWT(txToken, onStatusUpdate);
                     if (signingResult.success) {
-                        console.log('Transaction signed successfully:', signingResult.transactionHash);
                         // Return enhanced result with signing information
                         return {
                             ...result,
@@ -34179,9 +34255,7 @@ const useRedemptions = () => {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            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) {
@@ -34195,7 +34269,6 @@ const useRedemptions = () => {
         }
         try {
             const result = await sdk.redemptions.getAllRedemptions(active);
-            console.log('All redemptions fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34209,7 +34282,6 @@ const useRedemptions = () => {
         }
         try {
             const result = await sdk.redemptions.getRedemptionTypes();
-            console.log('Redemption types fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34223,7 +34295,6 @@ const useRedemptions = () => {
         }
         try {
             const result = await sdk.redemptions.updateRedemption(redemptionId, redemptionData);
-            console.log('Redemption updated successfully:', result);
             return result;
         }
         catch (error) {
@@ -34237,7 +34308,6 @@ const useRedemptions = () => {
         }
         try {
             const result = await sdk.redemptions.toggleRedemptionStatus(redemptionId);
-            console.log('Redemption status toggled successfully:', result);
             return result;
         }
         catch (error) {
@@ -34255,6 +34325,9 @@ const useRedemptions = () => {
         updateRedemption,
         toggleRedemptionStatus,
         isAvailable: isInitialized && !!sdk?.redemptions,
+        // Expose signing status for UI feedback
+        signingStatus: currentStatus,
+        signingStatusMessage: statusMessage,
     };
 };
 
@@ -34263,56 +34336,53 @@ const useRedemptions = () => {
  *
  * 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.
+ * explorer integration. Supports multi-chain operations.
+ *
+ * Note: Wallet addresses should be obtained from `user.wallets` via `usePersSDK()`.
  *
  * @returns Web3 hook with methods for blockchain operations
  *
  * @example
  * ```typescript
  * function Web3Component() {
- *   const {
- *     getTokenBalance,
- *     getTokenMetadata,
- *     getWalletInfo,
- *     accountAddress
- *   } = useWeb3();
+ *   const { user } = usePersSDK();
+ *   const { getTokenBalance, getTokenMetadata } = useWeb3();
+ *
+ *   // Get wallet address from user
+ *   const walletAddress = user?.wallets?.[0]?.address;
  *
  *   const loadTokenData = async () => {
- *     try {
- *       if (!accountAddress) {
- *         console.log('No wallet connected');
- *         return;
- *       }
+ *     if (!walletAddress) {
+ *       console.log('No wallet connected');
+ *       return;
+ *     }
  *
- *       const balance = await getTokenBalance({
- *         walletAddress: accountAddress,
- *         contractAddress: '0x123...',
- *         chainId: 1
- *       });
+ *     const balance = await getTokenBalance({
+ *       walletAddress,
+ *       contractAddress: '0x123...',
+ *       chainId: 1
+ *     });
  *
- *       console.log('Token balance:', balance);
- *     } catch (error) {
- *       console.error('Failed to load token data:', error);
- *     }
+ *     console.log('Token balance:', balance);
  *   };
  *
  *   return (
- *     <div>
- *       {accountAddress ? (
- *         <div>
- *           <p>Wallet: {accountAddress}</p>
- *           <button onClick={loadTokenData}>Load Tokens</button>
- *         </div>
+ *     <View>
+ *       {walletAddress ? (
+ *         <View>
+ *           <Text>Wallet: {walletAddress}</Text>
+ *           <Button onPress={loadTokenData} title="Load Tokens" />
+ *         </View>
  *       ) : (
- *         <p>No wallet connected</p>
+ *         <Text>No wallet connected</Text>
  *       )}
- *     </div>
+ *     </View>
  *   );
  * }
  * ```
  */
 const useWeb3 = () => {
-    const { sdk, isInitialized, isAuthenticated, accountAddress } = usePersSDK();
+    const { sdk, isInitialized, isAuthenticated } = usePersSDK();
     if (!isAuthenticated && isInitialized) {
         console.warn('SDK not authenticated. Some web3 operations may fail.');
     }
@@ -34336,13 +34406,11 @@ const useWeb3 = () => {
      * ```
      */
     const getTokenBalance = react.useCallback(async (request) => {
-        console.log('[useWeb3] getTokenBalance called with request:', request);
         if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
             const result = await sdk.web3.getTokenBalance(request);
-            console.log('Token balance fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34375,7 +34443,6 @@ const useWeb3 = () => {
         }
         try {
             const result = await sdk.web3.getTokenMetadata(request);
-            console.log('Token metadata fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34389,7 +34456,6 @@ const useWeb3 = () => {
         }
         try {
             const result = await sdk.web3.getTokenCollection(request);
-            console.log('Token collection fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34403,7 +34469,6 @@ const useWeb3 = () => {
         }
         try {
             const result = await sdk.web3.resolveIPFSUrl(url, chainId);
-            console.log('IPFS URL resolved successfully:', result);
             return result;
         }
         catch (error) {
@@ -34417,7 +34482,6 @@ const useWeb3 = () => {
         }
         try {
             const result = await sdk.web3.fetchAndProcessMetadata(tokenUri, chainId);
-            console.log('Metadata fetched and processed successfully:', result);
             return result;
         }
         catch (error) {
@@ -34431,7 +34495,6 @@ const useWeb3 = () => {
         }
         try {
             const result = await sdk.web3.getChainDataById(chainId);
-            console.log('Chain data fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34445,7 +34508,6 @@ const useWeb3 = () => {
         }
         try {
             const result = await sdk.web3.getExplorerUrl(chainId, address, type);
-            console.log('Explorer URL generated successfully:', result);
             return result;
         }
         catch (error) {
@@ -34453,19 +34515,6 @@ const useWeb3 = () => {
             throw error;
         }
     }, [sdk, isInitialized]);
-    const getWalletInfo = react.useCallback(async () => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!accountAddress) {
-            console.warn('No account address available');
-            return null;
-        }
-        return {
-            address: accountAddress,
-            isConnected: !!accountAddress,
-        };
-    }, [isInitialized, accountAddress]);
     return {
         getTokenBalance,
         getTokenMetadata,
@@ -34474,8 +34523,6 @@ const useWeb3 = () => {
         fetchAndProcessMetadata,
         getChainDataById,
         getExplorerUrl,
-        getWalletInfo,
-        accountAddress: isInitialized ? accountAddress : null,
         isAvailable: isInitialized && !!sdk?.web3,
     };
 };
@@ -34488,7 +34535,6 @@ const usePurchases = () => {
         }
         try {
             const result = await sdk.purchases.createPaymentIntent(amount, currency, receiptEmail, description);
-            console.log('Payment intent created successfully:', result);
             return result;
         }
         catch (error) {
@@ -34502,7 +34548,6 @@ const usePurchases = () => {
         }
         try {
             const result = await sdk.purchases.getActivePurchaseTokens();
-            console.log('Active purchase tokens fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34519,7 +34564,6 @@ const usePurchases = () => {
         }
         try {
             const result = await sdk.purchases.getAllUserPurchases();
-            console.log('User purchases fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34556,7 +34600,6 @@ const useTenants = () => {
         }
         try {
             const result = await sdk.tenants.getClientConfig();
-            console.log('Client config fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34570,7 +34613,6 @@ const useTenants = () => {
         }
         try {
             const result = await sdk.tenants.getLoginToken();
-            console.log('Login token fetched successfully');
             return result;
         }
         catch (error) {
@@ -34584,7 +34626,6 @@ const useTenants = () => {
         }
         try {
             const result = await sdk.tenants.getAdmins();
-            console.log('Admins fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34612,7 +34653,6 @@ const useUsers = () => {
         }
         try {
             const result = await sdk.users.getCurrentUser();
-            console.log('Current user fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34629,7 +34669,6 @@ const useUsers = () => {
         }
         try {
             const result = await sdk.users.updateCurrentUser(userData);
-            console.log('Current user updated successfully:', result);
             return result;
         }
         catch (error) {
@@ -34643,7 +34682,6 @@ const useUsers = () => {
         }
         try {
             const result = await sdk.users.getUserById(userId);
-            console.log('User fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34657,7 +34695,6 @@ const useUsers = () => {
         }
         try {
             const result = await sdk.users.getAllUsersPublic(filter);
-            console.log('Public users fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34672,7 +34709,6 @@ const useUsers = () => {
         }
         try {
             const result = await sdk.users.getAllUsers();
-            console.log('All users fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34686,7 +34722,6 @@ const useUsers = () => {
         }
         try {
             const result = await sdk.users.updateUser(userId, userData);
-            console.log('User updated successfully:', result);
             return result;
         }
         catch (error) {
@@ -34700,7 +34735,6 @@ const useUsers = () => {
         }
         try {
             const result = await sdk.users.toggleUserStatus(user);
-            console.log('User status toggled successfully:', result);
             return result;
         }
         catch (error) {
@@ -34728,7 +34762,6 @@ const useUserStatus = () => {
         }
         try {
             const result = await sdk.userStatus.getUserStatusTypes();
-            console.log('User status types fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34745,7 +34778,6 @@ const useUserStatus = () => {
         }
         try {
             const result = await sdk.userStatus.getEarnedUserStatus();
-            console.log('Earned user status fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34760,7 +34792,6 @@ const useUserStatus = () => {
         }
         try {
             const result = await sdk.userStatus.createUserStatusType(userStatusType);
-            console.log('User status type created successfully:', result);
             return result;
         }
         catch (error) {
@@ -34840,7 +34871,6 @@ const useFiles = () => {
         }
         try {
             const result = await sdk.files.getSignedPutUrl(entityId, entityType, fileExtension);
-            console.log('Signed put URL generated successfully:', result);
             return result;
         }
         catch (error) {
@@ -34870,7 +34900,6 @@ const useFiles = () => {
         }
         try {
             const result = await sdk.files.getSignedGetUrl(entityId, entityType, expireSeconds);
-            console.log('Signed get URL generated successfully:', result);
             return result;
         }
         catch (error) {
@@ -34884,7 +34913,6 @@ const useFiles = () => {
         }
         try {
             const result = await sdk.files.getSignedUrl(request);
-            console.log('Signed URL generated successfully:', result);
             return result;
         }
         catch (error) {
@@ -34898,7 +34926,6 @@ const useFiles = () => {
         }
         try {
             const result = await sdk.files.optimizeMedia(url, width, height);
-            console.log('Media optimized successfully:', result);
             return result;
         }
         catch (error) {
@@ -34973,7 +35000,6 @@ const useAnalytics = () => {
         }
         try {
             const result = await sdk.analytics.getTransactionAnalytics(request);
-            console.log('Transaction analytics fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -35034,7 +35060,6 @@ const useDonations = () => {
         }
         try {
             const result = await sdk.donations.getDonationTypes();
-            console.log('Donation types fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -35056,6 +35081,7 @@ exports.PersSDKProvider = PersSDKProvider;
 exports.ReactNativeDPoPProvider = ReactNativeDPoPProvider;
 exports.ReactNativeHttpClient = ReactNativeHttpClient;
 exports.ReactNativeSecureStorage = ReactNativeSecureStorage;
+exports.SigningStatus = SigningStatus;
 exports.TRANSACTION_FORMATS = TRANSACTION_FORMATS;
 exports.TRANSACTION_FORMAT_DESCRIPTIONS = TRANSACTION_FORMAT_DESCRIPTIONS;
 exports.apiPublicKeyTestPrefix = apiPublicKeyTestPrefix;