@explorins/pers-sdk-react-native 1.3.2 → 1.5.2

package/dist/index.esm.js

@@ -1,1057 +0,0 @@
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import { jsx } from 'react/jsx-runtime';
-import { createContext, useRef, useState, useCallback, useContext } from 'react';
-import { PersApiClient } from '@explorins/pers-sdk/core';
-import { TokenSDK } from '@explorins/pers-sdk/token';
-import { createTransactionSDK } from '@explorins/pers-sdk/transaction';
-import { createBusinessSDK } from '@explorins/pers-sdk/business';
-import { createCampaignSDK } from '@explorins/pers-sdk/campaign';
-import { createRedemptionSDK } from '@explorins/pers-sdk/redemption';
-import { createWeb3SDK } from '@explorins/pers-sdk/web3';
-
-// Minimal React Native environment setup
-// No polyfills needed - modules are disabled at Metro level
-// Simple initialization function for compatibility
-const initializeReactNativePolyfills = () => {
-    console.log('✅ [PERS SDK] React Native environment ready (no polyfills needed)');
-    return true;
-};
-// Platform detection
-const isReactNative = () => {
-    return typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
-};
-// Auto-initialize
-initializeReactNativePolyfills();
-
-/**
- * Storage strategy for different types of data
- */
-var StorageStrategy;
-(function (StorageStrategy) {
-    /** Use AsyncStorage for general app data */
-    StorageStrategy["ASYNC_STORAGE"] = "async_storage";
-    /** Use Keychain for sensitive tokens (when available) */
-    StorageStrategy["KEYCHAIN"] = "keychain";
-    /** Use in-memory storage (fallback) */
-    StorageStrategy["MEMORY"] = "memory";
-})(StorageStrategy || (StorageStrategy = {}));
-/**
- * Base React Native Authentication Provider
- *
- * This serves as a blueprint for native implementations and can be extended
- * by consuming applications to integrate with their specific auth systems.
- *
- * Features:
- * - Multiple storage strategies (AsyncStorage, Keychain, Memory)
- * - Configurable security levels per token type
- * - Cross-platform compatibility (iOS/Android/Web)
- * - Blueprint for native iOS/Android implementations
- */
-class BaseReactNativeAuthProvider {
-    constructor(projectKey, config = {}) {
-        // In-memory fallback storage
-        this.memoryStorage = new Map();
-        // Validate projectKey
-        if (!projectKey || typeof projectKey !== 'string') {
-            throw new Error('ReactNativeAuthProvider: projectKey is required and must be a string');
-        }
-        // Set default configuration
-        this.config = {
-            accessTokenStrategy: StorageStrategy.ASYNC_STORAGE,
-            refreshTokenStrategy: StorageStrategy.KEYCHAIN,
-            keyPrefix: `pers_${projectKey.slice(0, 8)}`,
-            debug: false,
-            ...config
-        };
-        // Create storage keys
-        this.ACCESS_TOKEN_KEY = `${this.config.keyPrefix}_access_token`;
-        this.REFRESH_TOKEN_KEY = `${this.config.keyPrefix}_refresh_token`;
-        this.PROJECT_KEY_KEY = `${this.config.keyPrefix}_project_key`;
-        if (this.config.debug) {
-            console.log('🔧 ReactNativeAuthProvider initialized with config:', this.config);
-        }
-    }
-    // Core token management methods
-    async getToken() {
-        return this.getStoredValue(this.ACCESS_TOKEN_KEY, this.config.accessTokenStrategy);
-    }
-    async setAccessToken(token) {
-        await this.storeValue(this.ACCESS_TOKEN_KEY, token, this.config.accessTokenStrategy);
-        if (this.config.debug) {
-            console.log('✅ Access token stored securely');
-        }
-    }
-    async setRefreshToken(token) {
-        await this.storeValue(this.REFRESH_TOKEN_KEY, token, this.config.refreshTokenStrategy);
-        if (this.config.debug) {
-            console.log('✅ Refresh token stored securely');
-        }
-    }
-    async getRefreshToken() {
-        return this.getStoredValue(this.REFRESH_TOKEN_KEY, this.config.refreshTokenStrategy);
-    }
-    async clearTokens() {
-        await Promise.all([
-            this.removeStoredValue(this.ACCESS_TOKEN_KEY, this.config.accessTokenStrategy),
-            this.removeStoredValue(this.REFRESH_TOKEN_KEY, this.config.refreshTokenStrategy)
-        ]);
-        if (this.config.debug) {
-            console.log('✅ All tokens cleared from storage');
-        }
-    }
-    // Token validation methods
-    hasValidToken() {
-        // Synchronous check - for async check use hasValidTokenAsync()
-        return true; // Actual validation happens in getToken()
-    }
-    hasRefreshToken() {
-        // Synchronous check - for async check use hasRefreshTokenAsync()
-        return true; // Actual validation happens in getRefreshToken()
-    }
-    // Async token validation methods
-    async hasValidTokenAsync() {
-        const token = await this.getToken();
-        return !!token;
-    }
-    async hasRefreshTokenAsync() {
-        const refreshToken = await this.getRefreshToken();
-        return !!refreshToken;
-    }
-    // Legacy methods for backward compatibility
-    setToken(token) {
-        this.setAccessToken(token).catch(error => {
-            console.error('Legacy setToken failed:', error);
-        });
-    }
-    clearToken() {
-        this.clearTokens().catch(error => {
-            console.error('Legacy clearToken failed:', error);
-        });
-    }
-    // Protected storage implementation methods
-    async storeValue(key, value, strategy) {
-        try {
-            switch (strategy) {
-                case StorageStrategy.KEYCHAIN:
-                    // Try Keychain first, fallback to AsyncStorage
-                    if (await this.isKeychainAvailable()) {
-                        await this.storeInKeychain(key, value);
-                    }
-                    else {
-                        await AsyncStorage.setItem(key, value);
-                    }
-                    break;
-                case StorageStrategy.ASYNC_STORAGE:
-                    await AsyncStorage.setItem(key, value);
-                    break;
-                case StorageStrategy.MEMORY:
-                default:
-                    this.memoryStorage.set(key, value);
-                    break;
-            }
-        }
-        catch (error) {
-            console.error(`Failed to store value with strategy ${strategy}:`, error);
-            // Fallback to memory storage
-            this.memoryStorage.set(key, value);
-        }
-    }
-    async getStoredValue(key, strategy) {
-        try {
-            switch (strategy) {
-                case StorageStrategy.KEYCHAIN:
-                    // Try Keychain first, fallback to AsyncStorage
-                    if (await this.isKeychainAvailable()) {
-                        return await this.getFromKeychain(key);
-                    }
-                    else {
-                        return await AsyncStorage.getItem(key);
-                    }
-                case StorageStrategy.ASYNC_STORAGE:
-                    return await AsyncStorage.getItem(key);
-                case StorageStrategy.MEMORY:
-                default:
-                    return this.memoryStorage.get(key) || null;
-            }
-        }
-        catch (error) {
-            console.warn(`Failed to get value with strategy ${strategy}:`, error);
-            // Fallback to memory storage
-            return this.memoryStorage.get(key) || null;
-        }
-    }
-    async removeStoredValue(key, strategy) {
-        try {
-            switch (strategy) {
-                case StorageStrategy.KEYCHAIN:
-                    // Try Keychain first, fallback to AsyncStorage
-                    if (await this.isKeychainAvailable()) {
-                        await this.removeFromKeychain(key);
-                    }
-                    else {
-                        await AsyncStorage.removeItem(key);
-                    }
-                    break;
-                case StorageStrategy.ASYNC_STORAGE:
-                    await AsyncStorage.removeItem(key);
-                    break;
-                case StorageStrategy.MEMORY:
-                default:
-                    this.memoryStorage.delete(key);
-                    break;
-            }
-        }
-        catch (error) {
-            console.error(`Failed to remove value with strategy ${strategy}:`, error);
-            // Ensure memory fallback is also cleared
-            this.memoryStorage.delete(key);
-        }
-    }
-    // Keychain helper methods
-    async isKeychainAvailable() {
-        try {
-            // Check if react-native-keychain is available
-            const Keychain = require('react-native-keychain');
-            return !!Keychain && typeof Keychain.setInternetCredentials === 'function';
-        }
-        catch {
-            return false;
-        }
-    }
-    async storeInKeychain(key, value) {
-        const Keychain = require('react-native-keychain');
-        await Keychain.setInternetCredentials(key, 'pers-token', value);
-    }
-    async getFromKeychain(key) {
-        const Keychain = require('react-native-keychain');
-        const credentials = await Keychain.getInternetCredentials(key);
-        return credentials ? credentials.password : null;
-    }
-    async removeFromKeychain(key) {
-        const Keychain = require('react-native-keychain');
-        await Keychain.resetInternetCredentials(key);
-    }
-}
-/**
- * React Native Authentication Provider
- *
- * A ready-to-use implementation for basic use cases.
- * Uses AsyncStorage for access tokens and Keychain for refresh tokens (when available).
- */
-class ReactNativeAuthProvider extends BaseReactNativeAuthProvider {
-    constructor(projectKey, config = {}) {
-        // Validate projectKey
-        if (!projectKey || typeof projectKey !== 'string') {
-            throw new Error('ReactNativeAuthProvider: projectKey is required and must be a string');
-        }
-        super(projectKey, {
-            accessTokenStrategy: StorageStrategy.ASYNC_STORAGE,
-            refreshTokenStrategy: StorageStrategy.KEYCHAIN,
-            debug: false,
-            ...config
-        });
-        this.projectKey = projectKey;
-        this.authType = 'user';
-    }
-    async getProjectKey() {
-        return this.projectKey;
-    }
-    async onTokenExpired() {
-        if (this.config.debug) {
-            console.warn('ReactNativeAuthProvider: Token expired - no refresh logic implemented');
-        }
-    }
-}
-/**
- * Secure React Native Authentication Provider
- *
- * Maximum security implementation using Keychain for all sensitive data.
- */
-class SecureReactNativeAuthProvider extends BaseReactNativeAuthProvider {
-    constructor(projectKey, config = {}) {
-        // Validate projectKey
-        if (!projectKey || typeof projectKey !== 'string') {
-            throw new Error('SecureReactNativeAuthProvider: projectKey is required and must be a string');
-        }
-        super(projectKey, {
-            ...config,
-            accessTokenStrategy: StorageStrategy.KEYCHAIN,
-            refreshTokenStrategy: StorageStrategy.KEYCHAIN,
-        });
-        this.projectKey = projectKey;
-        this.authType = 'user';
-    }
-    async getProjectKey() {
-        return this.projectKey;
-    }
-    async onTokenExpired() {
-        if (this.config.debug) {
-            console.warn('SecureReactNativeAuthProvider: Token expired - implement refresh logic');
-        }
-    }
-}
-
-/**
- * HTTP Client implementation for React Native
- *
- * This implementation properly implements the core SDK's HttpClient interface
- * and uses fetch API which is available in React Native.
- */
-class ReactNativeHttpClient {
-    constructor(baseURL) {
-        this.baseURL = baseURL;
-    }
-    async get(url, options) {
-        return this.request('GET', url, undefined, options);
-    }
-    async post(url, body, options) {
-        return this.request('POST', url, body, options);
-    }
-    async put(url, body, options) {
-        return this.request('PUT', url, body, options);
-    }
-    async delete(url, options) {
-        return this.request('DELETE', url, undefined, options);
-    }
-    async request(method, url, body, options) {
-        const fullUrl = this.buildUrl(url, options?.params);
-        const config = {
-            method,
-            headers: {
-                'Content-Type': 'application/json',
-                ...options?.headers,
-            },
-        };
-        // Add timeout if specified
-        if (options?.timeout) {
-            const controller = new AbortController();
-            config.signal = controller.signal;
-            setTimeout(() => controller.abort(), options.timeout);
-        }
-        // Add body for POST/PUT requests
-        if (body && (method === 'POST' || method === 'PUT')) {
-            config.body = JSON.stringify(body);
-        }
-        try {
-            const response = await fetch(fullUrl, config);
-            if (!response.ok) {
-                // Try to get error details from response
-                let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
-                try {
-                    const errorBody = await response.text();
-                    if (errorBody) {
-                        errorMessage += ` - ${errorBody}`;
-                    }
-                }
-                catch (e) {
-                    // Ignore errors when reading error body
-                }
-                throw new Error(errorMessage);
-            }
-            // Handle different response types
-            switch (options?.responseType) {
-                case 'text':
-                    return response.text();
-                case 'blob':
-                    return response.blob();
-                case 'arraybuffer':
-                    return response.arrayBuffer();
-                case 'json':
-                default:
-                    // Check if response has content
-                    const contentLength = response.headers.get('content-length');
-                    if (contentLength === '0' || response.status === 204) {
-                        return undefined;
-                    }
-                    return response.json();
-            }
-        }
-        catch (error) {
-            if (error instanceof Error && error.name === 'AbortError') {
-                throw new Error(`Request timeout after ${options?.timeout}ms`);
-            }
-            throw error;
-        }
-    }
-    buildUrl(url, params) {
-        const fullUrl = this.baseURL ? `${this.baseURL}${url}` : url;
-        if (!params || Object.keys(params).length === 0) {
-            return fullUrl;
-        }
-        const urlObj = new URL(fullUrl);
-        Object.entries(params).forEach(([key, value]) => {
-            urlObj.searchParams.append(key, value);
-        });
-        return urlObj.toString();
-    }
-}
-
-// Create the context
-const SDKContext = createContext(null);
-// Custom auth provider for React Native
-class ReactNativeSDKAuthProvider extends BaseReactNativeAuthProvider {
-    constructor(projectKey) {
-        super(projectKey);
-        this.projectKey = projectKey;
-        this.authType = 'user';
-        this._token = null;
-    }
-    async getToken() {
-        return this._token;
-    }
-    async setToken(token) {
-        this._token = token;
-    }
-    async getProjectKey() {
-        return this.projectKey;
-    }
-    async onTokenExpired() {
-        console.log('Token expired - clearing token');
-        this._token = null;
-    }
-}
-// Provider component
-const PersSDKProvider = ({ children }) => {
-    const initializingRef = useRef(false);
-    const [apiClient, setApiClient] = useState(null);
-    const [authProvider, setAuthProvider] = useState(null);
-    const [sdks, setSdks] = useState({
-        tokens: null,
-        transactions: null,
-        business: null,
-        campaigns: null,
-        redemptions: null,
-        web3: null,
-    });
-    const [isInitialized, setIsInitialized] = useState(false);
-    const [isAuthenticated, setIsAuthenticated] = useState(false);
-    const [user, setUser] = useState(null);
-    const [accountAddress, setAccountAddress] = useState(null);
-    const initialize = useCallback(async (config) => {
-        // Prevent multiple initializations
-        if (isInitialized || initializingRef.current) {
-            console.log('⚠️ SDK already initialized or initializing, skipping...');
-            return;
-        }
-        initializingRef.current = true;
-        try {
-            console.log('🚀 Initializing PERS SDK with config:', config);
-            // Create auth provider
-            const auth = new ReactNativeSDKAuthProvider(config.apiProjectKey);
-            setAuthProvider(auth);
-            // Create HTTP client
-            const httpClient = new ReactNativeHttpClient();
-            // Create API client
-            const client = new PersApiClient(httpClient, {
-                apiProjectKey: config.apiProjectKey,
-                authProvider: auth,
-                environment: config.environment || 'development',
-            });
-            setApiClient(client);
-            // Initialize domain SDKs
-            const domainSDKs = {
-                tokens: new TokenSDK(client),
-                transactions: createTransactionSDK(client),
-                business: createBusinessSDK(client),
-                campaigns: createCampaignSDK(client),
-                redemptions: createRedemptionSDK(client),
-                web3: createWeb3SDK(client),
-            };
-            setSdks(domainSDKs);
-            setIsInitialized(true);
-            console.log('✅ PERS SDK initialized successfully');
-        }
-        catch (error) {
-            console.error('❌ Failed to initialize PERS SDK:', error);
-            initializingRef.current = false;
-            throw error;
-        }
-        finally {
-            initializingRef.current = false;
-        }
-    }, []);
-    const login = useCallback(async (jwtToken, userType = 'user') => {
-        if (!apiClient || !authProvider) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        try {
-            console.log(`🔐 Logging in as ${userType}...`);
-            // Set token in auth provider
-            await authProvider.setToken(jwtToken);
-            // Perform login with API client
-            const result = userType === 'admin'
-                ? await apiClient.loginAdmin(jwtToken)
-                : await apiClient.loginUser(jwtToken);
-            const userData = result.user || result.admin;
-            const userAccountAddress = userData?.accountAddress ||
-                userData?.wallets?.[0]?.address ||
-                null;
-            setUser(userData);
-            setAccountAddress(userAccountAddress);
-            setIsAuthenticated(true);
-            console.log('✅ Login successful');
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Login failed:', error);
-            throw error;
-        }
-    }, [apiClient, authProvider]);
-    const loginWithRawData = useCallback(async (rawUserData) => {
-        if (!apiClient || !authProvider) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        try {
-            console.log('🔐 Logging in with raw user data...');
-            const result = await apiClient.loginUserWithRawData(rawUserData);
-            // Set token from result
-            if (result.accessToken) {
-                await authProvider.setToken(result.accessToken);
-            }
-            const userData = result.user;
-            const userAccountAddress = userData?.accountAddress ||
-                userData?.wallets?.[0]?.address ||
-                null;
-            setUser(userData);
-            setAccountAddress(userAccountAddress);
-            setIsAuthenticated(true);
-            console.log('✅ Raw data login successful');
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Raw data login failed:', error);
-            throw error;
-        }
-    }, [apiClient, authProvider]);
-    const logout = useCallback(async () => {
-        try {
-            console.log('🔓 Logging out...');
-            if (authProvider) {
-                await authProvider.setToken(null);
-            }
-            setUser(null);
-            setAccountAddress(null);
-            setIsAuthenticated(false);
-            console.log('✅ Logout successful');
-        }
-        catch (error) {
-            console.error('❌ Logout failed:', error);
-            throw error;
-        }
-    }, [authProvider]);
-    const contextValue = {
-        // SDK instances
-        tokens: sdks.tokens,
-        transactions: sdks.transactions,
-        business: sdks.business,
-        campaigns: sdks.campaigns,
-        redemptions: sdks.redemptions,
-        web3: sdks.web3,
-        apiClient,
-        // State
-        isInitialized,
-        isAuthenticated,
-        user,
-        accountAddress,
-        // Methods
-        initialize,
-        login,
-        loginWithRawData,
-        logout,
-    };
-    return (jsx(SDKContext.Provider, { value: contextValue, children: children }));
-};
-// Custom hook to use the SDK context
-const usePersSDK = () => {
-    const context = useContext(SDKContext);
-    if (!context) {
-        throw new Error('usePersSDK must be used within a PersSDKProvider');
-    }
-    return context;
-};
-
-const useAuth = () => {
-    const { isInitialized, isAuthenticated, user, accountAddress, initialize, login, loginWithRawData, logout, } = usePersSDK();
-    return {
-        // State
-        isInitialized,
-        isAuthenticated,
-        user,
-        accountAddress,
-        // Actions
-        initialize,
-        login,
-        loginWithRawData,
-        logout,
-    };
-};
-
-const useTokens = () => {
-    const { tokens, isInitialized, isAuthenticated } = usePersSDK();
-    if (!isAuthenticated && isInitialized) {
-        console.warn('SDK not authenticated. Some token operations may fail.');
-    }
-    const getTokens = useCallback(async () => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!tokens?.getTokens) {
-            console.warn('getTokens method not available');
-            return [];
-        }
-        try {
-            const result = await tokens.getTokens();
-            console.log('✅ Tokens fetched successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to fetch tokens:', error);
-            throw error;
-        }
-    }, [tokens]);
-    const getTokenById = useCallback(async (tokenId) => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!tokens?.getTokenById) {
-            throw new Error('getTokenById method not available');
-        }
-        try {
-            const result = await tokens.getTokenById(tokenId);
-            console.log('✅ Token fetched successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to fetch token:', error);
-            throw error;
-        }
-    }, [tokens]);
-    return {
-        getTokens,
-        getTokenById,
-        isAvailable: isInitialized && !!tokens,
-    };
-};
-
-const useTransactions = () => {
-    const { transactions, isInitialized, isAuthenticated } = usePersSDK();
-    if (!isAuthenticated && isInitialized) {
-        console.warn('SDK not authenticated. Some transaction operations may fail.');
-    }
-    const createTransaction = useCallback(async (request) => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!transactions?.createTransaction) {
-            throw new Error('createTransaction method not available');
-        }
-        try {
-            console.log('🔄 Creating transaction with request:', request);
-            const result = await transactions.createTransaction(request);
-            // React Native specific: Handle signature URLs
-            if (result?.actionable?.actionUrl) {
-                try {
-                    const { Linking } = require('react-native');
-                    console.log('🔗 Opening signature URL:', result.actionable.actionUrl);
-                    await Linking.openURL(result.actionable.actionUrl);
-                }
-                catch (linkingError) {
-                    console.error('❌ Failed to open signature URL:', linkingError);
-                }
-            }
-            console.log('✅ Transaction created successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to create transaction:', error);
-            throw error;
-        }
-    }, [transactions]);
-    const getTransactionById = useCallback(async (transactionId) => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!transactions?.getTransactionById) {
-            throw new Error('getTransactionById method not available');
-        }
-        try {
-            const result = await transactions.getTransactionById(transactionId);
-            console.log('✅ Transaction fetched successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to fetch transaction:', error);
-            throw error;
-        }
-    }, [transactions]);
-    const getTransactionHistory = useCallback(async (filters) => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!transactions?.getTransactionHistory) {
-            console.warn('getTransactionHistory method not available');
-            return [];
-        }
-        try {
-            const result = await transactions.getTransactionHistory(filters);
-            console.log('✅ Transaction history fetched successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to fetch transaction history:', error);
-            throw error;
-        }
-    }, [transactions]);
-    return {
-        createTransaction,
-        getTransactionById,
-        getTransactionHistory,
-        isAvailable: isInitialized && !!transactions,
-    };
-};
-
-const useBusiness = () => {
-    const { business, isInitialized } = usePersSDK();
-    const getActiveBusinesses = useCallback(async () => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!business?.getActiveBusinesses) {
-            console.warn('getActiveBusinesses method not available');
-            return [];
-        }
-        try {
-            const result = await business.getActiveBusinesses();
-            console.log('✅ Active businesses fetched successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to fetch active businesses:', error);
-            throw error;
-        }
-    }, [business]);
-    const getAllBusinessTypes = useCallback(async () => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!business?.getAllBusinessTypes) {
-            console.warn('getAllBusinessTypes method not available');
-            return [];
-        }
-        try {
-            const result = await business.getAllBusinessTypes();
-            console.log('✅ Business types fetched successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to fetch business types:', error);
-            throw error;
-        }
-    }, [business]);
-    const getBusinessById = useCallback(async (businessId) => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!business?.getBusinessById) {
-            throw new Error('getBusinessById method not available');
-        }
-        try {
-            const result = await business.getBusinessById(businessId);
-            console.log('✅ Business fetched successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to fetch business:', error);
-            throw error;
-        }
-    }, [business]);
-    return {
-        getActiveBusinesses,
-        getAllBusinessTypes,
-        getBusinessById,
-        isAvailable: isInitialized && !!business,
-    };
-};
-
-const useCampaigns = () => {
-    const { campaigns, isInitialized, isAuthenticated } = usePersSDK();
-    const getActiveCampaigns = useCallback(async () => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!campaigns?.getActiveCampaigns) {
-            console.warn('getActiveCampaigns method not available');
-            return [];
-        }
-        try {
-            const result = await campaigns.getActiveCampaigns();
-            console.log('✅ Active campaigns fetched successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to fetch active campaigns:', error);
-            throw error;
-        }
-    }, [campaigns]);
-    const getCampaignById = useCallback(async (campaignId) => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!campaigns?.getCampaignById) {
-            throw new Error('getCampaignById method not available');
-        }
-        try {
-            const result = await campaigns.getCampaignById(campaignId);
-            console.log('✅ Campaign fetched successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to fetch campaign:', error);
-            throw error;
-        }
-    }, [campaigns]);
-    const claimCampaign = useCallback(async (request) => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!isAuthenticated) {
-            throw new Error('SDK not authenticated. claimCampaign requires authentication.');
-        }
-        if (!campaigns?.claimCampaign) {
-            throw new Error('claimCampaign method not available');
-        }
-        try {
-            console.log('🔄 Claiming campaign with request:', request);
-            const result = await campaigns.claimCampaign(request);
-            console.log('✅ Campaign claimed successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to claim campaign:', error);
-            throw error;
-        }
-    }, [isInitialized, isAuthenticated, campaigns]);
-    const getClaimsForLoggedUser = useCallback(async () => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!isAuthenticated) {
-            console.warn('SDK not authenticated. getClaimsForLoggedUser requires authentication.');
-            return [];
-        }
-        if (!campaigns?.getClaimsForLoggedUser) {
-            console.warn('getClaimsForLoggedUser method not available');
-            return [];
-        }
-        try {
-            const result = await campaigns.getClaimsForLoggedUser();
-            console.log('✅ User claims fetched successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to fetch user claims:', error);
-            throw error;
-        }
-    }, [isInitialized, isAuthenticated, campaigns]);
-    return {
-        getActiveCampaigns,
-        getCampaignById,
-        claimCampaign,
-        getClaimsForLoggedUser,
-        isAvailable: isInitialized && !!campaigns,
-    };
-};
-
-const useRedemptions = () => {
-    const { redemptions, isInitialized, isAuthenticated } = usePersSDK();
-    // Admin method: Create new redemption offers
-    const createRedemption = useCallback(async (redemptionData) => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!redemptions?.createRedemption) {
-            throw new Error('createRedemption method not available - admin access required');
-        }
-        try {
-            console.log('🔄 Creating redemption offer with data:', redemptionData);
-            const result = await redemptions.createRedemption(redemptionData);
-            console.log('✅ Redemption offer created successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to create redemption offer:', error);
-            throw error;
-        }
-    }, [redemptions]);
-    const getActiveRedemptions = useCallback(async () => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!redemptions?.getActiveRedemptions) {
-            console.warn('getActiveRedemptions method not available');
-            return [];
-        }
-        try {
-            const result = await redemptions.getActiveRedemptions();
-            console.log('✅ Active redemptions fetched successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to fetch active redemptions:', error);
-            throw error;
-        }
-    }, [redemptions]);
-    const getUserRedeems = useCallback(async () => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!isAuthenticated) {
-            console.warn('SDK not authenticated. getUserRedeems requires authentication.');
-            return [];
-        }
-        if (!redemptions?.getUserRedeems) {
-            console.warn('getUserRedeems method not available');
-            return [];
-        }
-        try {
-            const result = await redemptions.getUserRedeems();
-            console.log('✅ User redemptions fetched successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to fetch user redemptions:', error);
-            throw error;
-        }
-    }, [isInitialized, isAuthenticated, redemptions]);
-    const redeemRedemption = useCallback(async (redemptionId) => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!isAuthenticated) {
-            throw new Error('SDK not authenticated. redeemRedemption requires authentication.');
-        }
-        if (!redemptions?.redeemRedemption) {
-            throw new Error('redeemRedemption method not available');
-        }
-        try {
-            console.log('🔄 Redeeming redemption:', redemptionId);
-            const result = await redemptions.redeemRedemption(redemptionId);
-            // React Native specific: Handle signature URLs for redemptions
-            if (result?.actionable?.actionUrl) {
-                try {
-                    const { Linking } = require('react-native');
-                    console.log('🔗 Opening redemption signature URL:', result.actionable.actionUrl);
-                    await Linking.openURL(result.actionable.actionUrl);
-                }
-                catch (linkingError) {
-                    console.error('❌ Failed to open redemption signature URL:', linkingError);
-                }
-            }
-            console.log('✅ Redemption processed successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to redeem redemption:', error);
-            throw error;
-        }
-    }, [isInitialized, isAuthenticated, redemptions]);
-    const getRedemptionById = useCallback(async (redemptionId) => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!redemptions?.getRedemptionById) {
-            throw new Error('getRedemptionById method not available');
-        }
-        try {
-            const result = await redemptions.getRedemptionById(redemptionId);
-            console.log('✅ Redemption fetched successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to fetch redemption:', error);
-            throw error;
-        }
-    }, [redemptions]);
-    return {
-        createRedemption,
-        getActiveRedemptions,
-        getUserRedeems,
-        redeemRedemption,
-        getRedemptionById,
-        isAvailable: isInitialized && !!redemptions,
-    };
-};
-
-const useWeb3 = () => {
-    const { web3, isInitialized, isAuthenticated, accountAddress } = usePersSDK();
-    if (!isAuthenticated && isInitialized) {
-        console.warn('SDK not authenticated. Some web3 operations may fail.');
-    }
-    const getTokenBalance = useCallback(async (request) => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!web3?.getTokenBalance) {
-            throw new Error('getTokenBalance method not available');
-        }
-        try {
-            const result = await web3.getTokenBalance(request);
-            console.log('✅ Token balance fetched successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to fetch token balance:', error);
-            throw error;
-        }
-    }, [web3]);
-    const getTokenCollection = useCallback(async (request) => {
-        if (!isInitialized) {
-            throw new Error('SDK not initialized. Call initialize() first.');
-        }
-        if (!web3?.getTokenCollection) {
-            console.warn('getTokenCollection method not available');
-            return [];
-        }
-        try {
-            const result = await web3.getTokenCollection(request);
-            console.log('✅ Token collection fetched successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('❌ Failed to fetch token collection:', error);
-            throw error;
-        }
-    }, [web3]);
-    const getWalletInfo = 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,
-        getTokenCollection,
-        getWalletInfo,
-        accountAddress: isInitialized ? accountAddress : null,
-        isAvailable: isInitialized && !!web3,
-    };
-};
-
-// Initialize React Native polyfills automatically
-// TEMPORARY: Minimal exports to isolate the .from() error
-console.log('🔍 [DEBUG] Loading React Native SDK...');
-console.log('🔍 [DEBUG] Auth providers loaded successfully');
-console.log('🔍 [DEBUG] React Native SDK loaded with full exports including useWeb3');
-// Note: For types and DTOs, import directly from @explorins/pers-shared 
-// This maintains clean separation and avoids circular dependencies
-// Example: import { TokenDTO, BusinessDTO } from '@explorins/pers-shared';
-
-export { BaseReactNativeAuthProvider, PersSDKProvider, ReactNativeAuthProvider, ReactNativeHttpClient, SecureReactNativeAuthProvider, StorageStrategy, initializeReactNativePolyfills, isReactNative, useAuth, useBusiness, useCampaigns, usePersSDK, useRedemptions, useTokens, useTransactions, useWeb3 };
-//# sourceMappingURL=index.esm.js.map