@explorins/pers-signer 1.0.18 → 1.0.26

package/dist/react-native.d.ts

@@ -1,12 +1,69 @@
 import * as _explorins_web3_ts_types from '@explorins/web3-ts/types';
 import { LegacyTransaction, AnyTransactionData } from '@explorins/web3-ts/types';
-export { AnyTransactionData, BaseTransaction, CounterfactualWalletEIP712Data, EIP1559Transaction, EIP2930Transaction, EIP712TransactionData, EIP712TypedData, LegacyTransaction } from '@explorins/web3-ts/types';
+export { AnyTransactionData, LegacyTransaction } from '@explorins/web3-ts/types';
 import * as _explorins_pers_shared_browser from '@explorins/pers-shared/browser';
 import { TenantPublicDTO, SessionAuthContextResponseDTO, TransactionFormat, TransactionRequestResponseDTO, CounterfactualWalletTransactionResponse, TransactionStatus } from '@explorins/pers-shared/browser';
-export { CampaignClaimDTO, CampaignDTO, SessionAuthResponseDTO, TRANSACTION_FORMATS, TRANSACTION_FORMAT_DESCRIPTIONS, TransactionFormat, TransactionRequestResponseDTO, TransactionStatus, TransactionSubmissionRequestDTO } from '@explorins/pers-shared/browser';
+export { TransactionFormat, TransactionRequestResponseDTO } from '@explorins/pers-shared/browser';
 import { AbstractSigner, Provider, TransactionRequest, TypedDataDomain, TypedDataField } from 'ethers';
 import { CounterfactualWalletTransactionResponse as CounterfactualWalletTransactionResponse$1 } from '@explorins/pers-shared';
 
+interface JWTLoginResponse {
+    success: true;
+    access_token: string;
+    token_type: "Bearer";
+    expires_in: number;
+    user: {
+        id: string;
+        username: string;
+        org_id: string;
+    };
+    provider?: string;
+}
+interface VerifyTokenResponse {
+    valid: boolean;
+    provider: string;
+    claims: {
+        sub: string;
+        iss: string;
+        aud: string;
+        exp: number;
+        iat: number;
+        user_id: string;
+        username: string;
+        org_id: string;
+        provider: string;
+        permissions: unknown;
+    };
+    tenantId: string;
+}
+interface SigningKey {
+    curve: string;
+    publicKey: string;
+    scheme: string;
+}
+interface Wallet {
+    address?: string;
+    chainId?: number;
+    custodial?: boolean;
+    dateCreated?: string;
+    externalId?: string;
+    id: string;
+    name?: string;
+    network?: string;
+    provider?: string;
+    signingKey?: SigningKey;
+    status?: string;
+    tags?: string[];
+}
+interface CompleteSignatureResponse {
+    success: true;
+    data: {
+        status: string;
+        challenge?: unknown;
+        signature?: number[];
+    };
+}
+
 /**
  * Wallet management service
  * Updated for v1 API endpoints per migration reference
@@ -17,7 +74,7 @@ declare class WalletService {
      * @param signerToken - Signer JWT token
      * @returns Promise resolving to wallet data
      */
-    static listWallets(signerToken: string): Promise<unknown>;
+    static listWallets(signerToken: string): Promise<Wallet[]>;
 }
 
 /**
@@ -35,18 +92,12 @@ declare class PersService {
     private static tenantCache;
     private static currentProjectKey;
     private static currentTenantId;
-    private static useStaging;
     private static readonly TENANT_CACHE_TTL;
     /**
      * Configure the PERS API settings
      * @param config - The configuration object
      */
     static configure(config: Partial<PersApiConfig>): void;
-    /**
-     * Enable staging mode when project key is not available
-     * @param enableStaging Whether to use staging environment
-     */
-    static setStagingMode(enableStaging: boolean): void;
     /**
      * Get current configuration
      */
@@ -57,21 +108,21 @@ declare class PersService {
      * @param authToken - Optional auth token for authentication
      * @returns Promise with tenant public information
      */
-    static getTenantById(tenantId: string, authToken?: string): Promise<TenantPublicDTO>;
+    static getTenantById(tenantId: string, authToken: string): Promise<TenantPublicDTO>;
     /**
      * Initialize tenant configuration from JWT
      * @param tenantId - The tenant ID from JWT payload
      * @param authToken - Optional auth token for authentication
      * @returns Promise with tenant information
      */
-    static initializeTenant(tenantId: string, authToken?: string): Promise<TenantPublicDTO>;
+    static initializeTenant(tenantId: string, authToken: string): Promise<TenantPublicDTO>;
     /**
      * Ensure tenant is initialized and current, with automatic revalidation
      * @param tenantId - The tenant ID to ensure is initialized
      * @param authToken - Optional auth token for authentication
      * @returns Promise with tenant information
      */
-    static ensureTenantInitialized(tenantId: string, authToken?: string): Promise<TenantPublicDTO>;
+    static ensureTenantInitialized(tenantId: string, authToken: string): Promise<TenantPublicDTO>;
     /**
      * Get the current project key (either from tenant or fallback)
      * @param tenantId - Optional tenant ID to ensure is initialized
@@ -85,7 +136,7 @@ declare class PersService {
     /**
      * Authenticates a user with the PERS backend using their auth token
      *
-     * @param authToken - The authentication token received from DFNS after login/registration
+     * @param authToken - The authentication token received from backend after login/registration
      * @param tenantId - Optional tenant ID for automatic initialization
      * @returns A promise that resolves to the authentication response
      * @throws If the request fails
@@ -127,12 +178,78 @@ declare class PersService {
     static getTransactionDataForSigning(transactionResponse: TransactionRequestResponseDTO): _explorins_pers_shared_browser.CounterfactualWalletTransactionResponse | _explorins_web3_ts_types.LegacyTransaction;
 }
 
+interface GetWalletResponse {
+    id: string;
+    signingKey: {
+        publicKey: string;
+    };
+}
+type WalletMetadata = GetWalletResponse & {
+    boundToEvmNetwork: boolean;
+};
+
 /**
  * Types for WebAuthn provider abstraction
  */
+interface WebAuthnAssertion {
+    kind: 'Fido2';
+    credentialAssertion: {
+        credId: string;
+        clientData: string;
+        authenticatorData: string;
+        signature: string;
+        userHandle?: string;
+    };
+}
+interface WebAuthnAttestation {
+    id: string;
+    clientDataJSON: string;
+    attestationObject: string;
+}
+interface WebAuthnCredential {
+    id: string;
+    transports?: AuthenticatorTransport[];
+}
+interface WebAuthnSignChallenge {
+    challenge: string;
+    challengeIdentifier?: string;
+    allowCredentials?: {
+        webauthn?: WebAuthnCredential[];
+        key?: any[];
+    };
+    rpId?: string;
+    userVerification?: UserVerificationRequirement;
+    timeout?: number;
+    [key: string]: any;
+}
+interface WebAuthnCreateChallenge {
+    challenge: string;
+    user: {
+        id: string;
+        name: string;
+        displayName: string;
+    };
+    rp: {
+        id: string;
+        name: string;
+    };
+    pubKeyCredParams: {
+        type: "public-key";
+        alg: number;
+    }[];
+    authenticatorSelection?: AuthenticatorSelectionCriteria;
+    attestation?: AttestationConveyancePreference;
+    timeout?: number;
+    excludeCredentials?: {
+        id: string;
+        type: "public-key";
+        transports?: AuthenticatorTransport[];
+    }[];
+    [key: string]: any;
+}
 interface WebAuthnProvider {
-    create(challenge: any): Promise<any>;
-    sign(challenge: any): Promise<any>;
+    create(challenge: WebAuthnCreateChallenge): Promise<WebAuthnAttestation>;
+    sign(challenge: WebAuthnSignChallenge): Promise<WebAuthnAssertion>;
 }
 interface WebAuthnConfig {
     relyingParty: {
@@ -142,61 +259,6 @@ interface WebAuthnConfig {
     };
 }
 
-/**
- * Key service response types and interfaces
- */
-/**
- * Signature response from key signing operations
- */
-interface SignResponse {
-    id: string;
-    keyId: string;
-    requester: {
-        userId: string;
-        appId: string;
-    };
-    requestBody: {
-        hash: string;
-        kind: "Hash";
-    };
-    status: "Signed";
-    signature: {
-        r: string;
-        s: string;
-        v: number;
-        encoded: string;
-    };
-    network: "KeyECDSA";
-    dateRequested: string;
-    dateSigned: string;
-    walletId: string;
-}
-/**
- * Authentication response from login/register operations
- */
-interface AuthResponse {
-    token: string;
-    message?: string;
-    status?: number;
-}
-/**
- * Registration challenge response
- */
-interface RegistrationChallenge {
-    temporaryAuthenticationToken: string;
-    challenge: any;
-    status?: number;
-    message?: string;
-}
-/**
- * Registration completion response
- */
-interface RegistrationResult {
-    token: string;
-    walletId?: string;
-    status?: number;
-    message?: string;
-}
 /**
  * Individual wallet item
  */
@@ -221,162 +283,6 @@ interface TypedDataSigningRequest {
  * Generic signing request
  */
 type SigningRequest = HashSigningRequest | TypedDataSigningRequest;
-/**
- * Signing challenge response
- */
-interface SigningChallenge {
-    requestBody: any;
-    challenge: {
-        challengeIdentifier: string;
-        [key: string]: any;
-    };
-    status?: number;
-    message?: string;
-}
-/**
- * User credentials for authentication
- */
-interface UserCredentials {
-    username: string;
-    appId?: string;
-}
-/**
- * Relying party configuration for WebAuthn
- */
-interface RelyingPartyConfig {
-    id: string;
-    name: string;
-    origin?: string;
-}
-
-/**
- * Type definitions for the new PERS Signer API v1
- * Based on API_MIGRATION_REFERENCE.md - Updated for wrapped responses
- */
-interface SignerApiResponse<T = unknown> {
-    success: boolean;
-    data?: T;
-}
-interface SignerApiError {
-    status: number;
-    error: string;
-    message: string;
-    request_id: string;
-    timestamp: string;
-    suggestion?: {
-        action: string;
-        text: string;
-        endpoint: string;
-    };
-}
-interface LoginRequest {
-    authToken: string;
-}
-interface JWTLoginResponse {
-    success: true;
-    access_token: string;
-    token_type: "Bearer";
-    expires_in: number;
-    user: {
-        id: string;
-        username: string;
-        org_id: string;
-    };
-    provider: string;
-}
-interface WrappedProviderResponse {
-    success: true;
-    data: unknown;
-}
-type LoginResponse = JWTLoginResponse | WrappedProviderResponse;
-interface VerifyTokenRequest {
-    token: string;
-}
-interface VerifyTokenResponse {
-    valid: boolean;
-    provider: string;
-    claims: {
-        sub: string;
-        iss: string;
-        aud: string;
-        exp: number;
-        iat: number;
-        user_id: string;
-        username: string;
-        org_id: string;
-        provider: string;
-        permissions: unknown;
-    };
-    tenantId: string;
-}
-interface InitRegistrationRequest {
-    authToken: string;
-}
-interface InitRegistrationResponse {
-    success: true;
-    data: {
-        challenge?: string;
-        temporaryAuthenticationToken?: string;
-        user?: object;
-        [key: string]: unknown;
-    };
-}
-type CompleteRegistrationResponse = JWTLoginResponse | WrappedProviderResponse;
-interface ListWalletsRequest {
-}
-interface ListWalletsResponse {
-    success: true;
-    data: {
-        wallets?: Array<unknown>;
-        [key: string]: unknown;
-    };
-}
-interface InitSignatureRequest {
-    walletId: string;
-    request: unknown;
-}
-interface InitSignatureResponse {
-    success: true;
-    data: {
-        requestBody: unknown;
-        challenge: unknown;
-        [key: string]: unknown;
-    };
-}
-interface CompleteSignatureRequest {
-    walletId: string;
-    requestBody: unknown;
-    signedChallenge: unknown;
-}
-interface CompleteSignatureResponse {
-    success: true;
-    data: {
-        signature?: {
-            r: string;
-            s: string;
-            recid: number;
-            encoded: string;
-        } | string;
-        transaction?: unknown;
-        dateRequested?: string;
-        dateSigned?: string;
-        id?: string;
-        keyId?: string;
-        network?: string;
-        requestBody?: {
-            kind?: 'Eip712' | 'Hash' | string;
-            blockchainKind?: string;
-            [key: string]: unknown;
-        };
-        requester?: unknown;
-        status?: string;
-        walletId?: string;
-        [key: string]: unknown;
-    };
-}
-interface HealthCheckResponse {
-    success: boolean;
-}
 
 /**
  * Signing service for cryptographic operations
@@ -426,10 +332,6 @@ declare class SigningService {
  * Combined transaction status type that includes both PERS and additional statuses
  */
 type CombinedTransactionStatus = TransactionStatus;
-/**
- * Transaction statuses that allow signing
- */
-declare const SIGNABLE_STATUSES: readonly [TransactionStatus.PENDING_SIGNATURE, TransactionStatus.CREATED];
 /**
  * Transaction status information for UI display
  */
@@ -482,28 +384,6 @@ interface TransactionSigningParams {
     returnUrl?: string;
 }
 
-/**
- * Wallet list response from WalletService
- */
-interface WalletListResponse {
-    items: WalletItem[];
-}
-/**
- * Individual wallet item from wallet list - compatible with KeyWallet constructor
- */
-interface WalletItem {
-    id: string;
-    address: string;
-    network: string;
-    status: string;
-    signingKey?: unknown;
-    dateCreated?: string;
-    custodial?: boolean;
-    tags?: string[];
-    boundToEvmNetwork?: boolean;
-    [key: string]: unknown;
-}
-
 /**
  * Error codes for transaction signing operations
  */
@@ -530,6 +410,43 @@ interface TransactionSigningError extends Error {
     originalError?: unknown;
 }
 
+/**
+ * Signing status types for type-safe status updates
+ * Using const pattern instead of enum for better bundling compatibility
+ */
+declare const SigningStatus: {
+    readonly INITIALIZING: "initializing";
+    readonly AUTHENTICATING: "authenticating";
+    readonly PREPARING: "preparing";
+    readonly SIGNING: "signing";
+    readonly SUBMITTING: "submitting";
+    readonly COMPLETED: "completed";
+    readonly ERROR: "error";
+    readonly EXPIRED: "expired";
+};
+/**
+ * Type for signing status values
+ */
+type SigningStatus = typeof SigningStatus[keyof typeof SigningStatus];
+/**
+ * Status update data interface
+ */
+interface StatusUpdateData {
+    transactionId?: string;
+    transactionHash?: string;
+    error?: string;
+    [key: string]: any;
+}
+/**
+ * Status update callback interface for tracking transaction progress
+ *
+ * @interface StatusCallback
+ * @property {function} onStatusUpdate - Callback function that receives type-safe status updates
+ */
+interface StatusCallback {
+    onStatusUpdate?: (status: SigningStatus, message: string, data?: StatusUpdateData) => void;
+}
+
 /**
  * Central type definitions for the blockchain signer shared library
  * Single source of truth for all type exports
@@ -544,31 +461,12 @@ interface AuthenticatedUser {
     persAccessToken: string;
     expiresAt: number;
 }
-/**
- * Error types for service operations
- */
-interface ServiceError {
-    code: string;
-    message: string;
-    details?: any;
-    timestamp: Date;
-}
-
-interface GetWalletResponse {
-    id: string;
-    signingKey: {
-        publicKey: string;
-    };
-}
 
 type WalletOptions = {
     wallet: WalletMetadata;
     authToken: string;
     signingService: SigningService;
 };
-type WalletMetadata = GetWalletResponse & {
-    boundToEvmNetwork: boolean;
-};
 declare class KeyWallet extends AbstractSigner {
     private options;
     private address?;
@@ -629,12 +527,14 @@ declare class KeyWallet extends AbstractSigner {
  * @property {WebAuthnProvider} webAuthnProvider - WebAuthn provider for secure authentication
  * @property {string} [apiUrl] - Custom API base URL (defaults to production)
  * @property {string} [relyingPartyName] - WebAuthn relying party name for authentication
+ * @property {StatusCallback} [globalStatusCallback] - Optional global status callback for all operations
  */
 interface ExtendedPersSignerConfig {
     ethersProviderUrl?: string;
     webAuthnProvider: WebAuthnProvider;
     apiUrl?: string;
     relyingPartyName?: string;
+    globalStatusCallback?: StatusCallback;
 }
 interface PersSignerConfig extends Omit<ExtendedPersSignerConfig, 'webAuthnProvider'> {
 }
@@ -664,6 +564,11 @@ declare class PersSignerSDK {
      * @throws {Error} If required configuration is missing
      */
     constructor(config: ExtendedPersSignerConfig);
+    /**
+     * Helper method to trigger both global and method-specific status callbacks
+     * @private
+     */
+    private triggerStatusUpdate;
     /**
      * Authenticate user and cache session for 5 minutes
      *
@@ -671,20 +576,23 @@ declare class PersSignerSDK {
      * and caches the authenticated user session to avoid repeated authentication.
      *
      * @param {string} jwtToken - JWT token containing user identifier and tenant info
+     * @param {StatusCallback} [statusCallback] - Optional callback for status updates
      * @returns {Promise<AuthenticatedUser>} Authenticated user with access tokens
      * @throws {Error} If JWT is invalid, expired, or authentication fails
      *
      * @example
      * ```typescript
      * try {
-     *   const user = await sdk.loginUser(jwtToken);
+     *   const user = await sdk.loginUser(jwtToken, {
+     *     onStatusUpdate: (status, message) => console.log(`${status}: ${message}`)
+     *   });
      *   console.log('Authenticated:', user.identifier);
      * } catch (error) {
      *   console.error('Authentication failed:', error.message);
      * }
      * ```
      */
-    loginUser(jwtToken: string): Promise<AuthenticatedUser>;
+    loginUser(jwtToken: string, statusCallback?: StatusCallback): Promise<AuthenticatedUser>;
     /**
      * Sign a PERS transaction (legacy compatibility method)
      *
@@ -693,13 +601,16 @@ declare class PersSignerSDK {
      * maintained for backward compatibility.
      *
      * @param {string} jwtToken - JWT token containing transaction ID and user info
+     * @param {StatusCallback} [statusCallback] - Optional callback for status updates
      * @returns {Promise<TransactionSigningResult>} Signing result with signature and metadata
      * @throws {Error} If authentication fails, transaction ID missing, or signing fails
      *
      * @example
      * ```typescript
      * try {
-     *   const result = await sdk.signPersTransaction(jwtToken);
+     *   const result = await sdk.signPersTransaction(jwtToken, {
+     *     onStatusUpdate: (status, message) => console.log(`${status}: ${message}`)
+     *   });
      *   if (result.success) {
      *     console.log('Transaction signed:', result.signature);
      *   }
@@ -708,7 +619,7 @@ declare class PersSignerSDK {
      * }
      * ```
      */
-    signPersTransaction(jwtToken: string): Promise<TransactionSigningResult>;
+    signPersTransaction(jwtToken: string, statusCallback?: StatusCallback): Promise<TransactionSigningResult>;
     /**
      * Sign a transaction with provided signing data
      *
@@ -717,17 +628,20 @@ declare class PersSignerSDK {
      *
      * @param {CounterfactualWalletTransactionResponse | LegacyTransaction} signingData - Transaction data to sign
      * @param {string} jwtToken - JWT token containing transaction ID and user info
+     * @param {StatusCallback} [statusCallback] - Optional callback for status updates
      * @returns {Promise<TransactionSigningResult>} Signing result with signature and metadata
      * @throws {Error} If authentication fails, transaction ID missing, or signing fails
      *
      * @example
      * ```typescript
      * const signingData = await getTransactionData(transactionId);
-     * const result = await sdk.signTransaction(signingData, jwtToken);
+     * const result = await sdk.signTransaction(signingData, jwtToken, {
+     *   onStatusUpdate: (status, message) => console.log(`${status}: ${message}`)
+     * });
      * console.log('Signed transaction:', result.signature);
      * ```
      */
-    signTransaction(signingData: CounterfactualWalletTransactionResponse$1 | LegacyTransaction, jwtToken: string): Promise<TransactionSigningResult>;
+    signTransaction(signingData: CounterfactualWalletTransactionResponse$1 | LegacyTransaction, jwtToken: string, statusCallback?: StatusCallback): Promise<TransactionSigningResult>;
     /**
      * Complete transaction flow: sign and submit in one call
      *
@@ -736,13 +650,18 @@ declare class PersSignerSDK {
      * transaction lifecycle automatically.
      *
      * @param {string} jwtToken - JWT token containing transaction ID and user info
+     * @param {StatusCallback} [statusCallback] - Optional callback for status updates
      * @returns {Promise<SubmissionResult>} Submission result with transaction hash and status
      * @throws {Error} If authentication, signing, or submission fails
      *
      * @example
      * ```typescript
      * try {
-     *   const result = await sdk.signAndSubmitPersTransaction(jwtToken);
+     *   const result = await sdk.signAndSubmitPersTransaction(jwtToken, {
+     *     onStatusUpdate: (status, message) => {
+     *       console.log(`Status: ${status} - ${message}`);
+     *     }
+     *   });
      *   if (result.success) {
      *     console.log('Transaction completed:', result.transactionHash);
      *     if (result.shouldRedirect) {
@@ -754,7 +673,7 @@ declare class PersSignerSDK {
      * }
      * ```
      */
-    signAndSubmitPersTransaction(jwtToken: string): Promise<SubmissionResult>;
+    signAndSubmitPersTransaction(jwtToken: string, statusCallback?: StatusCallback): Promise<SubmissionResult>;
     /**
      * Submit a signed transaction to the blockchain
      *
@@ -764,17 +683,20 @@ declare class PersSignerSDK {
      *
      * @param {TransactionSigningResult} signingResult - Result from a successful transaction signing
      * @param {string} jwtToken - JWT token containing tenant and user info
+     * @param {StatusCallback} [statusCallback] - Optional callback for status updates
      * @returns {Promise<SubmissionResult>} Submission result with transaction hash and status
      * @throws {Error} If signing result is invalid, JWT is missing tenantId, or submission fails
      *
      * @example
      * ```typescript
      * const signedTx = await sdk.signPersTransaction(jwtToken);
-     * const result = await sdk.submitTransaction(signedTx, jwtToken);
+     * const result = await sdk.submitTransaction(signedTx, jwtToken, {
+     *   onStatusUpdate: (status, message) => console.log(`${status}: ${message}`)
+     * });
      * console.log('Transaction submitted:', result.transactionHash);
      * ```
      */
-    submitTransaction(signingResult: TransactionSigningResult, jwtToken: string): Promise<SubmissionResult>;
+    submitTransaction(signingResult: TransactionSigningResult, jwtToken: string, statusCallback?: StatusCallback): Promise<SubmissionResult>;
     /**
      * Clear user authentication cache
      *
@@ -873,11 +795,9 @@ declare class TransactionErrorHandler {
         error?: {
             code?: string;
             message?: string;
-            developerMessage?: string;
         };
         code?: string;
         message?: string;
-        developerMessage?: string;
     }, transactionId: string): never;
     /**
      * Process PERS API errors and handle TRANSACTION_NOT_PENDING cases
@@ -1043,7 +963,6 @@ declare function getHttpClient(): HttpClient;
  */
 declare class AuthenticationService {
     private signerToken;
-    private config;
     private webAuthnProvider;
     constructor(config: ExtendedPersSignerConfig);
     /**
@@ -1059,11 +978,11 @@ declare class AuthenticationService {
      */
     verifyToken(token: string): Promise<VerifyTokenResponse>;
     /**
-     * Initialize user registration
-     * @param persToken - PERS JWT token (registration is public)
-     * @returns Promise resolving to registration challenge
+     * Register user with unified flow
+     * @param persToken - PERS JWT token
+     * @returns Promise resolving to authenticated user data
      */
-    initializeRegistration(persToken: string): Promise<unknown>;
+    registerUser(persToken: string): Promise<JWTLoginResponse>;
     /**
      * Get current signer token
      * @returns The current signer JWT token
@@ -1074,14 +993,6 @@ declare class AuthenticationService {
      * @param token - Signer JWT token
      */
     setSignerToken(token: string): void;
-    /**
-     * Complete registration with WebAuthn challenge data (v1 API format)
-     * @param tmpAuthToken - Temporary auth token from init registration (temporaryAuthenticationToken)
-     * @param signedChallenge - WebAuthn credential response (will be restructured for backend)
-     * @param persToken - PERS JWT token (authToken)
-     * @returns Promise resolving to registration result
-     */
-    completeRegistrationWithChallenge(tmpAuthToken: string | null, signedChallenge: any, persToken: string): Promise<JWTLoginResponse | unknown>;
     /**
      * Combined authentication flow - handles both login and registration
      * @param identifier - User identifier (email/userId)
@@ -1094,7 +1005,8 @@ declare class AuthenticationService {
 }
 
 /**
- * React Native-specific WebAuthn provider using DFNS React Native SDK
+ * React Native-specific WebAuthn provider using react-native-passkey
+ * Fully agnostic implementation without external SDK dependencies
  * Falls back to browser implementation for React Native Web (Expo Web)
  */
 
@@ -1105,15 +1017,55 @@ declare function getReactNativeWebAuthnProvider(): Promise<WebAuthnProvider>;
 
 /**
  * React Native-specific entry point for the PERS Signer SDK
- * Includes both mobile and web compatibility for React Native projects
- * (e.g., Expo projects that serve both mobile and web)
+ *
+ * This module provides React Native-optimized SDK functionality with automatic WebAuthn provider setup.
+ * Compatible with both native mobile and Expo Web platforms.
+ * Use this entry point for all React Native applications (including Expo projects).
+ *
+ * @example
+ * ```typescript
+ * import { createPersSignerSDK } from '@explorins/pers-signer/react-native';
+ *
+ * // Simple initialization - WebAuthn provider is handled automatically
+ * const sdk = await createPersSignerSDK({
+ *   ethersProviderUrl: 'https://mainnet.infura.io/v3/YOUR_KEY'
+ * });
+ *
+ * // Complete transaction flow
+ * const result = await sdk.signAndSubmitPersTransaction(jwtToken);
+ * if (result.success) {
+ *   console.log('Transaction completed:', result.transactionHash);
+ * }
+ * ```
  */
 
 /**
  * Create a new PersSignerSDK instance with React Native WebAuthn provider
- * @param config - SDK configuration
+ *
+ * This is the recommended way to initialize the SDK in React Native environments.
+ * The WebAuthn provider is automatically configured for React Native usage,
+ * supporting both native mobile and Expo Web platforms.
+ *
+ * @param config - SDK configuration object
+ * @param config.ethersProviderUrl - Optional custom Ethereum RPC provider URL
+ * @param config.apiUrl - Optional custom API base URL (defaults to production)
+ * @param config.relyingPartyName - Optional WebAuthn relying party name
+ * @param config.globalStatusCallback - Optional global status callback for all operations
+ * @returns Promise resolving to configured PersSignerSDK instance
+ *
+ * @example
+ * ```typescript
+ * import { createPersSignerSDK } from '@explorins/pers-signer/react-native';
+ *
+ * const sdk = await createPersSignerSDK({
+ *   ethersProviderUrl: 'https://mainnet.infura.io/v3/YOUR_KEY'
+ * });
+ *
+ * // Use the SDK
+ * const result = await sdk.signAndSubmitPersTransaction(jwtToken);
+ * ```
  */
 declare function createPersSignerSDK(config: PersSignerConfig): Promise<PersSignerSDK>;
 
-export { AuthenticationService, FetchHttpClient, KeyWallet, PersService, PersSignerSDK, ReactNativeConfigProvider, SIGNABLE_STATUSES, SigningService, StaticConfigProvider, TransactionErrorHandler, TransactionSigningErrorCode, TransactionSigningService, TransactionSubmissionHandler, TransactionValidator, WalletService, WebAuthnCoordinator, WebConfigProvider, createPersSignerSDK, getConfigProvider, getHttpClient, getServiceConfig, getReactNativeWebAuthnProvider as getWebAuthnProvider, setConfigProvider, setHttpClient };
-export type { AuthResponse, AuthenticatedUser, CombinedTransactionStatus, CompleteRegistrationResponse, CompleteSignatureRequest, CompleteSignatureResponse, ConfigProvider, HashSigningRequest, HealthCheckResponse, HttpClient, HttpRequestOptions, HttpResponse, InitRegistrationRequest, InitRegistrationResponse, InitSignatureRequest, InitSignatureResponse, ListWalletsRequest, ListWalletsResponse, LoginRequest, LoginResponse, PersSignerConfig, PlatformConfig, RegistrationChallenge, RegistrationResult, RelyingPartyConfig, ServiceError, SignResponse, SignerApiError, SignerApiResponse, SigningAuthTokens, SigningChallenge, SigningRequest, SubmissionResult, TransactionSigningError, TransactionSigningParams, TransactionSigningResult, TransactionStatusInfo, TypedDataSigningRequest, UserCredentials, VerifyTokenRequest, VerifyTokenResponse, WalletItem, WalletListResponse, WebAuthnConfig, WebAuthnProvider };
+export { AuthenticationService, FetchHttpClient, KeyWallet, PersService, PersSignerSDK, ReactNativeConfigProvider, SigningService, SigningStatus, StaticConfigProvider, TransactionErrorHandler, TransactionSigningService, TransactionSubmissionHandler, TransactionValidator, WalletService, WebAuthnCoordinator, WebConfigProvider, createPersSignerSDK, getConfigProvider, getHttpClient, getServiceConfig, getReactNativeWebAuthnProvider as getWebAuthnProvider, setConfigProvider, setHttpClient };
+export type { AuthenticatedUser, ConfigProvider, HttpClient, HttpRequestOptions, HttpResponse, PersSignerConfig, PlatformConfig, StatusCallback, StatusUpdateData, SubmissionResult, TransactionSigningResult, WebAuthnConfig, WebAuthnProvider };