@explorins/pers-sdk-react-native 1.5.31 → 1.5.33

package/dist/index.js

@@ -22507,21 +22507,115 @@ const getTokenOfOwnerByIndex = async (tokenContract, ownerAddress, index) => {
 };
 
 /**
- * Clean an ABI to be compatible with Ethers.js
- * Removes 'indexed' property from function inputs (only valid for events)
+ * Clean input/output parameters for functions, constructors, errors
+ * Removes properties that are invalid for non-event parameters
+ */
+function cleanInputsOrOutputs(params) {
+    if (!Array.isArray(params)) {
+        return [];
+    }
+    return params.map((param) => {
+        if (!param || typeof param !== 'object') {
+            return param;
+        }
+        const cleanParam = {
+            name: param.name ?? '',
+            type: param.type ?? 'uint256', // Default to uint256 if type is missing (shouldn't happen)
+        };
+        // Handle tuple types with components
+        if (param.components && Array.isArray(param.components)) {
+            cleanParam.components = cleanInputsOrOutputs(param.components);
+        }
+        // Preserve internalType only if it doesn't cause issues
+        // (some malformed internalTypes can break ethers)
+        if (param.internalType && typeof param.internalType === 'string') {
+            cleanParam.internalType = param.internalType;
+        }
+        // NOTE: 'indexed' is intentionally NOT included here
+        // It's only valid for event parameters
+        return cleanParam;
+    });
+}
+/**
+ * Clean an ABI to be compatible with Ethers.js v6
+ * Handles common Web3.js ABI format incompatibilities:
+ * - Removes 'indexed' from function inputs (only valid for event parameters)
+ * - Removes 'indexed' from function outputs
+ * - Removes 'internalType' if it causes parsing issues
+ * - Ensures 'stateMutability' is valid
+ * - Removes unknown/invalid properties that cause ethers to drop fragments
  */
 function cleanABI(abi) {
     return abi.map(fragment => {
-        if (fragment.type === 'function' && fragment.inputs) {
-            return {
-                ...fragment,
-                inputs: fragment.inputs.map((input) => {
-                    const { indexed, ...cleanInput } = input;
-                    return cleanInput;
-                })
-            };
+        // Skip non-object fragments
+        if (!fragment || typeof fragment !== 'object') {
+            return fragment;
         }
-        return fragment;
+        const cleanFragment = {
+            type: fragment.type,
+            name: fragment.name,
+        };
+        // Handle functions
+        if (fragment.type === 'function') {
+            // Clean inputs - remove 'indexed' (only valid for events)
+            if (fragment.inputs) {
+                cleanFragment.inputs = cleanInputsOrOutputs(fragment.inputs);
+            }
+            // Clean outputs - remove 'indexed'
+            if (fragment.outputs) {
+                cleanFragment.outputs = cleanInputsOrOutputs(fragment.outputs);
+            }
+            // Preserve valid function properties
+            if (fragment.stateMutability) {
+                cleanFragment.stateMutability = fragment.stateMutability;
+            }
+            // Handle legacy 'constant' and 'payable' for older ABIs
+            if (fragment.constant !== undefined && !fragment.stateMutability) {
+                cleanFragment.stateMutability = fragment.constant ? 'view' : 'nonpayable';
+            }
+            if (fragment.payable && !fragment.stateMutability) {
+                cleanFragment.stateMutability = 'payable';
+            }
+        }
+        // Handle events - 'indexed' IS valid here
+        else if (fragment.type === 'event') {
+            cleanFragment.anonymous = fragment.anonymous ?? false;
+            if (fragment.inputs) {
+                cleanFragment.inputs = fragment.inputs.map((input) => ({
+                    name: input.name ?? '',
+                    type: input.type,
+                    indexed: input.indexed ?? false,
+                    // Keep internalType for events if present
+                    ...(input.internalType && { internalType: input.internalType })
+                }));
+            }
+        }
+        // Handle constructor
+        else if (fragment.type === 'constructor') {
+            if (fragment.inputs) {
+                cleanFragment.inputs = cleanInputsOrOutputs(fragment.inputs);
+            }
+            if (fragment.stateMutability) {
+                cleanFragment.stateMutability = fragment.stateMutability;
+            }
+        }
+        // Handle fallback/receive
+        else if (fragment.type === 'fallback' || fragment.type === 'receive') {
+            if (fragment.stateMutability) {
+                cleanFragment.stateMutability = fragment.stateMutability;
+            }
+        }
+        // Handle errors
+        else if (fragment.type === 'error') {
+            if (fragment.inputs) {
+                cleanFragment.inputs = cleanInputsOrOutputs(fragment.inputs);
+            }
+        }
+        // Pass through unknown types unchanged
+        else {
+            return fragment;
+        }
+        return cleanFragment;
     });
 }
 /**
@@ -22553,24 +22647,45 @@ function convertAbiToInterface(abi) {
             return abi;
         }
         // String format (JSON)
+        let abiArray;
         if (typeof abi === 'string') {
-            const parsedAbi = JSON.parse(abi);
-            const cleanedAbi = Array.isArray(parsedAbi) ? cleanABI(parsedAbi) : parsedAbi;
-            return new Interface(cleanedAbi);
+            abiArray = JSON.parse(abi);
+        }
+        else if (Array.isArray(abi)) {
+            abiArray = abi;
         }
-        // Array or object format
-        if (Array.isArray(abi) || typeof abi === 'object') {
-            const cleanedAbi = Array.isArray(abi) ? cleanABI(abi) : abi;
-            return new Interface(cleanedAbi);
+        else if (typeof abi === 'object') {
+            // Single fragment object
+            abiArray = [abi];
         }
-        throw new Error(`Unsupported ABI type: ${typeof abi}`);
+        else {
+            throw new Error(`Unsupported ABI type: ${typeof abi}`);
+        }
+        // Clean the ABI
+        const cleanedAbi = cleanABI(abiArray);
+        // Try to create Interface and validate all fragments were parsed
+        const iface = new Interface(cleanedAbi);
+        // Validation: Check if expected functions are present
+        const expectedFunctions = cleanedAbi
+            .filter((f) => f.type === 'function')
+            .map((f) => f.name);
+        const actualFunctions = iface.fragments
+            .filter(f => f.type === 'function')
+            .map(f => f.name);
+        const droppedFunctions = expectedFunctions.filter((name) => !actualFunctions.includes(name));
+        if (droppedFunctions.length > 0) {
+            console.warn(`[web3-ts] Warning: ${droppedFunctions.length} function(s) were dropped during ABI conversion:`, droppedFunctions.join(', '));
+        }
+        return iface;
     }
     catch (error) {
         if (error.message.includes('JSON')) {
             throw new Error('Invalid JSON format in ABI string');
         }
-        if (error.message.includes('invalid fragment') || error.message.includes('parameter cannot be indexed')) {
-            throw new Error('Invalid ABI fragment structure - function inputs cannot be indexed');
+        if (error.message.includes('invalid fragment') ||
+            error.message.includes('parameter cannot be indexed')) {
+            console.error('[web3-ts] ABI fragment error:', error.message);
+            throw new Error(`Invalid ABI fragment structure: ${error.message}`);
         }
         throw error;
     }
@@ -23974,7 +24089,7 @@ class CampaignApi {
      * NEW: GET /trigger-sources
      */
     async getCampaignTriggers(options) {
-        let url = '/trigger-sources';
+        let url = '/campaign-triggers';
         const params = [];
         if (options) {
             if (options.limit)
@@ -25402,6 +25517,17 @@ class IPFSInfrastructureApi {
         }
         return url;
     }
+    /**
+     * Fetch metadata from tokenURI, resolve all IPFS URLs, and normalize to SDK format.
+     *
+     * NORMALIZATION BOUNDARY: This is the single place where ERC metadata standard
+     * (snake_case: image, animation_url) is converted to SDK format (camelCase: imageUrl, animationUrl).
+     * All downstream consumers receive normalized SDK format with resolved HTTPS URLs.
+     *
+     * @param tokenUri - Token URI (can be ipfs:// or https://)
+     * @param chainId - Chain ID for IPFS gateway selection
+     * @returns Normalized TokenMetadata with resolved HTTPS URLs, or null on error
+     */
     async fetchAndProcessMetadata(tokenUri, chainId) {
         try {
             const resolvedUri = await this.resolveIPFSUrl(tokenUri, chainId);
@@ -25409,15 +25535,25 @@ class IPFSInfrastructureApi {
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${response.status}`);
             }
-            const metadata = await response.json();
-            // Process and return clean metadata
+            const rawMetadata = await response.json();
+            // Resolve IPFS URLs for media fields
+            const resolvedImageUrl = rawMetadata.image
+                ? await this.resolveIPFSUrl(rawMetadata.image, chainId)
+                : '';
+            const resolvedAnimationUrl = rawMetadata.animation_url
+                ? await this.resolveIPFSUrl(rawMetadata.animation_url, chainId)
+                : undefined;
+            // Extract custom properties (anything not in ERC standard)
+            const customProperties = Object.fromEntries(Object.entries(rawMetadata).filter(([key]) => !['name', 'description', 'image', 'animation_url', 'external_url', 'attributes'].includes(key)));
+            // Return normalized SDK format (typed as TokenMetadata)
             return {
-                name: metadata.name || '',
-                description: metadata.description || '',
-                image: metadata.image ? await this.resolveIPFSUrl(metadata.image, chainId) : '',
-                attributes: metadata.attributes || [],
-                animation_url: metadata.animation_url ? await this.resolveIPFSUrl(metadata.animation_url, chainId) : undefined,
-                external_url: metadata.external_url || undefined
+                name: rawMetadata.name || '',
+                description: rawMetadata.description || '',
+                imageUrl: resolvedImageUrl,
+                animationUrl: resolvedAnimationUrl,
+                externalUrl: rawMetadata.external_url || undefined,
+                attributes: rawMetadata.attributes || [],
+                ...customProperties
             };
         }
         catch (error) {
@@ -25701,8 +25837,8 @@ class MetadataDomainService {
 class ContractDomainService {
     constructor() { }
     analyzeContract(abi) {
-        abi = convertAbiToInterface(abi);
-        const methods = abi.fragments.filter(item => item.type === 'function').map(item => item.name);
+        const cleanAbi = convertAbiToInterface(abi);
+        const methods = cleanAbi.fragments.filter(item => item.type === 'function').map(item => item.name);
         // ERC-721 detection
         const hasOwnerOf = methods.includes('ownerOf');
         const hasTokenURI = methods.includes('tokenURI');
@@ -25733,28 +25869,6 @@ class ContractDomainService {
  */
 class Web3ApplicationService {
     constructor(web3Api, ipfsApi) {
-        // Type-safe metadata conversion methods for ERC-721/ERC-1155 standards
-        this.metadataMapper = {
-            fromERCStandard: (ercMetadata) => ({
-                name: ercMetadata.name || '',
-                description: ercMetadata.description || '',
-                imageUrl: ercMetadata.image || '',
-                externalUrl: ercMetadata.external_url,
-                animationUrl: ercMetadata.animation_url,
-                animationUrlConverted: undefined, // Will be set by IPFS conversion
-                attributes: ercMetadata.attributes || [],
-                ...ercMetadata
-            }),
-            toERCStandard: (metadata) => ({
-                name: metadata.name,
-                description: metadata.description,
-                image: metadata.imageUrl,
-                animation_url: metadata.animationUrl,
-                external_url: metadata.externalUrl,
-                attributes: metadata.attributes,
-                ...Object.fromEntries(Object.entries(metadata).filter(([key]) => !['name', 'description', 'imageUrl', 'animationUrl', 'externalUrl', 'attributes', 'animationUrlConverted'].includes(key)))
-            })
-        };
         // Create domain services with injected infrastructure dependencies
         this.contractDomainService = new ContractDomainService();
         this.metadataDomainService = new MetadataDomainService(ipfsApi);
@@ -25773,7 +25887,15 @@ class Web3ApplicationService {
         });
     }
     /**
-     * Get metadata for a specific token from on-chain
+     * Get metadata for a specific token from on-chain.
+     *
+     * Returns metadata with:
+     * - Normalized property names (imageUrl, animationUrl - SDK standard)
+     * - All IPFS URLs already resolved to HTTPS
+     * - Custom properties preserved from original metadata
+     *
+     * Note: Normalization happens at infrastructure layer (IPFS API),
+     * so no additional transformation needed here.
      */
     async getTokenMetadata(request) {
         const domainResult = await this.tokenDomainService.getTokenMetadata({
@@ -25782,6 +25904,7 @@ class Web3ApplicationService {
             tokenId: request.tokenId || '',
             chainId: request.chainId
         });
+        // Metadata is already normalized at infrastructure layer
         return domainResult.metadata;
     }
     /**
@@ -25804,22 +25927,13 @@ class Web3ApplicationService {
         return this.metadataDomainService.resolveIPFSUrl(url, chainId);
     }
     /**
-     * Fetch and process metadata from URI with IPFS conversion
+     * Fetch and process metadata from any URI with IPFS conversion.
+     *
+     * Use this for ad-hoc metadata fetching when you have a tokenURI.
+     * Normalization happens at infrastructure layer.
      */
     async fetchAndProcessMetadata(tokenUri, chainId) {
-        const domainMetadata = await this.metadataDomainService.fetchAndProcessMetadata(tokenUri, chainId);
-        if (!domainMetadata)
-            return null;
-        // Convert from ERC token standard to our clean interface
-        const cleanMetadata = this.metadataMapper.fromERCStandard(domainMetadata);
-        // Add IPFS conversion if needed
-        if (cleanMetadata.animationUrl?.startsWith('ipfs://')) {
-            return {
-                ...cleanMetadata,
-                animationUrlConverted: await this.resolveIPFSUrl(cleanMetadata.animationUrl, chainId)
-            };
-        }
-        return cleanMetadata;
+        return this.metadataDomainService.fetchAndProcessMetadata(tokenUri, chainId);
     }
 }
 
@@ -32044,6 +32158,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 +32297,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 +32318,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 +32343,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 +32352,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 +32373,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 +32393,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);
@@ -32238,119 +32462,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') {
@@ -32363,7 +32474,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'); }
     };
@@ -32372,26 +32482,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);
+                }
             });
         });
     }
@@ -32412,21 +32535,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 ---
@@ -32434,7 +32573,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, '')
@@ -32548,7 +32686,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) {
@@ -32610,9 +32747,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 () => {
@@ -32628,7 +32764,7 @@ const PersSDKProvider = ({ children, config }) => {
             throw error;
         }
     }, [sdk, isAuthenticated, isInitialized]);
-    const contextValue = {
+    const contextValue = react.useMemo(() => ({
         // Main SDK instance
         sdk,
         // Manager shortcuts for convenience
@@ -32643,20 +32779,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
@@ -32706,7 +32848,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
      *
@@ -32727,18 +32869,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 {
@@ -32767,7 +32904,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
@@ -32776,11 +32912,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');
@@ -32805,12 +32937,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);
@@ -32891,7 +33021,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)
@@ -32916,7 +33046,6 @@ const useAuth = () => {
         isInitialized,
         isAuthenticated,
         user,
-        accountAddress,
         // Methods
         login,
         loginWithRawData,
@@ -32982,7 +33111,6 @@ const useTokens = () => {
         }
         try {
             const result = await sdk.tokens.getTokens();
-            console.log('Tokens fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33009,7 +33137,6 @@ const useTokens = () => {
         }
         try {
             const result = await sdk.tokens.getActiveCreditToken();
-            console.log('Active credit token fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33036,7 +33163,6 @@ const useTokens = () => {
         }
         try {
             const result = await sdk.tokens.getRewardTokens();
-            console.log('Reward tokens fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33063,7 +33189,6 @@ const useTokens = () => {
         }
         try {
             const result = await sdk.tokens.getTokenTypes();
-            console.log('Token types fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33090,7 +33215,6 @@ const useTokens = () => {
         }
         try {
             const result = await sdk.tokens.getStatusTokens();
-            console.log('Status tokens fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33119,7 +33243,6 @@ const useTokens = () => {
         }
         try {
             const result = await sdk.tokens.getTokenByContract(contractAddress, contractTokenId);
-            console.log('Token by contract fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33138,6 +33261,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 {
@@ -33330,6 +33492,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(() => {
@@ -33378,6 +33542,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
@@ -33400,6 +33565,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 {
@@ -33434,20 +33608,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]);
@@ -33459,6 +33643,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,
@@ -33504,6 +33689,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,
     };
 };
 
@@ -33545,7 +33760,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.');
     }
@@ -33567,29 +33782,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
@@ -33634,7 +33849,6 @@ const useTransactions = () => {
         }
         try {
             const result = await sdk.transactions.getTransactionById(transactionId);
-            console.log('Transaction fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33662,7 +33876,6 @@ const useTransactions = () => {
         }
         try {
             const result = await sdk.transactions.getUserTransactionHistory(role);
-            console.log('Transaction history fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33689,7 +33902,6 @@ const useTransactions = () => {
         }
         try {
             const result = await sdk.transactions.getPaginatedTransactions(params);
-            console.log('Paginated transactions fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33703,7 +33915,6 @@ const useTransactions = () => {
         }
         try {
             const result = await sdk.transactions.exportTransactionsCSV();
-            console.log('Transactions CSV exported successfully');
             return result;
         }
         catch (error) {
@@ -33719,6 +33930,9 @@ const useTransactions = () => {
         getPaginatedTransactions,
         exportTransactionsCSV,
         isAvailable: isInitialized && !!sdk?.transactions,
+        // Expose signing status for UI feedback
+        signingStatus: currentStatus,
+        signingStatusMessage: statusMessage,
     };
 };
 
@@ -33777,7 +33991,6 @@ const useBusiness = () => {
         }
         try {
             const result = await sdk.businesses.getActiveBusinesses();
-            console.log('Active businesses fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33804,7 +34017,6 @@ const useBusiness = () => {
         }
         try {
             const result = await sdk.businesses.getBusinessTypes();
-            console.log('Business types fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33818,7 +34030,6 @@ const useBusiness = () => {
         }
         try {
             const result = await sdk.businesses.getBusinessById(businessId);
-            console.log('Business fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33832,7 +34043,6 @@ const useBusiness = () => {
         }
         try {
             const result = await sdk.businesses.getBusinesses();
-            console.log('All businesses fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33846,7 +34056,6 @@ const useBusiness = () => {
         }
         try {
             const result = await sdk.businesses.getBusinessByAccount(accountAddress);
-            console.log('Business by account fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33860,7 +34069,6 @@ const useBusiness = () => {
         }
         try {
             const result = await sdk.businesses.getBusinessesByType(typeId);
-            console.log('Businesses by type fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33889,7 +34097,6 @@ const useBusiness = () => {
         }
         try {
             const result = await sdk.businesses.createBusiness(displayName);
-            console.log('Business created successfully:', result);
             return result;
         }
         catch (error) {
@@ -33903,7 +34110,6 @@ const useBusiness = () => {
         }
         try {
             const result = await sdk.businesses.updateBusiness(businessId, businessData);
-            console.log('Business updated successfully:', result);
             return result;
         }
         catch (error) {
@@ -33917,7 +34123,6 @@ const useBusiness = () => {
         }
         try {
             const result = await sdk.businesses.toggleBusinessStatus(businessId, toggleData);
-            console.log('Business status toggled successfully:', result);
             return result;
         }
         catch (error) {
@@ -33947,7 +34152,6 @@ const useCampaigns = () => {
         }
         try {
             const result = await sdk.campaigns.getActiveCampaigns();
-            console.log('Active campaigns fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33961,7 +34165,6 @@ const useCampaigns = () => {
         }
         try {
             const result = await sdk.campaigns.getCampaignById(campaignId);
-            console.log('Campaign fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -33977,9 +34180,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) {
@@ -33997,7 +34198,6 @@ const useCampaigns = () => {
         }
         try {
             const result = await sdk.campaigns.getUserClaims();
-            console.log('User claims fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34011,7 +34211,6 @@ const useCampaigns = () => {
         }
         try {
             const result = await sdk.campaigns.getCampaignTriggers();
-            console.log('Campaign triggers fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34026,7 +34225,6 @@ const useCampaigns = () => {
         }
         try {
             const result = await sdk.campaigns.getAllCampaigns(active);
-            console.log('All campaigns fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34040,7 +34238,6 @@ const useCampaigns = () => {
         }
         try {
             const result = await sdk.campaigns.getCampaignClaims();
-            console.log('Campaign claims fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34054,7 +34251,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) {
@@ -34068,7 +34264,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) {
@@ -34092,14 +34287,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) {
@@ -34117,7 +34311,6 @@ const useRedemptions = () => {
         }
         try {
             const result = await sdk.redemptions.getUserRedemptions();
-            console.log('User redemptions fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34125,7 +34318,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.');
         }
@@ -34133,18 +34326,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,
@@ -34182,9 +34369,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) {
@@ -34198,7 +34383,6 @@ const useRedemptions = () => {
         }
         try {
             const result = await sdk.redemptions.getAllRedemptions(active);
-            console.log('All redemptions fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34212,7 +34396,6 @@ const useRedemptions = () => {
         }
         try {
             const result = await sdk.redemptions.getRedemptionTypes();
-            console.log('Redemption types fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34226,7 +34409,6 @@ const useRedemptions = () => {
         }
         try {
             const result = await sdk.redemptions.updateRedemption(redemptionId, redemptionData);
-            console.log('Redemption updated successfully:', result);
             return result;
         }
         catch (error) {
@@ -34240,7 +34422,6 @@ const useRedemptions = () => {
         }
         try {
             const result = await sdk.redemptions.toggleRedemptionStatus(redemptionId);
-            console.log('Redemption status toggled successfully:', result);
             return result;
         }
         catch (error) {
@@ -34258,6 +34439,9 @@ const useRedemptions = () => {
         updateRedemption,
         toggleRedemptionStatus,
         isAvailable: isInitialized && !!sdk?.redemptions,
+        // Expose signing status for UI feedback
+        signingStatus: currentStatus,
+        signingStatusMessage: statusMessage,
     };
 };
 
@@ -34266,56 +34450,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.');
     }
@@ -34339,13 +34520,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) {
@@ -34369,7 +34548,7 @@ const useWeb3 = () => {
      *   chainId: 1
      * });
      * console.log('NFT name:', metadata?.name);
-     * console.log('NFT image:', metadata?.image);
+     * console.log('NFT image:', metadata?.imageUrl); // IPFS URLs auto-resolved to HTTPS
      * ```
      */
     const getTokenMetadata = react.useCallback(async (request) => {
@@ -34378,7 +34557,6 @@ const useWeb3 = () => {
         }
         try {
             const result = await sdk.web3.getTokenMetadata(request);
-            console.log('Token metadata fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34392,7 +34570,6 @@ const useWeb3 = () => {
         }
         try {
             const result = await sdk.web3.getTokenCollection(request);
-            console.log('Token collection fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34406,7 +34583,6 @@ const useWeb3 = () => {
         }
         try {
             const result = await sdk.web3.resolveIPFSUrl(url, chainId);
-            console.log('IPFS URL resolved successfully:', result);
             return result;
         }
         catch (error) {
@@ -34420,7 +34596,6 @@ const useWeb3 = () => {
         }
         try {
             const result = await sdk.web3.fetchAndProcessMetadata(tokenUri, chainId);
-            console.log('Metadata fetched and processed successfully:', result);
             return result;
         }
         catch (error) {
@@ -34434,7 +34609,6 @@ const useWeb3 = () => {
         }
         try {
             const result = await sdk.web3.getChainDataById(chainId);
-            console.log('Chain data fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34448,7 +34622,6 @@ const useWeb3 = () => {
         }
         try {
             const result = await sdk.web3.getExplorerUrl(chainId, address, type);
-            console.log('Explorer URL generated successfully:', result);
             return result;
         }
         catch (error) {
@@ -34456,19 +34629,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,
@@ -34477,8 +34637,6 @@ const useWeb3 = () => {
         fetchAndProcessMetadata,
         getChainDataById,
         getExplorerUrl,
-        getWalletInfo,
-        accountAddress: isInitialized ? accountAddress : null,
         isAvailable: isInitialized && !!sdk?.web3,
     };
 };
@@ -34491,7 +34649,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) {
@@ -34505,7 +34662,6 @@ const usePurchases = () => {
         }
         try {
             const result = await sdk.purchases.getActivePurchaseTokens();
-            console.log('Active purchase tokens fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34522,7 +34678,6 @@ const usePurchases = () => {
         }
         try {
             const result = await sdk.purchases.getAllUserPurchases();
-            console.log('User purchases fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34559,7 +34714,6 @@ const useTenants = () => {
         }
         try {
             const result = await sdk.tenants.getClientConfig();
-            console.log('Client config fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34573,7 +34727,6 @@ const useTenants = () => {
         }
         try {
             const result = await sdk.tenants.getLoginToken();
-            console.log('Login token fetched successfully');
             return result;
         }
         catch (error) {
@@ -34587,7 +34740,6 @@ const useTenants = () => {
         }
         try {
             const result = await sdk.tenants.getAdmins();
-            console.log('Admins fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34615,7 +34767,6 @@ const useUsers = () => {
         }
         try {
             const result = await sdk.users.getCurrentUser();
-            console.log('Current user fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34632,7 +34783,6 @@ const useUsers = () => {
         }
         try {
             const result = await sdk.users.updateCurrentUser(userData);
-            console.log('Current user updated successfully:', result);
             return result;
         }
         catch (error) {
@@ -34646,7 +34796,6 @@ const useUsers = () => {
         }
         try {
             const result = await sdk.users.getUserById(userId);
-            console.log('User fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34660,7 +34809,6 @@ const useUsers = () => {
         }
         try {
             const result = await sdk.users.getAllUsersPublic(filter);
-            console.log('Public users fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34675,7 +34823,6 @@ const useUsers = () => {
         }
         try {
             const result = await sdk.users.getAllUsers();
-            console.log('All users fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34689,7 +34836,6 @@ const useUsers = () => {
         }
         try {
             const result = await sdk.users.updateUser(userId, userData);
-            console.log('User updated successfully:', result);
             return result;
         }
         catch (error) {
@@ -34703,7 +34849,6 @@ const useUsers = () => {
         }
         try {
             const result = await sdk.users.toggleUserStatus(user);
-            console.log('User status toggled successfully:', result);
             return result;
         }
         catch (error) {
@@ -34731,7 +34876,6 @@ const useUserStatus = () => {
         }
         try {
             const result = await sdk.userStatus.getUserStatusTypes();
-            console.log('User status types fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34748,7 +34892,6 @@ const useUserStatus = () => {
         }
         try {
             const result = await sdk.userStatus.getEarnedUserStatus();
-            console.log('Earned user status fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -34763,7 +34906,6 @@ const useUserStatus = () => {
         }
         try {
             const result = await sdk.userStatus.createUserStatusType(userStatusType);
-            console.log('User status type created successfully:', result);
             return result;
         }
         catch (error) {
@@ -34843,7 +34985,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) {
@@ -34873,7 +35014,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) {
@@ -34887,7 +35027,6 @@ const useFiles = () => {
         }
         try {
             const result = await sdk.files.getSignedUrl(request);
-            console.log('Signed URL generated successfully:', result);
             return result;
         }
         catch (error) {
@@ -34901,7 +35040,6 @@ const useFiles = () => {
         }
         try {
             const result = await sdk.files.optimizeMedia(url, width, height);
-            console.log('Media optimized successfully:', result);
             return result;
         }
         catch (error) {
@@ -34976,7 +35114,6 @@ const useAnalytics = () => {
         }
         try {
             const result = await sdk.analytics.getTransactionAnalytics(request);
-            console.log('Transaction analytics fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -35037,7 +35174,6 @@ const useDonations = () => {
         }
         try {
             const result = await sdk.donations.getDonationTypes();
-            console.log('Donation types fetched successfully:', result);
             return result;
         }
         catch (error) {
@@ -35059,6 +35195,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;