@explorins/pers-signer 1.0.11 → 1.0.16

package/dist/browser.d.ts

@@ -1,36 +1,23 @@
 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, CounterfactualWalletTransactionResponse, TransactionStatus } from '@explorins/pers-shared/browser';
 export { TransactionFormat, TransactionRequestResponseDTO, TransactionStatus } from '@explorins/pers-shared/browser';
 import { AbstractSigner, Provider, TransactionRequest, TypedDataDomain, TypedDataField } from 'ethers';
+import { CounterfactualWalletTransactionResponse as CounterfactualWalletTransactionResponse$1 } from '@explorins/pers-shared';
 
 /**
  * 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
-     */
-    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
+     * @param signerToken - Signer JWT token
+     * @returns Promise resolving to wallet data
      */
-    static createWallet(authToken: string, walletConfig: any): Promise<any>;
+    static listWallets(signerToken: string): Promise<unknown>;
 }
 
 /**
@@ -47,7 +34,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
@@ -76,8 +65,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;
@@ -89,19 +86,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
      *
@@ -109,53 +98,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
@@ -207,7 +163,8 @@ interface SignResponse {
     signature: {
         r: string;
         s: string;
-        recid: number;
+        v: number;
+        encoded: string;
     };
     network: "KeyECDSA";
     dateRequested: string;
@@ -240,29 +197,9 @@ interface RegistrationResult {
     status?: number;
     message?: string;
 }
-/**
- * Wallet listing response
- */
-interface WalletListResponse$1 {
-    wallets: WalletItem$1[];
-    status?: number;
-    message?: string;
-}
 /**
  * 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;
-}
 /**
  * Hash signing request
  */
@@ -312,6 +249,62 @@ interface RelyingPartyConfig {
     origin?: string;
 }
 
+interface JWTLoginResponse {
+    success: true;
+    access_token: string;
+    token_type: "Bearer";
+    expires_in: number;
+    user: {
+        id: string;
+        username: string;
+        org_id: string;
+    };
+    provider: string;
+}
+interface VerifyTokenResponse {
+    valid: boolean;
+    provider: string;
+    claims: {
+        sub: string;
+        iss: string;
+        aud: string;
+        exp: number;
+        iat: number;
+        user_id: string;
+        username: string;
+        org_id: string;
+        provider: string;
+        permissions: unknown;
+    };
+    tenantId: string;
+}
+interface CompleteSignatureResponse {
+    success: true;
+    data: {
+        signature?: {
+            r: string;
+            s: string;
+            recid: number;
+            encoded: string;
+        } | string;
+        transaction?: unknown;
+        dateRequested?: string;
+        dateSigned?: string;
+        id?: string;
+        keyId?: string;
+        network?: string;
+        requestBody?: {
+            kind?: 'Eip712' | 'Hash' | string;
+            blockchainKind?: string;
+            [key: string]: unknown;
+        };
+        requester?: unknown;
+        status?: string;
+        walletId?: string;
+        [key: string]: unknown;
+    };
+}
+
 /**
  * Signing service for cryptographic operations
  * Handles hash signing and typed data signing with WebAuthn
@@ -327,7 +320,7 @@ declare class SigningService {
      * @param hash - Hash to sign
      * @returns Promise resolving to signature response
      */
-    signHash(authToken: string, walletId: string, hash: string): Promise<SignResponse>;
+    signHash(authToken: string, walletId: string, hash: string): Promise<CompleteSignatureResponse['data']>;
     /**
      * Sign EIP-712 typed data using the specified wallet
      * @param authToken - Authentication token
@@ -337,7 +330,7 @@ declare class SigningService {
      * @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>;
+    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
@@ -353,7 +346,7 @@ declare class SigningService {
      * @param requests - Array of signing requests
      * @returns Promise resolving to array of signature responses
      */
-    signBatch(authToken: string, walletId: string, requests: SigningRequest[]): Promise<SignResponse[]>;
+    signBatch(authToken: string, walletId: string, requests: SigningRequest[]): Promise<CompleteSignatureResponse['data'][]>;
 }
 
 /**
@@ -361,65 +354,19 @@ declare class SigningService {
  */
 
 /**
- * Represents a wallet configuration with its metadata
- */
-interface WalletConfig {
-    id: string;
-    name: string;
-    address?: string;
-    credentialId?: string;
-    publicKey?: string;
-    createdAt?: Date;
-}
-/**
- * Authentication token structure
- */
-interface AuthToken {
-    token: string;
-    expiresAt: Date;
-    refreshToken?: string;
-}
-/**
- * User authentication state
- */
-interface AuthState {
-    isAuthenticated: boolean;
-    token?: AuthToken;
-    user?: UserProfile;
-    wallets?: WalletConfig[];
-}
-/**
- * User profile information
- */
-interface UserProfile {
-    id: string;
-    username: string;
-    email?: string;
-    createdAt: Date;
-    lastLoginAt?: Date;
-}
-/**
- * Prepared transaction from PERS service
- */
-interface PreparedTransaction {
-    id: string;
-    transactionData: AnyTransactionData;
-    metadata?: Record<string, any>;
-    createdAt: Date;
-    expiresAt?: Date;
-}
-/**
- * Transaction signing result
+ * Authentication types for 3-function split architecture
  */
-interface SigningResult$1 {
-    signature: string;
-    transactionHash?: string;
-    rawTransaction?: string;
+interface AuthenticatedUser {
+    identifier: string;
+    signerAuthToken: string;
+    persAccessToken: string;
+    tenantId: string;
+    expiresAt: number;
 }
 /**
  * Service configuration options
  */
-interface ServiceConfig$1 {
+interface ServiceConfig {
     apiUrl: string;
     environment: 'development' | 'staging' | 'production';
     timeout?: number;
@@ -434,15 +381,6 @@ interface ServiceError {
     details?: any;
     timestamp: Date;
 }
-/**
- * API response wrapper
- */
-interface ApiResponse<T = any> {
-    success: boolean;
-    data?: T;
-    error?: ServiceError;
-    metadata?: Record<string, any>;
-}
 
 interface GetWalletResponse {
     id: string;
@@ -503,21 +441,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
  */
@@ -525,18 +454,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;
 }
 /**
@@ -544,12 +473,10 @@ interface SigningAuthTokens {
  */
 interface TransactionSigningParams {
     transactionId: string;
+    tenantId: string;
     authTokens: SigningAuthTokens;
     ethersProviderUrl: string;
     returnUrl?: string;
-    metadata?: TransactionMetadata;
-    walletRegistrationFailed?: boolean;
-    walletErrorDetails?: string;
 }
 
 /**
@@ -559,7 +486,7 @@ interface TransactionSigningParams {
  */
 declare class TransactionSigningService {
     private webAuthnProvider;
-    constructor(webAuthnProvider: WebAuthnProvider);
+    constructor(config: PersSignerConfig);
     /**
      * Prepare transaction for signing - fetch and validate
      */
@@ -572,6 +499,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
@@ -579,7 +511,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>;
 }
 
 /**
@@ -698,19 +630,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>;
 }
 
 /**
@@ -718,11 +638,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
@@ -739,7 +654,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: {
@@ -749,7 +664,7 @@ interface ServiceConfig {
     };
 }
 interface ConfigProvider {
-    getServiceConfig(): ServiceConfig;
+    getServiceConfig(): PlatformConfig;
 }
 /**
  * Web platform configuration provider
@@ -757,8 +672,8 @@ interface ConfigProvider {
  */
 declare class WebConfigProvider implements ConfigProvider {
     private config;
-    constructor(config: ServiceConfig);
-    getServiceConfig(): ServiceConfig;
+    constructor(config: PlatformConfig);
+    getServiceConfig(): PlatformConfig;
 }
 /**
  * React Native configuration provider
@@ -766,16 +681,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
@@ -789,7 +704,7 @@ declare function getConfigProvider(): ConfigProvider;
 /**
  * Get the service configuration
  */
-declare function getServiceConfig(): ServiceConfig;
+declare function getServiceConfig(): PlatformConfig;
 
 /**
  * Platform-agnostic HTTP client abstraction
@@ -835,50 +750,44 @@ declare function setHttpClient(client: HttpClient): void;
 declare function getHttpClient(): HttpClient;
 
 /**
- * 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';
+ *
+ * const sdk = createPersSignerSDK({
+ *   webAuthnProvider: myWebAuthnProvider,
+ *   ethersProviderUrl: 'https://ethereum-rpc.com'
+ * });
  *
- * Lightweight SDK that orchestrates existing services.
- * Uses environment configuration and existing infrastructure.
+ * // 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
+ * 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 SignerAuthenticatedUser {
-    identifier: string;
-    signerAuthToken: string;
-    persAccessToken: string;
-}
-interface AuthenticationResult {
-    user: SignerAuthenticatedUser;
-    isExpired: boolean;
-}
-interface JWTExtractionResult {
-    payload: JWTPayload | null;
-    isExpired: boolean;
-}
 interface PersSignerConfig {
     tenantId?: string;
     ethersProviderUrl?: string;
@@ -886,112 +795,158 @@ interface PersSignerConfig {
     apiUrl?: string;
     relyingPartyName?: string;
 }
-interface SigningResult {
-    success: boolean;
-    transactionHash?: string;
-    error?: string;
-}
 /**
- * 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.
  *
- * Simple orchestrator that uses existing services and environment configuration.
- * No complex initialization needed - services are already configured.
+ * 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 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
-     */
-    signTransactionData(signerAuthToken: string, signingData: AnyTransactionData): Promise<string>;
-    /**
-     * Submit signed transaction to PERS - uses existing PersService
-     */
-    submitTransaction(transactionId: string, signature: string, persAccessToken: string, transactionFormat?: TransactionFormat): Promise<{
-        transactionHash?: string;
-        success: boolean;
-    }>;
-    /**
-     * Check if user exists - uses existing AuthenticationService
-     */
-    checkUserExists(identifier: string): Promise<boolean>;
     /**
-     * Get user wallets - uses existing WalletService
-     */
-    getUserWallets(signerAuthToken: string): Promise<any>;
-    /**
-     * Get transaction status - uses existing PersService
-     */
-    getTransactionStatus(transactionId: string, persAccessToken: string): Promise<{
-        status: string;
-        transactionHash?: string;
-    }>;
-    /**
-     * Initialize tenant - uses existing PersService
-     */
-    initializeTenant(tenantId: string): Promise<void>;
-    /**
-     * Extract and validate JWT token from URL search parameters
-     * Uses a simpler approach compatible with browser environments
-     */
-    extractJWTFromURL(searchParams: URLSearchParams): JWTExtractionResult;
-    /**
-     * Initialize tenant from JWT payload using existing PersService
-     */
-    initializeTenantFromJWT(payload: JWTPayload): Promise<string>;
-    /**
-     * Authenticate user with PERS API using existing PersService pattern
+     * Initialize the PERS Signer SDK
+     *
+     * @param {PersSignerConfig} config - SDK configuration object
+     * @throws {Error} If required configuration is missing
      */
+    constructor(config: PersSignerConfig);
     /**
-     * Authenticate user with PERS API using 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);
+     * ```
      */
-    authenticatePersUser(jwtToken: string, projectKey: string): Promise<PersAuthResult>;
+    signTransaction(signingData: CounterfactualWalletTransactionResponse$1 | LegacyTransaction, jwtToken: string): Promise<TransactionSigningResult>;
     /**
-     * Combined PERS + DFNS authentication flow
+     * 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);
+     * ```
      */
-    combinedAuthentication(identifier: string, persAccessToken: string): Promise<SignerAuthenticatedUser>;
+    submitTransaction(signingResult: TransactionSigningResult, jwtToken: string): Promise<SubmissionResult>;
     /**
-     * Complete JWT-based authentication flow (legacy PERS flow)
+     * 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');
+     * ```
      */
-    authenticateWithJWT(searchParams: URLSearchParams): Promise<AuthenticationResult | null>;
+    clearCache(): void;
 }
 
 /**
@@ -1017,150 +972,68 @@ interface WalletItem {
 }
 
 /**
- * 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
- */
-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
- */
-declare function updateSearchParam(key: string, value: string, search?: string): string;
-
-/**
- * Utility for debugging search parameter handling
- */
-/**
- * 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
- */
-declare function logSearchParams(message: string, additionalData?: any): void;
-/**
- * Creates a search parameter tracking hook that can be used in React components
- * Logs search parameter changes when the component mounts/updates
- *
- * @param componentName - The name of the component (for logging)
- */
-declare function createSearchParamLogger(componentName: string): () => void;
-
-/**
- * Generates a RFC4122 version 4 compliant UUID
- * @returns A randomly generated UUID
- */
-declare function generateUUID(): string;
-/**
- * Create a semi-anonymous username for users
- * @returns A username in the format "user_[random string]"
- */
-declare function generateAnonymousUsername(): string;
-/**
- * Create a guest username for the application with a random prefix
- * @returns A guest email in the format "randomstring_guest@explorins.com"
- */
-declare function generateGuestUsername(): string;
-
-/**
- * Utility functions for tenant-specific operations
- */
-/**
- * Represents a tenant configuration
+ * Authenticated user with all required tokens
  */
-interface TenantConfig {
-    id: string;
-    name: string;
-    analytics?: {
-        enabled: boolean;
-        trackingId?: string;
-    };
+interface SignerAuthenticatedUser {
+    identifier: string;
+    signerAuthToken: string;
+    persAccessToken: string;
 }
-/**
- * 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;
-
 /**
  * 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(webAuthnProvider: WebAuthnProvider);
+    constructor(config: PersSignerConfig);
     /**
-     * Authenticate user with username
-     * @param username - User identifier
-     * @returns Promise resolving to authentication token
+     * 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
      */
-    login(username: string): Promise<string>;
+    loginWithPersToken(persToken: string): Promise<JWTLoginResponse | unknown>;
     /**
-     * Register new user with WebAuthn credential
-     * @param username - User identifier
-     * @returns Promise resolving to registration result
+     * Verify signer token validity
+     * @param token - Signer JWT to verify
+     * @returns Promise resolving to verification result
      */
-    register(username: string): Promise<RegistrationResult>;
+    verifyToken(token: string): Promise<VerifyTokenResponse>;
     /**
-     * Validate authentication token (when backend supports it)
-     * @param authToken - Token to validate
-     * @returns Promise resolving to validation result
+     * Initialize user registration
+     * @param persToken - PERS JWT token (registration is public)
+     * @returns Promise resolving to registration challenge
      */
-    validateToken(authToken: string): Promise<boolean>;
+    initializeRegistration(persToken: string): Promise<unknown>;
     /**
-     * Get user information (when backend supports it)
-     * @param authToken - Authentication token
-     * @returns Promise resolving to user info or null
+     * Get current signer token
+     * @returns The current signer JWT token
      */
-    getUser(authToken: string): Promise<{
-        username: string;
-    } | null>;
+    getSignerToken(): string | null;
+    /**
+     * Set signer token (for external token management)
+     * @param token - Signer JWT token
+     */
+    setSignerToken(token: string): void;
+    /**
+     * Complete registration with WebAuthn challenge data (v1 API format)
+     * @param tmpAuthToken - Temporary auth token from init registration (temporaryAuthenticationToken)
+     * @param signedChallenge - WebAuthn credential response (will be restructured for backend)
+     * @param persToken - PERS JWT token (authToken)
+     * @returns Promise resolving to registration result
+     */
+    completeRegistrationWithChallenge(tmpAuthToken: string | null, signedChallenge: any, persToken: string): Promise<JWTLoginResponse | unknown>;
+    /**
+     * Combined authentication flow - handles both login and registration
+     * @param identifier - User identifier (email/userId)
+     * @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>;
 }
 
 /**
@@ -1177,19 +1050,11 @@ declare function getBrowserWebAuthnProvider(): Promise<WebAuthnProvider>;
  * Includes only browser-compatible dependencies
  */
 
-/**
- * Create a new AuthenticationService instance with browser WebAuthn provider
- */
-declare function createAuthenticationService(): Promise<AuthenticationService>;
-/**
- * Create a new SigningService instance with browser WebAuthn provider
- */
-declare function createSigningService(): Promise<SigningService>;
 /**
  * Create a new PersSignerSDK instance with browser WebAuthn provider
  * @param config - SDK configuration (ethersProviderUrl is required)
  */
 declare function createPersSignerSDK(config: Omit<PersSignerConfig, 'webAuthnProvider'>): Promise<PersSignerSDK>;
 
-export { AuthenticationService, FetchHttpClient, KeyWallet, PersService, PersSignerSDK, ReactNativeConfigProvider, SIGNABLE_STATUSES, SigningService, StaticConfigProvider, TransactionErrorHandler, TransactionSigningErrorCode, TransactionSigningService, TransactionSubmissionHandler, TransactionValidator, WalletService, WebAuthnCoordinator, WebConfigProvider, createAuthenticationService, createPersSignerSDK, createSearchParamLogger, createSearchString, createSigningService, createUrlWithSearchParams, generateAnonymousUsername, generateGuestUsername, generateUUID, getAllSearchParams, getBrowserWebAuthnProvider, getConfigProvider, getHttpClient, getSearchParam, getServiceConfig, getBrowserWebAuthnProvider as getWebAuthnProvider, 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, KeyWallet, PersService, PersSignerSDK, ReactNativeConfigProvider, SIGNABLE_STATUSES, SigningService, StaticConfigProvider, TransactionErrorHandler, TransactionSigningErrorCode, TransactionSigningService, TransactionSubmissionHandler, TransactionValidator, WalletService, WebAuthnCoordinator, WebConfigProvider, createPersSignerSDK, getBrowserWebAuthnProvider, getConfigProvider, getHttpClient, getServiceConfig, getBrowserWebAuthnProvider as getWebAuthnProvider, setConfigProvider, setHttpClient };
+export type { AuthResponse, AuthenticatedUser, CombinedTransactionStatus, ConfigProvider, HashSigningRequest, HttpClient, HttpRequestOptions, HttpResponse, PersSignerConfig, PlatformConfig, RegistrationChallenge, RegistrationResult, RelyingPartyConfig, ServiceConfig, ServiceError, SignResponse, SigningAuthTokens, SigningChallenge, SigningRequest, SubmissionResult, TransactionSigningError, TransactionSigningParams, TransactionSigningResult, TransactionStatusInfo, TypedDataSigningRequest, UserCredentials, WalletItem, WalletListResponse, WebAuthnConfig, WebAuthnProvider };