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

package/README.md

@@ -376,6 +376,28 @@ function BlockchainRedemption() {
 
 ## Advanced Configuration
 
+### SDK Initialization & DPoP
+
+The `PersSDKProvider` accepts a `config` object allowing you to customize behavior, including **DPoP (Distributed Proof of Possession)**.
+
+**DPoP Behavior:**
+- **Enabled by Default**: Automatically active on iOS/Android using a high-performance C++ crypto bridge (`react-native-quick-crypto`).
+- **Web Support**: Uses standard WebCrypto API.
+- **Security**: Binds access tokens to the device, preventing replay attacks.
+
+**Customizing Initialization:**
+```typescript
+<PersSDKProvider config={{
+  apiProjectKey: 'your-project-key',
+  // DPoP is enabled by default. To disable (not recommended):
+  dpop: {
+    enabled: false
+  }
+}}>
+  <YourApp />
+</PersSDKProvider>
+```
+
 ### Custom Authentication Provider
 
 The SDK automatically uses `ReactNativeSecureStorage` for React Native (iOS/Android) and `LocalStorageTokenStorage` for Web. You can customize this if needed:

package/dist/index.js

@@ -32078,8 +32078,20 @@ class ReactNativeSecureStorage {
         // In runtime, 'key' is just a string, so this is safe.
         if (this.SECURE_KEYS.has(key)) {
             // Store in Keychain/Keystore
-            // Service name acts as the key identifier in simple usage
-            await Keychain.setGenericPassword(prefixedKey, stringValue, { service: prefixedKey });
+            try {
+                if (Keychain) {
+                    // Service name acts as the key identifier in simple usage
+                    await Keychain.setGenericPassword(prefixedKey, stringValue, { service: prefixedKey });
+                }
+                else {
+                    throw new Error('RN Keychain not available');
+                }
+            }
+            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);
+            }
         }
         else {
             // Store standard config/metadata in AsyncStorage
@@ -32090,15 +32102,24 @@ class ReactNativeSecureStorage {
         const prefixedKey = this.getKeyName(key);
         if (this.SECURE_KEYS.has(key)) {
             try {
-                const credentials = await Keychain.getGenericPassword({ service: prefixedKey });
-                if (credentials) {
-                    return this.tryParse(credentials.password);
+                if (Keychain) {
+                    const credentials = await Keychain.getGenericPassword({ service: prefixedKey });
+                    if (credentials) {
+                        return this.tryParse(credentials.password);
+                    }
                 }
-                return null;
             }
             catch (e) {
                 console.warn(`[ReactNativeSecureStorage] Failed to access keychain for ${key}`, e);
-                return null; // Key not found or access denied
+                // Continue to fallback check...
+            }
+            // Fallback: Check AsyncStorage if not found in Keychain or Keychain failed
+            try {
+                const val = await AsyncStorage.getItem(prefixedKey);
+                return val ? this.tryParse(val) : null;
+            }
+            catch (e) {
+                return null;
             }
         }
         else {
@@ -32115,7 +32136,16 @@ class ReactNativeSecureStorage {
     async remove(key) {
         const prefixedKey = this.getKeyName(key);
         if (this.SECURE_KEYS.has(key)) {
-            await Keychain.resetGenericPassword({ service: prefixedKey });
+            try {
+                if (Keychain) {
+                    await Keychain.resetGenericPassword({ service: prefixedKey });
+                }
+            }
+            catch (e) {
+                console.warn(`[ReactNativeSecureStorage] Failed to reset keychain for ${key}`, e);
+            }
+            // Always remove from fallback storage too, just in case
+            await AsyncStorage.removeItem(prefixedKey);
         }
         else {
             await AsyncStorage.removeItem(prefixedKey);
@@ -32124,7 +32154,14 @@ class ReactNativeSecureStorage {
     async clear() {
         // Clear all known secure keys
         for (const key of this.SECURE_KEYS) {
-            await Keychain.resetGenericPassword({ service: this.getKeyName(key) });
+            try {
+                if (Keychain) {
+                    await Keychain.resetGenericPassword({ service: this.getKeyName(key) });
+                }
+            }
+            catch (e) {
+                console.warn(`[ReactNativeSecureStorage] Failed to clear keychain key ${key}`, e);
+            }
         }
         // Clear AsyncStorage keys related to PERS
         try {
@@ -32178,16 +32215,22 @@ function createReactNativeAuthProvider(projectKey, config = {}) {
     if (!projectKey || typeof projectKey !== 'string') {
         throw new Error('createReactNativeAuthProvider: projectKey is required and must be a string');
     }
-    const { keyPrefix = `pers_${projectKey.slice(0, 8)}_`, debug = false, customStorage, authType = 'user' } = config;
+    const { keyPrefix = `pers_${projectKey.slice(0, 8)}_`, debug = false, customStorage, authType = 'user', dpop } = config;
     // Platform-specific storage selection
     const tokenStorage = customStorage || (isWebPlatform
         ? new LocalStorageTokenStorage()
         : new ReactNativeSecureStorage(keyPrefix));
+    // Prepare DPoP config ensuring enabled is boolean (default true)
+    const dpopConfig = dpop ? {
+        enabled: dpop.enabled ?? true,
+        cryptoProvider: dpop.cryptoProvider
+    } : undefined;
     // Return DefaultAuthProvider configured with platform-appropriate storage
     return new DefaultAuthProvider({
         authType,
         projectKey,
-        storage: tokenStorage
+        storage: tokenStorage,
+        dpop: dpopConfig
     });
 }
 
@@ -32494,7 +32537,7 @@ class ReactNativeHttpClient {
 // Create the context
 const SDKContext = react.createContext(null);
 // Provider component
-const PersSDKProvider = ({ children }) => {
+const PersSDKProvider = ({ children, config }) => {
     const initializingRef = react.useRef(false);
     const [sdk, setSdk] = react.useState(null);
     const [authProvider, setAuthProvider] = react.useState(null);
@@ -32511,6 +32554,18 @@ const PersSDKProvider = ({ children }) => {
         try {
             // Create HTTP client
             const httpClient = new ReactNativeHttpClient();
+            // Ensure DPoP is enabled by default for all platforms
+            const dpopConfig = config.dpop || {};
+            const isDpopEnabled = dpopConfig.enabled ?? true;
+            // Prepare DPoP settings for Auth Provider
+            const dpopSettings = {
+                enabled: isDpopEnabled,
+                cryptoProvider: dpopConfig.cryptoProvider
+            };
+            // Inject Native DPoP Provider (crypto-based) for mobile platforms if not already provided
+            if (reactNative.Platform.OS !== 'web' && isDpopEnabled && !dpopSettings.cryptoProvider) {
+                dpopSettings.cryptoProvider = new ReactNativeDPoPProvider();
+            }
             // Create platform-aware auth provider if not provided
             let authProvider;
             if (config.authProvider) {
@@ -32519,23 +32574,16 @@ const PersSDKProvider = ({ children }) => {
             else {
                 // Use our platform-aware auth provider that automatically selects LocalStorage (web) or AsyncStorage (mobile)
                 authProvider = createReactNativeAuthProvider(config.apiProjectKey || 'default-project', {
-                    debug: false
+                    debug: false,
+                    dpop: dpopSettings
                 });
             }
             // Enhanced config with platform-appropriate auth provider
             const sdkConfig = {
                 ...config,
-                authProvider
+                authProvider,
+                dpop: dpopSettings
             };
-            // Inject Native DPoP Provider (crypto-based) for mobile platforms
-            // Web platforms use built-in WebCrypto provider by default
-            if (reactNative.Platform.OS !== 'web' && (!config.dpop?.cryptoProvider)) {
-                sdkConfig.dpop = {
-                    ...(config.dpop || {}),
-                    enabled: config.dpop?.enabled ?? true,
-                    cryptoProvider: new ReactNativeDPoPProvider()
-                };
-            }
             // Initialize PersSDK with platform-aware auth provider
             const sdkInstance = new PersSDK(httpClient, sdkConfig);
             setAuthProvider(authProvider);
@@ -32550,7 +32598,15 @@ const PersSDKProvider = ({ children }) => {
         finally {
             initializingRef.current = false;
         }
-    }, []);
+    }, [isInitialized]);
+    // Auto-initialize if config is provided
+    react.useEffect(() => {
+        if (config && !isInitialized && !initializingRef.current) {
+            initialize(config).catch(err => {
+                console.error('Auto-initialization failed:', err);
+            });
+        }
+    }, [config, isInitialized, initialize]);
     const setAuthenticationState = react.useCallback((user, accountAddress, isAuthenticated) => {
         setUser(user);
         setAccountAddress(accountAddress);