@explorins/pers-sdk-react-native 2.1.20 → 2.1.22

package/dist/index.js

@@ -3717,6 +3717,109 @@ const TRANSACTION_FORMAT_DESCRIPTIONS = {
     [TRANSACTION_FORMATS.EIP_712]: 'EIP-712 structured data for smart wallet meta-transactions'
 };
 
+/**
+ * Error Codes extracted from actual domain error classes
+ *
+ * This object maps all error codes from domain error classes to provide
+ * type-safe constants for API documentation and usage.
+ *
+ * Using object pattern for better performance and developer experience:
+ * - Single export vs 50+ individual exports
+ * - Namespaced access: CommonErrorCodes.USER_NOT_FOUND
+ * - Better tree-shaking and bundle optimization
+ * - Cleaner type definition
+ */
+const CommonErrorCodes = {
+    // User domain
+    USER_NOT_FOUND: 'USER_NOT_FOUND',
+    USER_ALREADY_EXISTS: 'USER_ALREADY_EXISTS',
+    USER_NOT_AUTHORIZED: 'USER_NOT_AUTHORIZED',
+    // Token domain
+    TOKEN_NOT_FOUND: 'TOKEN_NOT_FOUND',
+    TOKEN_NOT_ACTIVE: 'TOKEN_NOT_ACTIVE',
+    TOKEN_ID_REQUIRED: 'TOKEN_ID_REQUIRED',
+    TOKEN_TYPE_NOT_FOUND: 'TOKEN_TYPE_NOT_FOUND',
+    // Wallet domain
+    WALLET_MISSING_SIGNING: 'WALLET_MISSING_SIGNING',
+    WALLET_NOT_FOUND: 'WALLET_NOT_FOUND',
+    SMART_WALLET_PROCESSING_FAILED: 'SMART_WALLET_PROCESSING_FAILED',
+    // Balance domain
+    INSUFFICIENT_BALANCE: 'INSUFFICIENT_BALANCE',
+    // Contract domain
+    CONTRACT_NOT_FOUND: 'CONTRACT_NOT_FOUND',
+    // Business domain
+    BUSINESS_NOT_FOUND: 'BUSINESS_NOT_FOUND',
+    BUSINESS_NOT_MINTER: 'BUSINESS_NOT_MINTER',
+    // Membership domain
+    MEMBERSHIP_NOT_FOUND: 'MEMBERSHIP_NOT_FOUND',
+    MEMBERSHIP_ALREADY_EXISTS: 'MEMBERSHIP_ALREADY_EXISTS',
+    MEMBERSHIP_LAST_OWNER: 'MEMBERSHIP_LAST_OWNER',
+    // Transaction domain
+    TRANSACTION_NOT_FOUND: 'TRANSACTION_NOT_FOUND',
+    TRANSACTION_SIGNATURE_INVALID: 'TRANSACTION_SIGNATURE_INVALID',
+    TRANSACTION_ALREADY_COMPLETED: 'TRANSACTION_ALREADY_COMPLETED',
+    TRANSACTION_NOT_PENDING: 'TRANSACTION_NOT_PENDING',
+    TRANSACTION_EXPIRED: 'TRANSACTION_EXPIRED',
+    TRANSACTION_VALIDATION_ERROR: 'TRANSACTION_VALIDATION_ERROR',
+    UNEXPECTED_VALIDATION_SCENARIO: 'UNEXPECTED_VALIDATION_SCENARIO',
+    // Campaign domain
+    CAMPAIGN_USER_INFO_REQUIRED: 'CAMPAIGN_USER_INFO_REQUIRED',
+    CAMPAIGN_BUSINESS_REQUIRED: 'CAMPAIGN_BUSINESS_REQUIRED',
+    CAMPAIGN_CONDITION_NOT_MET: 'CAMPAIGN_CONDITION_NOT_MET',
+    CAMPAIGN_ALREADY_CLAIMED: 'CAMPAIGN_ALREADY_CLAIMED',
+    CAMPAIGN_NO_TRIGGER: 'CAMPAIGN_NO_TRIGGER',
+    CAMPAIGN_LOCATION_REQUIRED: 'CAMPAIGN_LOCATION_REQUIRED',
+    CAMPAIGN_DISTANCE_EXCEEDED: 'CAMPAIGN_DISTANCE_EXCEEDED',
+    CAMPAIGN_NOT_ACTIVE: 'CAMPAIGN_NOT_ACTIVE',
+    CAMPAIGN_ENDED: 'CAMPAIGN_ENDED',
+    CAMPAIGN_NOT_STARTED: 'CAMPAIGN_NOT_STARTED',
+    CAMPAIGN_CLAIM_LIMIT_REACHED: 'CAMPAIGN_CLAIM_LIMIT_REACHED',
+    CAMPAIGN_COOLDOWN_ACTIVE: 'CAMPAIGN_COOLDOWN_ACTIVE',
+    CAMPAIGN_DAILY_LIMIT_REACHED: 'CAMPAIGN_DAILY_LIMIT_REACHED',
+    CAMPAIGN_GLOBAL_LIMIT_REACHED: 'CAMPAIGN_GLOBAL_LIMIT_REACHED',
+    CAMPAIGN_GLOBAL_DAILY_LIMIT_REACHED: 'CAMPAIGN_GLOBAL_DAILY_LIMIT_REACHED',
+    // Trigger domain
+    TRIGGER_NOT_FOUND: 'TRIGGER_NOT_FOUND',
+    // Trigger Source domain
+    TRIGGER_SOURCE_NOT_FOUND: 'TRIGGER_SOURCE_NOT_FOUND',
+    // Generic domain errors
+    RESOURCE_ALREADY_EXISTS: 'RESOURCE_ALREADY_EXISTS',
+    RESOURCE_IN_USE: 'RESOURCE_IN_USE',
+    // Technical errors
+    TECHNICAL_ERROR: 'TECHNICAL_ERROR',
+    ORCHESTRATION_ERROR: 'ORCHESTRATION_ERROR',
+    // System errors
+    SYSTEM_ERROR: 'SYSTEM_ERROR',
+    EXTERNAL_SERVICE_ERROR: 'EXTERNAL_SERVICE_ERROR',
+    AUTHENTICATION_REQUIRED: 'AUTHENTICATION_REQUIRED',
+    AUTHORIZATION_FAILED: 'AUTHORIZATION_FAILED',
+    // Authentication errors
+    INVALID_TOKEN: 'INVALID_TOKEN',
+    TOKEN_EXPIRED: 'TOKEN_EXPIRED',
+    TOKEN_REVOKED: 'TOKEN_REVOKED',
+    REFRESH_TOKEN_EXPIRED: 'REFRESH_TOKEN_EXPIRED',
+    REFRESH_TOKEN_REVOKED: 'REFRESH_TOKEN_REVOKED',
+    FIREBASE_AUTH_ERROR: 'FIREBASE_AUTH_ERROR',
+    // Generic fallbacks
+    INTERNAL_ERROR: 'INTERNAL_ERROR',
+    VALIDATION_ERROR: 'VALIDATION_ERROR',
+    BUSINESS_RULE_VIOLATION: 'BUSINESS_RULE_VIOLATION',
+    RESOURCE_NOT_FOUND: 'RESOURCE_NOT_FOUND',
+    // Webhook domain
+    WEBHOOK_NOT_FOUND: 'WEBHOOK_NOT_FOUND',
+    WEBHOOK_INACTIVE: 'WEBHOOK_INACTIVE',
+    WEBHOOK_SOURCE_NOT_ALLOWED: 'WEBHOOK_SOURCE_NOT_ALLOWED',
+    WEBHOOK_SIGNATURE_INVALID: 'WEBHOOK_SIGNATURE_INVALID',
+    WEBHOOK_FORWARD_FAILED: 'WEBHOOK_FORWARD_FAILED',
+    WEBHOOK_TIMEOUT: 'WEBHOOK_TIMEOUT',
+    // Conflict errors (409)
+    RESOURCE_CONFLICT: 'RESOURCE_CONFLICT',
+    CONCURRENT_MODIFICATION: 'CONCURRENT_MODIFICATION',
+    // Timeout errors (504)
+    REQUEST_TIMEOUT: 'REQUEST_TIMEOUT',
+    GATEWAY_TIMEOUT: 'GATEWAY_TIMEOUT'
+};
+
 /**
  * JWT token expiration utilities
  * Native implementation without external dependencies for optimal performance
@@ -6817,6 +6920,22 @@ class RedemptionApi {
     async createRedemptionType(redemptionType) {
         return this.apiClient.post(this.typesPath, redemptionType);
     }
+    /**
+     * ADMIN: Update redemption type
+     *
+     * @param redemptionType - Updated redemption type data (must include id)
+     */
+    async updateRedemptionType(redemptionType) {
+        return this.apiClient.put(`${this.typesPath}/${redemptionType.id}`, redemptionType);
+    }
+    /**
+     * ADMIN: Delete redemption type
+     *
+     * @param id - Redemption type ID to delete
+     */
+    async deleteRedemptionType(id) {
+        return this.apiClient.delete(`${this.typesPath}/${id}`);
+    }
     // ==========================================
     // TOKEN UNIT MANAGEMENT (Admin)
     // ==========================================
@@ -6974,6 +7093,27 @@ class RedemptionService {
     async deleteRedemptionTokenUnit(redemptionId, redemptionTokenUnitId) {
         return this.redemptionApi.deleteRedemptionTokenUnit(redemptionId, redemptionTokenUnitId);
     }
+    // ==========================================
+    // REDEMPTION TYPE MANAGEMENT (Admin)
+    // ==========================================
+    /**
+     * ADMIN: Create redemption type
+     */
+    async createRedemptionType(data) {
+        return this.redemptionApi.createRedemptionType(data);
+    }
+    /**
+     * ADMIN: Update redemption type
+     */
+    async updateRedemptionType(data) {
+        return this.redemptionApi.updateRedemptionType(data);
+    }
+    /**
+     * ADMIN: Delete redemption type
+     */
+    async deleteRedemptionType(id) {
+        return this.redemptionApi.deleteRedemptionType(id);
+    }
 }
 
 /**
@@ -8236,8 +8376,6 @@ class TenantService {
  *
  * Provides a simplified API for common tenant management tasks while maintaining
  * access to the full tenant SDK for advanced use cases.
- *
- * Also provides chain-agnostic IPFS URL resolution using tenant configuration.
  */
 class TenantManager {
     constructor(apiClient) {
@@ -8281,52 +8419,6 @@ class TenantManager {
     async getClientConfig() {
         return this.cache.getOrSet('clientConfig', () => this.tenantService.getRemoteClientConfig(), CacheTTL.LONG);
     }
-    // ==========================================
-    // IPFS OPERATIONS (Chain-agnostic)
-    // ==========================================
-    /**
-     * Resolve IPFS URL to HTTPS URL using tenant's configured gateway.
-     *
-     * This is chain-agnostic - IPFS gateway is configured at the tenant level,
-     * not per-chain. Use this for resolving any ipfs:// URLs (images, metadata, etc.).
-     *
-     * @param url - URL to resolve (can be ipfs:// or https://)
-     * @returns Resolved HTTPS URL
-     * @throws Error if tenant's ipfsGatewayDomain is not configured
-     *
-     * @example
-     * ```typescript
-     * const imageUrl = await sdk.tenant.resolveIPFSUrl('ipfs://QmXxx.../image.png');
-     * // Returns: 'https://pers.mypinata.cloud/ipfs/QmXxx.../image.png'
-     *
-     * // Non-IPFS URLs pass through unchanged
-     * const httpUrl = await sdk.tenant.resolveIPFSUrl('https://example.com/image.png');
-     * // Returns: 'https://example.com/image.png'
-     * ```
-     */
-    async resolveIPFSUrl(url) {
-        if (!url || !url.startsWith('ipfs://')) {
-            return url;
-        }
-        const gateway = await this.getIpfsGatewayDomain();
-        return url.replace('ipfs://', `https://${gateway}/ipfs/`);
-    }
-    /**
-     * Get IPFS gateway domain from tenant configuration (cached).
-     *
-     * @returns IPFS gateway domain (e.g., 'pers.mypinata.cloud')
-     * @throws Error if ipfsGatewayDomain is not configured for this tenant
-     */
-    async getIpfsGatewayDomain() {
-        return this.cache.getOrSet('ipfsGateway', async () => {
-            const config = await this.getClientConfig();
-            if (!config.ipfsGatewayDomain) {
-                throw new Error('IPFS gateway domain not configured for tenant. ' +
-                    'Please configure ipfsGatewayDomain in tenant settings.');
-            }
-            return config.ipfsGatewayDomain;
-        }, CacheTTL.GATEWAY);
-    }
     /**
      * Get Google API key from tenant configuration (cached).
      *
@@ -8408,6 +8500,100 @@ class TenantManager {
     clearCache() {
         this.cache.clear();
     }
+    // ==========================================
+    // IPFS OPERATIONS (Lightweight, no Web3 deps)
+    // ==========================================
+    /**
+     * Get the IPFS gateway domain from tenant config (cached)
+     *
+     * @returns Promise resolving to IPFS gateway domain (e.g., 'gateway.pinata.cloud')
+     * @example
+     * ```typescript
+     * const gateway = await sdk.tenants.getIpfsGatewayDomain();
+     * // Returns 'gateway.pinata.cloud' or tenant-specific gateway
+     * ```
+     */
+    async getIpfsGatewayDomain() {
+        return this.cache.getOrSet('ipfsGateway', async () => {
+            const config = await this.getClientConfig();
+            return config.ipfsGatewayDomain || 'gateway.pinata.cloud';
+        }, CacheTTL.LONG);
+    }
+    /**
+     * Resolve an IPFS URL to an HTTP gateway URL
+     *
+     * @param url - The URL to resolve (ipfs://, ar://, or HTTP URL)
+     * @returns Promise resolving to HTTP gateway URL
+     *
+     * @example
+     * ```typescript
+     * const httpUrl = await sdk.tenants.resolveIpfsUrl('ipfs://QmXxx...');
+     * // Returns 'https://gateway.pinata.cloud/ipfs/QmXxx...'
+     * ```
+     */
+    async resolveIpfsUrl(url) {
+        if (!url)
+            return '';
+        // Already an HTTP URL
+        if (url.startsWith('http://') || url.startsWith('https://')) {
+            return url;
+        }
+        const gateway = await this.getIpfsGatewayDomain();
+        // Handle ipfs:// protocol
+        if (url.startsWith('ipfs://')) {
+            const cid = url.replace('ipfs://', '');
+            return `https://${gateway}/ipfs/${cid}`;
+        }
+        // Handle ar:// (Arweave) protocol
+        if (url.startsWith('ar://')) {
+            const txId = url.replace('ar://', '');
+            return `https://arweave.net/${txId}`;
+        }
+        return url;
+    }
+    /**
+     * Fetch and process token metadata from IPFS/HTTP URI
+     *
+     * @param tokenUri - The token URI (ipfs://, ar://, or HTTP)
+     * @returns Promise resolving to processed metadata or null on error
+     *
+     * @example
+     * ```typescript
+     * const metadata = await sdk.tenants.fetchAndProcessMetadata('ipfs://QmXxx.../metadata.json');
+     * if (metadata) {
+     *   console.log(metadata.name, metadata.imageUrl);
+     * }
+     * ```
+     */
+    async fetchAndProcessMetadata(tokenUri) {
+        try {
+            const resolvedUri = await this.resolveIpfsUrl(tokenUri);
+            const response = await fetch(resolvedUri);
+            if (!response.ok) {
+                console.warn(`Failed to fetch metadata from ${resolvedUri}: ${response.status}`);
+                return null;
+            }
+            const rawMetadata = await response.json();
+            // Normalize the metadata - resolve image URLs
+            const imageUrl = rawMetadata.image || rawMetadata.image_url || rawMetadata.imageUrl || '';
+            const resolvedImageUrl = await this.resolveIpfsUrl(imageUrl);
+            const animationUrl = rawMetadata.animation_url || rawMetadata.animationUrl || '';
+            const resolvedAnimationUrl = animationUrl ? await this.resolveIpfsUrl(animationUrl) : undefined;
+            return {
+                name: rawMetadata.name || 'Untitled',
+                description: rawMetadata.description || '',
+                imageUrl: resolvedImageUrl,
+                animationUrl: resolvedAnimationUrl,
+                externalUrl: rawMetadata.external_url || rawMetadata.externalUrl,
+                attributes: rawMetadata.attributes,
+                ...rawMetadata // Include any additional properties
+            };
+        }
+        catch (error) {
+            console.warn(`Error fetching metadata from ${tokenUri}:`, error);
+            return null;
+        }
+    }
 }
 
 /**
@@ -9144,6 +9330,19 @@ exports.AuthStatus = void 0;
 function isExtendedProvider(provider) {
     return 'setAuthType' in provider && typeof provider.setAuthType === 'function';
 }
+/**
+ * Fatal auth error codes that require immediate logout.
+ * These indicate the session is completely invalid and cannot be recovered.
+ * TOKEN_EXPIRED is NOT in this list - it's the normal "please refresh" case.
+ *
+ * Values validated against CommonErrorCodes from @explorins/pers-shared at compile time.
+ */
+const FATAL_AUTH_CODES = [
+    'REFRESH_TOKEN_EXPIRED',
+    'REFRESH_TOKEN_REVOKED',
+    'INVALID_TOKEN',
+    'TOKEN_REVOKED'
+];
 /**
  * Platform-agnostic authentication service
  * Handles login, token refresh, and storage operations
@@ -9153,6 +9352,7 @@ class AuthService {
         this.authApi = authApi;
         this.authProvider = authProvider;
         this.activeRefreshPromise = null;
+        this.activeAuthFailurePromise = null;
         this.currentAuthStatus = exports.AuthStatus.UNAUTHENTICATED;
     }
     /**
@@ -9291,13 +9491,42 @@ class AuthService {
         }
     }
     /**
-     * Handle authentication failure with proper cleanup
-     * Centralized method to avoid redundant token cleanup logic
+     * Check if an error code indicates a fatal auth failure.
+     * Fatal errors require immediate logout - the session cannot be recovered.
+     */
+    isFatalAuthError(errorCode) {
+        return FATAL_AUTH_CODES.includes(errorCode);
+    }
+    /**
+     * Handle authentication failure with proper cleanup.
+     * Called when backend returns fatal auth error codes or refresh fails.
      */
     async handleAuthFailure() {
+        // Already failed - nothing to do
         if (this.currentAuthStatus === exports.AuthStatus.AUTH_FAILED) {
             return;
         }
+        // If refresh is currently in progress, don't fail - wait for refresh result
+        if (this.activeRefreshPromise) {
+            return;
+        }
+        // If auth failure is already in progress, wait for it
+        if (this.activeAuthFailurePromise) {
+            return await this.activeAuthFailurePromise;
+        }
+        // Create the failure promise to deduplicate concurrent calls
+        this.activeAuthFailurePromise = this.performAuthFailure();
+        try {
+            await this.activeAuthFailurePromise;
+        }
+        finally {
+            this.activeAuthFailurePromise = null;
+        }
+    }
+    /**
+     * Performs the actual auth failure cleanup
+     */
+    async performAuthFailure() {
         // Clear active refresh operations to prevent hanging promises
         this.activeRefreshPromise = null;
         // Clear all stored tokens
@@ -9419,10 +9648,8 @@ class TokenRefreshManager {
             return true;
         }
         catch (error) {
-            const isAuthError = error && typeof error === 'object' && 'status' in error && error.status === 401;
-            if (isAuthError) {
-                await this.authService.handleAuthFailure();
-            }
+            // Don't call handleAuthFailure here - let the caller decide
+            // This prevents duplicate auth failure handling in race conditions
             return false;
         }
     }
@@ -9955,15 +10182,6 @@ class DefaultAuthProvider {
         const hasIndexedDB = this.canEnableDPoP();
         const canUseDPoP = hasCustomCryptoProvider || hasIndexedDB;
         this.dpopEnabled = !!(config.dpop?.enabled && canUseDPoP);
-        // Debug logging for DPoP configuration
-        console.log('[DefaultAuthProvider] DPoP config:', {
-            requestedEnabled: config.dpop?.enabled ?? false,
-            hasCustomCryptoProvider,
-            hasIndexedDB,
-            canUseDPoP,
-            finalEnabled: this.dpopEnabled,
-            cryptoProviderType: config.dpop?.cryptoProvider?.constructor?.name || 'none'
-        });
         if (config.dpop?.enabled && !canUseDPoP) {
             console.warn('[DefaultAuthProvider] DPoP disabled: IndexedDB not available and no custom crypto provider supplied. CryptoKey persistence requires IndexedDB or a custom provider.');
         }
@@ -10134,7 +10352,7 @@ class DefaultAuthProvider {
 /** SDK package name */
 const SDK_NAME = "@explorins/pers-sdk";
 /** SDK version - injected from package.json at build time */
-const SDK_VERSION = "2.1.27";
+const SDK_VERSION = "2.1.31";
 /** Full SDK identifier for headers */
 const SDK_USER_AGENT = `${SDK_NAME}/${SDK_VERSION}`;
 
@@ -10283,12 +10501,21 @@ class PersApiClient {
             // Handle 401 errors centrally through AuthService
             if (status === 401) {
                 const backendError = ErrorUtils.extractBackendErrorDetails(error);
+                // Check for fatal auth errors that require immediate logout
+                if (this.authService.isFatalAuthError(backendError.code)) {
+                    // Definitive auth failure - no retry, session is invalid
+                    await this.authService.handleAuthFailure();
+                    this.emitErrorEvent(backendError, errorMessage, endpoint, method, status, error);
+                    throw new AuthenticationError(errorMessage, endpoint, method, backendError);
+                }
                 // If this IS a refresh request that failed with 401, don't retry to avoid infinite loop
                 if (options?.isRefreshRequest) {
+                    // Refresh failed - this is a real auth failure
+                    await this.authService.handleAuthFailure();
                     this.emitErrorEvent(backendError, errorMessage, endpoint, method, status, error);
                     throw new AuthenticationError(errorMessage, endpoint, method, backendError);
                 }
-                // For regular requests: try refresh once, then fail
+                // TOKEN_EXPIRED or unknown 401: try refresh once, then retry
                 if (retryCount === 0 && this.mergedConfig.authProvider) {
                     try {
                         const refreshSuccessful = await this.refreshManager.attemptInternalRefresh();
@@ -10299,13 +10526,15 @@ class PersApiClient {
                                 domain: 'authentication',
                                 userMessage: 'Authentication token refreshed',
                             });
+                            // Retry with new token
                             return await this.request(method, endpoint, body, { ...options, retryCount: 1 });
                         }
                     }
                     catch (refreshError) {
-                        // Silent refresh failure
+                        // Refresh failed - fall through to handleAuthFailure
                     }
                 }
+                // All recovery attempts failed
                 await this.authService.handleAuthFailure();
                 this.emitErrorEvent(backendError, errorMessage, endpoint, method, status, error);
                 throw new AuthenticationError(errorMessage, endpoint, method, backendError);
@@ -12266,6 +12495,69 @@ class BusinessManager {
     async getBusinessTypes(options) {
         return this.businessService.getBusinessTypes();
     }
+    /**
+     * Admin: Create a new business type
+     *
+     * Creates a new business type category in the system.
+     * Requires administrator privileges.
+     *
+     * @param data - Business type data (name, description, code, iconUrl)
+     * @returns Promise resolving to the created business type
+     * @throws {PersApiError} When not authenticated as admin or validation fails
+     *
+     * @example
+     * ```typescript
+     * const newType = await sdk.business.createBusinessType({
+     *   name: 'Restaurant',
+     *   description: 'Food service establishments',
+     *   code: 'RESTAURANT',
+     *   iconUrl: 'https://example.com/restaurant-icon.png'
+     * });
+     * ```
+     */
+    async createBusinessType(data) {
+        return this.businessApi.createBusinessType(data);
+    }
+    /**
+     * Admin: Update an existing business type
+     *
+     * Updates a business type's properties.
+     * Requires administrator privileges.
+     *
+     * @param data - Updated business type data (must include id)
+     * @returns Promise resolving to the updated business type
+     * @throws {PersApiError} When not authenticated as admin or type not found
+     *
+     * @example
+     * ```typescript
+     * const updated = await sdk.business.updateBusinessType({
+     *   id: 123,
+     *   name: 'Fine Dining Restaurant',
+     *   description: 'Upscale dining establishments'
+     * });
+     * ```
+     */
+    async updateBusinessType(data) {
+        return this.businessApi.updateBusinessType(data);
+    }
+    /**
+     * Admin: Delete a business type
+     *
+     * Deletes a business type. Will fail if type is in use by businesses.
+     * Requires administrator privileges.
+     *
+     * @param id - Business type ID to delete
+     * @returns Promise resolving to true if deleted successfully
+     * @throws {PersApiError} When not authenticated as admin or type not found/in use
+     *
+     * @example
+     * ```typescript
+     * const success = await sdk.business.deleteBusinessType(123);
+     * ```
+     */
+    async deleteBusinessType(id) {
+        return this.businessApi.deleteBusinessType(id);
+    }
     /**
      * Get businesses by type
      *
@@ -14274,6 +14566,77 @@ class RedemptionManager {
     async deleteRedemptionTokenUnit(redemptionId, tokenUnitId) {
         return this.redemptionService.deleteRedemptionTokenUnit(redemptionId, tokenUnitId);
     }
+    // ==========================================
+    // REDEMPTION TYPE MANAGEMENT (Admin)
+    // ==========================================
+    /**
+     * Admin: Create redemption type
+     *
+     * Creates a new redemption type category for organizing redemption offers.
+     * Requires administrator privileges.
+     *
+     * @param data - Redemption type data (name, description, imageUrl)
+     * @returns Promise resolving to created redemption type
+     * @throws {PersApiError} When not authenticated as admin or validation fails
+     *
+     * @example
+     * ```typescript
+     * const newType = await sdk.redemptions.createRedemptionType({
+     *   name: 'Premium Rewards',
+     *   description: 'High-value exclusive rewards',
+     *   imageUrl: 'https://example.com/premium-icon.png'
+     * });
+     *
+     * console.log('Created type:', newType.name);
+     * ```
+     */
+    async createRedemptionType(data) {
+        return this.redemptionService.createRedemptionType(data);
+    }
+    /**
+     * Admin: Update redemption type
+     *
+     * Updates an existing redemption type's properties.
+     * Requires administrator privileges.
+     *
+     * @param data - Updated redemption type data (must include id)
+     * @returns Promise resolving to updated redemption type
+     * @throws {PersApiError} When not authenticated as admin or type not found
+     *
+     * @example
+     * ```typescript
+     * const updated = await sdk.redemptions.updateRedemptionType({
+     *   id: 123,
+     *   name: 'VIP Rewards',
+     *   description: 'Updated description',
+     *   imageUrl: 'https://example.com/vip-icon.png'
+     * });
+     *
+     * console.log('Updated type:', updated.name);
+     * ```
+     */
+    async updateRedemptionType(data) {
+        return this.redemptionService.updateRedemptionType(data);
+    }
+    /**
+     * Admin: Delete redemption type
+     *
+     * Deletes a redemption type. Will fail if type is in use by redemptions.
+     * Requires administrator privileges.
+     *
+     * @param id - Redemption type ID to delete
+     * @returns Promise resolving to true if deleted successfully
+     * @throws {PersApiError} When not authenticated as admin or type not found/in use
+     *
+     * @example
+     * ```typescript
+     * const success = await sdk.redemptions.deleteRedemptionType(123);
+     * console.log('Deleted:', success);
+     * ```
+     */
+    async deleteRedemptionType(id) {
+        return this.redemptionService.deleteRedemptionType(id);
+    }
     /**
      * Get the full redemption service for advanced operations
      *
@@ -19429,15 +19792,6 @@ function createReactNativeAuthProvider(projectKey, config = {}) {
         enabled: dpop.enabled ?? true,
         cryptoProvider: dpop.cryptoProvider
     } : undefined;
-    // Always log DPoP config for debugging (critical for mobile auth)
-    console.log('[ReactNativeAuthProvider] Config:', {
-        platform: reactNative.Platform.OS,
-        isWebPlatform,
-        dpopEnabled: dpopConfig?.enabled ?? false,
-        hasCryptoProvider: !!dpopConfig?.cryptoProvider,
-        cryptoProviderType: dpopConfig?.cryptoProvider?.constructor?.name || 'none',
-        storageType: tokenStorage.constructor.name
-    });
     // Return DefaultAuthProvider configured with platform-appropriate storage
     return new DefaultAuthProvider({
         authType,
@@ -19764,13 +20118,6 @@ const PersSDKProvider = ({ children, config }) => {
             if (reactNative.Platform.OS !== 'web' && isDpopEnabled && !dpopSettings.cryptoProvider) {
                 dpopSettings.cryptoProvider = new ReactNativeDPoPProvider();
             }
-            // Log DPoP settings before creating auth provider
-            console.log('[PersSDKProvider] DPoP settings:', {
-                platform: reactNative.Platform.OS,
-                isDpopEnabled,
-                hasCryptoProvider: !!dpopSettings.cryptoProvider,
-                cryptoProviderType: dpopSettings.cryptoProvider?.constructor?.name || 'none'
-            });
             // Create platform-aware auth provider if not provided
             let authProvider;
             if (config.authProvider) {
@@ -40279,6 +40626,13 @@ class MetadataDomainService {
         const cacheKey = `resolve:${url}`;
         return this.cache.getOrSet(cacheKey, () => this.ipfsApi.resolveIPFSUrl(url), CacheTTL.GATEWAY);
     }
+    /**
+     * Get IPFS gateway domain from tenant configuration.
+     * Useful for pipes that need to resolve URLs synchronously after initial fetch.
+     */
+    async getIpfsGatewayDomain() {
+        return this.ipfsApi.getIpfsGatewayDomain();
+    }
     /**
      * Clear all cached metadata and URLs for this service
      */
@@ -40384,6 +40738,15 @@ class Web3ApplicationService {
     async resolveIPFSUrl(url) {
         return this.metadataDomainService.resolveIPFSUrl(url);
     }
+    /**
+     * Get IPFS gateway domain from tenant configuration.
+     * Useful for pipes that need to resolve URLs synchronously after initial fetch.
+     *
+     * @returns Gateway domain (e.g., 'pers.mypinata.cloud')
+     */
+    async getIpfsGatewayDomain() {
+        return this.metadataDomainService.getIpfsGatewayDomain();
+    }
     /**
      * Fetch and process metadata from any URI with IPFS conversion.
      *
@@ -40504,25 +40867,26 @@ class IPFSInfrastructureApi {
                 throw new Error(`HTTP error! status: ${response.status}`);
             }
             const rawMetadata = await response.json();
-            // Resolve IPFS URLs for media fields
-            const resolvedImageUrl = rawMetadata.image
-                ? await this.resolveIPFSUrl(rawMetadata.image)
-                : '';
-            const resolvedAnimationUrl = rawMetadata.animation_url
-                ? await this.resolveIPFSUrl(rawMetadata.animation_url)
-                : undefined;
+            // Resolve any IPFS URLs in string fields
+            for (const key of Object.keys(rawMetadata)) {
+                const value = rawMetadata[key];
+                if (typeof value === 'string' && value.startsWith('ipfs://')) {
+                    rawMetadata[key] = await this.resolveIPFSUrl(value);
+                }
+            }
             // 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: rawMetadata.name || '',
-                description: rawMetadata.description || '',
-                imageUrl: resolvedImageUrl,
-                animationUrl: resolvedAnimationUrl,
-                externalUrl: rawMetadata.external_url || undefined,
-                attributes: rawMetadata.attributes || [],
+            // Return normalized SDK format
+            const result = {
+                name: String(rawMetadata.name ?? ''),
+                description: String(rawMetadata.description ?? ''),
+                imageUrl: String(rawMetadata.image ?? ''),
+                animationUrl: rawMetadata.animation_url ? String(rawMetadata.animation_url) : undefined,
+                externalUrl: rawMetadata.external_url ? String(rawMetadata.external_url) : undefined,
+                attributes: Array.isArray(rawMetadata.attributes) ? rawMetadata.attributes : [],
                 ...customProperties
             };
+            return result;
         }
         catch (error) {
             console.error('Error fetching metadata:', error);
@@ -40645,8 +41009,12 @@ async function getExplorerUrlByChainId(getChainData, chainId, address, type) {
  *
  * ## IPFS Resolution
  *
- * For IPFS URL resolution, use `sdk.tenant.resolveIPFSUrl()` instead.
- * IPFS is chain-agnostic and configured at the tenant level.
+ * **Note:** IPFS is chain-agnostic. Use `sdk.tenants` for IPFS operations:
+ *
+ * ```typescript
+ * const httpsUrl = await sdk.tenants.resolveIpfsUrl('ipfs://QmXxx.../image.png');
+ * const metadata = await sdk.tenants.fetchAndProcessMetadata('ipfs://QmXxx.../metadata.json');
+ * ```
  */
 class Web3Manager {
     // TODO: Add PersEventEmitter support for blockchain events
@@ -40700,9 +41068,10 @@ class Web3Manager {
      *
      * @param tokenUri - Token URI to fetch metadata from
      * @returns Promise resolving to processed metadata or null if not found
+     * @deprecated Use sdk.tenants.fetchAndProcessMetadata() instead - IPFS is chain-agnostic
      */
     async fetchAndProcessMetadata(tokenUri) {
-        return this.web3ApplicationService.fetchAndProcessMetadata(tokenUri);
+        return this.tenantManager.fetchAndProcessMetadata(tokenUri);
     }
     /**
      * Get blockchain chain data by chain ID
@@ -41010,16 +41379,27 @@ const useWeb3 = () => {
     /**
      * Resolve IPFS URL to HTTP gateway URL
      *
-     * @deprecated Use `sdk.tenant.resolveIPFSUrl()` directly - IPFS is chain-agnostic
+     * Converts an ipfs:// URL to an HTTPS URL using the tenant's configured IPFS gateway.
+     * Non-IPFS URLs are returned unchanged.
+     *
+     * Note: Uses sdk.tenants for IPFS resolution (chain-agnostic).
+     *
      * @param url - IPFS URL to resolve (ipfs://...)
      * @returns Promise resolving to HTTP gateway URL
+     *
+     * @example
+     * ```typescript
+     * const { resolveIPFSUrl } = useWeb3();
+     * const httpsUrl = await resolveIPFSUrl('ipfs://QmHash...');
+     * // Returns: 'https://gateway.pinata.cloud/ipfs/QmHash...'
+     * ```
      */
     const resolveIPFSUrl = react.useCallback(async (url) => {
         if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await sdk.tenants.resolveIPFSUrl(url);
+            const result = await sdk.tenants.resolveIpfsUrl(url);
             return result;
         }
         catch (error) {
@@ -41030,22 +41410,24 @@ const useWeb3 = () => {
     /**
      * Fetch and process token metadata from a URI
      *
+     * Note: Uses sdk.tenants for metadata fetching (chain-agnostic IPFS).
+     *
      * @param tokenUri - Token URI to fetch metadata from
      * @returns Promise resolving to processed metadata or null
      */
     const fetchAndProcessMetadata = react.useCallback(async (tokenUri) => {
-        if (!isInitialized || !web3) {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await web3.fetchAndProcessMetadata(tokenUri);
+            const result = await sdk.tenants.fetchAndProcessMetadata(tokenUri);
             return result;
         }
         catch (error) {
             console.error('Failed to fetch and process metadata:', error);
             throw error;
         }
-    }, [web3, isInitialized]);
+    }, [sdk, isInitialized]);
     const getChainDataById = react.useCallback(async (chainId) => {
         if (!isInitialized || !web3) {
             throw new Error('SDK not initialized. Call initialize() first.');
@@ -42680,8 +43062,7 @@ const useTransactions = () => {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await sdk.transactions.getTransactionById(transactionId, include);
-            return result;
+            return await sdk.transactions.getTransactionById(transactionId, include);
         }
         catch (error) {
             console.error('Failed to fetch transaction:', error);
@@ -42730,8 +43111,7 @@ const useTransactions = () => {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await sdk.transactions.getUserTransactionHistory(options);
-            return result;
+            return await sdk.transactions.getUserTransactionHistory(options);
         }
         catch (error) {
             console.error('Failed to fetch transaction history:', error);
@@ -43771,6 +44151,181 @@ const useRedemptions = () => {
     };
 };
 
+/**
+ * React hook for resolving media URLs (IPFS or HTTPS).
+ *
+ * Automatically handles IPFS URLs by resolving them to HTTPS via tenant's gateway.
+ * Non-IPFS URLs are returned as-is. Handles loading and error states.
+ *
+ * Uses sdk.tenants for IPFS resolution (lightweight, no Web3 deps).
+ *
+ * @param url - The URL to resolve (can be ipfs://, https://, or undefined)
+ * @returns Object with resolved URL, loading state, and error
+ *
+ * @example
+ * ```tsx
+ * function NFTImage({ metadataUri }: { metadataUri?: string }) {
+ *   const { url, isLoading } = useResolvedUrl(metadataUri);
+ *
+ *   if (isLoading) return <ActivityIndicator />;
+ *   return <Image source={{ uri: url }} />;
+ * }
+ * ```
+ */
+function useResolvedUrl(url) {
+    const { sdk, isInitialized } = usePersSDK();
+    const [resolvedUrl, setResolvedUrl] = react.useState(null);
+    const [isLoading, setIsLoading] = react.useState(false);
+    const [error, setError] = react.useState(null);
+    react.useEffect(() => {
+        if (!url || !isInitialized || !sdk) {
+            setResolvedUrl(null);
+            return;
+        }
+        // Non-IPFS URLs don't need resolution
+        if (!url.startsWith('ipfs://')) {
+            setResolvedUrl(url);
+            return;
+        }
+        setIsLoading(true);
+        setError(null);
+        sdk.tenants.resolveIpfsUrl(url)
+            .then((resolved) => {
+            setResolvedUrl(resolved);
+        })
+            .catch((err) => {
+            setError(err instanceof Error ? err.message : 'Failed to resolve URL');
+            setResolvedUrl(null);
+        })
+            .finally(() => {
+            setIsLoading(false);
+        });
+    }, [url, isInitialized, sdk]);
+    return {
+        /** Resolved HTTPS URL (or original if not IPFS) */
+        url: resolvedUrl,
+        /** Whether resolution is in progress */
+        isLoading,
+        /** Error message if resolution failed */
+        error,
+    };
+}
+/**
+ * React hook for fetching NFT/token metadata from a URI.
+ *
+ * Handles IPFS resolution automatically and returns parsed metadata
+ * with all nested IPFS URLs already resolved to HTTPS.
+ *
+ * Uses sdk.tenants for metadata fetching (lightweight, no Web3 deps).
+ *
+ * @param metadataUri - The metadata URI to fetch (can be ipfs:// or https://)
+ * @returns Object with metadata, loading state, error, and refresh function
+ *
+ * @example
+ * ```tsx
+ * function NFTDetails({ metadataUri }: { metadataUri?: string }) {
+ *   const { metadata, isLoading, error } = useMetadata(metadataUri);
+ *
+ *   if (isLoading) return <ActivityIndicator />;
+ *   if (error) return <Text>Error: {error}</Text>;
+ *   if (!metadata) return null;
+ *
+ *   return (
+ *     <View>
+ *       <Image source={{ uri: metadata.imageUrl }} />
+ *       <Text>{metadata.name}</Text>
+ *       <Text>{metadata.description}</Text>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+function useMetadata(metadataUri) {
+    const { sdk, isInitialized } = usePersSDK();
+    const [metadata, setMetadata] = react.useState(null);
+    const [isLoading, setIsLoading] = react.useState(false);
+    const [error, setError] = react.useState(null);
+    const fetchMetadata = react.useCallback(async () => {
+        if (!metadataUri || !isInitialized || !sdk) {
+            setMetadata(null);
+            return;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const result = await sdk.tenants.fetchAndProcessMetadata(metadataUri);
+            setMetadata(result);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to fetch metadata');
+            setMetadata(null);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [metadataUri, isInitialized, sdk]);
+    react.useEffect(() => {
+        fetchMetadata();
+    }, [fetchMetadata]);
+    return {
+        /** Parsed metadata with resolved IPFS URLs (imageUrl, animationUrl, etc.) */
+        metadata,
+        /** Whether fetch is in progress */
+        isLoading,
+        /** Error message if fetch failed */
+        error,
+        /** Manually refresh metadata */
+        refresh: fetchMetadata,
+    };
+}
+/**
+ * React hook for loading transaction/token metadata.
+ *
+ * Convenience wrapper around useMetadata specifically for transaction items.
+ * Pass a transaction's metadataUri to get the NFT image, name, description, etc.
+ *
+ * @param transaction - Transaction object with optional metadataUri field
+ * @returns Object with metadata, loading state, and image URL
+ *
+ * @example
+ * ```tsx
+ * import { useTransactionMetadata } from '@explorins/pers-sdk-react-native';
+ *
+ * function TransactionItem({ tx }: { tx: TransactionDTO }) {
+ *   const { metadata, isLoading, imageUrl } = useTransactionMetadata(tx);
+ *
+ *   if (isLoading) return <ActivityIndicator />;
+ *
+ *   return (
+ *     <View>
+ *       {imageUrl && <Image source={{ uri: imageUrl }} style={{ width: 60, height: 60 }} />}
+ *       <Text>{metadata?.name || tx.type}</Text>
+ *       <Text>{tx.amount} tokens</Text>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+function useTransactionMetadata(transaction) {
+    const { metadata, isLoading, error, refresh } = useMetadata(transaction?.metadataUri);
+    return {
+        /** Parsed metadata with resolved URLs */
+        metadata,
+        /** Whether metadata is loading */
+        isLoading,
+        /** Error message if fetch failed */
+        error,
+        /** Convenience: resolved image URL (or undefined) */
+        imageUrl: metadata?.imageUrl,
+        /** Convenience: token/NFT name (or undefined) */
+        name: metadata?.name,
+        /** Convenience: token/NFT description (or undefined) */
+        description: metadata?.description,
+        /** Manually refresh metadata */
+        refresh,
+    };
+}
+
 const usePurchases = () => {
     const { sdk, isInitialized, isAuthenticated } = usePersSDK();
     const createPaymentIntent = react.useCallback(async (amount, currency, receiptEmail, description) => {
@@ -45201,6 +45756,7 @@ exports.CampaignManager = CampaignManager;
 exports.CampaignService = CampaignService;
 exports.ChainTypes = ChainTypes;
 exports.ClientTransactionType = ClientTransactionType;
+exports.CommonErrorCodes = CommonErrorCodes;
 exports.DEFAULT_PERS_CONFIG = DEFAULT_PERS_CONFIG;
 exports.DPOP_STORAGE_KEYS = DPOP_STORAGE_KEYS;
 exports.DPoPManager = DPoPManager;
@@ -45348,12 +45904,16 @@ exports.useCampaigns = useCampaigns;
 exports.useDonations = useDonations;
 exports.useEvents = useEvents;
 exports.useFiles = useFiles;
+exports.useIPFSUrl = useResolvedUrl;
+exports.useMetadata = useMetadata;
 exports.usePersSDK = usePersSDK;
 exports.usePurchases = usePurchases;
 exports.useRedemptions = useRedemptions;
+exports.useResolvedUrl = useResolvedUrl;
 exports.useTenants = useTenants;
 exports.useTokenBalances = useTokenBalances;
 exports.useTokens = useTokens;
+exports.useTransactionMetadata = useTransactionMetadata;
 exports.useTransactionSigner = useTransactionSigner;
 exports.useTransactions = useTransactions;
 exports.useTriggerSources = useTriggerSources;