@explorins/pers-signer 1.0.32 → 1.0.34

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-import * as _explorins_web3_ts_types from '@explorins/web3-ts/types';
-import { LegacyTransaction, AnyTransactionData } from '@explorins/web3-ts/types';
-export { AnyTransactionData, BaseTransaction, CounterfactualWalletEIP712Data, EIP1559Transaction, EIP2930Transaction, EIP712TransactionData, EIP712TypedData, LegacyTransaction } from '@explorins/web3-ts/types';
+import { CounterfactualWalletTransactionResponse as CounterfactualWalletTransactionResponse$1 } from '@explorins/pers-shared';
 import * as _explorins_pers_shared_browser 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 * as _explorins_web3_ts_types from '@explorins/web3-ts/types';
+import { LegacyTransaction, AnyTransactionData } from '@explorins/web3-ts/types';
+export { AnyTransactionData, BaseTransaction, CounterfactualWalletEIP712Data, EIP1559Transaction, EIP2930Transaction, EIP712TransactionData, EIP712TypedData, LegacyTransaction } from '@explorins/web3-ts/types';
 import { AbstractSigner, Provider, TransactionRequest, TypedDataDomain, TypedDataField } from 'ethers';
 
 /**
@@ -309,7 +309,7 @@ interface TransactionSigningResult {
     shouldShowStatus?: boolean;
 }
 /**
- * Transaction submission result for internal processing
+ * Transaction submission result
  */
 interface SubmissionResult {
     submitResult: TransactionRequestResponseDTO;
@@ -319,9 +319,6 @@ interface SubmissionResult {
     success: boolean;
     error?: string;
 }
-/**
- * Metadata for transaction parameters - string values only
- */
 /**
  * Authentication tokens required for transaction signing
  */
@@ -459,117 +456,307 @@ interface ServiceError {
 }
 
 /**
- * Wallet management service
- * Updated for v1 API endpoints per migration reference
+ * 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);
+ * }
+ * ```
  */
-declare class WalletService {
-    /**
-     * List all wallets for authenticated user
-     * @param signerToken - Signer JWT token
-     * @returns Promise resolving to wallet data
-     */
-    static listWallets(signerToken: string): Promise<Wallet[]>;
-}
 
 /**
- * Service for interacting with PERS (Phygital Experience Rewards System) backend API
+ * Configuration options for the PERS Signer SDK
  */
+interface PersSignerConfig {
+    ethersProviderUrl?: string;
+    apiUrl?: string;
+    relyingPartyName?: string;
+    globalStatusCallback?: StatusCallback;
+}
 /**
- * Configuration interface for PERS API
+ * Extended configuration that includes the WebAuthn provider
  */
-interface PersApiConfig {
-    baseUrl: string;
-    projectKey?: string;
+interface ExtendedPersSignerConfig extends PersSignerConfig {
+    webAuthnProvider: WebAuthnProvider;
 }
-declare class PersService {
-    private static config;
-    private static tenantCache;
-    private static currentProjectKey;
-    private static currentTenantId;
-    private static readonly TENANT_CACHE_TTL;
-    /**
-     * Configure the PERS API settings
-     * @param config - The configuration object
-     */
-    static configure(config: Partial<PersApiConfig>): void;
-    /**
-     * Get current configuration
-     */
-    static getConfig(): PersApiConfig;
+/**
+ * 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;
     /**
-     * Get tenant information by tenant ID
-     * @param tenantId - The tenant ID to retrieve
-     * @param authToken - Optional auth token for authentication
-     * @returns Promise with tenant public information
+     * Initialize the PERS Signer SDK
+     *
+     * @param {ExtendedPersSignerConfig} config - SDK configuration object
+     * @throws {Error} If required configuration is missing
      */
-    static getTenantById(tenantId: string, authToken: string): Promise<TenantPublicDTO>;
+    constructor(config: ExtendedPersSignerConfig);
     /**
-     * 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
+     * Helper method to trigger both global and method-specific status callbacks
+     * @private
      */
-    static initializeTenant(tenantId: string, authToken: string): Promise<TenantPublicDTO>;
+    private triggerStatusUpdate;
     /**
-     * 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
+     * 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
+     * @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, {
+     *     onStatusUpdate: (status, message) => console.log(`${status}: ${message}`)
+     *   });
+     *   console.log('Authenticated:', user.identifier);
+     * } catch (error) {
+     *   console.error('Authentication failed:', error.message);
+     * }
+     * ```
      */
-    static ensureTenantInitialized(tenantId: string, authToken: string): Promise<TenantPublicDTO>;
+    loginUser(jwtToken: string, statusCallback?: StatusCallback): Promise<AuthenticatedUser>;
     /**
-     * Get the current project key (either from tenant or fallback)
-     * @param tenantId - Optional tenant ID to ensure is initialized
-     * @returns The project key to use for API calls
+     * 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
+     * @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, {
+     *     onStatusUpdate: (status, message) => console.log(`${status}: ${message}`)
+     *   });
+     *   if (result.success) {
+     *     console.log('Transaction signed:', result.signature);
+     *   }
+     * } catch (error) {
+     *   console.error('Signing failed:', error.message);
+     * }
+     * ```
      */
-    private static getProjectKey;
+    signPersTransaction(jwtToken: string, statusCallback?: StatusCallback): Promise<TransactionSigningResult>;
     /**
-     * Clear tenant cache and reset project key
+     * 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
+     * @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, {
+     *   onStatusUpdate: (status, message) => console.log(`${status}: ${message}`)
+     * });
+     * console.log('Signed transaction:', result.signature);
+     * ```
      */
-    static clearTenantCache(): void;
+    signTransaction(signingData: CounterfactualWalletTransactionResponse$1 | LegacyTransaction, jwtToken: string, statusCallback?: StatusCallback): Promise<TransactionSigningResult>;
     /**
-     * Authenticates a user with the PERS backend using their auth token
+     * Complete transaction flow: sign and submit in one call
      *
-     * @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
+     * 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
+     * @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, {
+     *     onStatusUpdate: (status, message) => {
+     *       console.log(`Status: ${status} - ${message}`);
+     *     }
+     *   });
+     *   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);
+     * }
+     * ```
      */
-    static authenticateUser(authToken: string, tenantId: string): Promise<SessionAuthContextResponseDTO>;
+    signAndSubmitPersTransaction(jwtToken: string, statusCallback?: StatusCallback): Promise<SubmissionResult>;
     /**
-     * Submits a transaction by calling the backend endpoint
+     * Submit a signed transaction to the blockchain
      *
-     * @param transactionId - The ID of the transaction to submit
-     * @param signedTransactionOrSignature - The signed transaction data or EIP-712 signature
-     * @param persAccessToken - The PERS access token for authentication (Bearer)
-     * @param submissionType - The transaction format type
-     * @param tenantId - Optional tenant ID for automatic initialization
-     * @returns A promise that resolves to the transaction submission response
-     * @throws If the request fails
+     * 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
+     * @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, {
+     *   onStatusUpdate: (status, message) => console.log(`${status}: ${message}`)
+     * });
+     * console.log('Transaction submitted:', result.transactionHash);
+     * ```
      */
-    static submitTransaction(transactionId: string, signedTransactionOrSignature: string, persAccessToken: string, submissionType: TransactionFormat, tenantId: string): Promise<TransactionRequestResponseDTO>;
+    submitTransaction(signingResult: TransactionSigningResult, jwtToken: string, statusCallback?: StatusCallback): Promise<SubmissionResult>;
     /**
-     * Fetches a prepared transaction for signing by transactionId
-     * @param transactionId - The transaction ID to fetch
-     * @param persAccessToken - The PERS access token for authentication (Bearer)
-     * @param tenantId - Optional tenant ID for automatic initialization
-     * @returns The prepared transaction data
-     * @throws If the request fails
+     * 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');
+     * ```
      */
-    static fetchPreparedTransaction(transactionId: string, persAccessToken: string, tenantId: string): Promise<TransactionRequestResponseDTO>;
+    clearCache(): void;
+}
+/**
+ * Create a new PERS Signer SDK instance
+ *
+ * Factory function to create and configure a new SDK instance with the provided
+ * configuration. This is the recommended way to initialize the SDK.
+ *
+ * @param {PersSignerConfig} config - SDK configuration object
+ * @returns {PersSignerSDK} Configured SDK instance ready for use
+ * @throws {Error} If required configuration is missing or invalid
+ *
+ * @example
+ * ```typescript
+ * import { createPersSignerSDK, getWebAuthnProvider } from '@explorins/pers-signer';
+ *
+ * const webAuthnProvider = await getWebAuthnProvider();
+ * const sdk = createPersSignerSDK({
+ *   webAuthnProvider,
+ *   ethersProviderUrl: 'https://mainnet.infura.io/v3/YOUR_KEY',
+ *   tenantId: 'your-tenant-id'
+ * });
+ * ```
+ */
+declare function createPersSignerSDK(config: ExtendedPersSignerConfig): PersSignerSDK;
+
+/**
+ * Authentication service for user login and registration
+ * Uses constructor-based dependency injection for WebAuthn provider
+ * Updated for new v1 API endpoints
+ */
+declare class AuthenticationService {
+    private signerToken;
+    private webAuthnProvider;
+    constructor(config: ExtendedPersSignerConfig);
     /**
-     * Helper method to determine if transaction data is available for signing
-     * @param transactionResponse - Response from prepare or fetch transaction
-     * @returns boolean indicating if transaction can be signed
+     * Login with PERS token to get signer JWT
+     * @param persToken - PERS JWT from PERS authentication
+     * @returns Promise resolving to login response or provider challenge data
      */
-    static isTransactionReadyForSigning(transactionResponse: TransactionRequestResponseDTO): boolean;
+    loginWithPersToken(persToken: string): Promise<JWTLoginResponse | unknown>;
     /**
-     * Helper method to get transaction data from response
-     * @param transactionResponse - Response from prepare or fetch transaction
-     * @returns The transaction data ready for signing
-     * @throws If transaction data is not available
+     * Verify signer token validity
+     * @param token - Signer JWT to verify
+     * @returns Promise resolving to verification result
      */
-    static getTransactionDataForSigning(transactionResponse: TransactionRequestResponseDTO): _explorins_pers_shared_browser.CounterfactualWalletTransactionResponse | _explorins_web3_ts_types.LegacyTransaction;
+    verifyToken(token: string): Promise<VerifyTokenResponse>;
+    /**
+     * Register user with unified flow
+     * @param persToken - PERS JWT token
+     * @returns Promise resolving to authenticated user data
+     */
+    registerUser(persToken: string): Promise<JWTLoginResponse>;
+    /**
+     * Get current signer token
+     * @returns The current signer JWT token
+     */
+    getSignerToken(): string | null;
+    /**
+     * Set signer token (for external token management)
+     * @param token - Signer JWT token
+     */
+    setSignerToken(token: string): void;
+    /**
+     * Combined authentication flow - handles both login and registration
+     * @param identifier - User identifier (email/userId)
+     * @param persAccessToken - PERS JWT token for authentication
+     * @param webAuthnProvider - WebAuthn provider for credential creation
+     * @param relyingPartyConfig - Configuration for WebAuthn relying party
+     * @returns Promise resolving to authenticated user with signer token
+     */
+    combinedAuthentication(identifier: string, persAccessToken: string): Promise<AuthenticatedUser>;
+}
+
+/**
+ * Wallet management service
+ * Updated for v1 API endpoints per migration reference
+ */
+declare class WalletService {
+    /**
+     * List all wallets for authenticated user
+     * @param signerToken - Signer JWT token
+     * @returns Promise resolving to wallet data
+     */
+    static listWallets(signerToken: string): Promise<Wallet[]>;
 }
 
 /**
@@ -616,6 +803,119 @@ declare class SigningService {
     signBatch(authToken: string, walletId: string, requests: SigningRequest[]): Promise<CompleteSignatureResponse['data'][]>;
 }
 
+/**
+ * Service for interacting with PERS (Phygital Experience Rewards System) backend API
+ */
+/**
+ * Configuration interface for PERS API
+ */
+interface PersApiConfig {
+    baseUrl: string;
+    projectKey?: string;
+}
+declare class PersService {
+    private static config;
+    private static tenantCache;
+    private static currentProjectKey;
+    private static currentTenantId;
+    private static readonly TENANT_CACHE_TTL;
+    /**
+     * Configure the PERS API settings
+     * @param config - The configuration object
+     */
+    static configure(config: Partial<PersApiConfig>): void;
+    /**
+     * Get current configuration
+     */
+    static getConfig(): PersApiConfig;
+    /**
+     * Get tenant information by tenant ID
+     * @param tenantId - The tenant ID to retrieve
+     * @param authToken - Optional auth token for authentication
+     * @returns Promise with tenant public information
+     */
+    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>;
+    /**
+     * 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>;
+    /**
+     * Get the current project key (either from tenant or fallback)
+     * @param tenantId - Optional tenant ID to ensure is initialized
+     * @returns The project key to use for API calls
+     */
+    private static getProjectKey;
+    /**
+     * Clear tenant cache and reset project key
+     */
+    static clearTenantCache(): void;
+    /**
+     * Authenticates a user with the PERS backend using their auth token
+     *
+     * @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
+     */
+    static authenticateUser(authToken: string, tenantId: string): Promise<SessionAuthContextResponseDTO>;
+    /**
+     * Submits a transaction by calling the backend endpoint
+     *
+     * @param transactionId - The ID of the transaction to submit
+     * @param signedTransactionOrSignature - The signed transaction data or EIP-712 signature
+     * @param persAccessToken - The PERS access token for authentication (Bearer)
+     * @param submissionType - The transaction format type
+     * @param tenantId - Optional tenant ID for automatic initialization
+     * @returns A promise that resolves to the transaction submission response
+     * @throws If the request fails
+     */
+    static submitTransaction(transactionId: string, signedTransactionOrSignature: string, persAccessToken: string, submissionType: TransactionFormat, tenantId: string): Promise<TransactionRequestResponseDTO>;
+    /**
+     * Fetches a prepared transaction for signing by transactionId
+     * @param transactionId - The transaction ID to fetch
+     * @param persAccessToken - The PERS access token for authentication (Bearer)
+     * @param tenantId - Optional tenant ID for automatic initialization
+     * @returns The prepared transaction data
+     * @throws If the request fails
+     */
+    static fetchPreparedTransaction(transactionId: string, persAccessToken: string, tenantId: string): Promise<TransactionRequestResponseDTO>;
+    /**
+     * Helper method to determine if transaction data is available for signing
+     * @param transactionResponse - Response from prepare or fetch transaction
+     * @returns boolean indicating if transaction can be signed
+     */
+    static isTransactionReadyForSigning(transactionResponse: TransactionRequestResponseDTO): boolean;
+    /**
+     * Helper method to get transaction data from response
+     * @param transactionResponse - Response from prepare or fetch transaction
+     * @returns The transaction data ready for signing
+     * @throws If transaction data is not available
+     */
+    static getTransactionDataForSigning(transactionResponse: TransactionRequestResponseDTO): _explorins_pers_shared_browser.CounterfactualWalletTransactionResponse | _explorins_web3_ts_types.LegacyTransaction;
+}
+
+/**
+ * Health check service for signer API
+ * Handles health check operations for the new v1 API
+ */
+declare class HealthService {
+    /**
+     * Perform health check on the signer API
+     * @returns Promise resolving to health check result
+     */
+    static checkHealth(): Promise<HealthCheckResponse>;
+}
+
 type WalletOptions = {
     wallet: WalletMetadata;
     authToken: string;
@@ -885,314 +1185,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
- * @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'> {
-}
-/**
- * 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 {ExtendedPersSignerConfig} config - SDK configuration object
-     * @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
-     *
-     * 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
-     * @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, {
-     *     onStatusUpdate: (status, message) => console.log(`${status}: ${message}`)
-     *   });
-     *   console.log('Authenticated:', user.identifier);
-     * } catch (error) {
-     *   console.error('Authentication failed:', error.message);
-     * }
-     * ```
-     */
-    loginUser(jwtToken: string, statusCallback?: StatusCallback): 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
-     * @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, {
-     *     onStatusUpdate: (status, message) => console.log(`${status}: ${message}`)
-     *   });
-     *   if (result.success) {
-     *     console.log('Transaction signed:', result.signature);
-     *   }
-     * } catch (error) {
-     *   console.error('Signing failed:', error.message);
-     * }
-     * ```
-     */
-    signPersTransaction(jwtToken: string, statusCallback?: StatusCallback): 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
-     * @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, {
-     *   onStatusUpdate: (status, message) => console.log(`${status}: ${message}`)
-     * });
-     * console.log('Signed transaction:', result.signature);
-     * ```
-     */
-    signTransaction(signingData: CounterfactualWalletTransactionResponse$1 | LegacyTransaction, jwtToken: string, statusCallback?: StatusCallback): 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
-     * @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, {
-     *     onStatusUpdate: (status, message) => {
-     *       console.log(`Status: ${status} - ${message}`);
-     *     }
-     *   });
-     *   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, statusCallback?: StatusCallback): 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
-     * @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, {
-     *   onStatusUpdate: (status, message) => console.log(`${status}: ${message}`)
-     * });
-     * console.log('Transaction submitted:', result.transactionHash);
-     * ```
-     */
-    submitTransaction(signingResult: TransactionSigningResult, jwtToken: string, statusCallback?: StatusCallback): 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;
-}
-/**
- * Create a new PERS Signer SDK instance
- *
- * Factory function to create and configure a new SDK instance with the provided
- * configuration. This is the recommended way to initialize the SDK.
- *
- * @param {PersSignerConfig} config - SDK configuration object
- * @returns {PersSignerSDK} Configured SDK instance ready for use
- * @throws {Error} If required configuration is missing or invalid
- *
- * @example
- * ```typescript
- * import { createPersSignerSDK, getWebAuthnProvider } from '@explorins/pers-signer';
- *
- * const webAuthnProvider = await getWebAuthnProvider();
- * const sdk = createPersSignerSDK({
- *   webAuthnProvider,
- *   ethersProviderUrl: 'https://mainnet.infura.io/v3/YOUR_KEY',
- *   tenantId: 'your-tenant-id'
- * });
- * ```
- */
-declare function createPersSignerSDK(config: ExtendedPersSignerConfig): PersSignerSDK;
-
-/**
- * Authentication service for user login and registration
- * Uses constructor-based dependency injection for WebAuthn provider
- * Updated for new v1 API endpoints
- */
-declare class AuthenticationService {
-    private signerToken;
-    private webAuthnProvider;
-    constructor(config: ExtendedPersSignerConfig);
-    /**
-     * Login with PERS token to get signer JWT
-     * @param persToken - PERS JWT from PERS authentication
-     * @returns Promise resolving to login response or provider challenge data
-     */
-    loginWithPersToken(persToken: string): Promise<JWTLoginResponse | unknown>;
-    /**
-     * Verify signer token validity
-     * @param token - Signer JWT to verify
-     * @returns Promise resolving to verification result
-     */
-    verifyToken(token: string): Promise<VerifyTokenResponse>;
-    /**
-     * Register user with unified flow
-     * @param persToken - PERS JWT token
-     * @returns Promise resolving to authenticated user data
-     */
-    registerUser(persToken: string): Promise<JWTLoginResponse>;
-    /**
-     * Get current signer token
-     * @returns The current signer JWT token
-     */
-    getSignerToken(): string | null;
-    /**
-     * Set signer token (for external token management)
-     * @param token - Signer JWT token
-     */
-    setSignerToken(token: string): void;
-    /**
-     * Combined authentication flow - handles both login and registration
-     * @param identifier - User identifier (email/userId)
-     * @param persAccessToken - PERS JWT token for authentication
-     * @param webAuthnProvider - WebAuthn provider for credential creation
-     * @param relyingPartyConfig - Configuration for WebAuthn relying party
-     * @returns Promise resolving to authenticated user with signer token
-     */
-    combinedAuthentication(identifier: string, persAccessToken: string): Promise<AuthenticatedUser>;
-}
-
-/**
- * Health check service for signer API
- * Handles health check operations for the new v1 API
- */
-declare class HealthService {
-    /**
-     * Perform health check on the signer API
-     * @returns Promise resolving to health check result
-     */
-    static checkHealth(): Promise<HealthCheckResponse>;
-}
-
 /**
  * Browser-specific WebAuthn provider using native browser APIs
  * Fully agnostic implementation without external SDK dependencies
@@ -1294,4 +1286,4 @@ declare class UserCache {
 }
 
 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 };
+export type { AuthResponse, AuthenticatedUser, CombinedTransactionStatus, CompleteSignatureResponse, ConfigProvider, ExtendedPersSignerConfig, 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 };