@explorins/pers-sdk-react-native 1.5.30 → 1.5.32

package/src/hooks/useWeb3.ts

@@ -9,73 +9,58 @@ import type {
 } from '@explorins/pers-sdk/web3';
 import type { ChainData } from '@explorins/pers-sdk/web3-chain';
 
-/**
- * Wallet information interface
- * 
- * @interface WalletInfo
- * @property {string | null} address - Wallet address if connected
- * @property {boolean} isConnected - Whether wallet is connected
- */
-export 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.
+ * explorer integration. Supports multi-chain operations.
+ * 
+ * Note: Wallet addresses should be obtained from `user.wallets` via `usePersSDK()`.
  * 
  * @returns Web3 hook with methods for blockchain operations
  * 
  * @example
  * ```typescript
  * function Web3Component() {
- *   const { 
- *     getTokenBalance, 
- *     getTokenMetadata, 
- *     getWalletInfo,
- *     accountAddress 
- *   } = useWeb3();
+ *   const { user } = usePersSDK();
+ *   const { getTokenBalance, getTokenMetadata } = useWeb3();
+ *   
+ *   // Get wallet address from user
+ *   const walletAddress = user?.wallets?.[0]?.address;
  *   
  *   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);
+ *     if (!walletAddress) {
+ *       console.log('No wallet connected');
+ *       return;
  *     }
+ *     
+ *     const balance = await getTokenBalance({
+ *       walletAddress,
+ *       contractAddress: '0x123...',
+ *       chainId: 1
+ *     });
+ *     
+ *     console.log('Token balance:', balance);
  *   };
  * 
  *   return (
- *     <div>
- *       {accountAddress ? (
- *         <div>
- *           <p>Wallet: {accountAddress}</p>
- *           <button onClick={loadTokenData}>Load Tokens</button>
- *         </div>
+ *     <View>
+ *       {walletAddress ? (
+ *         <View>
+ *           <Text>Wallet: {walletAddress}</Text>
+ *           <Button onPress={loadTokenData} title="Load Tokens" />
+ *         </View>
  *       ) : (
- *         <p>No wallet connected</p>
+ *         <Text>No wallet connected</Text>
  *       )}
- *     </div>
+ *     </View>
  *   );
  * }
  * ```
  */
 export const useWeb3 = () => {
-  const { sdk, isInitialized, isAuthenticated, accountAddress } = usePersSDK();
+  const { sdk, isInitialized, isAuthenticated } = usePersSDK();
 
   if (!isAuthenticated && isInitialized) {
     console.warn('SDK not authenticated. Some web3 operations may fail.');
@@ -101,14 +86,12 @@ export const useWeb3 = () => {
    * ```
    */
   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.');
     }
     
     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);
@@ -142,7 +125,6 @@ export const useWeb3 = () => {
     
     try {
       const result = await sdk.web3.getTokenMetadata(request);
-      console.log('Token metadata fetched successfully:', result);
       return result;
     } catch (error) {
       console.error('Failed to fetch token metadata:', error);
@@ -157,7 +139,6 @@ export const useWeb3 = () => {
     
     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);
@@ -172,7 +153,6 @@ export const useWeb3 = () => {
     
     try {
       const result = await sdk.web3.resolveIPFSUrl(url, chainId);
-      console.log('IPFS URL resolved successfully:', result);
       return result;
     } catch (error) {
       console.error('Failed to resolve IPFS URL:', error);
@@ -187,7 +167,6 @@ export const useWeb3 = () => {
     
     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);
@@ -202,7 +181,6 @@ export const useWeb3 = () => {
     
     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);
@@ -217,7 +195,6 @@ export const useWeb3 = () => {
     
     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);
@@ -225,21 +202,6 @@ export const useWeb3 = () => {
     }
   }, [sdk, isInitialized]);
 
-  const getWalletInfo = useCallback(async (): Promise<WalletInfo | null> => {
-    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,
     getTokenMetadata,
@@ -248,8 +210,6 @@ export const useWeb3 = () => {
     fetchAndProcessMetadata,
     getChainDataById,
     getExplorerUrl,
-    getWalletInfo,
-    accountAddress: isInitialized ? accountAddress : null,
     isAvailable: isInitialized && !!sdk?.web3,
   };
 };

package/src/index.ts

@@ -228,6 +228,7 @@ export {
   useTokens,
   useTransactions,
   useTransactionSigner,
+  SigningStatus,
   useBusiness,
   useCampaigns,
   useRedemptions,
@@ -241,6 +242,9 @@ export {
   useDonations
 } from './hooks';
 
+// Re-export signing status types for convenience
+export type { OnStatusUpdateFn, StatusUpdateData, SigningStatusType } from './hooks';
+
 // ==============================================================================
 // PLATFORM ADAPTERS
 // ==============================================================================

package/src/providers/PersSDKProvider.tsx

@@ -1,6 +1,6 @@
-import React, { createContext, useContext, useState, ReactNode, useCallback, useRef, useEffect } from 'react';
+import React, { createContext, useContext, useState, ReactNode, useCallback, useRef, useEffect, useMemo } from 'react';
 import { Platform } from 'react-native';
-import { PersSDK, PersConfig, DefaultAuthProvider, DPoPCryptoProvider } from '@explorins/pers-sdk/core';
+import { PersSDK, PersConfig, DefaultAuthProvider } from '@explorins/pers-sdk/core';
 import { ReactNativeHttpClient } from './react-native-http-client';
 import { createReactNativeAuthProvider } from './react-native-auth-provider';
 import { ReactNativeDPoPProvider } from './rn-dpop-provider';
@@ -41,21 +41,17 @@ export interface PersSDKContext {
   analytics: AnalyticsManager | null;
   donations: DonationManager | null;
   
-  // Legacy support (deprecated but kept for backward compatibility)
-  business: BusinessManager | null;
-  
-  // Platform-specific providers - now uses unified auth provider
+  // Platform-specific providers
   authProvider: DefaultAuthProvider | null;
   
   // State
   isInitialized: boolean;
   isAuthenticated: boolean;
   user: UserDTO | AdminDTO | null;
-  accountAddress: string | null;
   
   // Methods
   initialize: (config: PersConfig) => Promise<void>;
-  setAuthenticationState: (user: UserDTO | AdminDTO | null, accountAddress: string | null, isAuthenticated: boolean) => void;
+  setAuthenticationState: (user: UserDTO | AdminDTO | null, isAuthenticated: boolean) => void;
   refreshUserData: () => Promise<void>;
 }
 
@@ -74,7 +70,6 @@ export const PersSDKProvider: React.FC<{
   const [isInitialized, setIsInitialized] = useState(false);
   const [isAuthenticated, setIsAuthenticated] = useState(false);
   const [user, setUser] = useState<UserDTO | AdminDTO | null>(null);
-  const [accountAddress, setAccountAddress] = useState<string | null>(null);
 
   const initialize = useCallback(async (config: PersConfig) => {
     // Prevent multiple initializations
@@ -88,10 +83,10 @@ export const PersSDKProvider: React.FC<{
       // Create HTTP client
       const httpClient = new ReactNativeHttpClient();
       
-      // Ensure DPoP is enabled by default for all platforms
-      const dpopConfig = config.dpop || {};
+      const dpopConfig = config.dpop ?? {};
+      
       const isDpopEnabled = dpopConfig.enabled ?? true;
-
+      
       // Prepare DPoP settings for Auth Provider
       const dpopSettings = {
         enabled: isDpopEnabled,
@@ -146,9 +141,8 @@ export const PersSDKProvider: React.FC<{
     }
   }, [config, isInitialized, initialize]);
 
-  const setAuthenticationState = useCallback((user: UserDTO | AdminDTO | null, accountAddress: string | null, isAuthenticated: boolean) => {
+  const setAuthenticationState = useCallback((user: UserDTO | AdminDTO | null, isAuthenticated: boolean) => {
     setUser(user);
-    setAccountAddress(accountAddress);
     setIsAuthenticated(isAuthenticated);
   }, []);
 
@@ -166,7 +160,7 @@ export const PersSDKProvider: React.FC<{
     }
   }, [sdk, isAuthenticated, isInitialized]);
 
-  const contextValue: PersSDKContext = {
+  const contextValue: PersSDKContext = useMemo(() => ({
     // Main SDK instance
     sdk,
     
@@ -183,9 +177,6 @@ export const PersSDKProvider: React.FC<{
     analytics: sdk?.analytics || null,
     donations: sdk?.donations || null,
     
-    // Legacy support (deprecated but kept for backward compatibility)
-    business: sdk?.businesses || null,
-    
     // Platform-specific providers
     authProvider,
     
@@ -193,13 +184,21 @@ export const PersSDKProvider: React.FC<{
     isInitialized,
     isAuthenticated,
     user,
-    accountAddress,
     
     // Methods
     initialize,
     setAuthenticationState,
     refreshUserData,
-  };
+  }), [
+    sdk,
+    authProvider,
+    isInitialized,
+    isAuthenticated,
+    user,
+    initialize,
+    setAuthenticationState,
+    refreshUserData
+  ]);
 
   return (
     <SDKContext.Provider value={contextValue}>

package/src/providers/react-native-auth-provider.ts

@@ -73,6 +73,11 @@ export function createReactNativeAuthProvider(
     enabled: dpop.enabled ?? true,
     cryptoProvider: dpop.cryptoProvider
   } : undefined;
+  
+  // DEBUG LOGGING
+  if (debug) {
+    console.log('[ReactNativeAuthProvider] Creating provider with DPoP config:', JSON.stringify(dpopConfig));
+  }
 
   // Return DefaultAuthProvider configured with platform-appropriate storage
   return new DefaultAuthProvider({

package/src/providers/rn-dpop-provider.ts

@@ -12,7 +12,6 @@ if (Platform.OS !== 'web') {
   }
 } else {
   // on Web, we shouldn't be using this provider anyway (Core SDK has WebDPoPProvider)
-  // But to be safe, we can mock or throw
   crypto = {
     generateKeyPair: () => { throw new Error('ReactNativeDPoPProvider not supported on Web'); }
   };
@@ -22,83 +21,124 @@ export class ReactNativeDPoPProvider implements DPoPCryptoProvider {
   /**
    * Generates a new key pair (ES256 recommended)
    * 
-   * Note: options.extractable is ignored because for React Native Keychain storage,
-   * we MUST export the keys as JWK/strings. We rely on the Keychain encryption
-   * for security at rest (High Security), making the key "Extractable" in memory 
-   * but protected by hardware encryption when stored.
+   * Uses WebCrypto API (crypto.subtle) for cross-platform compatibility.
+   * Falls back to Node.js crypto API on iOS if needed.
    */
   async generateKeyPair(options?: { extractable?: boolean }): Promise<DPoPKeyPair> {
-    // Generate P-256 Key Pair
+    // Try WebCrypto API first (works on both iOS and Android)
+    if (crypto.subtle) {
+      try {
+        const keyPair = await crypto.subtle.generateKey(
+          { name: 'ECDSA', namedCurve: 'P-256' },
+          true, // extractable - required for JWK export
+          ['sign', 'verify']
+        );
+
+        const publicKeyJwk = await crypto.subtle.exportKey('jwk', keyPair.publicKey);
+        const privateKeyJwk = await crypto.subtle.exportKey('jwk', keyPair.privateKey);
+
+        return {
+          publicKey: publicKeyJwk,
+          privateKey: privateKeyJwk
+        };
+      } catch (err) {
+        console.warn('[DPoP] WebCrypto API failed, trying Node.js crypto API', err);
+      }
+    }
+
+    // Fallback: Node.js crypto API (works on iOS)
     return new Promise((resolve, reject) => {
-        crypto.generateKeyPair('ec', { namedCurve: 'P-256' }, (err: any, publicKey: any, privateKey: any) => {
-            if (err) return reject(err);
-            
-            // Export to JWK for SDK Compatibility
-            // We use 'export' because supportsObjects=false in our storage forces the SDK
-            // to expect serializable keys.
-            const pubJwk = publicKey.export({ format: 'jwk' });
-            const privJwk = privateKey.export({ format: 'jwk' });
-            
-            resolve({
-                publicKey: pubJwk,
-                privateKey: privJwk
-            });
-        });
+      crypto.generateKeyPair('ec', { namedCurve: 'P-256' }, (err: any, publicKey: any, privateKey: any) => {
+        if (err) return reject(err);
+        try {
+          const pJwk = publicKey.export({ format: 'jwk' });
+          const prJwk = privateKey.export({ format: 'jwk' });
+          resolve({ publicKey: pJwk, privateKey: prJwk });
+        } catch (exportErr) {
+          reject(exportErr);
+        }
+      });
     });
   }
 
   async signProof(payload: Record<string, any>, keyPair: DPoPKeyPair): Promise<string> {
     // 1. Construct Header
     const header = {
-        typ: 'dpop+jwt',
-        alg: 'ES256',
-        jwk: keyPair.publicKey
+      typ: 'dpop+jwt',
+      alg: 'ES256',
+      jwk: keyPair.publicKey
     };
 
     // 2. Add Claims (iat/jti)
     const finalPayload = {
-        ...payload,
-        iat: payload.iat || Math.floor(Date.now() / 1000),
-        jti: payload.jti || crypto.randomUUID()
+      ...payload,
+      iat: payload.iat || Math.floor(Date.now() / 1000),
+      jti: payload.jti || crypto.randomUUID()
     };
-    
+
     // 3. Encode
     const b64Header = this.base64Url(JSON.stringify(header));
     const b64Payload = this.base64Url(JSON.stringify(finalPayload));
     const signingInput = `${b64Header}.${b64Payload}`;
-    
-    // 4. Sign
+
+    // 4. Sign - try WebCrypto first, fallback to Node.js crypto
+    if (crypto.subtle) {
+      try {
+        const privateKey = await crypto.subtle.importKey(
+          'jwk',
+          keyPair.privateKey,
+          { name: 'ECDSA', namedCurve: 'P-256' },
+          false,
+          ['sign']
+        );
+
+        const signatureBuffer = await crypto.subtle.sign(
+          { name: 'ECDSA', hash: 'SHA-256' },
+          privateKey,
+          Buffer.from(signingInput)
+        );
+
+        // WebCrypto returns signature in IEEE P1363 format (r || s), which is what we need for JWT
+        return `${signingInput}.${this.base64UrlBuffer(Buffer.from(signatureBuffer))}`;
+      } catch (err) {
+        console.warn('[DPoP] WebCrypto sign failed, trying Node.js crypto', err);
+      }
+    }
+
+    // Fallback: Node.js crypto API
     const sign = crypto.createSign('SHA256');
     sign.update(signingInput);
-    // sign.end() is not required/available in quick-crypto as it doesn't strictly follow stream interface
-    
-    // Import private key back from JWK to sign
-    // The keyPair.privateKey is a JsonWebKey object because we exported it earlier.
-    // quick-crypto createPrivateKey expects jwk object if format is jwk
     const privateKeyObj = crypto.createPrivateKey({ key: keyPair.privateKey as any, format: 'jwk' });
-    const signature = sign.sign(privateKeyObj); 
-    // signature is a Buffer in quick-crypto
-    
+    const signature = sign.sign(privateKeyObj);
+
     return `${signingInput}.${this.base64UrlBuffer(signature)}`;
   }
 
   async hashAccessToken(accessToken: string): Promise<string> {
+    // Try WebCrypto first
+    if (crypto.subtle) {
+      try {
+        const hashBuffer = await crypto.subtle.digest('SHA-256', Buffer.from(accessToken));
+        return this.base64UrlBuffer(Buffer.from(hashBuffer));
+      } catch (err) {
+        // Fallback to Node.js crypto
+      }
+    }
+
     const hash = crypto.createHash('sha256').update(accessToken).digest();
-    // digest returns Buffer in quick-crypto
     return this.base64UrlBuffer(hash);
   }
 
   // --- Helpers ---
   private base64Url(str: string): string {
-      return this.base64UrlBuffer(Buffer.from(str));
+    return this.base64UrlBuffer(Buffer.from(str));
   }
 
   private base64UrlBuffer(buf: Buffer | Uint8Array): string {
-      // Ensure we have a Buffer
-      const buffer = Buffer.isBuffer(buf) ? buf : Buffer.from(buf);
-      return buffer.toString('base64')
-        .replace(/=/g, '')
-        .replace(/\+/g, '-')
-        .replace(/\//g, '_');
+    const buffer = Buffer.isBuffer(buf) ? buf : Buffer.from(buf);
+    return buffer.toString('base64')
+      .replace(/=/g, '')
+      .replace(/\+/g, '-')
+      .replace(/\//g, '_');
   }
 }

package/src/storage/rn-secure-storage.ts

@@ -1,10 +1,10 @@
 import { Platform } from 'react-native';
-import AsyncStorage from '@react-native-async-storage/async-storage';
 import { 
   TokenStorage, 
   DPOP_STORAGE_KEYS, 
   AUTH_STORAGE_KEYS 
 } from '@explorins/pers-sdk/core';
+import { AsyncStorageTokenStorage } from './async-storage-token-storage';
 
 // Conditionally require Keychain to avoid Web bundler errors
 let Keychain: any;
@@ -32,7 +32,11 @@ export class ReactNativeSecureStorage implements TokenStorage {
      AUTH_STORAGE_KEYS.PROVIDER_TOKEN
   ]);
 
-  constructor(private keyPrefix: string = 'pers_tokens_') {}
+  private fallbackStorage: AsyncStorageTokenStorage;
+
+  constructor(private keyPrefix: string = 'pers_tokens_') {
+    this.fallbackStorage = new AsyncStorageTokenStorage(keyPrefix);
+  }
 
   async set(key: string, value: unknown): Promise<void> {
     const prefixedKey = this.getKeyName(key);
@@ -52,11 +56,11 @@ export class ReactNativeSecureStorage implements TokenStorage {
       } catch (e) {
         console.warn(`[ReactNativeSecureStorage] Keychain set failed for ${key}, falling back to AsyncStorage`, e);
         // Fallback to AsyncStorage if Keychain fails
-        await AsyncStorage.setItem(prefixedKey, stringValue);
+        await this.fallbackStorage.set(key, stringValue);
       }
     } else {
       // Store standard config/metadata in AsyncStorage
-      await AsyncStorage.setItem(prefixedKey, stringValue);
+      await this.fallbackStorage.set(key, stringValue);
     }
   }
 
@@ -78,14 +82,14 @@ export class ReactNativeSecureStorage implements TokenStorage {
       
       // Fallback: Check AsyncStorage if not found in Keychain or Keychain failed
       try {
-        const val = await AsyncStorage.getItem(prefixedKey);
+        const val = await this.fallbackStorage.get(key);
         return val ? this.tryParse(val) : null;
       } catch (e) {
         return null;
       }
     } else {
       try {
-        const val = await AsyncStorage.getItem(prefixedKey);
+        const val = await this.fallbackStorage.get(key);
         return val ? this.tryParse(val) : null;
       } catch (e) {
         console.warn(`[ReactNativeSecureStorage] Failed to access AsyncStorage for ${key}`, e);
@@ -106,9 +110,9 @@ export class ReactNativeSecureStorage implements TokenStorage {
         console.warn(`[ReactNativeSecureStorage] Failed to reset keychain for ${key}`, e);
       }
       // Always remove from fallback storage too, just in case
-      await AsyncStorage.removeItem(prefixedKey);
+      await this.fallbackStorage.remove(key);
     } else {
-      await AsyncStorage.removeItem(prefixedKey);
+      await this.fallbackStorage.remove(key);
     }
   }
 
@@ -126,11 +130,7 @@ export class ReactNativeSecureStorage implements TokenStorage {
     
     // Clear AsyncStorage keys related to PERS
     try {
-      const allKeys = await AsyncStorage.getAllKeys();
-      const ourKeys = allKeys.filter(k => k.startsWith(this.keyPrefix));
-      if (ourKeys.length > 0) {
-        await AsyncStorage.multiRemove(ourKeys);
-      }
+      await this.fallbackStorage.clear();
     } catch (e) {
       console.warn('[ReactNativeSecureStorage] Failed to clear AsyncStorage', e);
     }