@explorins/pers-signer 1.0.16 → 1.0.18

package/dist/browser.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, CounterfactualWalletTransactionResponse, TransactionStatus } from '@explorins/pers-shared/browser';
-export { TransactionFormat, TransactionRequestResponseDTO, TransactionStatus } from '@explorins/pers-shared/browser';
+export { CampaignClaimDTO, CampaignDTO, SessionAuthResponseDTO, TRANSACTION_FORMATS, TRANSACTION_FORMAT_DESCRIPTIONS, TransactionFormat, TransactionRequestResponseDTO, TransactionStatus, TransactionSubmissionRequestDTO } from '@explorins/pers-shared/browser';
 import { AbstractSigner, Provider, TransactionRequest, TypedDataDomain, TypedDataField } from 'ethers';
 import { CounterfactualWalletTransactionResponse as CounterfactualWalletTransactionResponse$1 } from '@explorins/pers-shared';
 
@@ -249,6 +249,29 @@ interface RelyingPartyConfig {
     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;
@@ -261,6 +284,14 @@ interface JWTLoginResponse {
     };
     provider: string;
 }
+interface WrappedProviderResponse {
+    success: true;
+    data: unknown;
+}
+type LoginResponse = JWTLoginResponse | WrappedProviderResponse;
+interface VerifyTokenRequest {
+    token: string;
+}
 interface VerifyTokenResponse {
     valid: boolean;
     provider: string;
@@ -278,6 +309,45 @@ interface VerifyTokenResponse {
     };
     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: {
@@ -304,6 +374,9 @@ interface CompleteSignatureResponse {
         [key: string]: unknown;
     };
 }
+interface HealthCheckResponse {
+    success: boolean;
+}
 
 /**
  * Signing service for cryptographic operations
@@ -350,7 +423,116 @@ declare class SigningService {
 }
 
 /**
- * Shared type definitions for the blockchain signer shared library
+ * 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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Central type definitions for the blockchain signer shared library
+ * Single source of truth for all type exports
  */
 
 /**
@@ -360,18 +542,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
  */
@@ -420,63 +592,204 @@ declare class KeyWallet extends AbstractSigner {
 }
 
 /**
- * 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
+ * PERS Blockchain Signer SDK
+ *
+ * A lightweight blockchain transaction signing SDK with WebAuthn authentication.
+ * Provides 5 focused methods for complete transaction lifecycle management:
+ *
+ * 1. loginUser(jwtToken) - Authenticate user with 5-minute caching
+ * 2. signTransaction(signingData, jwtToken) - Sign transactions with auto-login
+ * 3. submitTransaction(signedTx, jwtToken) - Submit signed transactions to blockchain
+ * 4. signPersTransaction(jwtToken) - Legacy one-liner for backward compatibility
+ * 5. signAndSubmitPersTransaction(jwtToken) - Complete sign + submit flow
+ *
+ * @example
+ * ```typescript
+ * import { createPersSignerSDK } from '@explorins/pers-signer';
+ *
+ * const sdk = createPersSignerSDK({
+ *   webAuthnProvider: myWebAuthnProvider,
+ *   ethersProviderUrl: 'https://ethereum-rpc.com'
+ * });
+ *
+ * // Quick sign and submit
+ * const result = await sdk.signAndSubmitPersTransaction(jwtToken);
+ * if (result.success) {
+ *   console.log('Transaction submitted:', result.transactionHash);
+ * }
+ * ```
  */
-interface TransactionSigningResult {
-    success: boolean;
-    transactionId: string;
-    signature?: string;
-    signingData?: CounterfactualWalletTransactionResponse | LegacyTransaction;
-    error?: string;
-    statusInfo?: TransactionStatusInfo;
-    shouldShowStatus?: boolean;
-}
+
 /**
- * Transaction submission result for internal processing
+ * Configuration interface for the PERS Signer SDK
+ *
+ * @interface PersSignerConfig
+ * @property {string} [tenantId] - Optional tenant identifier for multi-tenant applications
+ * @property {string} [ethersProviderUrl] - Custom Ethereum RPC provider URL
+ * @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
  */
-interface SubmissionResult {
-    submitResult: TransactionRequestResponseDTO;
-    shouldRedirect: boolean;
-    redirectUrl?: string;
-    transactionHash: string | null;
-    success: boolean;
-    error?: string;
+interface ExtendedPersSignerConfig {
+    ethersProviderUrl?: string;
+    webAuthnProvider: WebAuthnProvider;
+    apiUrl?: string;
+    relyingPartyName?: string;
 }
-/**
- * Metadata for transaction parameters - string values only
- */
-/**
- * Authentication tokens required for transaction signing
- */
-interface SigningAuthTokens {
-    signerAuthToken: string;
-    persAccessToken: string;
+interface PersSignerConfig extends Omit<ExtendedPersSignerConfig, 'webAuthnProvider'> {
 }
 /**
- * Transaction signing parameters
+ * PERS Blockchain Signer SDK Class
+ *
+ * Main SDK class providing blockchain transaction signing capabilities with WebAuthn authentication.
+ * Implements a clean 5-method API for complete transaction lifecycle management.
+ *
+ * Features:
+ * - WebAuthn-based secure authentication
+ * - 5-minute user session caching
+ * - Automatic transaction data fetching
+ * - Blockchain transaction signing and submission
+ * - Multi-tenant support
+ *
+ * @class PersSignerSDK
  */
-interface TransactionSigningParams {
-    transactionId: string;
-    tenantId: string;
-    authTokens: SigningAuthTokens;
-    ethersProviderUrl: string;
-    returnUrl?: string;
+declare class PersSignerSDK {
+    private config;
+    private authenticationService;
+    private transactionSigningService;
+    /**
+     * Initialize the PERS Signer SDK
+     *
+     * @param {ExtendedPersSignerConfig} config - SDK configuration object
+     * @throws {Error} If required configuration is missing
+     */
+    constructor(config: ExtendedPersSignerConfig);
+    /**
+     * Authenticate user and cache session for 5 minutes
+     *
+     * Validates JWT token, authenticates with both signer and PERS backends,
+     * and caches the authenticated user session to avoid repeated authentication.
+     *
+     * @param {string} jwtToken - JWT token containing user identifier and tenant info
+     * @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);
+     *   console.log('Authenticated:', user.identifier);
+     * } catch (error) {
+     *   console.error('Authentication failed:', error.message);
+     * }
+     * ```
+     */
+    loginUser(jwtToken: string): Promise<AuthenticatedUser>;
+    /**
+     * Sign a PERS transaction (legacy compatibility method)
+     *
+     * Automatically handles user authentication, transaction data fetching,
+     * and transaction signing in a single call. This is the legacy method
+     * maintained for backward compatibility.
+     *
+     * @param {string} jwtToken - JWT token containing transaction ID and user info
+     * @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);
+     *   if (result.success) {
+     *     console.log('Transaction signed:', result.signature);
+     *   }
+     * } catch (error) {
+     *   console.error('Signing failed:', error.message);
+     * }
+     * ```
+     */
+    signPersTransaction(jwtToken: string): Promise<TransactionSigningResult>;
+    /**
+     * Sign a transaction with provided signing data
+     *
+     * Low-level method to sign transactions when you already have the signing data.
+     * Automatically handles user authentication and applies the blockchain signature.
+     *
+     * @param {CounterfactualWalletTransactionResponse | LegacyTransaction} signingData - Transaction data to sign
+     * @param {string} jwtToken - JWT token containing transaction ID and user info
+     * @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);
+     * console.log('Signed transaction:', result.signature);
+     * ```
+     */
+    signTransaction(signingData: CounterfactualWalletTransactionResponse$1 | LegacyTransaction, jwtToken: string): Promise<TransactionSigningResult>;
+    /**
+     * Complete transaction flow: sign and submit in one call
+     *
+     * Convenience method that combines signing and submission into a single operation.
+     * This is the recommended method for most use cases as it handles the complete
+     * transaction lifecycle automatically.
+     *
+     * @param {string} jwtToken - JWT token containing transaction ID and user info
+     * @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);
+     *   if (result.success) {
+     *     console.log('Transaction completed:', result.transactionHash);
+     *     if (result.shouldRedirect) {
+     *       window.location.href = result.redirectUrl;
+     *     }
+     *   }
+     * } catch (error) {
+     *   console.error('Transaction failed:', error.message);
+     * }
+     * ```
+     */
+    signAndSubmitPersTransaction(jwtToken: string): Promise<SubmissionResult>;
+    /**
+     * Submit a signed transaction to the blockchain
+     *
+     * Takes a signed transaction result and submits it to the blockchain network.
+     * Returns detailed submission results including transaction hash and any
+     * redirect information for UI flows.
+     *
+     * @param {TransactionSigningResult} signingResult - Result from a successful transaction signing
+     * @param {string} jwtToken - JWT token containing tenant and user info
+     * @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);
+     * console.log('Transaction submitted:', result.transactionHash);
+     * ```
+     */
+    submitTransaction(signingResult: TransactionSigningResult, jwtToken: string): Promise<SubmissionResult>;
+    /**
+     * Clear user authentication cache
+     *
+     * Removes all cached user sessions, forcing fresh authentication
+     * on the next method call. Useful for logout scenarios or when
+     * switching between different user contexts.
+     *
+     * @example
+     * ```typescript
+     * // Clear cache on user logout
+     * sdk.clearCache();
+     * console.log('User cache cleared');
+     * ```
+     */
+    clearCache(): void;
 }
 
 /**
@@ -486,7 +799,7 @@ interface TransactionSigningParams {
  */
 declare class TransactionSigningService {
     private webAuthnProvider;
-    constructor(config: PersSignerConfig);
+    constructor(config: ExtendedPersSignerConfig);
     /**
      * Prepare transaction for signing - fetch and validate
      */
@@ -514,32 +827,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
  */
@@ -749,236 +1036,6 @@ declare function setHttpClient(client: HttpClient): void;
  */
 declare function getHttpClient(): HttpClient;
 
-/**
- * PERS Blockchain Signer SDK
- *
- * A lightweight blockchain transaction signing SDK with WebAuthn authentication.
- * Provides 5 focused methods for complete transaction lifecycle management:
- *
- * 1. loginUser(jwtToken) - Authenticate user with 5-minute caching
- * 2. signTransaction(signingData, jwtToken) - Sign transactions with auto-login
- * 3. submitTransaction(signedTx, jwtToken) - Submit signed transactions to blockchain
- * 4. signPersTransaction(jwtToken) - Legacy one-liner for backward compatibility
- * 5. signAndSubmitPersTransaction(jwtToken) - Complete sign + submit flow
- *
- * @example
- * ```typescript
- * import { createPersSignerSDK } from '@explorins/pers-signer';
- *
- * const sdk = createPersSignerSDK({
- *   webAuthnProvider: myWebAuthnProvider,
- *   ethersProviderUrl: 'https://ethereum-rpc.com'
- * });
- *
- * // Quick sign and submit
- * const result = await sdk.signAndSubmitPersTransaction(jwtToken);
- * if (result.success) {
- *   console.log('Transaction submitted:', result.transactionHash);
- * }
- * ```
- */
-
-/**
- * Configuration interface for the PERS Signer SDK
- *
- * @interface PersSignerConfig
- * @property {string} [tenantId] - Optional tenant identifier for multi-tenant applications
- * @property {string} [ethersProviderUrl] - Custom Ethereum RPC provider URL
- * @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
- */
-interface PersSignerConfig {
-    tenantId?: string;
-    ethersProviderUrl?: string;
-    webAuthnProvider: WebAuthnProvider;
-    apiUrl?: string;
-    relyingPartyName?: string;
-}
-/**
- * PERS Blockchain Signer SDK Class
- *
- * Main SDK class providing blockchain transaction signing capabilities with WebAuthn authentication.
- * Implements a clean 5-method API for complete transaction lifecycle management.
- *
- * Features:
- * - WebAuthn-based secure authentication
- * - 5-minute user session caching
- * - Automatic transaction data fetching
- * - Blockchain transaction signing and submission
- * - Multi-tenant support
- *
- * @class PersSignerSDK
- */
-declare class PersSignerSDK {
-    private config;
-    private authenticationService;
-    private transactionSigningService;
-    /**
-     * Initialize the PERS Signer SDK
-     *
-     * @param {PersSignerConfig} config - SDK configuration object
-     * @throws {Error} If required configuration is missing
-     */
-    constructor(config: PersSignerConfig);
-    /**
-     * Authenticate user and cache session for 5 minutes
-     *
-     * Validates JWT token, authenticates with both signer and PERS backends,
-     * and caches the authenticated user session to avoid repeated authentication.
-     *
-     * @param {string} jwtToken - JWT token containing user identifier and tenant info
-     * @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);
-     *   console.log('Authenticated:', user.identifier);
-     * } catch (error) {
-     *   console.error('Authentication failed:', error.message);
-     * }
-     * ```
-     */
-    loginUser(jwtToken: string): Promise<AuthenticatedUser>;
-    /**
-     * Sign a PERS transaction (legacy compatibility method)
-     *
-     * Automatically handles user authentication, transaction data fetching,
-     * and transaction signing in a single call. This is the legacy method
-     * maintained for backward compatibility.
-     *
-     * @param {string} jwtToken - JWT token containing transaction ID and user info
-     * @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);
-     *   if (result.success) {
-     *     console.log('Transaction signed:', result.signature);
-     *   }
-     * } catch (error) {
-     *   console.error('Signing failed:', error.message);
-     * }
-     * ```
-     */
-    signPersTransaction(jwtToken: string): Promise<TransactionSigningResult>;
-    /**
-     * Sign a transaction with provided signing data
-     *
-     * Low-level method to sign transactions when you already have the signing data.
-     * Automatically handles user authentication and applies the blockchain signature.
-     *
-     * @param {CounterfactualWalletTransactionResponse | LegacyTransaction} signingData - Transaction data to sign
-     * @param {string} jwtToken - JWT token containing transaction ID and user info
-     * @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);
-     * console.log('Signed transaction:', result.signature);
-     * ```
-     */
-    signTransaction(signingData: CounterfactualWalletTransactionResponse$1 | LegacyTransaction, jwtToken: string): Promise<TransactionSigningResult>;
-    /**
-     * Complete transaction flow: sign and submit in one call
-     *
-     * Convenience method that combines signing and submission into a single operation.
-     * This is the recommended method for most use cases as it handles the complete
-     * transaction lifecycle automatically.
-     *
-     * @param {string} jwtToken - JWT token containing transaction ID and user info
-     * @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);
-     *   if (result.success) {
-     *     console.log('Transaction completed:', result.transactionHash);
-     *     if (result.shouldRedirect) {
-     *       window.location.href = result.redirectUrl;
-     *     }
-     *   }
-     * } catch (error) {
-     *   console.error('Transaction failed:', error.message);
-     * }
-     * ```
-     */
-    signAndSubmitPersTransaction(jwtToken: string): Promise<SubmissionResult>;
-    /**
-     * Submit a signed transaction to the blockchain
-     *
-     * Takes a signed transaction result and submits it to the blockchain network.
-     * Returns detailed submission results including transaction hash and any
-     * redirect information for UI flows.
-     *
-     * @param {TransactionSigningResult} signingResult - Result from a successful transaction signing
-     * @param {string} jwtToken - JWT token containing tenant and user info
-     * @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);
-     * console.log('Transaction submitted:', result.transactionHash);
-     * ```
-     */
-    submitTransaction(signingResult: TransactionSigningResult, jwtToken: string): Promise<SubmissionResult>;
-    /**
-     * Clear user authentication cache
-     *
-     * Removes all cached user sessions, forcing fresh authentication
-     * on the next method call. Useful for logout scenarios or when
-     * switching between different user contexts.
-     *
-     * @example
-     * ```typescript
-     * // Clear cache on user logout
-     * sdk.clearCache();
-     * console.log('User cache cleared');
-     * ```
-     */
-    clearCache(): void;
-}
-
-/**
- * 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
@@ -988,7 +1045,7 @@ declare class AuthenticationService {
     private signerToken;
     private config;
     private webAuthnProvider;
-    constructor(config: PersSignerConfig);
+    constructor(config: ExtendedPersSignerConfig);
     /**
      * Login with PERS token to get signer JWT
      * @param persToken - PERS JWT from PERS authentication
@@ -1033,7 +1090,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>;
 }
 
 /**
@@ -1054,7 +1111,7 @@ declare function getBrowserWebAuthnProvider(): Promise<WebAuthnProvider>;
  * Create a new PersSignerSDK instance with browser WebAuthn provider
  * @param config - SDK configuration (ethersProviderUrl is required)
  */
-declare function createPersSignerSDK(config: Omit<PersSignerConfig, 'webAuthnProvider'>): Promise<PersSignerSDK>;
+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 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 };