@explorins/pers-sdk-react-native 2.1.12 → 2.1.14-beta.0

package/dist/providers/rn-dpop-provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rn-dpop-provider.d.ts","sourceRoot":"","sources":["../../src/providers/rn-dpop-provider.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAiB3E,qBAAa,uBAAwB,YAAW,kBAAkB;IAChE;;;;;OAKG;IACG,eAAe,CAAC,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,WAAW,CAAC;IAqC1E,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAqD9E,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAgB3D,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,eAAe;CAOxB"}
+{"version":3,"file":"rn-dpop-provider.d.ts","sourceRoot":"","sources":["../../src/providers/rn-dpop-provider.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAgD3E,qBAAa,uBAAwB,YAAW,kBAAkB;IAChE;;;;;OAKG;IACG,eAAe,CAAC,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,WAAW,CAAC;IA0C1E,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IA0D9E,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAqB3D,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,eAAe;CAOxB"}

package/dist/providers/rn-dpop-provider.js

@@ -1,20 +1,44 @@
 import { Platform } from 'react-native';
 import { Buffer } from 'buffer';
-// Conditionally require quick-crypto for Native platforms only
-let crypto;
-if (Platform.OS !== 'web') {
+// Lazy-loaded crypto module - initialized on first use to avoid native module timing issues
+let _crypto = null;
+let _cryptoInitialized = false;
+/**
+ * Lazily load the crypto module.
+ *
+ * Supports customer pre-initialization via global.__QuickCrypto for environments
+ * where native module timing is unpredictable (e.g., certain React Native setups).
+ *
+ * @returns The crypto module or null if unavailable
+ */
+function getCrypto() {
+    if (_cryptoInitialized) {
+        return _crypto;
+    }
+    _cryptoInitialized = true;
+    if (Platform.OS === 'web') {
+        // On Web, we shouldn't be using this provider (Core SDK has WebDPoPProvider)
+        _crypto = {
+            generateKeyPair: () => { throw new Error('ReactNativeDPoPProvider not supported on Web'); },
+            randomUUID: () => globalThis.crypto?.randomUUID?.() || `${Date.now()}-${Math.random()}`
+        };
+        return _crypto;
+    }
+    // Check for customer pre-initialized global (for native module timing issues)
+    if (typeof global !== 'undefined' && global.__QuickCrypto) {
+        _crypto = global.__QuickCrypto;
+        return _crypto;
+    }
+    // Standard lazy load
     try {
-        crypto = require('react-native-quick-crypto').default || require('react-native-quick-crypto');
+        _crypto = require('react-native-quick-crypto').default || require('react-native-quick-crypto');
     }
     catch (e) {
-        console.warn('ReactNativeDPoPProvider: Failed to load react-native-quick-crypto', e);
+        console.warn('ReactNativeDPoPProvider: Failed to load react-native-quick-crypto.', e);
+        console.warn('Tip: If you encounter timing issues, pre-initialize in index.js: global.__QuickCrypto = require("react-native-quick-crypto")');
+        _crypto = null;
     }
-}
-else {
-    // on Web, we shouldn't be using this provider anyway (Core SDK has WebDPoPProvider)
-    crypto = {
-        generateKeyPair: () => { throw new Error('ReactNativeDPoPProvider not supported on Web'); }
-    };
+    return _crypto;
 }
 export class ReactNativeDPoPProvider {
     /**
@@ -24,6 +48,10 @@ export class ReactNativeDPoPProvider {
      * Falls back to Node.js crypto API on iOS if needed.
      */
     async generateKeyPair(options) {
+        const crypto = getCrypto();
+        if (!crypto) {
+            throw new Error('Crypto module not available. Install react-native-quick-crypto or pre-initialize global.__QuickCrypto');
+        }
         // Try WebCrypto API first (works on both iOS and Android)
         if (crypto.subtle) {
             try {
@@ -57,6 +85,10 @@ export class ReactNativeDPoPProvider {
         });
     }
     async signProof(payload, keyPair) {
+        const crypto = getCrypto();
+        if (!crypto) {
+            throw new Error('Crypto module not available for signing');
+        }
         // 1. Construct Header
         const header = {
             typ: 'dpop+jwt',
@@ -67,7 +99,7 @@ export class ReactNativeDPoPProvider {
         const finalPayload = {
             ...payload,
             iat: payload.iat || Math.floor(Date.now() / 1000),
-            jti: payload.jti || crypto.randomUUID()
+            jti: payload.jti || (crypto.randomUUID?.() || `${Date.now()}-${Math.random()}`)
         };
         // 3. Encode
         const b64Header = this.base64Url(JSON.stringify(header));
@@ -93,6 +125,10 @@ export class ReactNativeDPoPProvider {
         return `${signingInput}.${this.base64UrlBuffer(signature)}`;
     }
     async hashAccessToken(accessToken) {
+        const crypto = getCrypto();
+        if (!crypto) {
+            throw new Error('Crypto module not available for hashing');
+        }
         // Try WebCrypto first
         if (crypto.subtle) {
             try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@explorins/pers-sdk-react-native",
-  "version": "2.1.12",
+  "version": "2.1.14-beta.0",
   "description": "React Native SDK for PERS Platform - Tourism Loyalty System with Blockchain Transaction Signing and WebAuthn Authentication",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,7 +37,7 @@
   "author": "eXplorins",
   "license": "MIT",
   "dependencies": {
-    "@explorins/pers-sdk": "^2.1.18",
+    "@explorins/pers-sdk": "^2.1.21",
     "@explorins/pers-signer": "^1.0.33",
     "buffer": "^6.0.3",
     "ethers": "^6.15.0",
@@ -155,7 +155,7 @@
     "@ethersproject/scrypt": false
   },
   "devDependencies": {
-    "@explorins/pers-shared": "^2.1.117",
+    "@explorins/pers-shared": "^2.1.123",
     "@react-native-async-storage/async-storage": "^3.0.2",
     "@rollup/plugin-commonjs": "^25.0.7",
     "@rollup/plugin-json": "^6.1.0",

package/src/hooks/index.ts

@@ -38,7 +38,7 @@ export type {
 } from './useTokenBalances';
 
 // Export campaign-related types
-export type { CampaignClaimFilters, CampaignHook } from './useCampaigns';
+export type { CampaignClaimFilters, CampaignHook, GetCampaignsOptions } from './useCampaigns';
 
 // Export redemption-related types
 export type { RedemptionRedeemFilters, RedemptionHook } from './useRedemptions';

package/src/hooks/useCampaigns.ts

@@ -8,7 +8,8 @@ import type {
   PaginatedResponseDTO,
   CampaignClaimIncludeRelation,
   CampaignIncludeRelation,
-  SortOrder
+  SortOrder,
+  // DynamicContext
 } from '@explorins/pers-shared';
 import type { CampaignClaimFilters } from '@explorins/pers-sdk/campaign';
 
@@ -21,6 +22,8 @@ export type { CampaignClaimFilters } from '@explorins/pers-sdk/campaign';
 export interface GetCampaignsOptions {
   /** Filter by tag */
   tag?: string;
+  /** Free text search across name and description (case-insensitive) */
+  search?: string;
   /** Filter by business ID */
   businessId?: string;
   /** Page number (1-indexed) */
@@ -113,6 +116,63 @@ export const useCampaigns = () => {
     }
   }, [sdk, isInitialized]);
 
+  /**
+   * Claim a campaign reward with optional dynamic context
+   * 
+   * Triggers a campaign claim for the authenticated user. The campaign must be active
+   * and the user must meet all eligibility requirements. Supports dynamic context for
+   * personalized NFT generation when the campaign issues ERC721 tokens.
+   * 
+   * @param request - Campaign claim request with optional context
+   * @param request.campaignId - ID of the campaign to claim (optional if using triggerSourceId)
+   * @param request.triggerSourceId - ID of trigger source (QR, NFC, etc.)
+   * @param request.context - Dynamic context for NFT personalization
+   * @param request.metadata - Additional metadata for the claim
+   * @param request.latitude - User's latitude for geo-validated claims
+   * @param request.longitude - User's longitude for geo-validated claims
+   * @returns Promise resolving to campaign claim result
+   * 
+   * @example Basic campaign claim
+   * ```typescript
+   * const claim = await claimCampaign({
+   *   triggerSourceId: 'qr-code-123',
+   * });
+   * ```
+   * 
+   * @example Campaign claim with dynamic context (personalized NFT)
+   * ```typescript
+   * import { DynamicContext } from '@explorins/pers-sdk-react-native';
+   * 
+   * const context: DynamicContext = {
+   *   // Validity - token valid for 30 days
+   *   validityDate: new Date().toISOString(),
+   *   validityDuration: 30,
+   *   
+   *   // AI prompt context - available as {{context.xxx}} in prompts
+   *   visitorName: 'John Doe',
+   *   visitLocation: 'Grand Hotel Lobby',
+   *   membershipTier: 'Gold',
+   * };
+   * 
+   * const claim = await claimCampaign({
+   *   triggerSourceId: 'hotel-checkin-qr',
+   *   context,
+   * });
+   * ```
+   * 
+   * @example Geo-validated claim with context
+   * ```typescript
+   * const claim = await claimCampaign({
+   *   triggerSourceId: 'museum-entrance-nfc',
+   *   latitude: 48.8606,
+   *   longitude: 2.3376,
+   *   context: {
+   *     visitorType: 'Adult',
+   *     ticketCategory: 'General Admission',
+   *   }
+   * });
+   * ```
+   */
   const claimCampaign = useCallback(async (request: CampaignClaimRequestDTO): Promise<CampaignClaimDTO | null> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
@@ -141,7 +201,7 @@ export const useCampaigns = () => {
    * // Get user's claims with campaign details
    * const { data: claims } = await getUserClaims({ include: ['campaign', 'business'] });
    * claims.forEach(claim => {
-   *   console.log('Campaign:', claim.included?.campaign?.title);
+   *   console.log('Campaign:', claim.included?.campaign?.name);
    * });
    * 
    * // With pagination

package/src/hooks/useRedemptions.ts

@@ -8,13 +8,34 @@ import type {
   RedemptionRedeemRequestResponseDTO,
   RedemptionTypeDTO,
   PaginatedResponseDTO,
-  RedemptionRedeemIncludeRelation
+  RedemptionRedeemIncludeRelation,
+  ProcessRecordStatus,
+  DynamicContext,
+  SortOrder
 } from '@explorins/pers-shared';
-import type { RedemptionRedeemFilters } from '@explorins/pers-sdk/redemption';
+import type { RedemptionRedeemFilters, RedemptionFilterOptions } from '@explorins/pers-sdk/redemption';
 import type { PaginationOptions } from '@explorins/pers-sdk';
 
 // Re-export for consumers
-export type { RedemptionRedeemFilters } from '@explorins/pers-sdk/redemption';
+export type { RedemptionRedeemFilters, RedemptionFilterOptions } from '@explorins/pers-sdk/redemption';
+
+/**
+ * Options for fetching redemptions with filtering and pagination
+ */
+export interface GetRedemptionsOptions {
+  /** Filter by active status (Admin only - regular users always see active offers) */
+  active?: boolean;
+  /** Free text search across name, description, tags (case-insensitive) */
+  search?: string;
+  /** Page number (1-indexed) */
+  page?: number;
+  /** Results per page */
+  limit?: number;
+  /** Field to sort by */
+  sortBy?: 'name' | 'createdAt';
+  /** Sort direction */
+  sortOrder?: SortOrder;
+}
 
 export const useRedemptions = () => {
   const { sdk, isInitialized, isAuthenticated } = usePersSDK();
@@ -27,8 +48,37 @@ export const useRedemptions = () => {
    * **Administrators:** Can see all redemptions and filter by active/inactive status
    * 
    * The backend enforces permission-based filtering automatically.
+   * 
+   * @param options - Filter and pagination options
+   * @param options.active - Filter by active status (Admin only)
+   * @param options.search - Free text search across name, description, tags
+   * @param options.page - Page number (1-indexed)
+   * @param options.limit - Results per page
+   * @param options.sortBy - Field to sort by ('name' | 'createdAt')
+   * @param options.sortOrder - Sort direction ('ASC' | 'DESC')
+   * 
+   * @example Basic usage
+   * ```typescript
+   * const { data: offers } = await getRedemptions();
+   * ```
+   * 
+   * @example Search redemptions
+   * ```typescript
+   * const { data: coffeeOffers } = await getRedemptions({ search: 'coffee' });
+   * ```
+   * 
+   * @example With pagination and sorting
+   * ```typescript
+   * const { data, pagination } = await getRedemptions({ 
+   *   search: 'discount',
+   *   page: 1, 
+   *   limit: 10,
+   *   sortBy: 'name',
+   *   sortOrder: 'ASC'
+   * });
+   * ```
    */
-  const getRedemptions = useCallback(async (options?: { active?: boolean }): Promise<PaginatedResponseDTO<RedemptionDTO>> => {
+  const getRedemptions = useCallback(async (options?: GetRedemptionsOptions): Promise<PaginatedResponseDTO<RedemptionDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
@@ -43,27 +93,33 @@ export const useRedemptions = () => {
   }, [sdk, isInitialized]);
 
   /**
-   * Get user's redemption history with optional pagination and include relations
+   * Get user's redemption history with optional filters, pagination and include relations
    * 
+   * @param filters - Optional filters (redemptionId, status)
    * @param options - Pagination options (page, limit, sortBy, sortOrder)
-   * @param include - Relations to include: 'redemption', 'user', 'business'
+   * @param include - Relations to include: 'redemption', 'user', 'business', 'transactions'
    * @returns Promise resolving to paginated redemption history
    * 
    * @example
    * ```typescript
    * // Get first page of user redemptions
-   * const { data: redeems, pagination } = await getUserRedemptions({ page: 1, limit: 10 });
+   * const { data: redeems, pagination } = await getUserRedemptions({}, { page: 1, limit: 10 });
    * console.log(`Page ${pagination.page} of ${pagination.pages}`);
    * 
+   * // Get only completed redemptions
+   * import { ProcessRecordStatus } from '@explorins/pers-shared';
+   * const { data: completed } = await getUserRedemptions({ status: ProcessRecordStatus.COMPLETED });
+   * 
    * // Get user redemptions with full redemption details
-   * const { data: redeems } = await getUserRedemptions({}, ['redemption', 'business']);
+   * const { data: redeems } = await getUserRedemptions({}, {}, ['redemption', 'business']);
    * redeems.forEach(redeem => {
-   *   console.log('Redemption:', redeem.included?.redemption?.title);
+   *   console.log('Redemption:', redeem.included?.redemption?.name);
    *   console.log('Business:', redeem.included?.business?.displayName);
    * });
    * ```
    */
   const getUserRedemptions = useCallback(async (
+    filters?: { redemptionId?: string; status?: ProcessRecordStatus },
     options?: PaginationOptions,
     include?: RedemptionRedeemIncludeRelation[]
   ): Promise<PaginatedResponseDTO<RedemptionRedeemDTO>> => {
@@ -76,7 +132,7 @@ export const useRedemptions = () => {
     }
     
     try {
-      const result = await sdk.redemptions.getUserRedemptions(options, include);
+      const result = await sdk.redemptions.getUserRedemptions(filters, options, include);
       return result;
     } catch (error) {
       console.error('Failed to fetch user redemptions:', error);
@@ -84,7 +140,57 @@ export const useRedemptions = () => {
     }
   }, [sdk, isInitialized, isAuthenticated]);
 
-  const redeem = useCallback(async (redemptionId: string, onStatusUpdate?: OnStatusUpdateFn): Promise<RedemptionRedeemRequestResponseDTO> => {
+  /**
+   * Redeem a redemption offer with optional dynamic context
+   * 
+   * Supports dynamic context for personalized NFT generation when the redemption
+   * issues ERC721 tokens. Context can include validity dates, AI prompt placeholders,
+   * and custom metadata.
+   * 
+   * @param redemptionId - ID of the redemption to redeem
+   * @param options - Optional settings
+   * @param options.context - Dynamic context for NFT personalization (validity dates, AI prompts)
+   * @param options.onStatusUpdate - Callback for transaction signing status updates
+   * @returns Promise resolving to redemption result
+   * 
+   * @example Basic redemption
+   * ```typescript
+   * const result = await redeem('redemption-123');
+   * ```
+   * 
+   * @example Redemption with dynamic context (personalized NFT)
+   * ```typescript
+   * const result = await redeem('event-ticket-123', {
+   *   context: {
+   *     // Validity - token valid for event duration
+   *     validityDate: new Date().toISOString(),
+   *     validityDuration: 8,  // 8 hours
+   *     
+   *     // AI prompt context - available as {{context.xxx}} in prompts
+   *     attendeeName: 'John Doe',
+   *     ticketTier: 'VIP',
+   *     seatSection: 'A12',
+   *   }
+   * });
+   * ```
+   * 
+   * @example Hotel stay NFT with check-in/check-out dates
+   * ```typescript
+   * const result = await redeem('hotel-nft-456', {
+   *   context: {
+   *     validityDate: '2026-04-15T14:00:00Z',      // Check-in
+   *     validityEndDate: '2026-04-20T11:00:00Z',   // Check-out
+   *     guestName: 'Jane Smith',
+   *     roomNumber: '305',
+   *     roomType: 'Suite',
+   *   }
+   * });
+   * ```
+   */
+  const redeem = useCallback(async (
+    redemptionId: string, 
+    options?: { context?: DynamicContext; onStatusUpdate?: OnStatusUpdateFn }
+  ): Promise<RedemptionRedeemRequestResponseDTO> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
@@ -93,12 +199,12 @@ export const useRedemptions = () => {
     }
     
     try {
-      const result = await sdk.redemptions.redeem(redemptionId);
+      const result = await sdk.redemptions.redeem(redemptionId, options?.context);
 
       const txToken = result.senderTransaction?.actionable?.authToken;
       if (txToken && isSignerAvailable) {
         try {
-          const signingResult: SubmissionResult = await signAndSubmitTransactionWithJWT(txToken, onStatusUpdate);
+          const signingResult: SubmissionResult = await signAndSubmitTransactionWithJWT(txToken, options?.onStatusUpdate);
           if (signingResult.success) {
             // Return enhanced result with signing information
             return {

package/src/hooks/useTokenBalances.ts

@@ -95,10 +95,17 @@ export interface UseTokenBalancesResult {
  * **Basic Usage:**
  * ```typescript
  * import { useTokenBalances, useTokens, usePersSDK } from '@explorins/pers-sdk-react-native';
+ * import { useState, useEffect } from 'react';
  * 
  * function TokenBalancesScreen() {
  *   const { user } = usePersSDK();
- *   const { availableTokens } = useTokens();
+ *   const { getTokens } = useTokens();
+ *   const [availableTokens, setAvailableTokens] = useState([]);
+ *   
+ *   // Load tokens on mount
+ *   useEffect(() => {
+ *     getTokens().then(result => setAvailableTokens(result.data));
+ *   }, []);
  *   
  *   // App explicitly selects which wallet to use
  *   const walletAddress = user?.wallets?.[0]?.address;

package/src/hooks/useTransactionSigner.ts

@@ -19,14 +19,44 @@ export type { StatusUpdateData };
 export type OnStatusUpdateFn = (status: SigningStatus, message: string, data?: StatusUpdateData) => void;
 
 
-// Dynamic import the signer SDK to avoid build issues with static dependencies
-let createPersSignerSDK: ((config: PersSignerConfig) => Promise<PersSignerSDK>) | null = null;
-try {
-  const signerModule = require('@explorins/pers-signer/react-native');
-  createPersSignerSDK = signerModule.createPersSignerSDK;
-} catch (error: unknown) {
-  console.warn('[useTransactionSigner] PERS Signer SDK not available:', (error as Error).message);
-  console.warn('[useTransactionSigner] Real blockchain signing will not be available');
+// Lazy-loaded signer SDK factory - initialized on first use to avoid native module timing issues
+let _createPersSignerSDK: ((config: PersSignerConfig) => Promise<PersSignerSDK>) | null = null;
+let _signerInitAttempted = false;
+
+/**
+ * Lazily load the PERS Signer SDK.
+ * 
+ * Supports customer pre-initialization via global.__PersSigner for environments
+ * where native module timing is unpredictable (e.g., certain React Native setups).
+ * 
+ * @returns The createPersSignerSDK function or null if unavailable
+ */
+function getSignerSDKFactory(): ((config: PersSignerConfig) => Promise<PersSignerSDK>) | null {
+  if (_signerInitAttempted) {
+    // Already tried - return cached result (could be null if failed)
+    return _createPersSignerSDK;
+  }
+  
+  _signerInitAttempted = true;
+  
+  // Check for customer pre-initialized global (for native module timing issues)
+  if (typeof global !== 'undefined' && (global as any).__PersSigner?.createPersSignerSDK) {
+    _createPersSignerSDK = (global as any).__PersSigner.createPersSignerSDK;
+    return _createPersSignerSDK;
+  }
+  
+  // Standard lazy load
+  try {
+    const signerModule = require('@explorins/pers-signer/react-native');
+    _createPersSignerSDK = signerModule.createPersSignerSDK;
+    return _createPersSignerSDK;
+  } catch (error: unknown) {
+    console.warn('[useTransactionSigner] PERS Signer SDK not available:', (error as Error).message);
+    console.warn('[useTransactionSigner] Real blockchain signing will not be available');
+    console.warn('[useTransactionSigner] Tip: If timing issues, pre-initialize in index.js: global.__PersSigner = require("@explorins/pers-signer/react-native")');
+    _createPersSignerSDK = null; // Mark as unavailable
+    return null;
+  }
 }
 
 
@@ -243,6 +273,7 @@ export const useTransactionSigner = (): TransactionSignerHook => {
   // Auto-initialize signer SDK when PERS SDK is ready
   useEffect(() => {
     const initializeSignerSDK = async () => {
+      const createPersSignerSDK = getSignerSDKFactory();
       if (!createPersSignerSDK) {
         console.warn('[useTransactionSigner] Signer SDK not available');
         return;
@@ -361,7 +392,7 @@ export const useTransactionSigner = (): TransactionSignerHook => {
     if (!isSignerInitialized || !signerSDKRef.current) {
       throw new Error('Transaction signer not initialized');
     }
-    if (!createPersSignerSDK) {
+    if (!getSignerSDKFactory()) {
       throw new Error('PERS Signer SDK not available. Blockchain signing is not supported.');
     }
 
@@ -514,7 +545,7 @@ export const useTransactionSigner = (): TransactionSignerHook => {
      * );
      * ```
      */
-    isSignerAvailable: isSignerInitialized && !!createPersSignerSDK,
+    isSignerAvailable: isSignerInitialized && !!getSignerSDKFactory(),
     
     /**
      * Current signing status for UI feedback

package/src/index.ts

@@ -284,7 +284,7 @@ export type { EventsHook, PersEvent, EventHandler, EventFilter, Unsubscribe } fr
 export type { TokenBalanceWithToken, UseTokenBalancesOptions, UseTokenBalancesResult } from './hooks';
 
 // Re-export campaign types for convenience
-export type { CampaignClaimFilters, CampaignHook } from './hooks';
+export type { CampaignClaimFilters, CampaignHook, GetCampaignsOptions } from './hooks';
 
 // Re-export redemption types for convenience
 export type { RedemptionRedeemFilters, RedemptionHook } from './hooks';

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

@@ -2,19 +2,50 @@ import { Platform } from 'react-native';
 import { Buffer } from 'buffer';
 import { DPoPCryptoProvider, DPoPKeyPair } from '@explorins/pers-sdk/core';
 
-// Conditionally require quick-crypto for Native platforms only
-let crypto: any;
-if (Platform.OS !== 'web') {
+// Lazy-loaded crypto module - initialized on first use to avoid native module timing issues
+let _crypto: any = null;
+let _cryptoInitialized = false;
+
+/**
+ * Lazily load the crypto module.
+ * 
+ * Supports customer pre-initialization via global.__QuickCrypto for environments
+ * where native module timing is unpredictable (e.g., certain React Native setups).
+ * 
+ * @returns The crypto module or null if unavailable
+ */
+function getCrypto(): any {
+  if (_cryptoInitialized) {
+    return _crypto;
+  }
+  
+  _cryptoInitialized = true;
+  
+  if (Platform.OS === 'web') {
+    // On Web, we shouldn't be using this provider (Core SDK has WebDPoPProvider)
+    _crypto = {
+      generateKeyPair: () => { throw new Error('ReactNativeDPoPProvider not supported on Web'); },
+      randomUUID: () => globalThis.crypto?.randomUUID?.() || `${Date.now()}-${Math.random()}`
+    };
+    return _crypto;
+  }
+  
+  // Check for customer pre-initialized global (for native module timing issues)
+  if (typeof global !== 'undefined' && (global as any).__QuickCrypto) {
+    _crypto = (global as any).__QuickCrypto;
+    return _crypto;
+  }
+  
+  // Standard lazy load
   try {
-    crypto = require('react-native-quick-crypto').default || require('react-native-quick-crypto');
+    _crypto = require('react-native-quick-crypto').default || require('react-native-quick-crypto');
   } catch (e) {
-    console.warn('ReactNativeDPoPProvider: Failed to load react-native-quick-crypto', e);
+    console.warn('ReactNativeDPoPProvider: Failed to load react-native-quick-crypto.', e);
+    console.warn('Tip: If you encounter timing issues, pre-initialize in index.js: global.__QuickCrypto = require("react-native-quick-crypto")');
+    _crypto = null;
   }
-} else {
-  // on Web, we shouldn't be using this provider anyway (Core SDK has WebDPoPProvider)
-  crypto = {
-    generateKeyPair: () => { throw new Error('ReactNativeDPoPProvider not supported on Web'); }
-  };
+  
+  return _crypto;
 }
 
 export class ReactNativeDPoPProvider implements DPoPCryptoProvider {
@@ -25,6 +56,11 @@ export class ReactNativeDPoPProvider implements DPoPCryptoProvider {
    * Falls back to Node.js crypto API on iOS if needed.
    */
   async generateKeyPair(options?: { extractable?: boolean }): Promise<DPoPKeyPair> {
+    const crypto = getCrypto();
+    if (!crypto) {
+      throw new Error('Crypto module not available. Install react-native-quick-crypto or pre-initialize global.__QuickCrypto');
+    }
+    
     // Try WebCrypto API first (works on both iOS and Android)
     if (crypto.subtle) {
       try {
@@ -62,6 +98,11 @@ export class ReactNativeDPoPProvider implements DPoPCryptoProvider {
   }
 
   async signProof(payload: Record<string, any>, keyPair: DPoPKeyPair): Promise<string> {
+    const crypto = getCrypto();
+    if (!crypto) {
+      throw new Error('Crypto module not available for signing');
+    }
+    
     // 1. Construct Header
     const header = {
       typ: 'dpop+jwt',
@@ -73,7 +114,7 @@ export class ReactNativeDPoPProvider implements DPoPCryptoProvider {
     const finalPayload = {
       ...payload,
       iat: payload.iat || Math.floor(Date.now() / 1000),
-      jti: payload.jti || crypto.randomUUID()
+      jti: payload.jti || (crypto.randomUUID?.() || `${Date.now()}-${Math.random()}`)
     };
 
     // 3. Encode
@@ -115,6 +156,11 @@ export class ReactNativeDPoPProvider implements DPoPCryptoProvider {
   }
 
   async hashAccessToken(accessToken: string): Promise<string> {
+    const crypto = getCrypto();
+    if (!crypto) {
+      throw new Error('Crypto module not available for hashing');
+    }
+    
     // Try WebCrypto first
     if (crypto.subtle) {
       try {