@explorins/pers-sdk-react-native 2.1.19 → 2.1.21

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).
      *
@@ -9144,6 +9236,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 +9258,7 @@ class AuthService {
         this.authApi = authApi;
         this.authProvider = authProvider;
         this.activeRefreshPromise = null;
+        this.activeAuthFailurePromise = null;
         this.currentAuthStatus = exports.AuthStatus.UNAUTHENTICATED;
     }
     /**
@@ -9291,13 +9397,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 +9554,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;
         }
     }
@@ -9948,11 +10081,15 @@ class DefaultAuthProvider {
         this.config = config;
         this.authTypeCache = null;
         this.authType = config.authType || exports.AccountOwnerType.USER;
-        // Determine if DPoP can be enabled (requires IndexedDB for key persistence)
-        const canUseDPoP = this.canEnableDPoP();
+        // Determine if DPoP can be enabled:
+        // 1. Custom crypto provider is supplied (e.g., React Native), OR
+        // 2. IndexedDB is available for browser CryptoKey persistence
+        const hasCustomCryptoProvider = !!config.dpop?.cryptoProvider;
+        const hasIndexedDB = this.canEnableDPoP();
+        const canUseDPoP = hasCustomCryptoProvider || hasIndexedDB;
         this.dpopEnabled = !!(config.dpop?.enabled && canUseDPoP);
         if (config.dpop?.enabled && !canUseDPoP) {
-            console.warn('[DefaultAuthProvider] DPoP disabled: IndexedDB not available. CryptoKey persistence requires IndexedDB.');
+            console.warn('[DefaultAuthProvider] DPoP disabled: IndexedDB not available and no custom crypto provider supplied. CryptoKey persistence requires IndexedDB or a custom provider.');
         }
         const storage = config.storage || this.createStorage();
         this.tokenManager = new AuthTokenManager(storage);
@@ -10121,7 +10258,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}`;
 
@@ -10270,12 +10407,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();
@@ -10286,13 +10432,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);
@@ -12253,6 +12401,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
      *
@@ -14261,6 +14472,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
      *
@@ -19416,10 +19698,6 @@ function createReactNativeAuthProvider(projectKey, config = {}) {
         enabled: dpop.enabled ?? true,
         cryptoProvider: dpop.cryptoProvider
     } : undefined;
-    // DEBUG LOGGING
-    if (debug) {
-        console.log('[ReactNativeAuthProvider] Creating provider with DPoP config:', JSON.stringify(dpopConfig));
-    }
     // Return DefaultAuthProvider configured with platform-appropriate storage
     return new DefaultAuthProvider({
         authType,
@@ -40254,6 +40532,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
      */
@@ -40359,6 +40644,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.
      *
@@ -40479,25 +40773,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);
@@ -40620,8 +40915,20 @@ 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.
+ * Use `sdk.web3.resolveIPFSUrl()` to resolve IPFS URLs to HTTPS:
+ *
+ * ```typescript
+ * const httpsUrl = await sdk.web3.resolveIPFSUrl('ipfs://QmXxx.../image.png');
+ * // Returns: 'https://pers.mypinata.cloud/ipfs/QmXxx.../image.png'
+ * ```
+ *
+ * Or fetch full metadata with resolved URLs:
+ *
+ * ```typescript
+ * const metadata = await sdk.web3.fetchAndProcessMetadata('ipfs://QmXxx.../metadata.json');
+ * // All IPFS URLs in metadata are resolved to HTTPS
+ * // Returns SDK format: { imageUrl, animationUrl, externalUrl, ... }
+ * ```
  */
 class Web3Manager {
     // TODO: Add PersEventEmitter support for blockchain events
@@ -40679,6 +40986,45 @@ class Web3Manager {
     async fetchAndProcessMetadata(tokenUri) {
         return this.web3ApplicationService.fetchAndProcessMetadata(tokenUri);
     }
+    // ==========================================
+    // IPFS OPERATIONS
+    // ==========================================
+    /**
+     * Resolve IPFS URL to HTTPS URL using tenant's configured gateway.
+     *
+     * @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.web3.resolveIPFSUrl('ipfs://QmXxx.../image.png');
+     * // Returns: 'https://pers.mypinata.cloud/ipfs/QmXxx.../image.png'
+     *
+     * // Non-IPFS URLs pass through unchanged
+     * const httpUrl = await sdk.web3.resolveIPFSUrl('https://example.com/image.png');
+     * // Returns: 'https://example.com/image.png'
+     * ```
+     */
+    async resolveIPFSUrl(url) {
+        return this.web3ApplicationService.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')
+     * @throws Error if tenant's ipfsGatewayDomain is not configured
+     *
+     * @example
+     * ```typescript
+     * const gateway = await sdk.web3.getIpfsGatewayDomain();
+     * // Use gateway for sync resolution: `https://${gateway}/ipfs/${cid}`
+     * ```
+     */
+    async getIpfsGatewayDomain() {
+        return this.web3ApplicationService.getIpfsGatewayDomain();
+    }
     /**
      * Get blockchain chain data by chain ID
      *
@@ -40985,23 +41331,32 @@ 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.
+     *
      * @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) {
+        if (!isInitialized || !web3) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await sdk.tenants.resolveIPFSUrl(url);
+            const result = await web3.resolveIPFSUrl(url);
             return result;
         }
         catch (error) {
             console.error('Failed to resolve IPFS URL:', error);
             throw error;
         }
-    }, [sdk, isInitialized]);
+    }, [web3, isInitialized]);
     /**
      * Fetch and process token metadata from a URI
      *
@@ -42655,8 +43010,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);
@@ -42705,8 +43059,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);
@@ -45176,6 +45529,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;