@explorins/pers-signer 1.0.12 → 1.0.17

package/dist/browser.cjs.js

@@ -49,7 +49,17 @@ class FetchHttpClient {
             setTimeout(() => controller.abort(), options.timeout);
         }
         const response = await fetch(url, fetchOptions);
-        const data = await response.json();
+        // Check if response is actually JSON before parsing
+        const responseText = await response.text();
+        let data;
+        try {
+            data = JSON.parse(responseText);
+        }
+        catch (parseError) {
+            console.error('[HttpClient] JSON parse error:', parseError);
+            console.error('[HttpClient] Failed to parse response text:', responseText);
+            throw new Error(`Failed to parse JSON response: ${parseError instanceof Error ? parseError.message : 'Unknown error'}`);
+        }
         return {
             data,
             status: response.status,
@@ -159,74 +169,31 @@ function getServiceConfig() {
 
 /**
  * Wallet management service
- * Handles wallet listing and management operations
+ * Updated for v1 API endpoints per migration reference
  */
 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 async listWallets(authToken) {
+    static async listWallets(signerToken) {
         const httpClient = getHttpClient();
         const config = getServiceConfig();
         try {
-            const response = await httpClient.post(`${config.apiUrl}/wallets/list`, {
-                authToken,
-                appId: config.appId,
-            });
-            console.log('[WalletService] Raw API response:', response.data);
-            return response.data;
+            const requestBody = {};
+            const response = await httpClient.post(`${config.apiUrl}/wallets/list`, requestBody, { Authorization: `Bearer ${signerToken}` });
+            const backendResponse = response.data;
+            if (backendResponse.success && backendResponse.data) {
+                return backendResponse.data;
+            }
+            throw new Error('Failed to list wallets: Invalid response');
         }
         catch (error) {
             console.error('[WalletService] Error listing wallets:', error);
             throw error;
         }
     }
-    /**
-     * Get wallet by ID (when backend supports it)
-     * @param authToken - Authentication token
-     * @param walletId - Wallet identifier
-     * @returns Promise resolving to wallet details
-     */
-    static async getWallet(authToken, walletId) {
-        const httpClient = getHttpClient();
-        const config = getServiceConfig();
-        try {
-            const response = await httpClient.post(`${config.apiUrl}/wallets/get`, {
-                authToken,
-                walletId,
-                appId: config.appId,
-            });
-            return response.data;
-        }
-        catch (error) {
-            console.error(`[WalletService] Error getting wallet ${walletId}:`, error);
-            throw error;
-        }
-    }
-    /**
-     * Create new wallet (when backend supports it)
-     * @param authToken - Authentication token
-     * @param walletConfig - Wallet configuration
-     * @returns Promise resolving to wallet creation result
-     */
-    static async createWallet(authToken, walletConfig) {
-        const httpClient = getHttpClient();
-        const config = getServiceConfig();
-        try {
-            const response = await httpClient.post(`${config.apiUrl}/wallets/create`, {
-                authToken,
-                ...walletConfig,
-                appId: config.appId,
-            });
-            return response.data;
-        }
-        catch (error) {
-            console.error('[WalletService] Error creating wallet:', error);
-            throw error;
-        }
-    }
 }
 
 /**
@@ -305,10 +272,10 @@ class PersService {
      * @returns Promise with tenant public information
      */
     static async getTenantById(tenantId, authToken) {
-        // Check memory cache first
+        // Check memory cache first with expiration
         const cached = this.tenantCache.get(tenantId);
-        if (cached) {
-            return cached;
+        if (cached && Date.now() < cached.expiresAt) {
+            return cached.tenant;
         }
         try {
             const headers = {
@@ -346,10 +313,16 @@ class PersService {
                 }
             }
             const tenantData = await response.json();
-            // Cache the tenant data in memory only
-            this.tenantCache.set(tenantId, tenantData);
+            // Cache the tenant data with expiration
+            const now = Date.now();
+            this.tenantCache.set(tenantId, {
+                tenant: tenantData,
+                cachedAt: now,
+                expiresAt: now + this.TENANT_CACHE_TTL
+            });
             // Update current project key (check multiple possible property names)
             this.currentProjectKey = tenantData.projectKey || tenantData.projectApiKey || tenantData.apiKey;
+            this.currentTenantId = tenantId;
             return tenantData;
         }
         catch (error) {
@@ -369,14 +342,35 @@ class PersService {
         const projectKey = tenantData.projectApiKey;
         if (projectKey) {
             this.currentProjectKey = projectKey;
+            this.currentTenantId = tenantId;
         }
         return tenantData;
     }
+    /**
+     * 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 async ensureTenantInitialized(tenantId, authToken) {
+        // Check if we already have the right tenant initialized and it's still valid
+        const cached = this.tenantCache.get(tenantId);
+        if (this.currentTenantId === tenantId && cached && Date.now() < cached.expiresAt) {
+            return cached.tenant;
+        }
+        // Initialize or refresh tenant data
+        return await this.initializeTenant(tenantId, authToken);
+    }
     /**
      * 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
      */
-    static getProjectKey() {
+    static async getProjectKey(tenantId) {
+        // If tenantId provided and different from current, initialize it
+        if (tenantId && this.currentTenantId !== tenantId) {
+            await this.ensureTenantInitialized(tenantId);
+        }
         if (this.currentProjectKey) {
             return this.currentProjectKey;
         }
@@ -392,17 +386,19 @@ class PersService {
     static clearTenantCache() {
         this.tenantCache.clear();
         this.currentProjectKey = null;
+        this.currentTenantId = null;
     }
     /**
      * 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 async authenticateUser(authToken) {
+    static async authenticateUser(authToken, tenantId) {
         try {
-            const projectKey = this.getProjectKey();
+            const projectKey = await this.getProjectKey(tenantId);
             const headers = {
                 'accept': 'application/json',
                 'x-project-key': projectKey,
@@ -452,30 +448,6 @@ class PersService {
             };
         }
     }
-    /**
-     * 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 async prepareTransaction(form, persAccessToken) {
-        // ✅ UPDATED: /transaction/auth/prepare-signing → /transactions/prepare
-        const res = await fetch(`${getPersApiUrl(this.useStaging)}/transactions`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                'x-project-key': this.getProjectKey(),
-                Authorization: `Bearer ${persAccessToken}`,
-            },
-            body: JSON.stringify(form),
-        });
-        if (!res.ok)
-            throw new Error("Failed to prepare transaction");
-        const response = await res.json();
-        return response;
-    }
     /**
      * Submits a transaction by calling the backend endpoint
      *
@@ -483,208 +455,86 @@ 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 async submitTransaction(transactionId, signedTransactionOrSignature, persAccessToken, submissionType) {
-        // Map TransactionFormat to the backend's expected submission type
-        const dto = {
-            transactionId,
-            type: submissionType,
-            ...(submissionType === browser.TRANSACTION_FORMATS.EIP_712
-                ? { signature: signedTransactionOrSignature }
-                : { signedTransaction: signedTransactionOrSignature })
-        };
-        // ✅ UPDATED: /transaction/auth/submit/${transactionId} → /transactions/${transactionId}/submit
-        const res = await fetch(`${getPersApiUrl(this.useStaging)}/transactions/submit`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                'x-project-key': this.getProjectKey(),
-                Authorization: `Bearer ${persAccessToken}`,
-            },
-            body: JSON.stringify(dto),
-        });
-        if (!res.ok)
-            throw new Error("Failed to submit transaction");
-        return await res.json();
-    }
-    /**
-     * Fetches a prepared transaction for signing by transactionId
-     * @param transactionId - The transaction ID to fetch
-     * @param persAccessToken - The PERS access token for authentication (Bearer)
-     * @returns The prepared transaction data
-     * @throws If the request fails
-     */
-    static async fetchPreparedTransaction(transactionId, persAccessToken) {
-        // ✅ UPDATED: /transaction/auth/prepare-signing/${transactionId} → /transactions/${transactionId}/prepare
-        const res = await fetch(`${getPersApiUrl(this.useStaging)}/transactions/${transactionId}/prepare`, {
-            headers: {
-                "Content-Type": "application/json",
-                "x-project-key": this.getProjectKey(),
-                Authorization: `Bearer ${persAccessToken}`,
-            },
-        });
-        const response = await res.json();
-        if (!res.ok) {
-            // Throw structured error with the backend response
-            throw {
-                status: res.status,
-                message: response.message || "Failed to fetch prepared transaction",
-                error: response
-            };
-        }
-        return response;
-    }
-    /**
-     * 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 async claimReward(rewardId, pointsCost, persAccessToken) {
-        const res = await fetch(`${getPersApiUrl(this.useStaging)}/rewards/auth/claim`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                'x-project-key': this.getProjectKey(),
-                Authorization: `Bearer ${persAccessToken}`,
-            },
-            body: JSON.stringify({
-                rewardId,
-                pointsCost
-            }),
-        });
-        if (!res.ok) {
-            const error = await res.text();
-            throw new Error(`Failed to claim reward: ${error}`);
-        }
-        return await res.json();
-    }
-    /**
-     * Get all active campaigns
-     * @returns Promise with list of active campaigns
-     */
-    static async getActiveCampaigns() {
-        try {
-            const response = await fetch(`${getPersApiUrl(this.useStaging)}/campaign`, {
-                method: 'GET',
-                headers: {
-                    'accept': 'application/json',
-                    'x-project-key': this.getProjectKey()
-                }
-            });
-            if (!response.ok) {
-                const errorData = await response.json().catch(() => ({}));
-                throw {
-                    status: response.status,
-                    message: errorData.message || 'Failed to fetch active campaigns',
-                    error: errorData
-                };
-            }
-            const data = await response.json();
-            return data;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    /**
-     * 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 async claimCampaign(campaignId, persAccessToken) {
+    static async submitTransaction(transactionId, signedTransactionOrSignature, persAccessToken, submissionType, tenantId) {
         try {
-            const response = await fetch(`${getPersApiUrl(this.useStaging)}/campaign/auth/claim`, {
-                method: 'POST',
+            // Map TransactionFormat to the backend's expected submission type
+            const dto = {
+                transactionId,
+                type: submissionType,
+                ...(submissionType === browser.TRANSACTION_FORMATS.EIP_712
+                    ? { signature: signedTransactionOrSignature }
+                    : { signedTransaction: signedTransactionOrSignature })
+            };
+            // ✅ UPDATED: /transaction/auth/submit/${transactionId} → /transactions/${transactionId}/submit
+            const res = await fetch(`${getPersApiUrl(this.useStaging)}/transactions/submit`, {
+                method: "POST",
                 headers: {
-                    'accept': 'application/json',
-                    'x-project-key': this.getProjectKey(),
-                    'Authorization': `Bearer ${persAccessToken}`,
-                    'Content-Type': 'application/json'
+                    "Content-Type": "application/json",
+                    'x-project-key': await this.getProjectKey(tenantId),
+                    Authorization: `Bearer ${persAccessToken}`,
                 },
-                body: JSON.stringify({
-                    campaignId
-                })
+                body: JSON.stringify(dto),
             });
-            if (!response.ok) {
-                const errorData = await response.json().catch(() => ({}));
+            const response = await res.json();
+            if (!res.ok) {
+                // Throw structured error with the backend response
                 throw {
-                    status: response.status,
-                    message: errorData.message || 'Failed to claim campaign',
-                    error: errorData
+                    status: res.status,
+                    message: response.message || "Failed to submit transaction",
+                    error: response
                 };
             }
-            const data = await response.json();
-            return data;
+            return response;
         }
         catch (error) {
-            throw error;
+            // Rethrow a structured error
+            throw {
+                status: error.status || 500,
+                message: error.message || 'Failed to submit transaction to PERS backend',
+                error
+            };
         }
     }
     /**
-     * Gets all campaign claims for the authenticated user
+     * Fetches a prepared transaction for signing by transactionId
+     * @param transactionId - The transaction ID to fetch
      * @param persAccessToken - The PERS access token for authentication (Bearer)
-     * @returns Promise with list of user's campaign claims
-     * @throws If the request fails
-     */
-    static async getUserCampaignClaims(persAccessToken) {
-        try {
-            const response = await fetch(`${getPersApiUrl(this.useStaging)}/campaign/auth/claim`, {
-                method: 'GET',
-                headers: {
-                    'accept': 'application/json',
-                    'x-project-key': this.getProjectKey(),
-                    'Authorization': `Bearer ${persAccessToken}`
-                }
-            });
-            if (!response.ok) {
-                const errorData = await response.json().catch(() => ({}));
-                throw {
-                    status: response.status,
-                    message: errorData.message || 'Failed to fetch user campaign claims',
-                    error: errorData
-                };
-            }
-            const data = await response.json();
-            return data;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    /**
-     * Gets all available rewards for redemption
-     * @returns Promise with list of available rewards that can be exchanged for points
+     * @param tenantId - Optional tenant ID for automatic initialization
+     * @returns The prepared transaction data
      * @throws If the request fails
      */
-    static async getAvailableRedemptions() {
+    static async fetchPreparedTransaction(transactionId, persAccessToken, tenantId) {
         try {
-            const response = await fetch(`${getPersApiUrl(this.useStaging)}/redemption`, {
-                method: 'GET',
+            // ✅ UPDATED: /transaction/auth/prepare-signing/${transactionId} → /transactions/${transactionId}/prepare
+            const res = await fetch(`${getPersApiUrl(this.useStaging)}/transactions/${transactionId}/prepare`, {
                 headers: {
-                    'accept': 'application/json',
-                    'x-project-key': this.getProjectKey()
-                }
+                    "Content-Type": "application/json",
+                    "x-project-key": await this.getProjectKey(tenantId),
+                    Authorization: `Bearer ${persAccessToken}`,
+                },
             });
-            if (!response.ok) {
-                const errorData = await response.json().catch(() => ({}));
+            const response = await res.json();
+            if (!res.ok) {
+                // Throw structured error with the backend response
                 throw {
-                    status: response.status,
-                    message: errorData.message || 'Failed to fetch available redemptions',
-                    error: errorData
+                    status: res.status,
+                    message: response.message || "Failed to fetch prepared transaction",
+                    error: response
                 };
             }
-            const data = await response.json();
-            return data;
+            return response;
         }
         catch (error) {
-            throw error;
+            // Rethrow a structured error
+            throw {
+                status: error.status || 500,
+                message: error.message || 'Failed to fetch prepared transaction from PERS backend',
+                error
+            };
         }
     }
     /**
@@ -702,7 +552,7 @@ class PersService {
      * @throws If transaction data is not available
      */
     static getTransactionDataForSigning(transactionResponse) {
-        if (!this.isTransactionReadyForSigning(transactionResponse)) {
+        if (!transactionResponse.signingData) {
             throw new Error('Transaction data is not ready for signing');
         }
         return transactionResponse.signingData;
@@ -711,8 +561,53 @@ class PersService {
 PersService.config = DEFAULT_PERS_CONFIG;
 PersService.tenantCache = new Map();
 PersService.currentProjectKey = null;
+PersService.currentTenantId = null;
 PersService.useStaging = false;
+PersService.TENANT_CACHE_TTL = 24 * 60 * 60 * 1000; // 24 hours - tenant configs are essentially static
 
+// Adapter function to convert backend signature response to legacy format
+const adaptSignatureResponse = (newResponse) => {
+    if (!newResponse.signature) {
+        console.error('[KeyWallet] No signature in response:', newResponse);
+        throw new Error('Signature missing from response');
+    }
+    // Handle structured signature format (typically from EIP-712 signing)
+    if (typeof newResponse.signature === 'object' && 'r' in newResponse.signature) {
+        const { r, s, recid } = newResponse.signature;
+        return {
+            status: 'Signed',
+            signature: {
+                r,
+                s,
+                recid // Use recid directly from backend
+            }
+        };
+    }
+    // Handle string signature format (potentially from hash signing)
+    if (typeof newResponse.signature === 'string') {
+        // Parse string signature into components
+        // Assuming it's a hex string that can be split into r, s, v components
+        const signature = newResponse.signature;
+        if (signature.length === 132) { // 0x + 32 bytes r + 32 bytes s + 1 byte v
+            const r = '0x' + signature.slice(2, 66);
+            const s = '0x' + signature.slice(66, 130);
+            const v = parseInt(signature.slice(130, 132), 16);
+            const recid = v >= 27 ? v - 27 : v; // Convert v to recid
+            return {
+                status: 'Signed',
+                signature: {
+                    r,
+                    s,
+                    recid
+                }
+            };
+        }
+        console.error('[KeyWallet] Invalid string signature length:', signature.length);
+        throw new Error(`Invalid string signature format - expected 132 characters, got ${signature.length}`);
+    }
+    console.error('[KeyWallet] Invalid signature format - expected structured object or string:', typeof newResponse.signature);
+    throw new Error('Invalid signature format in response - expected structured object or string from backend');
+};
 let DfnsError$1 = class DfnsError extends Error {
     constructor(code, message, details) {
         super(message);
@@ -731,14 +626,16 @@ const assertSigned = (res) => {
 };
 const combineSignature = (res) => {
     if (!res.signature) {
+        console.error('[KeyWallet] No signature in response for combining:', res);
         throw new DfnsError$1(-1, "signature missing", res);
     }
     const { r, s, recid } = res.signature;
-    return ethers.Signature.from({
+    const ethersSignature = ethers.Signature.from({
         r,
         s,
         v: recid ? 0x1c : 0x1b, // Assuming 0x1c for chain_id > 0, 0x1b otherwise. DFNS usually provides recid.
-    }).serialized;
+    });
+    return ethersSignature.serialized;
 };
 class KeyWallet extends ethers.AbstractSigner {
     constructor(options, provider) {
@@ -764,9 +661,11 @@ class KeyWallet extends ethers.AbstractSigner {
         return this.address;
     }
     async signHash(hash) {
-        const res = await this.signingService.signHash(this.authToken, this.metadata.id, hash);
+        const rawRes = await this.signingService.signHash(this.authToken, this.metadata.id, hash);
+        const res = adaptSignatureResponse(rawRes);
         assertSigned(res);
-        return combineSignature(res);
+        const combinedSignature = combineSignature(res);
+        return combinedSignature;
     }
     async signTransaction(tx) {
         // Resolve any addresses
@@ -803,9 +702,11 @@ class KeyWallet extends ethers.AbstractSigner {
     async signTypedData(domain, types, value) {
         try {
             // Use DFNS native EIP-712 support with correct structure
-            const res = await this.signingService.signTypedData(this.authToken, this.metadata.id, domain, types, value);
+            const rawRes = await this.signingService.signTypedData(this.authToken, this.metadata.id, domain, types, value);
+            const res = adaptSignatureResponse(rawRes);
             assertSigned(res);
-            return combineSignature(res);
+            const combinedSignature = combineSignature(res);
+            return combinedSignature;
         }
         catch (error) {
             console.error('[KeyWallet] EIP-712 signing failed:', error);
@@ -935,27 +836,36 @@ class SigningService {
         const config = getServiceConfig();
         try {
             // Step 1: Initialize signing and get challenge
-            const initResponse = await httpClient.post(`${config.apiUrl}/wallets/signatures/init`, {
-                authToken,
+            const initRequest = {
                 walletId,
-                request,
-                appId: config.appId,
-            });
-            const { requestBody, challenge } = initResponse.data;
+                request
+            };
+            const initResponse = await httpClient.post(`${config.apiUrl}/wallets/signatures/init`, initRequest, { Authorization: `Bearer ${authToken}` });
+            const backendInitResponse = initResponse.data;
+            if (!backendInitResponse.success || !backendInitResponse.data) {
+                console.error('[SigningService] Init response invalid:', backendInitResponse);
+                throw new Error('Signature initialization failed');
+            }
+            const { requestBody, challenge } = backendInitResponse.data;
             // Step 2: Sign the challenge using WebAuthn
             const assertion = await this.webAuthnProvider.sign(challenge);
             // Step 3: Complete signing with signed challenge
-            const completeResponse = await httpClient.post(`${config.apiUrl}/wallets/signatures/complete`, {
-                authToken,
+            const completeRequest = {
                 walletId,
                 requestBody,
                 signedChallenge: {
-                    challengeIdentifier: challenge.challengeIdentifier,
+                    challengeIdentifier: challenge?.challengeIdentifier,
                     firstFactor: assertion,
-                },
-                appId: config.appId,
-            });
-            return completeResponse.data;
+                }
+            };
+            const completeResponse = await httpClient.post(`${config.apiUrl}/wallets/signatures/complete`, completeRequest, { Authorization: `Bearer ${authToken}` });
+            const backendCompleteResponse = completeResponse.data;
+            if (!backendCompleteResponse.success || !backendCompleteResponse.data) {
+                console.error('[SigningService] Complete response invalid:', backendCompleteResponse);
+                throw new Error('Signature completion failed');
+            }
+            // Return the complete signature data from backend response
+            return backendCompleteResponse.data;
         }
         catch (error) {
             console.error(`[SigningService] Signing failed for wallet ${walletId}:`, error);
@@ -1152,8 +1062,8 @@ class TransactionValidator {
         if (!params.authTokens) {
             throw TransactionErrorHandler.createError(exports.TransactionSigningErrorCode.INVALID_TOKENS, 'Authentication tokens are required', params.transactionId);
         }
-        if (!params.authTokens.backendAuthToken || !params.authTokens.persAccessToken) {
-            throw TransactionErrorHandler.createError(exports.TransactionSigningErrorCode.INVALID_TOKENS, 'Both backend and PERS authentication tokens are required', params.transactionId);
+        if (!params.authTokens.signerAuthToken || !params.authTokens.persAccessToken) {
+            throw TransactionErrorHandler.createError(exports.TransactionSigningErrorCode.INVALID_TOKENS, 'Both signer and PERS authentication tokens are required', params.transactionId);
         }
         if (!params.ethersProviderUrl || typeof params.ethersProviderUrl !== 'string') {
             throw TransactionErrorHandler.createError(exports.TransactionSigningErrorCode.INVALID_TOKENS, 'Ethers provider URL is required', params.transactionId);
@@ -1165,81 +1075,18 @@ class TransactionValidator {
      * @returns true if valid, throws error if invalid
      */
     static validateAuthTokens(authTokens) {
-        if (!authTokens.persAccessToken || !authTokens.backendAuthToken) {
-            throw TransactionErrorHandler.createError(exports.TransactionSigningErrorCode.INVALID_TOKENS, 'Both PERS access token and backend auth token are required');
+        if (!authTokens.persAccessToken || !authTokens.signerAuthToken) {
+            throw TransactionErrorHandler.createError(exports.TransactionSigningErrorCode.INVALID_TOKENS, 'Both PERS access token and signer auth token are required');
         }
         return true;
     }
 }
 
-/**
- * Handles transaction submission, success flows, and redirect logic
- */
-class TransactionSubmissionHandler {
-    /**
-     * Create redirect URL with transaction parameters
-     * @param returnUrl - Base return URL
-     * @param transactionHash - Transaction hash to include
-     * @param metadata - Optional metadata to include as parameters
-     * @returns Promise resolving to the complete redirect URL
-     */
-    static async createRedirectUrl(returnUrl, transactionHash, metadata) {
-        const additionalParams = {
-            txHash: transactionHash,
-            success: 'true'
-        };
-        // Add metadata if available
-        if (metadata) {
-            Object.entries(metadata).forEach(([key, value]) => {
-                // metadata is already constrained to string values by TransactionMetadata interface
-                additionalParams[key] = value;
-            });
-        }
-        // Dynamic import to avoid build issues
-        const { createUrlWithSearchParams } = await Promise.resolve().then(function () { return searchParams; });
-        return createUrlWithSearchParams(returnUrl, ['transactionId', 'returnUrl', 'jwt', 'token'], additionalParams);
-    }
-    /**
-     * 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 async handleTransactionSubmission(preparedTransaction, signature, signingData, authTokens, returnUrl, metadata) {
-        // Submit signed transaction
-        const submitResult = await PersService.submitTransaction(preparedTransaction.transaction.id, signature, authTokens.persAccessToken, signingData.format);
-        // Get transaction hash for return URL or response
-        const transactionHash = submitResult.transaction?.transactionHash || '';
-        // Handle success - check for return URL
-        if (returnUrl) {
-            const redirectUrl = await this.createRedirectUrl(returnUrl, transactionHash, metadata);
-            return { submitResult, shouldRedirect: true, redirectUrl };
-        }
-        else {
-            return { submitResult, shouldRedirect: false };
-        }
-    }
-}
-
 /**
  * Utility class for coordinating WebAuthn operations to prevent conflicts
  * Manages global state flags to ensure only one WebAuthn operation runs at a time
  */
 class WebAuthnCoordinator {
-    /**
-     * Clear the landing authentication flag
-     * Used when starting a new transaction signing flow
-     */
-    static clearLandingAuthentication() {
-        if (typeof window !== 'undefined') {
-            window.landingAuthenticationInProgress = false;
-        }
-    }
     /**
      * Check if a WebAuthn operation is currently in progress
      * @returns True if an operation is in progress, false otherwise
@@ -1272,16 +1119,16 @@ const SIGNABLE_STATUSES = [browser.TransactionStatus.PENDING_SIGNATURE, browser.
  * Uses constructor-based dependency injection for WebAuthn provider
  */
 class TransactionSigningService {
-    constructor(webAuthnProvider) {
-        this.webAuthnProvider = webAuthnProvider;
+    constructor(config) {
+        this.webAuthnProvider = config.webAuthnProvider;
     }
     /**
      * Prepare transaction for signing - fetch and validate
      */
-    async prepareTransaction(transactionId, authTokens) {
+    async prepareTransaction(transactionId, authTokens, tenantId) {
         let preparedTransaction;
         try {
-            preparedTransaction = await PersService.fetchPreparedTransaction(transactionId, authTokens.persAccessToken);
+            preparedTransaction = await PersService.fetchPreparedTransaction(transactionId, authTokens.persAccessToken, tenantId);
         }
         catch (err) {
             // Use TransactionErrorHandler to process PERS API errors
@@ -1302,7 +1149,7 @@ class TransactionSigningService {
         // Authenticate with PERS using backend signer token to set up signing account
         let updatedPersAccessToken = authTokens.persAccessToken;
         try {
-            const persSignerAuth = await PersService.authenticateUser(authTokens.backendAuthToken);
+            const persSignerAuth = await PersService.authenticateUser(authTokens.signerAuthToken, tenantId);
             // Update PERS access token with the new one that has signing account linked
             const newPersAccessToken = persSignerAuth.accessToken;
             if (newPersAccessToken) {
@@ -1316,7 +1163,7 @@ class TransactionSigningService {
         }
         // If transaction is 'created' status but doesn't have signingData, fetch again with wallet-enabled token
         if (transactionStatus === browser.TransactionStatus.CREATED && !PersService.isTransactionReadyForSigning(preparedTransaction)) {
-            preparedTransaction = await PersService.fetchPreparedTransaction(transactionId, updatedPersAccessToken);
+            preparedTransaction = await PersService.fetchPreparedTransaction(transactionId, updatedPersAccessToken, tenantId);
         }
         if (!PersService.isTransactionReadyForSigning(preparedTransaction)) {
             throw TransactionErrorHandler.createError(exports.TransactionSigningErrorCode.TRANSACTION_NOT_READY, 'Transaction is not ready for signing', transactionId);
@@ -1331,19 +1178,21 @@ class TransactionSigningService {
      */
     async prepareWallet(authTokens, ethersProviderUrl) {
         // Wallet validation will be handled through API responses - no localStorage needed
-        let walletData;
+        let walletListResult;
         try {
-            walletData = await WalletService.listWallets(authTokens.backendAuthToken);
-            console.log('[TransactionSigningService] Wallet list response:', walletData);
+            // Use new WalletService API with signer token
+            walletListResult = await WalletService.listWallets(authTokens.signerAuthToken);
         }
         catch (error) {
             console.error('[TransactionSigningService] Wallet list API failed:', error);
             throw TransactionErrorHandler.createError(exports.TransactionSigningErrorCode.WALLET_NOT_AVAILABLE, 'Failed to retrieve wallet information. Please refresh the page and try again.', undefined, error);
         }
-        // Check both possible response structures for compatibility
-        const wallets = walletData?.wallets || walletData?.items || [];
+        // Handle multiple response formats for compatibility
+        const wallets = walletListResult?.items ||
+            walletListResult?.data?.wallets ||
+            walletListResult?.wallets || [];
         if (!wallets?.length) {
-            console.error('[TransactionSigningService] No wallets found in response:', walletData);
+            console.error('[TransactionSigningService] No wallets found in response:', walletListResult);
             throw TransactionErrorHandler.createError(exports.TransactionSigningErrorCode.WALLET_NOT_AVAILABLE, 'No wallet found for transaction signing. Please refresh the page and complete account setup.');
         }
         // Create SigningService with injected WebAuthn provider
@@ -1351,7 +1200,7 @@ class TransactionSigningService {
         // Create wallet instance with provider - use unknown type for flexibility
         const provider = new ethers.JsonRpcProvider(ethersProviderUrl);
         const wallet = new KeyWallet({
-            authToken: authTokens.backendAuthToken,
+            authToken: authTokens.signerAuthToken,
             wallet: wallets[0],
             signingService: signingService,
         }).connect(provider);
@@ -1360,7 +1209,9 @@ class TransactionSigningService {
     /**
      * Execute the transaction signing with WebAuthn coordination
      */
-    async executeTransactionSigning(wallet, preparedTransaction) {
+    async executeTransactionSigning(wallet, 
+    // preparedTransaction: TransactionRequestResponseDTO,
+    signingData) {
         // Check for concurrent WebAuthn operations
         if (WebAuthnCoordinator.checkConcurrentOperations()) {
             throw TransactionErrorHandler.createError(exports.TransactionSigningErrorCode.WEBAUTHN_OPERATION_IN_PROGRESS, 'Another WebAuthn operation is in progress. Please wait and try again.');
@@ -1368,7 +1219,7 @@ class TransactionSigningService {
         // Set WebAuthn operation flag for transaction signing
         WebAuthnCoordinator.setOperationInProgress(true);
         try {
-            const signingData = PersService.getTransactionDataForSigning(preparedTransaction);
+            // const signingData = PersService.getTransactionDataForSigning(preparedTransaction);
             const signature = await wallet.signPersTransaction(signingData);
             return signature;
         }
@@ -1387,6 +1238,13 @@ class TransactionSigningService {
             WebAuthnCoordinator.setOperationInProgress(false);
         }
     }
+    async getPersSigningData(data) {
+        // Step 1: Prepare transaction for signing
+        const { preparedTransaction } = await this.prepareTransaction(data.transactionId, data.authTokens, data.tenantId);
+        // const signingData = PersService.getTransactionDataForSigning(preparedTransaction);
+        const signingData = PersService.getTransactionDataForSigning(preparedTransaction);
+        return signingData;
+    }
     /**
      * Main transaction signing orchestration method
      * Handles the complete flow from preparation to submission
@@ -1394,31 +1252,23 @@ class TransactionSigningService {
      * @returns Promise resolving to transaction signing result
      * @throws TransactionSigningError for validation and operation failures
      */
-    async signTransaction(params) {
+    async signTransaction(params, signingData) {
         // Validate input parameters first using TransactionValidator
         TransactionValidator.validateSigningParams(params);
-        const { transactionId, authTokens, ethersProviderUrl, returnUrl, metadata } = params;
+        const { transactionId, authTokens, ethersProviderUrl } = params;
         console.info(`[TransactionSigningService] Starting signature process for ${transactionId}`);
         try {
-            // Clear previous landing authentication state
-            WebAuthnCoordinator.clearLandingAuthentication();
-            // Step 1: Prepare transaction for signing
-            const { preparedTransaction, updatedTokens } = await this.prepareTransaction(transactionId, authTokens);
             // Step 2: Prepare wallet for signing
-            const wallet = await this.prepareWallet(updatedTokens, ethersProviderUrl);
+            const wallet = await this.prepareWallet(authTokens, ethersProviderUrl);
             // Step 3: Execute transaction signing
-            const signature = await this.executeTransactionSigning(wallet, preparedTransaction);
-            const signingData = PersService.getTransactionDataForSigning(preparedTransaction);
-            // Step 4: Submit transaction and handle success using TransactionSubmissionHandler
-            const { submitResult, shouldRedirect, redirectUrl } = await TransactionSubmissionHandler.handleTransactionSubmission(preparedTransaction, signature, signingData, updatedTokens, returnUrl, metadata);
-            console.info(`[TransactionSigningService] Completed successfully: ${transactionId}`);
+            const signature = await this.executeTransactionSigning(wallet, signingData);
+            console.info(`[TransactionSigningService] Completed signing successfully: ${transactionId}`);
             return {
                 success: true,
                 transactionId,
-                transactionHash: submitResult.transaction?.transactionHash ?? undefined,
+                signingData,
+                // transactionHash: submitResult.transaction?.transactionHash ?? undefined,
                 signature,
-                shouldRedirect,
-                redirectUrl
             };
         }
         catch (error) {
@@ -1444,719 +1294,727 @@ class TransactionSigningService {
     }
 }
 
+/**
+ * Handles transaction submission, success flows, and redirect logic
+ */
+class TransactionSubmissionHandler {
+    /**
+     * Create redirect URL with transaction parameters
+     * @param returnUrl - Base return URL
+     * @param transactionHash - Transaction hash to include
+     * @param metadata - Optional metadata to include as parameters
+     * @returns Promise resolving to the complete redirect URL
+     */
+    static async createRedirectUrl(returnUrl, transactionHash) {
+        const additionalParams = {
+            txHash: transactionHash,
+            success: 'true'
+        };
+        // Build URL with required params
+        const paramKeys = ['transactionId', 'returnUrl', 'jwt', 'token'];
+        const url = new URL(returnUrl, window.location.origin);
+        // Add required params if present in additionalParams
+        paramKeys.forEach(key => {
+            if (additionalParams[key]) {
+                url.searchParams.set(key, additionalParams[key]);
+            }
+        });
+        // Add all other params
+        Object.entries(additionalParams).forEach(([key, value]) => {
+            if (!paramKeys.includes(key)) {
+                url.searchParams.set(key, value);
+            }
+        });
+        return url.toString();
+    }
+}
+
 /**
  * Authentication service for user login and registration
  * Uses constructor-based dependency injection for WebAuthn provider
+ * Updated for new v1 API endpoints
  */
 class AuthenticationService {
-    constructor(webAuthnProvider) {
-        this.webAuthnProvider = webAuthnProvider;
+    constructor(config) {
+        this.signerToken = null;
+        this.config = config;
+        this.webAuthnProvider = config.webAuthnProvider;
     }
     /**
-     * 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
      */
-    async login(username) {
+    async loginWithPersToken(persToken) {
         const httpClient = getHttpClient();
         const config = getServiceConfig();
         try {
-            const response = await httpClient.post(`${config.apiUrl}/login`, {
-                username,
-                appId: config.appId,
-            });
-            // Check if the response contains an error
-            if (response.data.status && response.data.status >= 400) {
-                throw new Error(response.data.message || 'Login failed');
-            }
-            if (!response.data.token) {
-                throw new Error(response.data.message || 'No token received from login');
+            const requestBody = {
+                authToken: persToken
+            };
+            const response = await httpClient.post(`${config.apiUrl}/auth/login`, requestBody
+            // Note: Login endpoint doesn't require Authorization header (public endpoint)
+            );
+            const backendResponse = response.data;
+            if (backendResponse && backendResponse.success) {
+                // Check if it's JWT response or wrapped provider response
+                if ('access_token' in backendResponse) {
+                    // JWT response - set token and return
+                    this.signerToken = backendResponse.access_token;
+                    return backendResponse;
+                }
+                else {
+                    // Wrapped provider response - return the data
+                    return backendResponse.data;
+                }
             }
-            console.info(`[WebAuthn] User login successful: ${username}`);
-            return response.data.token;
+            console.error('[AuthenticationService] Invalid response - no success or success=false:', backendResponse);
+            throw new Error('Login failed: Invalid response format');
         }
         catch (error) {
-            console.error(`[AuthenticationService] Login failed for ${username}:`, error);
+            // console.error(`[AuthenticationService] PERS token login failed:`, error);
             throw error;
         }
     }
     /**
-     * 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
      */
-    async register(username) {
+    async verifyToken(token) {
         const httpClient = getHttpClient();
         const config = getServiceConfig();
         try {
-            // Step 1: Initialize registration and get challenge
-            const initResponse = await httpClient.post(`${config.apiUrl}/register/init`, {
-                username,
-                appId: config.appId,
-            });
-            const challenge = initResponse.data;
-            // Check if the registration init failed
-            if (challenge.status && challenge.status >= 400) {
-                throw new Error(challenge.message || 'Registration initialization failed');
-            }
-            // Step 2: Create WebAuthn credential using the challenge
-            const attestation = await this.webAuthnProvider.create(challenge);
-            console.info(`[WebAuthn] Credential created successfully for user: ${username}`);
-            // Step 3: Complete registration with signed challenge
-            const completeResponse = await httpClient.post(`${config.apiUrl}/register/complete`, {
-                signedChallenge: { firstFactorCredential: attestation },
-                temporaryAuthenticationToken: challenge.temporaryAuthenticationToken,
-                appId: config.appId,
-            });
-            const result = completeResponse.data;
-            // Check if the registration completion failed
-            if (result.status && result.status >= 400) {
-                throw new Error(result.message || 'Registration completion failed');
+            const requestBody = {
+                token
+            };
+            const response = await httpClient.post(`${config.apiUrl}/auth/verify`, requestBody, { Authorization: `Bearer ${token}` });
+            const verifyData = response.data;
+            if (!verifyData.valid) {
+                throw new Error('Token verification failed');
             }
-            console.info(`[AuthenticationService] Registration successful for: ${username}`);
-            return result;
+            return verifyData;
         }
         catch (error) {
-            console.error(`[AuthenticationService] Registration failed for ${username}:`, error);
+            console.error(`[AuthenticationService] Token verification failed:`, error);
             throw error;
         }
     }
     /**
-     * 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
      */
-    async validateToken(authToken) {
+    async initializeRegistration(persToken) {
         const httpClient = getHttpClient();
         const config = getServiceConfig();
         try {
-            const response = await httpClient.post(`${config.apiUrl}/validate-token`, {
-                authToken,
-                appId: config.appId,
-            });
-            return response.data.valid === true;
+            const requestBody = {
+                authToken: persToken
+            };
+            const response = await httpClient.post(`${config.apiUrl}/auth/register/init`, requestBody);
+            const backendResponse = response.data;
+            if (backendResponse.success && backendResponse.data) {
+                return backendResponse.data;
+            }
+            throw new Error('Registration initialization failed: No data returned');
         }
         catch (error) {
-            console.error('[AuthenticationService] Error validating token:', error);
-            return false;
+            // console.error(`[AuthenticationService] Registration initialization failed:`, error);
+            throw error;
         }
     }
     /**
-     * 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
+     */
+    getSignerToken() {
+        return this.signerToken;
+    }
+    /**
+     * Set signer token (for external token management)
+     * @param token - Signer JWT token
+     */
+    setSignerToken(token) {
+        this.signerToken = token;
+    }
+    /**
+     * 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
      */
-    async getUser(authToken) {
+    async completeRegistrationWithChallenge(tmpAuthToken, signedChallenge, persToken) {
         const httpClient = getHttpClient();
+        const config = getServiceConfig();
         try {
-            const response = await httpClient.get(`${getServiceConfig().apiUrl}/user`, {
-                'Authorization': `Bearer ${authToken}`
-            });
-            return response.data;
-        }
+            const requestBody = {
+                temporaryAuthenticationToken: tmpAuthToken,
+                signedChallenge: {
+                    firstFactorCredential: {
+                        credentialKind: signedChallenge.credentialKind || "Fido2",
+                        credentialInfo: {
+                            credId: signedChallenge.credentialInfo?.credId || "",
+                            clientData: signedChallenge.credentialInfo?.clientData || "",
+                            attestationData: signedChallenge.credentialInfo?.attestationData || ""
+                        }
+                    }
+                },
+                authToken: persToken
+            };
+            const response = await httpClient.post(`${config.apiUrl}/auth/register/complete`, requestBody);
+            const backendResponse = response.data;
+            if (backendResponse && backendResponse.success) {
+                // Check if it's JWT response (has access_token at root level) or wrapped provider response
+                if ('access_token' in backendResponse) {
+                    // JWT response - set token and return
+                    this.signerToken = backendResponse.access_token;
+                    return backendResponse;
+                }
+                else if ('data' in backendResponse) {
+                    // Wrapped provider response - registration is not complete yet, needs more steps
+                    return backendResponse.data;
+                }
+                else {
+                    // Wrapped provider response - return the data
+                    return backendResponse.data;
+                }
+            }
+            console.error('[AuthenticationService] Registration with challenge failed - invalid response:', backendResponse);
+            throw new Error('Registration completion with challenge failed');
+        }
         catch (error) {
-            console.error('[AuthenticationService] Error getting user:', error);
-            return null;
+            console.error(`[AuthenticationService] Registration completion with challenge failed:`, error);
+            throw error;
         }
     }
-}
-
-/**
- * PERS Blockchain Signer SDK - Simple Orchestrator
- *
- * Lightweight SDK that orchestrates existing services.
- * Uses environment configuration and existing infrastructure.
- */
-/**
- * Main PERS Signer SDK class
- *
- * Simple orchestrator that uses existing services and environment configuration.
- * No complex initialization needed - services are already configured.
- */
-class PersSignerSDK {
-    constructor(config) {
-        this.config = config;
-        this.webAuthnProvider = config.webAuthnProvider;
-        // Set up the configuration provider with stable defaults from constants
-        const serviceConfig = {
-            apiUrl: config.apiUrl || SIGNER_CONFIG.DEFAULT_SIGNER_API_URL,
-            relyingParty: {
-                id: typeof window !== 'undefined' ? window.location.hostname : 'localhost',
-                name: config.relyingPartyName || SIGNER_CONFIG.DEFAULT_RELYING_PARTY_NAME,
-                origin: typeof window !== 'undefined' ? window.location.origin : undefined,
-            },
-        };
-        setConfigProvider(new WebConfigProvider(serviceConfig));
-        // Initialize services with the WebAuthn provider
-        this.authService = new AuthenticationService(this.webAuthnProvider);
-        this.signingService = new SigningService(this.webAuthnProvider);
-        this.transactionSigningService = new TransactionSigningService(this.webAuthnProvider);
-    }
     /**
-     * Re-export TransactionSigningService with WebAuthn provider already injected
-     * This provides the same interface as the original service but with automatic provider injection
+     * 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
      */
-    get TransactionSigningService() {
-        return this.transactionSigningService;
-    }
-    // ========================================================================
-    // HIGH-LEVEL METHODS (Same as Web Project)
-    // ========================================================================
-    /**
-     * Complete user onboarding flow - same as web project
-     * Uses existing AuthenticationService and PersService
-     */
-    async authenticateUser(userInfo) {
-        const identifier = userInfo.identifier;
+    async combinedAuthentication(identifier, persAccessToken) {
         try {
-            // Step 1: Try login first (existing user)
-            let signerAuthToken;
+            // Step 1: Try to login with PERS token first (this will get signer JWT if user exists)
+            let signerToken;
             try {
-                signerAuthToken = await this.authService.login(identifier);
+                const loginResult = await this.loginWithPersToken(persAccessToken);
+                // Extract token from login result
+                if (loginResult && typeof loginResult === 'object' && 'access_token' in loginResult) {
+                    signerToken = loginResult.access_token;
+                }
+                else {
+                    throw new Error('Invalid login response format');
+                }
             }
             catch (loginError) {
-                // User doesn't exist - register new user
-                await this.authService.register(identifier);
-                signerAuthToken = await this.authService.login(identifier);
-            }
-            // Step 2: Authenticate with PERS backend
-            let persAccessToken = '';
-            try {
-                const persResponse = await PersService.authenticateUser(signerAuthToken);
-                persAccessToken = persResponse?.accessToken || '';
-            }
-            catch (persError) {
-                console.warn(`PERS authentication failed:`, persError);
-                // Continue without PERS but provide empty token
-                persAccessToken = '';
+                // Step 2: User doesn't exist - register with v1 API
+                // 2a. Initialize registration  
+                const initResult = await this.initializeRegistration(persAccessToken);
+                let signedChallenge = null;
+                let tmpAuthToken = null;
+                // 2b. Create WebAuthn credential using the challenge (if available)
+                if (initResult && typeof initResult === 'object') {
+                    // Extract challenge and tmpAuthToken from init result with better type safety
+                    const initData = initResult;
+                    const challenge = initData.challenge;
+                    tmpAuthToken = initData.temporaryAuthenticationToken || initData.tmpAuthToken || null;
+                    if (challenge && initData.user) {
+                        // Construct proper WebAuthn credential creation options
+                        const credentialCreationOptions = {
+                            challenge: challenge,
+                            rp: {
+                                name: this.config.relyingPartyName || 'PERS Signer',
+                                id: typeof window !== 'undefined' ? window.location.hostname : 'localhost'
+                            },
+                            user: {
+                                id: initData.user.id,
+                                name: initData.user.name,
+                                displayName: initData.user.displayName
+                            },
+                            pubKeyCredParams: initData.pubKeyCredParams || [
+                                { alg: -7, type: "public-key" },
+                                { alg: -257, type: "public-key" }
+                            ],
+                            authenticatorSelection: initData.authenticatorSelection || {},
+                            attestation: initData.attestation || "direct",
+                            excludeCredentials: initData.excludeCredentials || []
+                        };
+                        signedChallenge = await this.webAuthnProvider.create(credentialCreationOptions);
+                    }
+                    else {
+                        console.warn(`[PersSignerSDK] Missing challenge or user data in init result`);
+                    }
+                }
+                // 2c. Complete registration with proper challenge data - call AuthenticationService directly
+                const completeResult = await this.completeRegistrationWithChallenge(tmpAuthToken, signedChallenge, persAccessToken);
+                // Extract token from registration result
+                if (completeResult && typeof completeResult === 'object') {
+                    // Check if this is a complete JWT response with access_token
+                    if ('access_token' in completeResult) {
+                        signerToken = completeResult.access_token;
+                    }
+                    else {
+                        // This is a wrapped provider response - registration is not complete
+                        // We have user created and wallet created, but need to get JWT token
+                        // For now, throw an error indicating we need additional backend integration steps
+                        throw new Error('Registration created user and wallet but JWT token not provided. Backend integration incomplete.');
+                    }
+                }
+                else {
+                    throw new Error('Registration completed but no response received');
+                }
             }
             return {
                 identifier,
-                signerAuthToken,
+                signerAuthToken: signerToken,
                 persAccessToken
             };
         }
         catch (error) {
-            throw new Error(`User authentication failed: ${error}`);
+            console.error(`[PersSignerSDK] Combined authentication failed for ${identifier}:`, error);
+            throw new Error(`Combined authentication failed: ${error}`);
         }
     }
+}
+
+/**
+ * JWT Utility Functions
+ *
+ * Browser-compatible JWT handling without external dependencies
+ */
+/**
+ * Extract and validate JWT token payload
+ * Uses a browser-compatible approach without external dependencies
+ */
+function extractJWTFromToken(jwtToken) {
+    if (!jwtToken) {
+        return { payload: null, isExpired: false };
+    }
+    try {
+        // Use a more compatible JWT decoding approach
+        // Split JWT into parts
+        const parts = jwtToken.split('.');
+        if (parts.length !== 3) {
+            throw new Error('Invalid JWT format');
+        }
+        // Decode the payload (middle part)
+        const payload = JSON.parse(atob(parts[1]));
+        // Check expiration
+        const isExpired = payload.exp ? Date.now() >= payload.exp * 1000 : false;
+        return { payload, isExpired };
+    }
+    catch (error) {
+        console.warn('JWT decode failed:', error);
+        return { payload: null, isExpired: false };
+    }
+}
+
+/**
+ * In-memory User Cache
+ *
+ * Provides secure, storage-free user authentication caching
+ * Uses memory-only storage with TTL expiration for security
+ */
+/**
+ * In-memory user cache with TTL expiration
+ * Security-first approach - no persistent storage
+ */
+class UserCache {
     /**
-     * Complete PERS transaction signing flow - exactly like web project
-     * Uses existing TransactionSigningService with injected WebAuthn provider
+     * Get cached user by identifier
+     * @param identifier - User identifier (email/userId)
+     * @returns Cached user or null if not found/expired
      */
-    async signPersTransaction(user, transactionId) {
-        if (!user.signerAuthToken) {
-            throw new Error('Signer authentication token required');
-        }
-        if (!user.persAccessToken) {
-            throw new Error('PERS access token required for transaction signing');
-        }
-        try {
-            // Use the existing high-level service with injected WebAuthn provider
-            const result = await this.transactionSigningService.signTransaction({
-                transactionId,
-                authTokens: {
-                    backendAuthToken: user.signerAuthToken,
-                    persAccessToken: user.persAccessToken
-                },
-                ethersProviderUrl: this.config.ethersProviderUrl || 'https://sepolia.infura.io/v3/2781b4b5242343d5b0954c98f287b29e'
-            });
-            return {
-                success: result.success,
-                transactionHash: result.transactionHash,
-                error: result.error
-            };
+    static get(identifier) {
+        const cached = this.cache.get(identifier);
+        if (!cached) {
+            return null;
         }
-        catch (error) {
-            return {
-                success: false,
-                error: `Transaction signing failed: ${error}`
-            };
+        // Check if expired
+        if (Date.now() > cached.expiresAt) {
+            this.cache.delete(identifier);
+            return null;
         }
+        return cached.user;
     }
-    // ========================================================================
-    // GRANULAR METHODS (For Custom Integrations)
-    // ========================================================================
     /**
-     * Register new user - uses existing AuthenticationService
+     * Cache user with TTL
+     * @param identifier - User identifier
+     * @param user - Authenticated user data
+     * @param ttlMs - Time to live in milliseconds (default: 5 minutes)
      */
-    async registerUser(identifier) {
-        try {
-            await this.authService.register(identifier);
-            const authToken = await this.authService.login(identifier);
-            return { authToken };
-        }
-        catch (error) {
-            throw new Error(`User registration failed: ${error}`);
-        }
+    static set(identifier, user, ttlMs = this.DEFAULT_TTL_MS) {
+        this.cache.set(identifier, {
+            user,
+            expiresAt: Date.now() + ttlMs
+        });
     }
     /**
-     * Login existing user - uses existing AuthenticationService
+     * Remove user from cache
+     * @param identifier - User identifier
      */
-    async loginUser(identifier) {
-        try {
-            return await this.authService.login(identifier);
-        }
-        catch (error) {
-            throw new Error(`User login failed: ${error}`);
-        }
+    static delete(identifier) {
+        return this.cache.delete(identifier);
     }
     /**
-     * Add wallet to PERS user - uses existing PersService
+     * Clear all cached users
      */
-    async addWalletToPersUser(signerAuthToken) {
-        try {
-            const persResponse = await PersService.authenticateUser(signerAuthToken);
-            if (!persResponse?.accessToken) {
-                throw new Error('Failed to get PERS access token');
-            }
-            return persResponse.accessToken;
-        }
-        catch (error) {
-            throw new Error(`Failed to add wallet to PERS user: ${error}`);
-        }
+    static clear() {
+        this.cache.clear();
     }
     /**
-     * Retrieve transaction data from PERS - uses existing PersService
+     * Get cache size (for debugging)
      */
-    async retrieveTransactionData(transactionId, persAccessToken) {
-        try {
-            return await PersService.fetchPreparedTransaction(transactionId, persAccessToken);
-        }
-        catch (error) {
-            // Preserve original error structure for proper error handling
-            throw error;
-        }
+    static size() {
+        return this.cache.size;
     }
     /**
-     * Sign transaction data - uses existing SigningService
-     * Follows same patterns as KeyWallet.signPersTransaction
+     * Clean up expired entries
      */
-    async signTransactionData(signerAuthToken, signingData) {
-        try {
-            const wallets = await WalletService.listWallets(signerAuthToken);
-            if (!wallets.items || wallets.items.length === 0) {
-                throw new Error('No wallet found for user');
-            }
-            const walletId = wallets.items[0].id;
-            // Sign based on transaction format - same pattern as KeyWallet
-            switch (signingData.format) {
-                case browser.TRANSACTION_FORMATS.EIP_712: {
-                    const eip712Data = signingData;
-                    const typedData = eip712Data.typedData;
-                    // Sign using same pattern as KeyWallet
-                    const signResponse = await this.signingService.signTypedData(signerAuthToken, walletId, typedData.domain, { Transaction: typedData.types.Transaction }, typedData.message);
-                    return `${signResponse.signature?.r}${signResponse.signature?.s}`;
-                }
-                default: {
-                    // For legacy and other formats, use raw signing data
-                    const signResponse = await this.signingService.signHash(signerAuthToken, walletId, JSON.stringify(signingData));
-                    return `${signResponse.signature?.r}${signResponse.signature?.s}`;
-                }
+    static cleanup() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [identifier, cached] of this.cache.entries()) {
+            if (now > cached.expiresAt) {
+                this.cache.delete(identifier);
+                cleaned++;
             }
         }
-        catch (error) {
-            throw new Error(`Transaction signing failed: ${error}`);
-        }
+        return cleaned;
     }
+}
+UserCache.cache = new Map();
+UserCache.DEFAULT_TTL_MS = 300000; // 5 minutes
+
+/**
+ * PERS Blockchain Signer SDK
+ *
+ * A lightweight blockchain transaction signing SDK with WebAuthn authentication.
+ * Provides 5 focused methods for complete transaction lifecycle management:
+ *
+ * 1. loginUser(jwtToken) - Authenticate user with 5-minute caching
+ * 2. signTransaction(signingData, jwtToken) - Sign transactions with auto-login
+ * 3. submitTransaction(signedTx, jwtToken) - Submit signed transactions to blockchain
+ * 4. signPersTransaction(jwtToken) - Legacy one-liner for backward compatibility
+ * 5. signAndSubmitPersTransaction(jwtToken) - Complete sign + submit flow
+ *
+ * @example
+ * ```typescript
+ * import { createPersSignerSDK } from '@explorins/pers-signer';
+ *
+ * const sdk = createPersSignerSDK({
+ *   webAuthnProvider: myWebAuthnProvider,
+ *   ethersProviderUrl: 'https://ethereum-rpc.com'
+ * });
+ *
+ * // Quick sign and submit
+ * const result = await sdk.signAndSubmitPersTransaction(jwtToken);
+ * if (result.success) {
+ *   console.log('Transaction submitted:', result.transactionHash);
+ * }
+ * ```
+ */
+/**
+ * PERS Blockchain Signer SDK Class
+ *
+ * Main SDK class providing blockchain transaction signing capabilities with WebAuthn authentication.
+ * Implements a clean 5-method API for complete transaction lifecycle management.
+ *
+ * Features:
+ * - WebAuthn-based secure authentication
+ * - 5-minute user session caching
+ * - Automatic transaction data fetching
+ * - Blockchain transaction signing and submission
+ * - Multi-tenant support
+ *
+ * @class PersSignerSDK
+ */
+class PersSignerSDK {
     /**
-     * Submit signed transaction to PERS - uses existing PersService
+     * Initialize the PERS Signer SDK
+     *
+     * @param {ExtendedPersSignerConfig} config - SDK configuration object
+     * @throws {Error} If required configuration is missing
      */
-    async submitTransaction(transactionId, signature, persAccessToken, transactionFormat = browser.TRANSACTION_FORMATS.EIP_712) {
-        try {
-            const submitResult = await PersService.submitTransaction(transactionId, signature, persAccessToken, transactionFormat);
-            return {
-                transactionHash: submitResult.transaction?.transactionHash || undefined,
-                success: true
-            };
-        }
-        catch (error) {
-            throw new Error(`Transaction submission failed: ${error}`);
-        }
+    constructor(config) {
+        this.config = config;
+        setConfigProvider(new WebConfigProvider({
+            apiUrl: config.apiUrl || SIGNER_CONFIG.DEFAULT_SIGNER_API_URL,
+            relyingParty: {
+                id: typeof window !== 'undefined' ? window.location.hostname : 'localhost',
+                name: config.relyingPartyName || SIGNER_CONFIG.DEFAULT_RELYING_PARTY_NAME,
+                origin: typeof window !== 'undefined' ? window.location.origin : undefined,
+            },
+        }));
+        this.authenticationService = new AuthenticationService(this.config);
+        this.transactionSigningService = new TransactionSigningService(config);
     }
     /**
-     * Check if user exists - uses existing AuthenticationService
+     * 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);
+     * }
+     * ```
      */
-    async checkUserExists(identifier) {
-        try {
-            await this.authService.login(identifier);
-            return true;
+    async loginUser(jwtToken) {
+        if (!jwtToken || typeof jwtToken !== 'string') {
+            throw new Error('JWT token is required and must be a string');
         }
-        catch {
-            return false;
+        const { payload, isExpired } = extractJWTFromToken(jwtToken);
+        if (!payload || isExpired) {
+            throw new Error('Invalid or expired JWT token');
         }
-    }
-    /**
-     * Get user wallets - uses existing WalletService
-     */
-    async getUserWallets(signerAuthToken) {
-        try {
-            return await WalletService.listWallets(signerAuthToken);
+        const identifier = payload.identifierEmail || payload.email || payload.userId;
+        const tenantId = payload.tenantId || '';
+        if (!identifier) {
+            throw new Error('JWT token missing user identifier (identifierEmail, email, or userId)');
         }
-        catch (error) {
-            throw new Error(`Failed to get user wallets: ${error}`);
+        // Check cache first
+        const cachedUser = UserCache.get(identifier);
+        if (cachedUser && cachedUser.tenantId === tenantId && Date.now() < cachedUser.expiresAt) {
+            return cachedUser;
         }
-    }
-    /**
-     * Get transaction status - uses existing PersService
-     */
-    async getTransactionStatus(transactionId, persAccessToken) {
         try {
-            const transaction = await PersService.fetchPreparedTransaction(transactionId, persAccessToken);
-            return {
-                status: transaction.transactionStatus,
-                transactionHash: transaction.transaction?.transactionHash || undefined
+            // Authenticate and cache
+            const authResult = await this.authenticationService.combinedAuthentication(identifier, jwtToken);
+            const user = {
+                identifier: authResult.identifier,
+                signerAuthToken: authResult.signerAuthToken,
+                persAccessToken: authResult.persAccessToken,
+                tenantId,
+                expiresAt: Date.now() + 300000 // 5 minutes
             };
+            UserCache.set(identifier, user);
+            return user;
         }
         catch (error) {
-            throw new Error(`Failed to get transaction status: ${error}`);
+            throw new Error(`Authentication failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
     /**
-     * Initialize tenant - uses existing PersService
-     */
-    async initializeTenant(tenantId) {
-        await PersService.initializeTenant(tenantId);
-    }
-    // ========================================================================
-    // JWT AUTHENTICATION METHODS (For Legacy PERS Flow)
-    // ========================================================================
-    /**
-     * Extract and validate JWT token from URL search parameters
-     * Uses a simpler approach compatible with browser environments
+     * 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);
+     * }
+     * ```
      */
-    extractJWTFromURL(searchParams) {
-        const jwtToken = searchParams.get('jwt') || searchParams.get('token');
-        if (!jwtToken) {
-            return { payload: null, isExpired: false };
-        }
+    async signPersTransaction(jwtToken) {
+        if (!jwtToken || typeof jwtToken !== 'string') {
+            throw new Error('JWT token is required and must be a string');
+        }
+        const user = await this.loginUser(jwtToken);
+        const { payload } = extractJWTFromToken(jwtToken);
+        if (!payload?.transactionId) {
+            throw new Error('JWT token missing transactionId in payload');
+        }
+        const authTokens = {
+            signerAuthToken: user.signerAuthToken,
+            persAccessToken: user.persAccessToken
+        };
         try {
-            // Use a more compatible JWT decoding approach
-            // Split JWT into parts
-            const parts = jwtToken.split('.');
-            if (parts.length !== 3) {
-                throw new Error('Invalid JWT format');
+            const persSigningData = await this.transactionSigningService.getPersSigningData({
+                transactionId: payload.transactionId,
+                authTokens,
+                tenantId: user.tenantId
+            });
+            const result = await this.signTransaction(persSigningData, jwtToken);
+            if (!result.success) {
+                throw new Error(result.error || 'Transaction signing failed');
             }
-            // Decode the payload (middle part)
-            const payload = JSON.parse(atob(parts[1]));
-            // Check expiration
-            const isExpired = payload.exp ? Date.now() >= payload.exp * 1000 : false;
-            return { payload, isExpired };
+            return result;
         }
         catch (error) {
-            console.warn('JWT decode failed:', error);
-            return { payload: null, isExpired: false };
+            throw new Error(`PERS transaction signing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
     /**
-     * Initialize tenant from JWT payload using existing PersService
+     * 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);
+     * ```
      */
-    async initializeTenantFromJWT(payload) {
-        if (!payload.tenantId) {
-            return 'default';
+    async signTransaction(signingData, jwtToken) {
+        if (!signingData) {
+            throw new Error('Signing data is required');
+        }
+        if (!jwtToken || typeof jwtToken !== 'string') {
+            throw new Error('JWT token is required and must be a string');
+        }
+        const user = await this.loginUser(jwtToken);
+        const { payload } = extractJWTFromToken(jwtToken);
+        if (!payload?.transactionId) {
+            throw new Error('JWT token missing transactionId in payload');
         }
+        const authTokens = {
+            signerAuthToken: user.signerAuthToken,
+            persAccessToken: user.persAccessToken
+        };
         try {
-            // Use existing PersService.initializeTenant method
-            const tenantData = await PersService.initializeTenant(payload.tenantId);
-            // Extract project key from tenant data
-            const projectKey = tenantData.projectKey ||
-                tenantData.projectApiKey ||
-                tenantData.apiKey ||
-                payload.tenantId;
-            return projectKey;
+            const result = await this.transactionSigningService.signTransaction({
+                transactionId: payload.transactionId,
+                tenantId: user.tenantId,
+                authTokens,
+                ethersProviderUrl: this.config.ethersProviderUrl || ''
+            }, signingData);
+            return result;
         }
         catch (error) {
-            console.warn('Tenant initialization failed:', error);
-            return payload.tenantId;
+            throw new Error(`Transaction signing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
     /**
-     * Authenticate user with PERS API using existing PersService pattern
-     */
-    /**
-     * Authenticate user with PERS API using existing PersService
+     * 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);
+     * }
+     * ```
      */
-    async authenticatePersUser(jwtToken, projectKey) {
+    async signAndSubmitPersTransaction(jwtToken) {
+        if (!jwtToken || typeof jwtToken !== 'string') {
+            throw new Error('JWT token is required and must be a string');
+        }
         try {
-            // Configure PersService with the project key from tenant initialization
-            PersService.configure({ projectKey });
-            // Use the existing PersService method which handles all the complexity
-            const result = await PersService.authenticateUser(jwtToken);
-            // Convert to expected PersAuthResult format
-            return {
-                user: {
-                    email: result.user?.email || undefined,
-                    id: result.user?.id || undefined
-                },
-                accessToken: result.accessToken
-            };
+            const signedTx = await this.signPersTransaction(jwtToken);
+            const submittedTx = await this.submitTransaction(signedTx, jwtToken);
+            return submittedTx;
         }
         catch (error) {
-            throw new Error(`PERS authentication failed: ${error}`);
+            throw new Error(`Sign and submit transaction failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
     /**
-     * Combined PERS + DFNS authentication flow
+     * 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);
+     * ```
      */
-    async combinedAuthentication(identifier, persAccessToken) {
+    async submitTransaction(signingResult, jwtToken) {
+        if (!signingResult) {
+            throw new Error('Signing result is required');
+        }
+        if (!jwtToken || typeof jwtToken !== 'string') {
+            throw new Error('JWT token is required and must be a string');
+        }
+        if (!signingResult.success || !signingResult.signature || !signingResult.signingData) {
+            throw new Error('Invalid signing result: must be successful with signature and signing data');
+        }
+        const { payload } = extractJWTFromToken(jwtToken);
+        if (!payload?.tenantId) {
+            throw new Error('JWT token missing tenantId in payload');
+        }
+        const user = await this.loginUser(jwtToken);
         try {
-            // Authenticate with DFNS - try login first, register if user doesn't exist
-            let signerAuthToken;
-            try {
-                signerAuthToken = await this.loginUser(identifier);
-            }
-            catch (loginError) {
-                console.log(`[PersSignerSDK] User not found, registering new user: ${identifier}`);
-                // User doesn't exist - register new user (registerUser already includes login)
-                const registrationResult = await this.registerUser(identifier);
-                signerAuthToken = registrationResult.authToken;
-            }
+            const submitResult = await PersService.submitTransaction(signingResult.transactionId, signingResult.signature, user.persAccessToken, signingResult.signingData.format, payload.tenantId);
+            // Transform response to SubmissionResult
             return {
-                identifier,
-                signerAuthToken,
-                persAccessToken
+                success: true,
+                transactionHash: submitResult.transaction.transactionHash,
+                shouldRedirect: false, // Can be configured based on business requirements
+                redirectUrl: undefined, // Can be set based on business logic
+                error: undefined,
+                submitResult: submitResult
             };
         }
         catch (error) {
-            throw new Error(`Combined authentication failed: ${error}`);
+            throw new Error(`Transaction submission failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
     /**
-     * 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');
+     * ```
      */
-    async authenticateWithJWT(searchParams) {
-        // 1. Extract JWT from URL
-        const { payload, isExpired } = this.extractJWTFromURL(searchParams);
-        if (!payload) {
-            // Return null instead of throwing error to allow graceful handling
-            return null;
-        }
-        if (isExpired) {
-            return {
-                user: {
-                    identifier: payload.email || payload.userId || 'unknown',
-                    signerAuthToken: '',
-                    persAccessToken: ''
-                },
-                isExpired: true
-            };
-        }
-        // 2. Initialize tenant and get project key
-        const projectKey = await this.initializeTenantFromJWT(payload);
-        // 3. Get JWT token from URL
-        const jwtToken = searchParams.get('jwt') || searchParams.get('token');
-        if (!jwtToken) {
-            throw new Error('JWT token not found in URL parameters');
-        }
-        // 4. Authenticate with PERS
-        const persResult = await this.authenticatePersUser(jwtToken, projectKey);
-        // 5. Get identifier for DFNS authentication
-        const identifier = persResult.user.email || persResult.user.id;
-        if (!identifier) {
-            throw new Error('No identifier found in PERS response');
-        }
-        // 6. Combined authentication
-        const user = await this.combinedAuthentication(identifier, persResult.accessToken);
-        return {
-            user,
-            isExpired: false
-        };
-    }
-}
-
-/**
- * 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
- */
-function createSearchString(paramsToExclude = [], paramsToAdd = {}, baseParams) {
-    // Get base search params from the provided value or window location
-    const currentParams = new URLSearchParams(baseParams instanceof URLSearchParams
-        ? baseParams
-        : baseParams !== undefined
-            ? baseParams
-            : (typeof window !== 'undefined' ? window.location.search : ''));
-    // Remove excluded parameters
-    paramsToExclude.forEach(param => {
-        if (currentParams.has(param)) {
-            currentParams.delete(param);
-        }
-    });
-    // Add or update new parameters
-    Object.entries(paramsToAdd).forEach(([key, value]) => {
-        if (value !== undefined && value !== null) {
-            currentParams.set(key, value);
-        }
-    });
-    const searchString = currentParams.toString();
-    return searchString ? `?${searchString}` : '';
-}
-/**
- * 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
- */
-function createUrlWithSearchParams(basePath, paramsToExclude = [], paramsToAdd = {}, baseParams) {
-    const searchString = createSearchString(paramsToExclude, paramsToAdd, baseParams);
-    return `${basePath}${searchString}`;
-}
-/**
- * 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
- */
-function mergeSearchParams(searchParams, additionalParams = {}) {
-    const merged = new URLSearchParams(searchParams.toString());
-    Object.entries(additionalParams).forEach(([key, value]) => {
-        if (value !== undefined && value !== null) {
-            merged.set(key, value);
-        }
-    });
-    return merged;
-}
-/**
- * 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
- */
-function getSearchParam(key, search) {
-    const params = new URLSearchParams(search || (typeof window !== 'undefined' ? window.location.search : ''));
-    return params.get(key);
-}
-/**
- * Gets all search parameters as a URLSearchParams object
- * @param search Optional search string to parse (defaults to window.location.search)
- * @returns A URLSearchParams object
- */
-function getAllSearchParams(search) {
-    return new URLSearchParams(search || (typeof window !== 'undefined' ? window.location.search : ''));
-}
-/**
- * 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
- */
-function removeSearchParam(key, search) {
-    const params = new URLSearchParams(search || (typeof window !== 'undefined' ? window.location.search : ''));
-    params.delete(key);
-    const searchString = params.toString();
-    return searchString ? `?${searchString}` : '';
-}
-/**
- * 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
- */
-function updateSearchParam(key, value, search) {
-    const params = new URLSearchParams(search || (typeof window !== 'undefined' ? window.location.search : ''));
-    params.set(key, value);
-    const searchString = params.toString();
-    return searchString ? `?${searchString}` : '';
-}
-
-var searchParams = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    createSearchString: createSearchString,
-    createUrlWithSearchParams: createUrlWithSearchParams,
-    getAllSearchParams: getAllSearchParams,
-    getSearchParam: getSearchParam,
-    mergeSearchParams: mergeSearchParams,
-    removeSearchParam: removeSearchParam,
-    updateSearchParam: updateSearchParam
-});
-
-/**
- * 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
- */
-function logSearchParams(message, additionalData) {
-    if (process.env.NODE_ENV !== 'production') {
-        // Check if window exists (for SSR compatibility)
-        if (typeof window === 'undefined') {
-            return;
-        }
-        const searchParams = new URLSearchParams(window.location.search);
-        searchParams.forEach((value, key) => {
-        });
-        console.group(`🔍 Search Params: ${message}`);
-        console.groupEnd();
+    clearCache() {
+        UserCache.clear();
     }
 }
-/**
- * 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)
- */
-function createSearchParamLogger(componentName) {
-    return () => {
-        logSearchParams(`${componentName} rendered`);
-    };
-}
-
-/**
- * Generates a RFC4122 version 4 compliant UUID
- * @returns A randomly generated UUID
- */
-function generateUUID() {
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-        const r = Math.random() * 16 | 0;
-        const v = c === 'x' ? r : (r & 0x3 | 0x8);
-        return v.toString(16);
-    });
-}
-/**
- * Create a semi-anonymous username for users
- * @returns A username in the format "user_[random string]"
- */
-function generateAnonymousUsername() {
-    const randomPart = Math.random().toString(36).substring(2, 10);
-    return `user_${randomPart}`;
-}
-/**
- * Create a guest username for the application with a random prefix
- * @returns A guest email in the format "randomstring_guest@explorins.com"
- */
-function generateGuestUsername() {
-    const randomPart = Math.random().toString(36).substring(2, 8); // 6 character random string
-    return `${randomPart}_guest@explorins.com`;
-}
-
-/**
- * Utility functions for tenant-specific operations
- */
-/**
- * Initialize tenant-specific analytics
- * @param tenantId The tenant ID
- * @param getTenantConfig Function to retrieve tenant configuration
- */
-const initTenantAnalytics = (tenantId, getTenantConfig) => {
-    const tenant = getTenantConfig(tenantId);
-    if (!tenant) {
-        console.warn(`Tenant ${tenantId} not found`);
-        return;
-    }
-    if (tenant.analytics && tenant.analytics.enabled && tenant.analytics.trackingId) ;
-};
 
 /**
  * Browser-specific WebAuthn provider using DFNS browser SDK
@@ -2211,20 +2069,6 @@ async function getBrowserWebAuthnProvider() {
  * Includes only browser-compatible dependencies
  */
 // Re-export all shared functionality
-/**
- * Create a new AuthenticationService instance with browser WebAuthn provider
- */
-async function createAuthenticationService() {
-    const webAuthnProvider = await getBrowserWebAuthnProvider();
-    return new AuthenticationService(webAuthnProvider);
-}
-/**
- * Create a new SigningService instance with browser WebAuthn provider
- */
-async function createSigningService() {
-    const webAuthnProvider = await getBrowserWebAuthnProvider();
-    return new SigningService(webAuthnProvider);
-}
 /**
  * Create a new PersSignerSDK instance with browser WebAuthn provider
  * @param config - SDK configuration (ethersProviderUrl is required)
@@ -11472,27 +11316,12 @@ exports.TransactionValidator = TransactionValidator;
 exports.WalletService = WalletService;
 exports.WebAuthnCoordinator = WebAuthnCoordinator;
 exports.WebConfigProvider = WebConfigProvider;
-exports.createAuthenticationService = createAuthenticationService;
 exports.createPersSignerSDK = createPersSignerSDK;
-exports.createSearchParamLogger = createSearchParamLogger;
-exports.createSearchString = createSearchString;
-exports.createSigningService = createSigningService;
-exports.createUrlWithSearchParams = createUrlWithSearchParams;
-exports.generateAnonymousUsername = generateAnonymousUsername;
-exports.generateGuestUsername = generateGuestUsername;
-exports.generateUUID = generateUUID;
-exports.getAllSearchParams = getAllSearchParams;
 exports.getBrowserWebAuthnProvider = getBrowserWebAuthnProvider;
 exports.getConfigProvider = getConfigProvider;
 exports.getHttpClient = getHttpClient;
-exports.getSearchParam = getSearchParam;
 exports.getServiceConfig = getServiceConfig;
 exports.getWebAuthnProvider = getBrowserWebAuthnProvider;
-exports.initTenantAnalytics = initTenantAnalytics;
-exports.logSearchParams = logSearchParams;
-exports.mergeSearchParams = mergeSearchParams;
-exports.removeSearchParam = removeSearchParam;
 exports.setConfigProvider = setConfigProvider;
 exports.setHttpClient = setHttpClient;
-exports.updateSearchParam = updateSearchParam;
 //# sourceMappingURL=browser.cjs.js.map