@explorins/pers-sdk-react-native 1.3.2

package/dist/index.js

@@ -0,0 +1,1077 @@
+
+// React Native optimized CJS bundle
+// Node.js dependencies excluded for web compatibility
+
+'use strict';
+
+var AsyncStorage = require('@react-native-async-storage/async-storage');
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var core = require('@explorins/pers-sdk/core');
+var token = require('@explorins/pers-sdk/token');
+var transaction = require('@explorins/pers-sdk/transaction');
+var business = require('@explorins/pers-sdk/business');
+var campaign = require('@explorins/pers-sdk/campaign');
+var redemption = require('@explorins/pers-sdk/redemption');
+var web3 = require('@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
+ */
+exports.StorageStrategy = void 0;
+(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";
+})(exports.StorageStrategy || (exports.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: exports.StorageStrategy.ASYNC_STORAGE,
+            refreshTokenStrategy: exports.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 exports.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 exports.StorageStrategy.ASYNC_STORAGE:
+                    await AsyncStorage.setItem(key, value);
+                    break;
+                case exports.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 exports.StorageStrategy.KEYCHAIN:
+                    // Try Keychain first, fallback to AsyncStorage
+                    if (await this.isKeychainAvailable()) {
+                        return await this.getFromKeychain(key);
+                    }
+                    else {
+                        return await AsyncStorage.getItem(key);
+                    }
+                case exports.StorageStrategy.ASYNC_STORAGE:
+                    return await AsyncStorage.getItem(key);
+                case exports.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 exports.StorageStrategy.KEYCHAIN:
+                    // Try Keychain first, fallback to AsyncStorage
+                    if (await this.isKeychainAvailable()) {
+                        await this.removeFromKeychain(key);
+                    }
+                    else {
+                        await AsyncStorage.removeItem(key);
+                    }
+                    break;
+                case exports.StorageStrategy.ASYNC_STORAGE:
+                    await AsyncStorage.removeItem(key);
+                    break;
+                case exports.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: exports.StorageStrategy.ASYNC_STORAGE,
+            refreshTokenStrategy: exports.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: exports.StorageStrategy.KEYCHAIN,
+            refreshTokenStrategy: exports.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 = react.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 = react.useRef(false);
+    const [apiClient, setApiClient] = react.useState(null);
+    const [authProvider, setAuthProvider] = react.useState(null);
+    const [sdks, setSdks] = react.useState({
+        tokens: null,
+        transactions: null,
+        business: null,
+        campaigns: null,
+        redemptions: null,
+        web3: null,
+    });
+    const [isInitialized, setIsInitialized] = react.useState(false);
+    const [isAuthenticated, setIsAuthenticated] = react.useState(false);
+    const [user, setUser] = react.useState(null);
+    const [accountAddress, setAccountAddress] = react.useState(null);
+    const initialize = react.useCallback(async (config) => {
+        // Prevent multiple initializations
+        if (isInitialized || initializingRef.current) {
+            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 core.PersApiClient(httpClient, {
+                apiProjectKey: config.apiProjectKey,
+                authProvider: auth,
+                environment: config.environment || 'development',
+            });
+            setApiClient(client);
+            // Initialize domain SDKs
+            const domainSDKs = {
+                tokens: new token.TokenSDK(client),
+                transactions: transaction.createTransactionSDK(client),
+                business: business.createBusinessSDK(client),
+                campaigns: campaign.createCampaignSDK(client),
+                redemptions: redemption.createRedemptionSDK(client),
+                web3: 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 = react.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 = react.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 = react.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 (jsxRuntime.jsx(SDKContext.Provider, { value: contextValue, children: children }));
+};
+// Custom hook to use the SDK context
+const usePersSDK = () => {
+    const context = react.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 = react.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 = react.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 = react.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 = react.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 = react.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 = react.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 = react.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 = react.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 = react.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 = react.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 = react.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 = react.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 = react.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 = react.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 = react.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 = react.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 = react.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 = react.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 = react.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 = react.useCallback(async () => {
+        if (!isInitialized) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!accountAddress) {
+            console.warn('No account address available');
+            return null;
+        }
+        return {
+            address: accountAddress,
+            isConnected: !!accountAddress,
+        };
+    }, [isInitialized, accountAddress]);
+    return {
+        getTokenBalance,
+        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';
+
+exports.BaseReactNativeAuthProvider = BaseReactNativeAuthProvider;
+exports.PersSDKProvider = PersSDKProvider;
+exports.ReactNativeAuthProvider = ReactNativeAuthProvider;
+exports.ReactNativeHttpClient = ReactNativeHttpClient;
+exports.SecureReactNativeAuthProvider = SecureReactNativeAuthProvider;
+exports.initializeReactNativePolyfills = initializeReactNativePolyfills;
+exports.isReactNative = isReactNative;
+exports.useAuth = useAuth;
+exports.useBusiness = useBusiness;
+exports.useCampaigns = useCampaigns;
+exports.usePersSDK = usePersSDK;
+exports.useRedemptions = useRedemptions;
+exports.useTokens = useTokens;
+exports.useTransactions = useTransactions;
+exports.useWeb3 = useWeb3;
+//# sourceMappingURL=index.js.map