@explorins/pers-signer 1.0.17 → 1.0.25

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import * as _explorins_web3_ts_types from '@explorins/web3-ts/types';
-import { AnyTransactionData, LegacyTransaction } from '@explorins/web3-ts/types';
-export { AnyTransactionData } 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';
 import * as _explorins_pers_shared_browser from '@explorins/pers-shared/browser';
-import { TenantPublicDTO, SessionAuthContextResponseDTO, TransactionFormat, TransactionRequestResponseDTO, TransactionStatus, CounterfactualWalletTransactionResponse } from '@explorins/pers-shared/browser';
-export { TransactionFormat, TransactionRequestResponseDTO, TransactionStatus } from '@explorins/pers-shared/browser';
+import { CounterfactualWalletTransactionResponse, TransactionStatus, TransactionRequestResponseDTO, TenantPublicDTO, SessionAuthContextResponseDTO, TransactionFormat } from '@explorins/pers-shared/browser';
+export { CampaignClaimDTO, CampaignDTO, SessionAuthResponseDTO, TRANSACTION_FORMATS, TRANSACTION_FORMAT_DESCRIPTIONS, TransactionFormat, TransactionRequestResponseDTO, TransactionStatus, TransactionSubmissionRequestDTO } from '@explorins/pers-shared/browser';
 import { CounterfactualWalletTransactionResponse as CounterfactualWalletTransactionResponse$1 } from '@explorins/pers-shared';
 import { AbstractSigner, Provider, TransactionRequest, TypedDataDomain, TypedDataField } from 'ethers';
 
@@ -40,13 +40,12 @@ interface JWTLoginResponse {
         username: string;
         org_id: string;
     };
-    provider: string;
+    provider?: string;
 }
-interface WrappedProviderResponse {
-    success: true;
-    data: unknown;
+type LoginResponse = JWTLoginResponse;
+interface VerifyTokenRequest {
+    token: string;
 }
-type LoginResponse = JWTLoginResponse | WrappedProviderResponse;
 interface VerifyTokenResponse {
     valid: boolean;
     provider: string;
@@ -64,62 +63,380 @@ interface VerifyTokenResponse {
     };
     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 ListWalletsRequest {
 }
 interface ListWalletsResponse {
     success: true;
     data: {
-        wallets?: Array<unknown>;
-        [key: string]: unknown;
+        items: Wallet[];
     };
 }
 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;
+        status: string;
+        challenge?: unknown;
+        signature?: number[];
     };
 }
 interface HealthCheckResponse {
     success: 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: WebAuthnCreateChallenge): Promise<WebAuthnAttestation>;
+    sign(challenge: WebAuthnSignChallenge): Promise<WebAuthnAssertion>;
+}
+interface WebAuthnConfig {
+    relyingParty: {
+        id: string;
+        name: string;
+        origin?: string;
+    };
+}
+
+/**
+ * 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
+ */
+/**
+ * Hash signing request
+ */
+interface HashSigningRequest {
+    kind: "Hash";
+    hash: string;
+}
+/**
+ * EIP-712 typed data signing request
+ */
+interface TypedDataSigningRequest {
+    blockchainKind: "Evm";
+    kind: "Eip712";
+    types: Record<string, any[]>;
+    domain: any;
+    message: Record<string, any>;
+}
+/**
+ * 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;
+}
+
+/**
+ * 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
+ */
+interface TransactionStatusInfo {
+    transactionId: string;
+    transactionStatus: CombinedTransactionStatus;
+    message: string;
+}
+/**
+ * Transaction signing result
+ */
+interface TransactionSigningResult {
+    success: boolean;
+    transactionId: string;
+    signature?: string;
+    signingData?: CounterfactualWalletTransactionResponse | LegacyTransaction;
+    error?: string;
+    statusInfo?: TransactionStatusInfo;
+    shouldShowStatus?: boolean;
+}
+/**
+ * Transaction submission result for internal processing
+ */
+interface SubmissionResult {
+    submitResult: TransactionRequestResponseDTO;
+    shouldRedirect: boolean;
+    redirectUrl?: string;
+    transactionHash: string | null;
+    success: boolean;
+    error?: string;
+}
+/**
+ * Metadata for transaction parameters - string values only
+ */
+/**
+ * Authentication tokens required for transaction signing
+ */
+interface SigningAuthTokens {
+    signerAuthToken: string;
+    persAccessToken: string;
+}
+/**
+ * Transaction signing parameters
+ */
+interface TransactionSigningParams {
+    transactionId: string;
+    tenantId: string;
+    authTokens: SigningAuthTokens;
+    ethersProviderUrl: string;
+    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;
+}
+interface GetWalletResponse {
+    id: string;
+    signingKey: {
+        publicKey: string;
+    };
+}
+type WalletMetadata = GetWalletResponse & {
+    boundToEvmNetwork: boolean;
+};
+
+/**
+ * Error codes for transaction signing operations
+ */
+declare enum TransactionSigningErrorCode {
+    INVALID_TOKENS = "INVALID_TOKENS",
+    TRANSACTION_NOT_FOUND = "TRANSACTION_NOT_FOUND",
+    TRANSACTION_NOT_PENDING = "TRANSACTION_NOT_PENDING",
+    WALLET_NOT_AVAILABLE = "WALLET_NOT_AVAILABLE",
+    WEBAUTHN_OPERATION_IN_PROGRESS = "WEBAUTHN_OPERATION_IN_PROGRESS",
+    SIGNING_CANCELLED = "SIGNING_CANCELLED",
+    PERS_AUTH_FAILED = "PERS_AUTH_FAILED",
+    AUTH_FAILED = "AUTH_FAILED",
+    TRANSACTION_NOT_READY = "TRANSACTION_NOT_READY",
+    SUBMISSION_FAILED = "SUBMISSION_FAILED",
+    SERVER_ERROR = "SERVER_ERROR",
+    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+}
+/**
+ * Structured error for transaction signing operations
+ */
+interface TransactionSigningError extends Error {
+    code: TransactionSigningErrorCode;
+    transactionId?: string;
+    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;
+}
 /**
- * Types for WebAuthn provider abstraction
+ * Status update callback interface for tracking transaction progress
+ *
+ * @interface StatusCallback
+ * @property {function} onStatusUpdate - Callback function that receives type-safe status updates
  */
-interface WebAuthnProvider {
-    create(challenge: any): Promise<any>;
-    sign(challenge: any): Promise<any>;
-}
-interface WebAuthnConfig {
-    relyingParty: {
-        id: string;
-        name: string;
-        origin?: string;
-    };
+interface StatusCallback {
+    onStatusUpdate?: (status: SigningStatus, message: string, data?: StatusUpdateData) => void;
 }
 
 /**
- * Shared type definitions for the blockchain signer shared library
+ * Central type definitions for the blockchain signer shared library
+ * Single source of truth for all type exports
  */
 
 /**
@@ -129,18 +446,8 @@ interface AuthenticatedUser {
     identifier: string;
     signerAuthToken: string;
     persAccessToken: string;
-    tenantId: string;
     expiresAt: number;
 }
-/**
- * Service configuration options
- */
-interface ServiceConfig {
-    apiUrl: string;
-    environment: 'development' | 'staging' | 'production';
-    timeout?: number;
-    retryAttempts?: number;
-}
 /**
  * Error types for service operations
  */
@@ -161,7 +468,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[]>;
 }
 
 /**
@@ -179,18 +486,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
      */
@@ -201,21 +502,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
@@ -229,7 +530,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
@@ -271,113 +572,6 @@ declare class PersService {
     static getTransactionDataForSigning(transactionResponse: TransactionRequestResponseDTO): _explorins_pers_shared_browser.CounterfactualWalletTransactionResponse | _explorins_web3_ts_types.LegacyTransaction;
 }
 
-/**
- * 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
- */
-/**
- * Hash signing request
- */
-interface HashSigningRequest {
-    kind: "Hash";
-    hash: string;
-}
-/**
- * EIP-712 typed data signing request
- */
-interface TypedDataSigningRequest {
-    blockchainKind: "Evm";
-    kind: "Eip712";
-    types: Record<string, any[]>;
-    domain: any;
-    message: Record<string, any>;
-}
-/**
- * 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;
-}
-
 /**
  * Signing service for cryptographic operations
  * Handles hash signing and typed data signing with WebAuthn
@@ -422,21 +616,11 @@ declare class SigningService {
     signBatch(authToken: string, walletId: string, requests: SigningRequest[]): Promise<CompleteSignatureResponse['data'][]>;
 }
 
-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?;
@@ -459,66 +643,6 @@ declare class KeyWallet extends AbstractSigner {
     signPersTransaction(transactionData: AnyTransactionData): Promise<string>;
 }
 
-/**
- * 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
- */
-interface TransactionStatusInfo {
-    transactionId: string;
-    transactionStatus: CombinedTransactionStatus;
-    message: string;
-}
-/**
- * Transaction signing result
- */
-interface TransactionSigningResult {
-    success: boolean;
-    transactionId: string;
-    signature?: string;
-    signingData?: CounterfactualWalletTransactionResponse | LegacyTransaction;
-    error?: string;
-    statusInfo?: TransactionStatusInfo;
-    shouldShowStatus?: boolean;
-}
-/**
- * Transaction submission result for internal processing
- */
-interface SubmissionResult {
-    submitResult: TransactionRequestResponseDTO;
-    shouldRedirect: boolean;
-    redirectUrl?: string;
-    transactionHash: string | null;
-    success: boolean;
-    error?: string;
-}
-/**
- * Metadata for transaction parameters - string values only
- */
-/**
- * Authentication tokens required for transaction signing
- */
-interface SigningAuthTokens {
-    signerAuthToken: string;
-    persAccessToken: string;
-}
-/**
- * Transaction signing parameters
- */
-interface TransactionSigningParams {
-    transactionId: string;
-    tenantId: string;
-    authTokens: SigningAuthTokens;
-    ethersProviderUrl: string;
-    returnUrl?: string;
-}
-
 /**
  * Service for orchestrating transaction signing operations
  * Handles the complete flow from transaction preparation to submission
@@ -554,32 +678,6 @@ declare class TransactionSigningService {
     signTransaction(params: TransactionSigningParams, signingData: CounterfactualWalletTransactionResponse | LegacyTransaction): Promise<TransactionSigningResult>;
 }
 
-/**
- * Error codes for transaction signing operations
- */
-declare enum TransactionSigningErrorCode {
-    INVALID_TOKENS = "INVALID_TOKENS",
-    TRANSACTION_NOT_FOUND = "TRANSACTION_NOT_FOUND",
-    TRANSACTION_NOT_PENDING = "TRANSACTION_NOT_PENDING",
-    WALLET_NOT_AVAILABLE = "WALLET_NOT_AVAILABLE",
-    WEBAUTHN_OPERATION_IN_PROGRESS = "WEBAUTHN_OPERATION_IN_PROGRESS",
-    SIGNING_CANCELLED = "SIGNING_CANCELLED",
-    PERS_AUTH_FAILED = "PERS_AUTH_FAILED",
-    AUTH_FAILED = "AUTH_FAILED",
-    TRANSACTION_NOT_READY = "TRANSACTION_NOT_READY",
-    SUBMISSION_FAILED = "SUBMISSION_FAILED",
-    SERVER_ERROR = "SERVER_ERROR",
-    UNKNOWN_ERROR = "UNKNOWN_ERROR"
-}
-/**
- * Structured error for transaction signing operations
- */
-interface TransactionSigningError extends Error {
-    code: TransactionSigningErrorCode;
-    transactionId?: string;
-    originalError?: unknown;
-}
-
 /**
  * Handles all error-related operations for transaction signing
  */
@@ -626,11 +724,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
@@ -789,28 +885,6 @@ declare function setHttpClient(client: HttpClient): void;
  */
 declare function getHttpClient(): HttpClient;
 
-/**
- * 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;
-}
-
 /**
  * PERS Blockchain Signer SDK
  *
@@ -849,12 +923,14 @@ interface WalletItem {
  * @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'> {
 }
@@ -884,6 +960,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
      *
@@ -891,20 +972,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)
      *
@@ -913,13 +997,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);
      *   }
@@ -928,7 +1015,7 @@ declare class PersSignerSDK {
      * }
      * ```
      */
-    signPersTransaction(jwtToken: string): Promise<TransactionSigningResult>;
+    signPersTransaction(jwtToken: string, statusCallback?: StatusCallback): Promise<TransactionSigningResult>;
     /**
      * Sign a transaction with provided signing data
      *
@@ -937,17 +1024,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
      *
@@ -956,13 +1046,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) {
@@ -974,7 +1069,7 @@ declare class PersSignerSDK {
      * }
      * ```
      */
-    signAndSubmitPersTransaction(jwtToken: string): Promise<SubmissionResult>;
+    signAndSubmitPersTransaction(jwtToken: string, statusCallback?: StatusCallback): Promise<SubmissionResult>;
     /**
      * Submit a signed transaction to the blockchain
      *
@@ -984,17 +1079,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
      *
@@ -1035,14 +1133,6 @@ declare class PersSignerSDK {
  */
 declare function createPersSignerSDK(config: ExtendedPersSignerConfig): PersSignerSDK;
 
-/**
- * Authenticated user with all required tokens
- */
-interface SignerAuthenticatedUser {
-    identifier: string;
-    signerAuthToken: string;
-    persAccessToken: string;
-}
 /**
  * Authentication service for user login and registration
  * Uses constructor-based dependency injection for WebAuthn provider
@@ -1050,7 +1140,6 @@ interface SignerAuthenticatedUser {
  */
 declare class AuthenticationService {
     private signerToken;
-    private config;
     private webAuthnProvider;
     constructor(config: ExtendedPersSignerConfig);
     /**
@@ -1066,11 +1155,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
@@ -1081,14 +1170,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)
@@ -1097,7 +1178,7 @@ declare class AuthenticationService {
      * @param relyingPartyConfig - Configuration for WebAuthn relying party
      * @returns Promise resolving to authenticated user with signer token
      */
-    combinedAuthentication(identifier: string, persAccessToken: string): Promise<SignerAuthenticatedUser>;
+    combinedAuthentication(identifier: string, persAccessToken: string): Promise<AuthenticatedUser>;
 }
 
 /**
@@ -1113,7 +1194,8 @@ declare class HealthService {
 }
 
 /**
- * Browser-specific WebAuthn provider using DFNS browser SDK
+ * Browser-specific WebAuthn provider using native browser APIs
+ * Fully agnostic implementation without external SDK dependencies
  */
 
 /**
@@ -1122,7 +1204,8 @@ declare class HealthService {
 declare function getBrowserWebAuthnProvider(): Promise<WebAuthnProvider>;
 
 /**
- * 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)
  */
 
@@ -1137,6 +1220,7 @@ declare function getReactNativeWebAuthnProvider(): Promise<WebAuthnProvider>;
  * Browser-compatible JWT handling without external dependencies
  */
 interface JWTPayload {
+    iss?: string;
     email?: string;
     identifierEmail?: string;
     userId?: string;
@@ -1209,5 +1293,5 @@ declare class UserCache {
     static cleanup(): number;
 }
 
-export { AuthenticationService, FetchHttpClient, HealthService, KeyWallet, PersService, PersSignerSDK, ReactNativeConfigProvider, SIGNABLE_STATUSES, SigningService, StaticConfigProvider, TransactionErrorHandler, TransactionSigningErrorCode, TransactionSigningService, TransactionSubmissionHandler, TransactionValidator, UserCache, WalletService, WebAuthnCoordinator, WebConfigProvider, createPersSignerSDK, extractJWTFromToken, getBrowserWebAuthnProvider, getConfigProvider, getHttpClient, getJWTPayload, getReactNativeWebAuthnProvider, getServiceConfig, isJWTExpired, setConfigProvider, setHttpClient };
-export type { AuthResponse, AuthenticatedUser, CombinedTransactionStatus, ConfigProvider, HashSigningRequest, HttpClient, HttpRequestOptions, HttpResponse, JWTExtractionResult, JWTPayload, ListWalletsRequest, ListWalletsResponse, LoginRequest, LoginResponse, PersSignerConfig, RegistrationChallenge, RegistrationResult, RelyingPartyConfig, ServiceConfig, ServiceError, SignResponse, SignerApiError, SignerApiResponse, SigningAuthTokens, SigningChallenge, SigningRequest, SubmissionResult, TransactionSigningError, TransactionSigningParams, TransactionSigningResult, TransactionStatusInfo, TypedDataSigningRequest, UserCredentials, WalletItem, WalletListResponse, WebAuthnConfig, WebAuthnProvider };
+export { AuthenticationService, FetchHttpClient, HealthService, KeyWallet, PersService, PersSignerSDK, ReactNativeConfigProvider, SIGNABLE_STATUSES, SigningService, SigningStatus, StaticConfigProvider, TransactionErrorHandler, TransactionSigningErrorCode, TransactionSigningService, TransactionSubmissionHandler, TransactionValidator, UserCache, WalletService, WebAuthnCoordinator, WebConfigProvider, createPersSignerSDK, extractJWTFromToken, getBrowserWebAuthnProvider, getConfigProvider, getHttpClient, getJWTPayload, getReactNativeWebAuthnProvider, getServiceConfig, isJWTExpired, setConfigProvider, setHttpClient };
+export type { AuthResponse, AuthenticatedUser, CombinedTransactionStatus, CompleteSignatureResponse, ConfigProvider, HashSigningRequest, HealthCheckResponse, HttpClient, HttpRequestOptions, HttpResponse, JWTExtractionResult, JWTPayload, ListWalletsRequest, ListWalletsResponse, LoginRequest, LoginResponse, PersSignerConfig, RegistrationChallenge, RegistrationResult, RelyingPartyConfig, ServiceError, SignResponse, SignerApiError, SignerApiResponse, SigningAuthTokens, SigningChallenge, SigningRequest, StatusCallback, StatusUpdateData, SubmissionResult, TransactionSigningError, TransactionSigningParams, TransactionSigningResult, TransactionStatusInfo, TypedDataSigningRequest, UserCredentials, VerifyTokenRequest, VerifyTokenResponse, WalletItem, WalletListResponse, WebAuthnConfig, WebAuthnProvider };