@explorins/pers-signer 1.0.17 → 1.0.25

package/dist/browser.d.ts

@@ -1,12 +1,69 @@
 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, 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 { TransactionFormat, TransactionRequestResponseDTO, TransactionStatus } 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,89 +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;
-}
-
-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 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;
-    };
-}
 
 /**
  * Signing service for cryptographic operations
@@ -349,84 +328,10 @@ declare class SigningService {
     signBatch(authToken: string, walletId: string, requests: SigningRequest[]): Promise<CompleteSignatureResponse['data'][]>;
 }
 
-/**
- * Shared type definitions for the blockchain signer shared library
- */
-
-/**
- * Authentication types for 3-function split architecture
- */
-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
- */
-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?;
-    private authToken;
-    private metadata;
-    private signingService;
-    constructor(options: WalletOptions, provider?: Provider | null);
-    connect(provider: Provider | null): KeyWallet;
-    getAddress(): Promise<string>;
-    private signHash;
-    signTransaction(tx: TransactionRequest): Promise<string>;
-    signMessage(message: string | Uint8Array): Promise<string>;
-    signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataField[]>, value: Record<string, any>): Promise<string>;
-    /**
-     * Signs a PERS transaction based on its format
-     * Handles different transaction types: Legacy, EIP-2930, EIP-1559, and EIP-712
-     * @param transactionData - The transaction data from PERS API
-     * @returns The signature string
-     */
-    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
  */
@@ -479,6 +384,111 @@ interface TransactionSigningParams {
     returnUrl?: string;
 }
 
+/**
+ * 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;
+}
+/**
+ * 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
+ */
+
+/**
+ * Authentication types for 3-function split architecture
+ */
+interface AuthenticatedUser {
+    identifier: string;
+    signerAuthToken: string;
+    persAccessToken: string;
+    expiresAt: number;
+}
+
+type WalletOptions = {
+    wallet: WalletMetadata;
+    authToken: string;
+    signingService: SigningService;
+};
+declare class KeyWallet extends AbstractSigner {
+    private options;
+    private address?;
+    private authToken;
+    private metadata;
+    private signingService;
+    constructor(options: WalletOptions, provider?: Provider | null);
+    connect(provider: Provider | null): KeyWallet;
+    getAddress(): Promise<string>;
+    private signHash;
+    signTransaction(tx: TransactionRequest): Promise<string>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+    signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataField[]>, value: Record<string, any>): Promise<string>;
+    /**
+     * Signs a PERS transaction based on its format
+     * Handles different transaction types: Legacy, EIP-2930, EIP-1559, and EIP-712
+     * @param transactionData - The transaction data from PERS API
+     * @returns The signature string
+     */
+    signPersTransaction(transactionData: AnyTransactionData): Promise<string>;
+}
+
 /**
  * PERS Blockchain Signer SDK
  *
@@ -517,12 +527,14 @@ interface TransactionSigningParams {
  * @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'> {
 }
@@ -552,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
      *
@@ -559,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)
      *
@@ -581,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);
      *   }
@@ -596,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
      *
@@ -605,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
      *
@@ -624,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) {
@@ -642,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
      *
@@ -652,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
      *
@@ -715,32 +749,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
  */
@@ -787,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
@@ -950,36 +956,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;
-}
-
-/**
- * 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
@@ -987,7 +963,6 @@ interface SignerAuthenticatedUser {
  */
 declare class AuthenticationService {
     private signerToken;
-    private config;
     private webAuthnProvider;
     constructor(config: ExtendedPersSignerConfig);
     /**
@@ -1003,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
@@ -1018,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)
@@ -1034,11 +1001,12 @@ 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>;
 }
 
 /**
- * Browser-specific WebAuthn provider using DFNS browser SDK
+ * Browser-specific WebAuthn provider using native browser APIs
+ * Fully agnostic implementation without external SDK dependencies
  */
 
 /**
@@ -1048,14 +1016,53 @@ declare function getBrowserWebAuthnProvider(): Promise<WebAuthnProvider>;
 
 /**
  * Browser-specific entry point for the PERS Signer SDK
- * Includes only browser-compatible dependencies
+ *
+ * This module provides browser-optimized SDK functionality with automatic WebAuthn provider setup.
+ * Use this entry point for all browser-based applications (React, Vue, Angular, etc.).
+ *
+ * @example
+ * ```typescript
+ * import { createPersSignerSDK } from '@explorins/pers-signer/browser';
+ *
+ * // 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 browser WebAuthn provider
- * @param config - SDK configuration (ethersProviderUrl is required)
+ *
+ * This is the recommended way to initialize the SDK in browser environments.
+ * The WebAuthn provider is automatically configured for browser usage.
+ *
+ * @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/browser';
+ *
+ * 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, getBrowserWebAuthnProvider, getConfigProvider, getHttpClient, getServiceConfig, getBrowserWebAuthnProvider as getWebAuthnProvider, setConfigProvider, setHttpClient };
-export type { AuthResponse, AuthenticatedUser, CombinedTransactionStatus, ConfigProvider, HashSigningRequest, HttpClient, HttpRequestOptions, HttpResponse, PersSignerConfig, PlatformConfig, RegistrationChallenge, RegistrationResult, RelyingPartyConfig, ServiceConfig, ServiceError, SignResponse, SigningAuthTokens, SigningChallenge, SigningRequest, SubmissionResult, TransactionSigningError, TransactionSigningParams, TransactionSigningResult, TransactionStatusInfo, TypedDataSigningRequest, UserCredentials, WalletItem, WalletListResponse, WebAuthnConfig, WebAuthnProvider };
+export { AuthenticationService, FetchHttpClient, KeyWallet, PersService, PersSignerSDK, ReactNativeConfigProvider, SigningService, SigningStatus, StaticConfigProvider, TransactionErrorHandler, TransactionSigningService, TransactionSubmissionHandler, TransactionValidator, WalletService, WebAuthnCoordinator, WebConfigProvider, createPersSignerSDK, getBrowserWebAuthnProvider, getConfigProvider, getHttpClient, getServiceConfig, getBrowserWebAuthnProvider as getWebAuthnProvider, setConfigProvider, setHttpClient };
+export type { AuthenticatedUser, ConfigProvider, HttpClient, HttpRequestOptions, HttpResponse, PersSignerConfig, PlatformConfig, StatusCallback, StatusUpdateData, SubmissionResult, TransactionSigningResult, WebAuthnConfig, WebAuthnProvider };