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

package/src/hooks/useWeb3.ts

@@ -1,51 +1,224 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
+import type { 
+  TokenBalance, 
+  TokenBalanceRequest, 
+  TokenCollectionRequest, 
+  TokenCollection,
+  TokenMetadata
+} from '@explorins/pers-sdk/web3';
+import type { ChainData } from '@explorins/pers-sdk/web3-chain';
 
+interface WalletInfo {
+  address: string | null;
+  isConnected: boolean;
+}
+
+/**
+ * React hook for Web3 operations in the PERS SDK
+ * 
+ * Provides comprehensive Web3 functionality including token balance queries,
+ * metadata retrieval, collection management, IPFS resolution, and blockchain
+ * explorer integration. Supports multi-chain operations and wallet management.
+ * 
+ * @returns Web3 hook with methods for blockchain operations
+ * 
+ * @example
+ * ```typescript
+ * function Web3Component() {
+ *   const { 
+ *     getTokenBalance, 
+ *     getTokenMetadata, 
+ *     getWalletInfo,
+ *     accountAddress 
+ *   } = useWeb3();
+ *   
+ *   const loadTokenData = async () => {
+ *     try {
+ *       if (!accountAddress) {
+ *         console.log('No wallet connected');
+ *         return;
+ *       }
+ *       
+ *       const balance = await getTokenBalance({
+ *         walletAddress: accountAddress,
+ *         contractAddress: '0x123...',
+ *         chainId: 1
+ *       });
+ *       
+ *       console.log('Token balance:', balance);
+ *     } catch (error) {
+ *       console.error('Failed to load token data:', error);
+ *     }
+ *   };
+ * 
+ *   return (
+ *     <div>
+ *       {accountAddress ? (
+ *         <div>
+ *           <p>Wallet: {accountAddress}</p>
+ *           <button onClick={loadTokenData}>Load Tokens</button>
+ *         </div>
+ *       ) : (
+ *         <p>No wallet connected</p>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
 export const useWeb3 = () => {
-  const { web3, isInitialized, isAuthenticated, accountAddress } = usePersSDK();
+  const { sdk, 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) {
+  /**
+   * Retrieves token balance for a specific wallet and contract
+   * 
+   * @param request - Token balance request containing wallet address, contract, and chain info
+   * @returns Promise resolving to token balance data
+   * @throws Error if SDK is not initialized
+   * 
+   * @example
+   * ```typescript
+   * const { getTokenBalance } = useWeb3();
+   * const balance = await getTokenBalance({
+   *   walletAddress: '0x123...',
+   *   contractAddress: '0x456...',
+   *   chainId: 1,
+   *   tokenId: '1' // For NFTs
+   * });
+   * console.log('Balance:', balance.balance);
+   * ```
+   */
+  const getTokenBalance = useCallback(async (request: TokenBalanceRequest): Promise<TokenBalance> => {
+    console.log('[useWeb3] getTokenBalance called with request:', request);
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
-    if (!web3?.getTokenBalance) {
-      throw new Error('getTokenBalance method not available');
+    
+    try {
+      const result = await sdk.web3.getTokenBalance(request);
+      console.log('Token balance fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch token balance:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  /**
+   * Retrieves metadata for a specific token (useful for NFTs)
+   * 
+   * @param request - Token balance request containing contract and token info
+   * @returns Promise resolving to token metadata or null if not available
+   * @throws Error if SDK is not initialized
+   * 
+   * @example
+   * ```typescript
+   * const { getTokenMetadata } = useWeb3();
+   * const metadata = await getTokenMetadata({
+   *   contractAddress: '0x123...',
+   *   tokenId: '1',
+   *   chainId: 1
+   * });
+   * console.log('NFT name:', metadata?.name);
+   * console.log('NFT image:', metadata?.image);
+   * ```
+   */
+  const getTokenMetadata = useCallback(async (request: TokenBalanceRequest): Promise<TokenMetadata | null> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
     }
     
     try {
-      const result = await web3.getTokenBalance(request);
-      console.log('✅ Token balance fetched successfully:', result);
+      const result = await sdk.web3.getTokenMetadata(request);
+      console.log('Token metadata fetched successfully:', result);
       return result;
     } catch (error) {
-      console.error('❌ Failed to fetch token balance:', error);
+      console.error('Failed to fetch token metadata:', error);
       throw error;
     }
-  }, [web3]);
+  }, [sdk, isInitialized]);
 
-  const getTokenCollection = useCallback(async (request: any) => {
-    if (!isInitialized) {
+  const getTokenCollection = useCallback(async (request: TokenCollectionRequest): Promise<TokenCollection> => {
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
-    if (!web3?.getTokenCollection) {
-      console.warn('getTokenCollection method not available');
-      return [];
+    
+    try {
+      const result = await sdk.web3.getTokenCollection(request);
+      console.log('Token collection fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch token collection:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const resolveIPFSUrl = useCallback(async (url: string, chainId: number): Promise<string> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
     }
     
     try {
-      const result = await web3.getTokenCollection(request);
-      console.log('✅ Token collection fetched successfully:', result);
+      const result = await sdk.web3.resolveIPFSUrl(url, chainId);
+      console.log('IPFS URL resolved successfully:', result);
       return result;
     } catch (error) {
-      console.error('❌ Failed to fetch token collection:', error);
+      console.error('Failed to resolve IPFS URL:', error);
       throw error;
     }
-  }, [web3]);
+  }, [sdk, isInitialized]);
 
-  const getWalletInfo = useCallback(async () => {
+  const fetchAndProcessMetadata = useCallback(async (tokenUri: string, chainId: number): Promise<TokenMetadata | null> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.web3.fetchAndProcessMetadata(tokenUri, chainId);
+      console.log('Metadata fetched and processed successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch and process metadata:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const getChainDataById = useCallback(async (chainId: number): Promise<ChainData | null> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.web3.getChainDataById(chainId);
+      console.log('Chain data fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch chain data:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const getExplorerUrl = useCallback(async (chainId: number, address: string, type: 'address' | 'tx'): Promise<string> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.web3.getExplorerUrl(chainId, address, type);
+      console.log('Explorer URL generated successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to generate explorer URL:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const getWalletInfo = useCallback(async (): Promise<WalletInfo | null> => {
     if (!isInitialized) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
@@ -62,9 +235,16 @@ export const useWeb3 = () => {
 
   return {
     getTokenBalance,
+    getTokenMetadata,
     getTokenCollection,
+    resolveIPFSUrl,
+    fetchAndProcessMetadata,
+    getChainDataById,
+    getExplorerUrl,
     getWalletInfo,
     accountAddress: isInitialized ? accountAddress : null,
-    isAvailable: isInitialized && !!web3,
+    isAvailable: isInitialized && !!sdk?.web3,
   };
-};
+};
+
+export type Web3Hook = ReturnType<typeof useWeb3>;

package/src/index.ts

@@ -1,25 +1,17 @@
 // 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 PersConfig,
   type PersSDKContext
 } from './providers/PersSDKProvider';
 
@@ -31,21 +23,33 @@ export {
   useBusiness,
   useCampaigns,
   useRedemptions,
-  useWeb3
+  useWeb3,
+  usePurchases,
+  useTenants,
+  useUsers,
+  useUserStatus,
+  useFiles,
+  useAnalytics,
+  useDonations
 } 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
+  initializeReactNativePolyfills
 } 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';
+// Re-export all types and utilities from @explorins/pers-shared
+export * from '@explorins/pers-shared';
+
+// Re-export Web3 types from base SDK
+export type { 
+  TokenBalanceRequest, 
+  TokenBalance, 
+  TokenMetadata, 
+  TokenCollection,
+  TokenCollectionRequest
+} from '@explorins/pers-sdk/web3';

package/src/polyfills/index.ts

@@ -1,16 +1,169 @@
-// Minimal React Native environment setup
-// No polyfills needed - modules are disabled at Metro level
+// React Native polyfills for crypto and Web3 functionality
+// Consolidated "batteries included" approach for React Native SDK
 
-// Simple initialization function for compatibility
+import { Buffer } from 'buffer';
+import { setupWeb3InstanceofPolyfill } from './web3-polyfills';
+
+// Initialize React Native polyfills
 export const initializeReactNativePolyfills = (): boolean => {
-  console.log('✅ [PERS SDK] React Native environment ready (no polyfills needed)');
-  return true;
+  try {
+    // Set up basic global environment
+    (global as any).global = global;
+    (global as any).Buffer = Buffer;
+
+    // Add process if missing
+    if (typeof global !== 'undefined' && !global.process) {
+      global.process = { 
+        env: {},
+        version: '16.0.0',
+        nextTick: (callback: () => void) => setTimeout(callback, 0)
+      } as any;
+    }
+
+    // Initialize crypto polyfills (CRITICAL for Web3)
+    require('react-native-get-random-values');
+    
+    // Crypto polyfill for better Web3 compatibility
+    if (typeof global !== 'undefined' && !(global as any).crypto) {
+      (global as any).crypto = {
+        getRandomValues: (arr: any) => {
+          require('react-native-get-random-values');
+          return (global as any).crypto.getRandomValues(arr);
+        },
+        randomUUID: () => {
+          const hex = '0123456789abcdef';
+          let result = '';
+          for (let i = 0; i < 32; i++) {
+            result += hex[Math.floor(Math.random() * 16)];
+            if (i === 7 || i === 11 || i === 15 || i === 19) result += '-';
+          }
+          return result;
+        }
+      };
+    }
+    
+    // Add URL polyfill for Web3 compatibility
+    if (typeof global !== 'undefined' && !(global as any).URL) {
+      try {
+        // Try to use react-native-url-polyfill if available
+        require('react-native-url-polyfill/auto');
+      } catch {
+        // Fallback to basic URL implementation
+        (global as any).URL = class URL {
+          constructor(public href: string) {}
+          toString() { return this.href; }
+        } as any;
+      }
+    }
+
+    // Add btoa/atob polyfills for Web3 compatibility
+    if (typeof global !== 'undefined') {
+      if (!(global as any).btoa) {
+        (global as any).btoa = (str: string) => Buffer.from(str, 'binary').toString('base64');
+      }
+      if (!(global as any).atob) {
+        (global as any).atob = (str: string) => Buffer.from(str, 'base64').toString('binary');
+      }
+    }
+
+    // EventTarget polyfill for Web3 providers
+    if (typeof global !== 'undefined' && !(global as any).EventTarget) {
+      (global as any).EventTarget = class EventTarget {
+        private listeners: { [key: string]: ((...args: any[]) => void)[] } = {};
+        
+        addEventListener(type: string, listener: (...args: any[]) => void) {
+          if (!this.listeners[type]) {
+            this.listeners[type] = [];
+          }
+          this.listeners[type].push(listener);
+        }
+        
+        removeEventListener(type: string, listener: (...args: any[]) => void) {
+          if (this.listeners[type]) {
+            const index = this.listeners[type].indexOf(listener);
+            if (index > -1) {
+              this.listeners[type].splice(index, 1);
+            }
+          }
+        }
+        
+        dispatchEvent(event: any) {
+          if (this.listeners[event.type]) {
+            this.listeners[event.type].forEach(listener => {
+              listener(event);
+            });
+          }
+          return true;
+        }
+      };
+    }
+
+    // Performance polyfill
+    if (typeof global !== 'undefined' && !(global as any).performance) {
+      (global as any).performance = {
+        now: () => Date.now(),
+        timeOrigin: Date.now()
+      };
+    }
+
+    // Stream polyfill (minimal)
+    if (typeof global !== 'undefined' && !(global as any).stream) {
+      (global as any).stream = {
+        Readable: class {},
+        Writable: class {},
+        Transform: class {}
+      };
+    }
+
+    // Web3 specific polyfills for instanceof issues
+    setupWeb3Polyfills();
+    setupWeb3InstanceofPolyfill();
+    
+    return true;
+  } catch (error) {
+    console.warn('[PERS SDK] Failed to initialize some polyfills:', error);
+    return true;
+  }
 };
 
-// Platform detection
-export const isReactNative = (): boolean => {
-  return typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
+// Web3 specific polyfills to fix instanceof issues
+const setupWeb3Polyfills = () => {
+  try {
+    // Ensure Symbol polyfill for constructor comparison
+    if (typeof global !== 'undefined' && !(global as any).Symbol) {
+      (global as any).Symbol = {
+        for: (key: string) => `Symbol(${key})`,
+        iterator: '@@iterator',
+        toStringTag: '@@toStringTag'
+      };
+    }
+
+    // Add constructor.name polyfill for better class detection
+    if (typeof global !== 'undefined' && typeof Function !== 'undefined') {
+      const originalToString = Function.prototype.toString;
+      if (!Function.prototype.name) {
+        Object.defineProperty(Function.prototype, 'name', {
+          get: function() {
+            const match = originalToString.call(this).match(/function\s*([^(]*)/);
+            return match ? match[1] : '';
+          }
+        });
+      }
+    }
+
+    // Module resolution enhancement for Web3
+    if (typeof global !== 'undefined') {
+      // Store reference to help with instanceof checks
+      (global as any).__PERS_SDK_WEB3_POLYFILLS__ = true;
+    }
+
+  } catch (error) {
+    console.warn('[PERS SDK] Web3 polyfills setup failed:', error);
+  }
 };
 
-// Auto-initialize
-initializeReactNativePolyfills();
+// Auto-initialize polyfills when SDK is imported
+initializeReactNativePolyfills();
+
+// Export utilities for advanced usage
+export { createSafeWeb3Check } from './web3-polyfills';

package/src/polyfills/web3-polyfills.ts

@@ -0,0 +1,98 @@
+/**
+ * Web3 specific polyfills for React Native
+ * Addresses instanceof and constructor issues in React Native environments
+ */
+
+export const setupWeb3InstanceofPolyfill = () => {
+  try {
+    // Store the original instanceof behavior
+    const originalInstanceof = Function.prototype[Symbol.hasInstance];
+    
+    // Override Symbol.hasInstance for better Web3 detection in React Native
+    if (typeof global !== 'undefined' && global.Symbol && global.Symbol.hasInstance) {
+      // Create a safer instanceof check for Web3
+      const createSafeInstanceofCheck = (constructor: any) => {
+        return function(instance: any) {
+          // Try the original check first
+          try {
+            if (originalInstanceof) {
+              return originalInstanceof.call(constructor, instance);
+            }
+            return instance instanceof constructor;
+          } catch (error) {
+            // Fallback to constructor and duck-typing checks
+            if (!instance || typeof instance !== 'object') {
+              return false;
+            }
+            
+            // Check constructor name
+            if (instance.constructor && instance.constructor.name === constructor.name) {
+              return true;
+            }
+            
+            // Check constructor reference
+            if (instance.constructor === constructor) {
+              return true;
+            }
+            
+            // For Web3 specifically, check characteristic properties
+            if (constructor.name === 'Web3' && 
+                'currentProvider' in instance && 
+                'eth' in instance && 
+                'utils' in instance) {
+              return true;
+            }
+            
+            return false;
+          }
+        };
+      };
+      
+      // Apply the polyfill to global scope for dynamic loading
+      (global as any).__PERS_SDK_SAFE_INSTANCEOF__ = createSafeInstanceofCheck;
+      
+    }
+    
+    return true;
+  } catch (error) {
+    console.warn('[PERS SDK] Web3 instanceof polyfill setup failed:', error);
+    return false;
+  }
+};
+
+export const createSafeWeb3Check = (provider: unknown): boolean => {
+  if (!provider || typeof provider !== 'object') {
+    return false;
+  }
+  
+  try {
+    // Method 1: Check if it's already a Web3 instance using multiple approaches
+    const providerObj = provider as any;
+    
+    // Constructor name check
+    if (providerObj.constructor?.name === 'Web3') {
+      return true;
+    }
+    
+    // Duck typing for Web3 properties
+    if ('currentProvider' in providerObj && 
+        'eth' in providerObj && 
+        'utils' in providerObj &&
+        typeof providerObj.eth === 'object') {
+      return true;
+    }
+    
+    // Check for Web3 version property
+    if ('version' in providerObj && typeof providerObj.version === 'string') {
+      return true;
+    }
+    
+    return false;
+  } catch (error) {
+    console.warn('Safe Web3 check failed:', error);
+    return false;
+  }
+};
+
+// Auto-initialize
+setupWeb3InstanceofPolyfill();