@explorins/pers-sdk-react-native 1.3.2

package/src/hooks/useTransactions.ts

@@ -0,0 +1,85 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+
+export 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: any) => {
+    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: string) => {
+    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?: any) => {
+    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,
+  };
+};

package/src/hooks/useWeb3.ts

@@ -0,0 +1,70 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+
+export 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: any) => {
+    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: any) => {
+    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,
+  };
+};

package/src/index.ts

@@ -0,0 +1,51 @@
+// Initialize React Native polyfills automatically
+import './polyfills';
+
+// TEMPORARY: Minimal exports to isolate the .from() error
+console.log('🔍 [DEBUG] Loading React Native SDK...');
+
+// Export React Native specific providers (FIRST - break circular dependency)
+export {
+  BaseReactNativeAuthProvider,
+  ReactNativeAuthProvider,
+  SecureReactNativeAuthProvider,
+  StorageStrategy,
+  type ReactNativeAuthConfig
+} from './providers/react-native-auth-provider';
+
+console.log('🔍 [DEBUG] Auth providers loaded successfully');
+
+// Export Provider and Context directly (avoid circular import through hooks)
+export {
+  PersSDKProvider,
+  usePersSDK,
+  type PersSDKConfig,
+  type PersSDKContext
+} from './providers/PersSDKProvider';
+
+// Export hooks (Primary Interface)
+export {
+  useAuth,
+  useTokens,
+  useTransactions,
+  useBusiness,
+  useCampaigns,
+  useRedemptions,
+  useWeb3
+} from './hooks';
+
+console.log('🔍 [DEBUG] React Native SDK loaded with full exports including useWeb3');
+
+export {
+  ReactNativeHttpClient
+} from './providers/react-native-http-client';
+
+// Export polyfill utilities for advanced usage
+export {
+  initializeReactNativePolyfills,
+  isReactNative
+} from './polyfills';
+
+// 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';

package/src/polyfills/index.simple.ts

@@ -0,0 +1,22 @@
+import { Buffer } from 'buffer';
+
+// Simple polyfills based on proven web project pattern
+// Minimal setup that actually works
+
+// Set up global environment
+(global as any).global = global;
+(global as any).Buffer = Buffer;
+
+// Only add what's actually needed for React Native
+if (typeof global !== 'undefined' && !global.process) {
+  global.process = { env: {} } as any;
+}
+
+// Export initialization function for compatibility
+export const initializeReactNativePolyfills = (): boolean => {
+  console.log('✅ [PERS SDK] Simple polyfills initialized');
+  return true;
+};
+
+// Auto-initialize
+initializeReactNativePolyfills();

package/src/polyfills/index.ts

@@ -0,0 +1,16 @@
+// Minimal React Native environment setup
+// No polyfills needed - modules are disabled at Metro level
+
+// Simple initialization function for compatibility
+export const initializeReactNativePolyfills = (): boolean => {
+  console.log('✅ [PERS SDK] React Native environment ready (no polyfills needed)');
+  return true;
+};
+
+// Platform detection
+export const isReactNative = (): boolean => {
+  return typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
+};
+
+// Auto-initialize
+initializeReactNativePolyfills();

package/src/providers/PersSDKProvider.tsx

@@ -0,0 +1,274 @@
+import React, { createContext, useContext, useEffect, useState, ReactNode, useCallback, useRef } 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';
+import { ReactNativeHttpClient } from './react-native-http-client';
+import { BaseReactNativeAuthProvider } from './react-native-auth-provider';
+
+// Types for the SDK context
+export interface PersSDKConfig {
+  apiProjectKey: string;
+  environment?: 'development' | 'staging' | 'production';
+  timeout?: number;
+}
+
+export interface PersSDKContext {
+  // SDK instances
+  tokens: any | null;
+  transactions: any | null;
+  business: any | null;
+  campaigns: any | null;
+  redemptions: any | null;
+  web3: any | null;
+  apiClient: PersApiClient | null;
+  
+  // State
+  isInitialized: boolean;
+  isAuthenticated: boolean;
+  user: any | null;
+  accountAddress: string | null;
+  
+  // Methods
+  initialize: (config: PersSDKConfig) => Promise<void>;
+  login: (jwtToken: string, userType?: 'user' | 'admin') => Promise<any>;
+  loginWithRawData: (rawUserData: any) => Promise<any>;
+  logout: () => Promise<void>;
+}
+
+// Create the context
+const SDKContext = createContext<PersSDKContext | null>(null);
+
+// Custom auth provider for React Native
+class ReactNativeSDKAuthProvider extends BaseReactNativeAuthProvider {
+  public authType: 'admin' | 'user' = 'user';
+  private _token: string | null = null;
+  
+  constructor(private projectKey: string) {
+    super(projectKey);
+  }
+
+  async getToken(): Promise<string | null> {
+    return this._token;
+  }
+
+  async setToken(token: string | null): Promise<void> {
+    this._token = token;
+  }
+
+  async getProjectKey(): Promise<string | null> {
+    return this.projectKey;
+  }
+
+  async onTokenExpired(): Promise<void> {
+    console.log('Token expired - clearing token');
+    this._token = null;
+  }
+}
+
+// Provider component
+export const PersSDKProvider: React.FC<{
+  children: ReactNode;
+}> = ({ children }) => {
+  const initializingRef = useRef(false);
+  const [apiClient, setApiClient] = useState<PersApiClient | null>(null);
+  const [authProvider, setAuthProvider] = useState<ReactNativeSDKAuthProvider | null>(null);
+  const [sdks, setSdks] = useState<{
+    tokens: any | null;
+    transactions: any | null;
+    business: any | null;
+    campaigns: any | null;
+    redemptions: any | null;
+    web3: any | null;
+  }>({
+    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<any>(null);
+  const [accountAddress, setAccountAddress] = useState<string | null>(null);
+
+  const initialize = useCallback(async (config: PersSDKConfig) => {
+    // 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: string, userType: 'user' | 'admin' = '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 as any)?.accountAddress || 
+                                (userData as any)?.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: any) => {
+    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 as any)?.accountAddress || 
+                                (userData as any)?.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: PersSDKContext = {
+    // 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 (
+    <SDKContext.Provider value={contextValue}>
+      {children}
+    </SDKContext.Provider>
+  );
+};
+
+// Custom hook to use the SDK context
+export const usePersSDK = (): PersSDKContext => {
+  const context = useContext(SDKContext);
+  
+  if (!context) {
+    throw new Error('usePersSDK must be used within a PersSDKProvider');
+  }
+  
+  return context;
+};