@explorins/pers-signer 1.0.12 → 1.0.17

package/dist/index.d.ts

@@ -1,256 +1,167 @@
 import * as _explorins_web3_ts_types from '@explorins/web3-ts/types';
-import { AnyTransactionData } from '@explorins/web3-ts/types';
+import { AnyTransactionData, LegacyTransaction } from '@explorins/web3-ts/types';
 export { AnyTransactionData } from '@explorins/web3-ts/types';
 import * as _explorins_pers_shared_browser from '@explorins/pers-shared/browser';
-import { TenantPublicDTO, SessionAuthContextResponseDTO, TransactionRequestResponseDTO, TransactionFormat, CampaignDTO, CampaignClaimDTO, TransactionStatus } from '@explorins/pers-shared/browser';
+import { TenantPublicDTO, SessionAuthContextResponseDTO, TransactionFormat, TransactionRequestResponseDTO, TransactionStatus, CounterfactualWalletTransactionResponse } from '@explorins/pers-shared/browser';
 export { TransactionFormat, TransactionRequestResponseDTO, TransactionStatus } from '@explorins/pers-shared/browser';
+import { CounterfactualWalletTransactionResponse as CounterfactualWalletTransactionResponse$1 } from '@explorins/pers-shared';
 import { AbstractSigner, Provider, TransactionRequest, TypedDataDomain, TypedDataField } from 'ethers';
 
 /**
- * Types for WebAuthn provider abstraction
+ * Type definitions for the new PERS Signer API v1
+ * Based on API_MIGRATION_REFERENCE.md - Updated for wrapped responses
  */
-interface WebAuthnProvider {
-    create(challenge: any): Promise<any>;
-    sign(challenge: any): Promise<any>;
+interface SignerApiResponse<T = unknown> {
+    success: boolean;
+    data?: T;
 }
-interface WebAuthnConfig {
-    relyingParty: {
-        id: string;
-        name: string;
-        origin?: string;
+interface SignerApiError {
+    status: number;
+    error: string;
+    message: string;
+    request_id: string;
+    timestamp: string;
+    suggestion?: {
+        action: string;
+        text: string;
+        endpoint: string;
     };
 }
-
-/**
- * Key service response types and interfaces
- */
-/**
- * Signature response from key signing operations
- */
-interface SignResponse {
-    id: string;
-    keyId: string;
-    requester: {
-        userId: string;
-        appId: string;
-    };
-    requestBody: {
-        hash: string;
-        kind: "Hash";
+interface LoginRequest {
+    authToken: string;
+}
+interface JWTLoginResponse {
+    success: true;
+    access_token: string;
+    token_type: "Bearer";
+    expires_in: number;
+    user: {
+        id: string;
+        username: string;
+        org_id: string;
     };
-    status: "Signed";
-    signature: {
-        r: string;
-        s: string;
-        recid: number;
+    provider: string;
+}
+interface WrappedProviderResponse {
+    success: true;
+    data: unknown;
+}
+type LoginResponse = JWTLoginResponse | WrappedProviderResponse;
+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;
     };
-    network: "KeyECDSA";
-    dateRequested: string;
-    dateSigned: string;
-    walletId: string;
+    tenantId: 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;
+interface ListWalletsRequest {
 }
-/**
- * Registration completion response
- */
-interface RegistrationResult {
-    token: string;
-    walletId?: string;
-    status?: number;
-    message?: string;
+interface ListWalletsResponse {
+    success: true;
+    data: {
+        wallets?: Array<unknown>;
+        [key: string]: unknown;
+    };
 }
-/**
- * Wallet listing response
- */
-interface WalletListResponse$1 {
-    wallets: WalletItem$1[];
-    status?: number;
-    message?: 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;
+    };
 }
-/**
- * Individual wallet item
- */
-interface WalletItem$1 {
-    id: string;
-    address: string;
-    network: string;
-    status: string;
-    signingKey?: unknown;
-    dateCreated?: string;
-    custodial?: boolean;
-    tags?: string[];
-    boundToEvmNetwork?: boolean;
-    [key: string]: unknown;
+interface HealthCheckResponse {
+    success: boolean;
 }
+
 /**
- * Hash signing request
+ * Types for WebAuthn provider abstraction
  */
-interface HashSigningRequest {
-    kind: "Hash";
-    hash: string;
+interface WebAuthnProvider {
+    create(challenge: any): Promise<any>;
+    sign(challenge: any): Promise<any>;
 }
-/**
- * EIP-712 typed data signing request
- */
-interface TypedDataSigningRequest {
-    blockchainKind: "Evm";
-    kind: "Eip712";
-    types: Record<string, any[]>;
-    domain: any;
-    message: Record<string, any>;
+interface WebAuthnConfig {
+    relyingParty: {
+        id: string;
+        name: string;
+        origin?: string;
+    };
 }
+
 /**
- * Generic signing request
+ * Shared type definitions for the blockchain signer shared library
  */
-type SigningRequest = HashSigningRequest | TypedDataSigningRequest;
+
 /**
- * Signing challenge response
+ * Authentication types for 3-function split architecture
  */
-interface SigningChallenge {
-    requestBody: any;
-    challenge: {
-        challengeIdentifier: string;
-        [key: string]: any;
-    };
-    status?: number;
-    message?: string;
-}
-/**
- * User credentials for authentication
- */
-interface UserCredentials {
-    username: string;
-    appId?: string;
+interface AuthenticatedUser {
+    identifier: string;
+    signerAuthToken: string;
+    persAccessToken: string;
+    tenantId: string;
+    expiresAt: number;
 }
 /**
- * Relying party configuration for WebAuthn
+ * Service configuration options
  */
-interface RelyingPartyConfig {
-    id: string;
-    name: string;
-    origin?: string;
+interface ServiceConfig {
+    apiUrl: string;
+    environment: 'development' | 'staging' | 'production';
+    timeout?: number;
+    retryAttempts?: number;
 }
-
 /**
- * Authentication service for user login and registration
- * Uses constructor-based dependency injection for WebAuthn provider
+ * Error types for service operations
  */
-declare class AuthenticationService {
-    private webAuthnProvider;
-    constructor(webAuthnProvider: WebAuthnProvider);
-    /**
-     * Authenticate user with username
-     * @param username - User identifier
-     * @returns Promise resolving to authentication token
-     */
-    login(username: string): Promise<string>;
-    /**
-     * Register new user with WebAuthn credential
-     * @param username - User identifier
-     * @returns Promise resolving to registration result
-     */
-    register(username: string): Promise<RegistrationResult>;
-    /**
-     * Validate authentication token (when backend supports it)
-     * @param authToken - Token to validate
-     * @returns Promise resolving to validation result
-     */
-    validateToken(authToken: string): Promise<boolean>;
-    /**
-     * Get user information (when backend supports it)
-     * @param authToken - Authentication token
-     * @returns Promise resolving to user info or null
-     */
-    getUser(authToken: string): Promise<{
-        username: string;
-    } | null>;
+interface ServiceError {
+    code: string;
+    message: string;
+    details?: any;
+    timestamp: Date;
 }
 
 /**
  * Wallet management service
- * Handles wallet listing and management operations
+ * Updated for v1 API endpoints per migration reference
  */
 declare class WalletService {
     /**
      * List all wallets for authenticated user
-     * @param authToken - Authentication token
-     * @returns Promise resolving to wallet list
+     * @param signerToken - Signer JWT token
+     * @returns Promise resolving to wallet data
      */
-    static listWallets(authToken: string): Promise<any>;
-    /**
-     * Get wallet by ID (when backend supports it)
-     * @param authToken - Authentication token
-     * @param walletId - Wallet identifier
-     * @returns Promise resolving to wallet details
-     */
-    static getWallet(authToken: string, walletId: string): Promise<any>;
-    /**
-     * Create new wallet (when backend supports it)
-     * @param authToken - Authentication token
-     * @param walletConfig - Wallet configuration
-     * @returns Promise resolving to wallet creation result
-     */
-    static createWallet(authToken: string, walletConfig: any): Promise<any>;
-}
-
-/**
- * Signing service for cryptographic operations
- * Handles hash signing and typed data signing with WebAuthn
- * Uses constructor-based dependency injection for WebAuthn provider
- */
-declare class SigningService {
-    private webAuthnProvider;
-    constructor(webAuthnProvider: WebAuthnProvider);
-    /**
-     * Sign a hash using the specified wallet
-     * @param authToken - Authentication token
-     * @param walletId - Wallet identifier
-     * @param hash - Hash to sign
-     * @returns Promise resolving to signature response
-     */
-    signHash(authToken: string, walletId: string, hash: string): Promise<SignResponse>;
-    /**
-     * Sign EIP-712 typed data using the specified wallet
-     * @param authToken - Authentication token
-     * @param walletId - Wallet identifier
-     * @param domain - EIP-712 domain
-     * @param types - EIP-712 types definition
-     * @param value - Data to sign
-     * @returns Promise resolving to signature response
-     */
-    signTypedData(authToken: string, walletId: string, domain: any, types: Record<string, any[]>, value: Record<string, any>): Promise<SignResponse>;
-    /**
-     * Generic signing method that handles the complete signing flow
-     * @param authToken - Authentication token
-     * @param walletId - Wallet identifier
-     * @param request - Signing request object
-     * @returns Promise resolving to signature response
-     */
-    private signRequest;
-    /**
-     * Sign multiple requests in batch (when backend supports it)
-     * @param authToken - Authentication token
-     * @param walletId - Wallet identifier
-     * @param requests - Array of signing requests
-     * @returns Promise resolving to array of signature responses
-     */
-    signBatch(authToken: string, walletId: string, requests: SigningRequest[]): Promise<SignResponse[]>;
+    static listWallets(signerToken: string): Promise<unknown>;
 }
 
 /**
@@ -267,7 +178,9 @@ declare class PersService {
     private static config;
     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
@@ -296,8 +209,16 @@ declare class PersService {
      * @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;
@@ -309,19 +230,11 @@ 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 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): Promise<SessionAuthContextResponseDTO>;
-    /**
-     * Prepares a transaction by calling the backend endpoint
-     *
-     * @param form - The transaction details
-     * @param persAccessToken - The PERS access token for authentication (Bearer)
-     * @returns A promise that resolves to the transaction preparation response
-     * @throws If the request fails
-     */
-    static prepareTransaction(form: any, persAccessToken: string): Promise<TransactionRequestResponseDTO>;
+    static authenticateUser(authToken: string, tenantId: string): Promise<SessionAuthContextResponseDTO>;
     /**
      * Submits a transaction by calling the backend endpoint
      *
@@ -329,53 +242,20 @@ declare class PersService {
      * @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): Promise<any>;
+    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): Promise<TransactionRequestResponseDTO>;
-    /**
-     * Claims a reward from the PERS blockchain system
-     * @param rewardId - The ID of the reward to claim
-     * @param pointsCost - The points cost for the reward
-     * @param persAccessToken - The PERS access token for authentication (Bearer)
-     * @returns The reward claim response including reward image URL
-     * @throws If the request fails
-     */
-    static claimReward(rewardId: string, pointsCost: number, persAccessToken: string): Promise<any>;
-    /**
-     * Get all active campaigns
-     * @returns Promise with list of active campaigns
-     */
-    static getActiveCampaigns(): Promise<CampaignDTO[]>;
-    /**
-     * Claims a campaign for a user
-     * @param campaignId - The ID of the campaign to claim
-     * @param persAccessToken - The PERS access token for authentication (Bearer)
-     * @returns Promise with the campaign claim response
-     * @throws If the request fails
-     */
-    static claimCampaign(campaignId: string, persAccessToken: string): Promise<CampaignClaimDTO>;
-    /**
-     * Gets all campaign claims for the authenticated user
-     * @param persAccessToken - The PERS access token for authentication (Bearer)
-     * @returns Promise with list of user's campaign claims
-     * @throws If the request fails
-     */
-    static getUserCampaignClaims(persAccessToken: string): Promise<CampaignClaimDTO[]>;
-    /**
-     * Gets all available rewards for redemption
-     * @returns Promise with list of available rewards that can be exchanged for points
-     * @throws If the request fails
-     */
-    static getAvailableRedemptions(): Promise<any[]>;
+    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
@@ -392,91 +272,154 @@ declare class PersService {
 }
 
 /**
- * Shared type definitions for the blockchain signer shared library
+ * Key service response types and interfaces
  */
-
 /**
- * Represents a wallet configuration with its metadata
+ * Signature response from key signing operations
  */
-interface WalletConfig {
+interface SignResponse {
     id: string;
-    name: string;
-    address?: string;
-    credentialId?: string;
-    publicKey?: string;
-    createdAt?: Date;
+    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 token structure
+ * Authentication response from login/register operations
  */
-interface AuthToken {
+interface AuthResponse {
     token: string;
-    expiresAt: Date;
-    refreshToken?: string;
+    message?: string;
+    status?: number;
 }
 /**
- * User authentication state
+ * Registration challenge response
  */
-interface AuthState {
-    isAuthenticated: boolean;
-    token?: AuthToken;
-    user?: UserProfile;
-    wallets?: WalletConfig[];
+interface RegistrationChallenge {
+    temporaryAuthenticationToken: string;
+    challenge: any;
+    status?: number;
+    message?: string;
 }
 /**
- * User profile information
+ * Registration completion response
  */
-interface UserProfile {
-    id: string;
-    username: string;
-    email?: string;
-    createdAt: Date;
-    lastLoginAt?: Date;
+interface RegistrationResult {
+    token: string;
+    walletId?: string;
+    status?: number;
+    message?: string;
 }
 /**
- * Prepared transaction from PERS service
+ * Individual wallet item
  */
-interface PreparedTransaction {
-    id: string;
-    transactionData: AnyTransactionData;
-    metadata?: Record<string, any>;
-    createdAt: Date;
-    expiresAt?: Date;
+/**
+ * Hash signing request
+ */
+interface HashSigningRequest {
+    kind: "Hash";
+    hash: string;
 }
 /**
- * Transaction signing result
+ * EIP-712 typed data signing request
  */
-interface SigningResult$1 {
-    signature: string;
-    transactionHash?: string;
-    rawTransaction?: string;
+interface TypedDataSigningRequest {
+    blockchainKind: "Evm";
+    kind: "Eip712";
+    types: Record<string, any[]>;
+    domain: any;
+    message: Record<string, any>;
 }
 /**
- * Service configuration options
+ * Generic signing request
  */
-interface ServiceConfig$1 {
-    apiUrl: string;
-    environment: 'development' | 'staging' | 'production';
-    timeout?: number;
-    retryAttempts?: number;
+type SigningRequest = HashSigningRequest | TypedDataSigningRequest;
+/**
+ * Signing challenge response
+ */
+interface SigningChallenge {
+    requestBody: any;
+    challenge: {
+        challengeIdentifier: string;
+        [key: string]: any;
+    };
+    status?: number;
+    message?: string;
 }
 /**
- * Error types for service operations
+ * User credentials for authentication
  */
-interface ServiceError {
-    code: string;
-    message: string;
-    details?: any;
-    timestamp: Date;
+interface UserCredentials {
+    username: string;
+    appId?: string;
 }
 /**
- * API response wrapper
+ * Relying party configuration for WebAuthn
  */
-interface ApiResponse<T = any> {
-    success: boolean;
-    data?: T;
-    error?: ServiceError;
-    metadata?: Record<string, any>;
+interface RelyingPartyConfig {
+    id: string;
+    name: string;
+    origin?: string;
+}
+
+/**
+ * Signing service for cryptographic operations
+ * Handles hash signing and typed data signing with WebAuthn
+ * Uses constructor-based dependency injection for WebAuthn provider
+ */
+declare class SigningService {
+    private webAuthnProvider;
+    constructor(webAuthnProvider: WebAuthnProvider);
+    /**
+     * Sign a hash using the specified wallet
+     * @param authToken - Authentication token
+     * @param walletId - Wallet identifier
+     * @param hash - Hash to sign
+     * @returns Promise resolving to signature response
+     */
+    signHash(authToken: string, walletId: string, hash: string): Promise<CompleteSignatureResponse['data']>;
+    /**
+     * Sign EIP-712 typed data using the specified wallet
+     * @param authToken - Authentication token
+     * @param walletId - Wallet identifier
+     * @param domain - EIP-712 domain
+     * @param types - EIP-712 types definition
+     * @param value - Data to sign
+     * @returns Promise resolving to signature response
+     */
+    signTypedData(authToken: string, walletId: string, domain: any, types: Record<string, any[]>, value: Record<string, any>): Promise<CompleteSignatureResponse['data']>;
+    /**
+     * Generic signing method that handles the complete signing flow
+     * @param authToken - Authentication token
+     * @param walletId - Wallet identifier
+     * @param request - Signing request object
+     * @returns Promise resolving to signature response
+     */
+    private signRequest;
+    /**
+     * Sign multiple requests in batch (when backend supports it)
+     * @param authToken - Authentication token
+     * @param walletId - Wallet identifier
+     * @param requests - Array of signing requests
+     * @returns Promise resolving to array of signature responses
+     */
+    signBatch(authToken: string, walletId: string, requests: SigningRequest[]): Promise<CompleteSignatureResponse['data'][]>;
 }
 
 interface GetWalletResponse {
@@ -538,21 +481,12 @@ interface TransactionStatusInfo {
 interface TransactionSigningResult {
     success: boolean;
     transactionId: string;
-    transactionHash?: string;
     signature?: string;
+    signingData?: CounterfactualWalletTransactionResponse | LegacyTransaction;
     error?: string;
     statusInfo?: TransactionStatusInfo;
-    shouldRedirect?: boolean;
-    redirectUrl?: string;
     shouldShowStatus?: boolean;
 }
-/**
- * Transaction result for localStorage storage
- */
-interface StoredTransactionResult {
-    transactionId: string;
-    transactionHash: string;
-}
 /**
  * Transaction submission result for internal processing
  */
@@ -560,18 +494,18 @@ interface SubmissionResult {
     submitResult: TransactionRequestResponseDTO;
     shouldRedirect: boolean;
     redirectUrl?: string;
+    transactionHash: string | null;
+    success: boolean;
+    error?: string;
 }
 /**
  * Metadata for transaction parameters - string values only
  */
-interface TransactionMetadata {
-    [key: string]: string;
-}
 /**
  * Authentication tokens required for transaction signing
  */
 interface SigningAuthTokens {
-    backendAuthToken: string;
+    signerAuthToken: string;
     persAccessToken: string;
 }
 /**
@@ -579,12 +513,10 @@ interface SigningAuthTokens {
  */
 interface TransactionSigningParams {
     transactionId: string;
+    tenantId: string;
     authTokens: SigningAuthTokens;
     ethersProviderUrl: string;
     returnUrl?: string;
-    metadata?: TransactionMetadata;
-    walletRegistrationFailed?: boolean;
-    walletErrorDetails?: string;
 }
 
 /**
@@ -594,7 +526,7 @@ interface TransactionSigningParams {
  */
 declare class TransactionSigningService {
     private webAuthnProvider;
-    constructor(webAuthnProvider: WebAuthnProvider);
+    constructor(config: ExtendedPersSignerConfig);
     /**
      * Prepare transaction for signing - fetch and validate
      */
@@ -607,6 +539,11 @@ declare class TransactionSigningService {
      * Execute the transaction signing with WebAuthn coordination
      */
     private executeTransactionSigning;
+    getPersSigningData(data: {
+        transactionId: string;
+        authTokens: SigningAuthTokens;
+        tenantId: string;
+    }): Promise<CounterfactualWalletTransactionResponse | LegacyTransaction>;
     /**
      * Main transaction signing orchestration method
      * Handles the complete flow from preparation to submission
@@ -614,7 +551,7 @@ declare class TransactionSigningService {
      * @returns Promise resolving to transaction signing result
      * @throws TransactionSigningError for validation and operation failures
      */
-    signTransaction(params: TransactionSigningParams): Promise<TransactionSigningResult>;
+    signTransaction(params: TransactionSigningParams, signingData: CounterfactualWalletTransactionResponse | LegacyTransaction): Promise<TransactionSigningResult>;
 }
 
 /**
@@ -733,19 +670,7 @@ declare class TransactionSubmissionHandler {
      * @param metadata - Optional metadata to include as parameters
      * @returns Promise resolving to the complete redirect URL
      */
-    static createRedirectUrl(returnUrl: string, transactionHash: string, metadata?: TransactionMetadata): Promise<string>;
-    /**
-     * Submit transaction and handle success flow
-     * @param preparedTransaction - The prepared transaction
-     * @param signature - The transaction signature
-     * @param signingData - The signing data used
-     * @param authTokens - Authentication tokens
-     * @param transactionId - Transaction ID for tracking
-     * @param returnUrl - Optional return URL for redirect
-     * @param metadata - Optional metadata for redirect parameters
-     * @returns Promise resolving to submission result
-     */
-    static handleTransactionSubmission(preparedTransaction: TransactionRequestResponseDTO, signature: string, signingData: AnyTransactionData, authTokens: SigningAuthTokens, returnUrl?: string, metadata?: TransactionMetadata): Promise<SubmissionResult>;
+    static createRedirectUrl(returnUrl: string, transactionHash: string): Promise<string>;
 }
 
 /**
@@ -753,11 +678,6 @@ declare class TransactionSubmissionHandler {
  * Manages global state flags to ensure only one WebAuthn operation runs at a time
  */
 declare class WebAuthnCoordinator {
-    /**
-     * Clear the landing authentication flag
-     * Used when starting a new transaction signing flow
-     */
-    static clearLandingAuthentication(): void;
     /**
      * Check if a WebAuthn operation is currently in progress
      * @returns True if an operation is in progress, false otherwise
@@ -774,7 +694,7 @@ declare class WebAuthnCoordinator {
  * Platform-agnostic configuration provider
  * Abstracts environment variable access for cross-platform compatibility
  */
-interface ServiceConfig {
+interface PlatformConfig {
     apiUrl: string;
     appId?: string;
     relyingParty: {
@@ -784,7 +704,7 @@ interface ServiceConfig {
     };
 }
 interface ConfigProvider {
-    getServiceConfig(): ServiceConfig;
+    getServiceConfig(): PlatformConfig;
 }
 /**
  * Web platform configuration provider
@@ -792,8 +712,8 @@ interface ConfigProvider {
  */
 declare class WebConfigProvider implements ConfigProvider {
     private config;
-    constructor(config: ServiceConfig);
-    getServiceConfig(): ServiceConfig;
+    constructor(config: PlatformConfig);
+    getServiceConfig(): PlatformConfig;
 }
 /**
  * React Native configuration provider
@@ -801,16 +721,16 @@ declare class WebConfigProvider implements ConfigProvider {
  */
 declare class ReactNativeConfigProvider implements ConfigProvider {
     private config;
-    constructor(config: ServiceConfig);
-    getServiceConfig(): ServiceConfig;
+    constructor(config: PlatformConfig);
+    getServiceConfig(): PlatformConfig;
 }
 /**
  * Static configuration provider for testing or custom setups
  */
 declare class StaticConfigProvider implements ConfigProvider {
     private config;
-    constructor(config: ServiceConfig);
-    getServiceConfig(): ServiceConfig;
+    constructor(config: PlatformConfig);
+    getServiceConfig(): PlatformConfig;
 }
 /**
  * Set the global configuration provider
@@ -824,7 +744,7 @@ declare function getConfigProvider(): ConfigProvider;
 /**
  * Get the service configuration
  */
-declare function getServiceConfig(): ServiceConfig;
+declare function getServiceConfig(): PlatformConfig;
 
 /**
  * Platform-agnostic HTTP client abstraction
@@ -870,322 +790,424 @@ declare function setHttpClient(client: HttpClient): void;
 declare function getHttpClient(): HttpClient;
 
 /**
- * Browser-specific WebAuthn provider using DFNS browser SDK
- */
-
-/**
- * Get WebAuthn provider for browser environments
- */
-declare function getBrowserWebAuthnProvider(): Promise<WebAuthnProvider>;
-
-/**
- * React Native-specific WebAuthn provider using DFNS React Native SDK
- * Falls back to browser implementation for React Native Web (Expo Web)
+ * Wallet list response from WalletService
  */
-
+interface WalletListResponse {
+    items: WalletItem[];
+}
 /**
- * Get WebAuthn provider for React Native environments
+ * Individual wallet item from wallet list - compatible with KeyWallet constructor
  */
-declare function getReactNativeWebAuthnProvider(): Promise<WebAuthnProvider>;
+interface WalletItem {
+    id: string;
+    address: string;
+    network: string;
+    status: string;
+    signingKey?: unknown;
+    dateCreated?: string;
+    custodial?: boolean;
+    tags?: string[];
+    boundToEvmNetwork?: boolean;
+    [key: string]: unknown;
+}
 
 /**
- * PERS Blockchain Signer SDK - Simple Orchestrator
+ * 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';
  *
- * Lightweight SDK that orchestrates existing services.
- * Uses environment configuration and existing infrastructure.
+ * 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 JWTPayload {
-    email?: string;
-    userId?: string;
-    tenantId?: string;
-    exp?: number;
-    [key: string]: any;
-}
-interface PersAuthResult {
-    user: {
-        email?: string;
-        id?: string;
-    };
-    accessToken: string;
-}
 /**
- * User information for authentication
- */
-interface SignerUserInfo {
-    identifier: string;
-    email?: string;
-    id?: string;
-}
-/**
- * Authenticated user with all required tokens
- */
-interface SignerAuthenticatedUser {
-    identifier: string;
-    signerAuthToken: string;
-    persAccessToken: string;
-}
-interface AuthenticationResult {
-    user: SignerAuthenticatedUser;
-    isExpired: boolean;
-}
-interface JWTExtractionResult {
-    payload: JWTPayload | null;
-    isExpired: boolean;
-}
-interface PersSignerConfig {
-    tenantId?: string;
+ * 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 ExtendedPersSignerConfig {
     ethersProviderUrl?: string;
     webAuthnProvider: WebAuthnProvider;
     apiUrl?: string;
     relyingPartyName?: string;
 }
-interface SigningResult {
-    success: boolean;
-    transactionHash?: string;
-    error?: string;
+interface PersSignerConfig extends Omit<ExtendedPersSignerConfig, 'webAuthnProvider'> {
 }
 /**
- * Main PERS Signer SDK class
+ * 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
  *
- * Simple orchestrator that uses existing services and environment configuration.
- * No complex initialization needed - services are already configured.
+ * @class PersSignerSDK
  */
 declare class PersSignerSDK {
     private config;
-    private authService;
-    private signingService;
+    private authenticationService;
     private transactionSigningService;
-    private webAuthnProvider;
-    constructor(config: PersSignerConfig);
-    /**
-     * Re-export TransactionSigningService with WebAuthn provider already injected
-     * This provides the same interface as the original service but with automatic provider injection
-     */
-    get TransactionSigningService(): TransactionSigningService;
-    /**
-     * Complete user onboarding flow - same as web project
-     * Uses existing AuthenticationService and PersService
-     */
-    authenticateUser(userInfo: SignerUserInfo): Promise<SignerAuthenticatedUser>;
-    /**
-     * Complete PERS transaction signing flow - exactly like web project
-     * Uses existing TransactionSigningService with injected WebAuthn provider
-     */
-    signPersTransaction(user: SignerAuthenticatedUser, transactionId: string): Promise<SigningResult>;
     /**
-     * Register new user - uses existing AuthenticationService
-     */
-    registerUser(identifier: string): Promise<{
-        authToken: string;
-    }>;
-    /**
-     * Login existing user - uses existing AuthenticationService
-     */
-    loginUser(identifier: string): Promise<string>;
-    /**
-     * Add wallet to PERS user - uses existing PersService
-     */
-    addWalletToPersUser(signerAuthToken: string): Promise<string>;
-    /**
-     * Retrieve transaction data from PERS - uses existing PersService
-     */
-    retrieveTransactionData(transactionId: string, persAccessToken: string): Promise<TransactionRequestResponseDTO>;
-    /**
-     * Sign transaction data - uses existing SigningService
-     * Follows same patterns as KeyWallet.signPersTransaction
+     * Initialize the PERS Signer SDK
+     *
+     * @param {ExtendedPersSignerConfig} config - SDK configuration object
+     * @throws {Error} If required configuration is missing
      */
-    signTransactionData(signerAuthToken: string, signingData: AnyTransactionData): Promise<string>;
+    constructor(config: ExtendedPersSignerConfig);
     /**
-     * Submit signed transaction to PERS - uses existing PersService
+     * 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);
+     * ```
      */
-    submitTransaction(transactionId: string, signature: string, persAccessToken: string, transactionFormat?: TransactionFormat): Promise<{
-        transactionHash?: string;
-        success: boolean;
-    }>;
+    signTransaction(signingData: CounterfactualWalletTransactionResponse$1 | LegacyTransaction, jwtToken: string): Promise<TransactionSigningResult>;
     /**
-     * Check if user exists - uses existing AuthenticationService
+     * 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);
+     * ```
      */
-    checkUserExists(identifier: string): Promise<boolean>;
+    submitTransaction(signingResult: TransactionSigningResult, jwtToken: string): Promise<SubmissionResult>;
     /**
-     * Get user wallets - uses existing WalletService
+     * 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');
+     * ```
      */
-    getUserWallets(signerAuthToken: string): Promise<any>;
+    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;
+
+/**
+ * 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
+ * Updated for new v1 API endpoints
+ */
+declare class AuthenticationService {
+    private signerToken;
+    private config;
+    private webAuthnProvider;
+    constructor(config: ExtendedPersSignerConfig);
     /**
-     * Get transaction status - uses existing PersService
+     * 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
      */
-    getTransactionStatus(transactionId: string, persAccessToken: string): Promise<{
-        status: string;
-        transactionHash?: string;
-    }>;
+    loginWithPersToken(persToken: string): Promise<JWTLoginResponse | unknown>;
     /**
-     * Initialize tenant - uses existing PersService
+     * Verify signer token validity
+     * @param token - Signer JWT to verify
+     * @returns Promise resolving to verification result
      */
-    initializeTenant(tenantId: string): Promise<void>;
+    verifyToken(token: string): Promise<VerifyTokenResponse>;
     /**
-     * Extract and validate JWT token from URL search parameters
-     * Uses a simpler approach compatible with browser environments
+     * Initialize user registration
+     * @param persToken - PERS JWT token (registration is public)
+     * @returns Promise resolving to registration challenge
      */
-    extractJWTFromURL(searchParams: URLSearchParams): JWTExtractionResult;
+    initializeRegistration(persToken: string): Promise<unknown>;
     /**
-     * Initialize tenant from JWT payload using existing PersService
+     * Get current signer token
+     * @returns The current signer JWT token
      */
-    initializeTenantFromJWT(payload: JWTPayload): Promise<string>;
+    getSignerToken(): string | null;
     /**
-     * Authenticate user with PERS API using existing PersService pattern
+     * Set signer token (for external token management)
+     * @param token - Signer JWT token
      */
+    setSignerToken(token: string): void;
     /**
-     * Authenticate user with PERS API using existing PersService
+     * 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
      */
-    authenticatePersUser(jwtToken: string, projectKey: string): Promise<PersAuthResult>;
+    completeRegistrationWithChallenge(tmpAuthToken: string | null, signedChallenge: any, persToken: string): Promise<JWTLoginResponse | unknown>;
     /**
-     * Combined PERS + DFNS authentication flow
+     * 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<SignerAuthenticatedUser>;
-    /**
-     * Complete JWT-based authentication flow (legacy PERS flow)
-     */
-    authenticateWithJWT(searchParams: URLSearchParams): Promise<AuthenticationResult | null>;
 }
-/**
- * Factory function to create SDK
- * Requires WebAuthnProvider from platform-specific entry point
- */
-declare function createPersSignerSDK(config: PersSignerConfig): PersSignerSDK;
 
 /**
- * Wallet list response from WalletService
- */
-interface WalletListResponse {
-    items: WalletItem[];
-}
-/**
- * Individual wallet item from wallet list - compatible with KeyWallet constructor
+ * Health check service for signer API
+ * Handles health check operations for the new v1 API
  */
-interface WalletItem {
-    id: string;
-    address: string;
-    network: string;
-    status: string;
-    signingKey?: unknown;
-    dateCreated?: string;
-    custodial?: boolean;
-    tags?: string[];
-    boundToEvmNetwork?: boolean;
-    [key: string]: unknown;
+declare class HealthService {
+    /**
+     * Perform health check on the signer API
+     * @returns Promise resolving to health check result
+     */
+    static checkHealth(): Promise<HealthCheckResponse>;
 }
 
 /**
- * Utility functions for handling URL search parameters in a consistent way across applications
- */
-/**
- * Creates a URL search string that preserves all current parameters
- * @param paramsToExclude Array of parameter names to exclude from the result
- * @param paramsToAdd Object with additional parameters to add or override
- * @param baseParams Optional URLSearchParams object to use instead of window.location.search
- * @returns A search string with '?' prefix if there are parameters, or empty string if no parameters
- */
-declare function createSearchString(paramsToExclude?: string[], paramsToAdd?: Record<string, string>, baseParams?: URLSearchParams | string): string;
-/**
- * Creates a URL path with search parameters
- * @param basePath The base path without search parameters
- * @param paramsToExclude Array of parameter names to exclude from the result
- * @param paramsToAdd Object with additional parameters to add or override
- * @param baseParams Optional URLSearchParams object to use instead of window.location.search
- * @returns A full path with search parameters
- */
-declare function createUrlWithSearchParams(basePath: string, paramsToExclude?: string[], paramsToAdd?: Record<string, string>, baseParams?: URLSearchParams | string): string;
-/**
- * Combines the current search parameters with new ones
- * @param searchParams The current URLSearchParams object
- * @param additionalParams Object with parameters to add or update
- * @returns A new URLSearchParams object
- */
-declare function mergeSearchParams(searchParams: URLSearchParams, additionalParams?: Record<string, string>): URLSearchParams;
-/**
- * Gets a specific search parameter value
- * @param key The parameter name to get
- * @param search Optional search string to parse (defaults to window.location.search)
- * @returns The parameter value or null if not found
- */
-declare function getSearchParam(key: string, search?: string): string | null;
-/**
- * Gets all search parameters as a URLSearchParams object
- * @param search Optional search string to parse (defaults to window.location.search)
- * @returns A URLSearchParams object
- */
-declare function getAllSearchParams(search?: string): URLSearchParams;
-/**
- * Removes a specific search parameter
- * @param key The parameter name to remove
- * @param search Optional search string to parse (defaults to window.location.search)
- * @returns A new search string without the specified parameter
+ * Browser-specific WebAuthn provider using DFNS browser SDK
  */
-declare function removeSearchParam(key: string, search?: string): string;
+
 /**
- * Updates or adds a specific search parameter
- * @param key The parameter name to update
- * @param value The new value for the parameter
- * @param search Optional search string to parse (defaults to window.location.search)
- * @returns A new search string with the updated parameter
+ * Get WebAuthn provider for browser environments
  */
-declare function updateSearchParam(key: string, value: string, search?: string): string;
+declare function getBrowserWebAuthnProvider(): Promise<WebAuthnProvider>;
 
 /**
- * Utility for debugging search parameter handling
+ * React Native-specific WebAuthn provider using DFNS React Native SDK
+ * Falls back to browser implementation for React Native Web (Expo Web)
  */
+
 /**
- * Logs the current search parameters with a custom message
- * This is useful for debugging search parameter preservation across navigation
- *
- * @param message - A descriptive message to identify where the logging happens
- * @param additionalData - Optional additional data to log
+ * Get WebAuthn provider for React Native environments
  */
-declare function logSearchParams(message: string, additionalData?: any): void;
+declare function getReactNativeWebAuthnProvider(): Promise<WebAuthnProvider>;
+
 /**
- * Creates a search parameter tracking hook that can be used in React components
- * Logs search parameter changes when the component mounts/updates
+ * JWT Utility Functions
  *
- * @param componentName - The name of the component (for logging)
+ * Browser-compatible JWT handling without external dependencies
  */
-declare function createSearchParamLogger(componentName: string): () => void;
-
+interface JWTPayload {
+    email?: string;
+    identifierEmail?: string;
+    userId?: string;
+    tenantId?: string;
+    transactionId?: string;
+    exp?: number;
+    [key: string]: any;
+}
+interface JWTExtractionResult {
+    payload: JWTPayload | null;
+    isExpired: boolean;
+}
 /**
- * Generates a RFC4122 version 4 compliant UUID
- * @returns A randomly generated UUID
+ * Extract and validate JWT token payload
+ * Uses a browser-compatible approach without external dependencies
  */
-declare function generateUUID(): string;
+declare function extractJWTFromToken(jwtToken: string): JWTExtractionResult;
 /**
- * Create a semi-anonymous username for users
- * @returns A username in the format "user_[random string]"
+ * Check if a JWT token is expired
  */
-declare function generateAnonymousUsername(): string;
+declare function isJWTExpired(jwtToken: string): boolean;
 /**
- * Create a guest username for the application with a random prefix
- * @returns A guest email in the format "randomstring_guest@explorins.com"
+ * Get JWT payload without validation
  */
-declare function generateGuestUsername(): string;
+declare function getJWTPayload(jwtToken: string): JWTPayload | null;
 
 /**
- * Utility functions for tenant-specific operations
+ * In-memory User Cache
+ *
+ * Provides secure, storage-free user authentication caching
+ * Uses memory-only storage with TTL expiration for security
  */
+
 /**
- * Represents a tenant configuration
+ * In-memory user cache with TTL expiration
+ * Security-first approach - no persistent storage
  */
-interface TenantConfig {
-    id: string;
-    name: string;
-    analytics?: {
-        enabled: boolean;
-        trackingId?: string;
-    };
+declare class UserCache {
+    private static cache;
+    private static readonly DEFAULT_TTL_MS;
+    /**
+     * Get cached user by identifier
+     * @param identifier - User identifier (email/userId)
+     * @returns Cached user or null if not found/expired
+     */
+    static get(identifier: string): AuthenticatedUser | null;
+    /**
+     * Cache user with TTL
+     * @param identifier - User identifier
+     * @param user - Authenticated user data
+     * @param ttlMs - Time to live in milliseconds (default: 5 minutes)
+     */
+    static set(identifier: string, user: AuthenticatedUser, ttlMs?: number): void;
+    /**
+     * Remove user from cache
+     * @param identifier - User identifier
+     */
+    static delete(identifier: string): boolean;
+    /**
+     * Clear all cached users
+     */
+    static clear(): void;
+    /**
+     * Get cache size (for debugging)
+     */
+    static size(): number;
+    /**
+     * Clean up expired entries
+     */
+    static cleanup(): number;
 }
-/**
- * Initialize tenant-specific analytics
- * @param tenantId The tenant ID
- * @param getTenantConfig Function to retrieve tenant configuration
- */
-declare const initTenantAnalytics: (tenantId: string, getTenantConfig: (id: string) => TenantConfig | null) => void;
 
-export { AuthenticationService, FetchHttpClient, KeyWallet, PersService, PersSignerSDK, ReactNativeConfigProvider, SIGNABLE_STATUSES, SigningService, StaticConfigProvider, TransactionErrorHandler, TransactionSigningErrorCode, TransactionSigningService, TransactionSubmissionHandler, TransactionValidator, WalletService, WebAuthnCoordinator, WebConfigProvider, createPersSignerSDK, createSearchParamLogger, createSearchString, createUrlWithSearchParams, generateAnonymousUsername, generateGuestUsername, generateUUID, getAllSearchParams, getBrowserWebAuthnProvider, getConfigProvider, getHttpClient, getReactNativeWebAuthnProvider, getSearchParam, getServiceConfig, initTenantAnalytics, logSearchParams, mergeSearchParams, removeSearchParam, setConfigProvider, setHttpClient, updateSearchParam };
-export type { ApiResponse, AuthResponse, AuthState, AuthToken, AuthenticationResult, CombinedTransactionStatus, ConfigProvider, HashSigningRequest, HttpClient, HttpRequestOptions, HttpResponse, JWTExtractionResult, JWTPayload, WalletItem$1 as KeyWalletItem, WalletListResponse$1 as KeyWalletListResponse, PersAuthResult, PersSignerConfig, PreparedTransaction, RegistrationChallenge, RegistrationResult, RelyingPartyConfig, ServiceConfig$1 as ServiceConfig, ServiceError, SignResponse, SignerAuthenticatedUser, SignerUserInfo, SigningAuthTokens, SigningChallenge, SigningRequest, SigningResult$1 as SigningResult, StoredTransactionResult, SubmissionResult, TenantConfig, TransactionMetadata, TransactionSigningError, TransactionSigningParams, TransactionSigningResult, TransactionStatusInfo, TypedDataSigningRequest, UserCredentials, UserProfile, WalletConfig, WalletItem, WalletListResponse, WebAuthnConfig, WebAuthnProvider };
+export { AuthenticationService, FetchHttpClient, HealthService, KeyWallet, PersService, PersSignerSDK, ReactNativeConfigProvider, SIGNABLE_STATUSES, SigningService, StaticConfigProvider, TransactionErrorHandler, TransactionSigningErrorCode, TransactionSigningService, TransactionSubmissionHandler, TransactionValidator, UserCache, WalletService, WebAuthnCoordinator, WebConfigProvider, createPersSignerSDK, extractJWTFromToken, getBrowserWebAuthnProvider, getConfigProvider, getHttpClient, getJWTPayload, getReactNativeWebAuthnProvider, getServiceConfig, isJWTExpired, setConfigProvider, setHttpClient };
+export type { AuthResponse, AuthenticatedUser, CombinedTransactionStatus, ConfigProvider, HashSigningRequest, HttpClient, HttpRequestOptions, HttpResponse, JWTExtractionResult, JWTPayload, ListWalletsRequest, ListWalletsResponse, LoginRequest, LoginResponse, PersSignerConfig, RegistrationChallenge, RegistrationResult, RelyingPartyConfig, ServiceConfig, ServiceError, SignResponse, SignerApiError, SignerApiResponse, SigningAuthTokens, SigningChallenge, SigningRequest, SubmissionResult, TransactionSigningError, TransactionSigningParams, TransactionSigningResult, TransactionStatusInfo, TypedDataSigningRequest, UserCredentials, WalletItem, WalletListResponse, WebAuthnConfig, WebAuthnProvider };