signer-test-sdk-core 0.0.1

package/dist/src/core/AuthManager.js

@@ -0,0 +1,685 @@
+import { STORAGE_KEYS, TURNKEY_CONFIG, TURNKEY_ENDPOINTS } from '../utils/constants';
+import { AuthenticationError } from '../utils/errors';
+import { generateChallenge, createPasskeyCredential, generateAuthenticatorName, generateUserName, generateOrganizationName, } from '../utils/passkey';
+import { WebauthnStamper } from '@turnkey/webauthn-stamper';
+import { TurnkeyClient } from '@turnkey/http';
+export class AuthManager {
+    constructor(apiService, turnkeyService, tokenService, storage) {
+        this.apiService = apiService;
+        this.turnkeyService = turnkeyService;
+        this.tokenService = tokenService;
+        this.storage = storage;
+        this.currentUser = null;
+        this.whoamiPromise = null;
+    }
+    /**
+     * Initialize OTP authentication
+     */
+    async loginWithOTP(email) {
+        // Clear previous IndexedDB data and reset TurnkeyService before starting new login
+        await this.turnkeyService.reset();
+        // Initialize storage if not already initialized
+        await this.turnkeyService.init();
+        // Get public key from storage (internal - users don't see this)
+        const publicKey = await this.turnkeyService.getPublicKey();
+        if (!publicKey) {
+            throw new AuthenticationError('Failed to get public key from storage');
+        }
+        // Initialize OTP with backend
+        const response = await this.apiService.initOtp(email);
+        return { otpId: response.otpId };
+    }
+    /**
+     * Verify OTP and complete authentication
+     */
+    async verifyOTP(otpId, otpCode) {
+        // Clear previous IndexedDB data and reset TurnkeyService before verifying OTP
+        await this.turnkeyService.reset();
+        // Ensure storage is initialized
+        await this.turnkeyService.init();
+        // Get public key from storage (internal)
+        const publicKey = await this.turnkeyService.getPublicKey();
+        if (!publicKey) {
+            throw new AuthenticationError('Failed to get public key from storage');
+        }
+        try {
+            // Verify OTP with backend
+            const response = await this.apiService.verifyOtp(otpId, otpCode, publicKey);
+            if (!response.result?.user) {
+                throw new AuthenticationError('Failed to get user information');
+            }
+            // Set user in memory (not storing to storage)
+            this.currentUser = response.result.user;
+            // Store user in storage
+            await this.storage.setItem(STORAGE_KEYS.USER, this.currentUser);
+            // Handle whoami call based on isPolicy
+            // If isPolicy is true, ONLY call whoami (do NOT call PROXY)
+            // If isPolicy is false, call PROXY first, then whoami
+            const isPolicy = Boolean(this.currentUser.isPolicy);
+            if (isPolicy) {
+                // If isPolicy is true, call whoami directly (NO PROXY call)
+                try {
+                    await this.callWhoami();
+                }
+                catch (error) {
+                    // Log error but don't fail the verification if whoami call fails
+                    console.warn('Whoami call after OTP verification failed:', error);
+                }
+            }
+            else {
+                // If isPolicy is false, call PROXY first, then whoami
+                try {
+                    await this.callProxyAfterVerification('otp');
+                    // Call whoami after PROXY succeeds
+                    await this.callWhoami();
+                }
+                catch (error) {
+                    // Log error but don't fail the verification if PROXY or whoami call fails
+                    console.warn('PROXY or whoami call after OTP verification failed:', error);
+                }
+            }
+            return this.currentUser;
+        }
+        catch (error) {
+            // If verify OTP API fails (e.g., duplicate public key error), reset IndexedDB
+            // This allows the user to retry with a fresh key
+            try {
+                await this.turnkeyService.reset();
+            }
+            catch (resetError) {
+                // Log reset error but don't fail - we still want to throw the original error
+                console.warn('Failed to reset IndexedDB after verify error:', resetError);
+            }
+            // Re-throw the original error
+            throw error;
+        }
+    }
+    /**
+     * Call PROXY endpoint after successful authentication
+     * This is called internally after user is authenticated
+     * Calls Turnkey create_policy endpoint via PROXY
+     * @param authMethod - 'otp' for OTP login, 'google' for Google OAuth login
+     */
+    async callProxyAfterVerification(authMethod = 'otp') {
+        if (!this.currentUser?.subOrganizationId) {
+            return;
+        }
+        // Different policies for OTP vs OAuth login
+        const isOauth = authMethod !== 'otp';
+        const policyConfig = isOauth
+            ? {
+                policyName: 'Allow user to verify OTP',
+                effect: 'EFFECT_ALLOW',
+                condition: 'activity.resource in [\'AUTH\', \'OAUTH\'] && activity.action in [\'CREATE\',\'VERIFY\']',
+                consensus: 'true',
+                notes: 'Allow user to verify OTP',
+            }
+            : {
+                policyName: 'Allow user to verify OTP',
+                effect: 'EFFECT_ALLOW',
+                condition: 'activity.resource in [\'AUTH\', \'OTP\'] && activity.action in [\'CREATE\',\'VERIFY\']',
+                consensus: 'true',
+                notes: 'Allow user to verify OTP',
+            };
+        // Create request body for PROXY call (matching Turnkey stampCreatePolicy format)
+        const body = JSON.stringify({
+            timestampMs: new Date().getTime().toString(),
+            organizationId: this.currentUser.subOrganizationId,
+            parameters: policyConfig,
+            type: 'ACTIVITY_TYPE_CREATE_POLICY_V3',
+        });
+        // Create stamp for the request
+        const stamp = await this.turnkeyService.createStamp(body);
+        // Call PROXY endpoint to proxy the request to Turnkey
+        const turnkeyUrl = `${TURNKEY_CONFIG.BASE_URL}${TURNKEY_ENDPOINTS.CREATE_POLICY}`;
+        await this.apiService.callProxy(turnkeyUrl, 'POST', body, stamp);
+    }
+    /**
+     * Login with Google OAuth
+     */
+    async loginWithGoogle() {
+        // Initialize storage
+        await this.turnkeyService.init();
+        // Get public key from storage (internal) - force refresh to ensure we get latest from IndexedDB
+        // This is important in case user deleted keys from IndexedDB without reloading
+        const publicKey = await this.turnkeyService.getPublicKey(true);
+        const originUrl = window.location.href;
+        if (!publicKey) {
+            throw new AuthenticationError('Failed to get public key from storage');
+        }
+        // Redirect to Google OAuth
+        const authUrl = this.apiService.getGoogleAuthUrl(publicKey, originUrl);
+        window.location.href = authUrl;
+    }
+    /**
+     * Login with Discord OAuth
+     */
+    async loginWithDiscord() {
+        await this.turnkeyService.init();
+        // Force refresh to ensure we get latest public key from IndexedDB
+        const publicKey = await this.turnkeyService.getPublicKey(true);
+        const originUrl = window.location.href;
+        if (!publicKey) {
+            throw new AuthenticationError('Failed to get public key from storage');
+        }
+        const authUrl = this.apiService.getDiscordAuthUrl(publicKey, originUrl);
+        window.location.href = authUrl;
+    }
+    /**
+     * Login with X (Twitter) OAuth
+     */
+    async loginWithTwitter() {
+        await this.turnkeyService.init();
+        // Force refresh to ensure we get latest public key from IndexedDB
+        const publicKey = await this.turnkeyService.getPublicKey(true);
+        const originUrl = window.location.href;
+        if (!publicKey) {
+            throw new AuthenticationError('Failed to get public key from storage');
+        }
+        const authUrl = this.apiService.getTwitterAuthUrl(publicKey, originUrl);
+        window.location.href = authUrl;
+    }
+    /**
+     * Handle Google OAuth callback
+     * This is called when user returns from Google OAuth
+     * Calls the backend API to get accessToken, refreshToken, and user data
+     */
+    async handleGoogleCallback() {
+        // Initialize storage WITHOUT resetting - this ensures we use the same public key
+        // that was used during loginWithGoogle()
+        // Turnkey's IndexedDbStamper will automatically reuse existing keys from IndexedDB
+        await this.turnkeyService.init();
+        const params = new URLSearchParams(window.location.search);
+        // Check for errors in URL
+        if (params.get('error')) {
+            throw new AuthenticationError(params.get('error') || 'Google authentication failed');
+        }
+        // Extract code and state from URL (standard OAuth flow)
+        const code = params.get('code');
+        const state = params.get('state');
+        // Fallback: Check if tokens are in URL params (legacy flow)
+        const accessToken = params.get('accessToken');
+        const refreshToken = params.get('refreshToken');
+        const userJson = params.get('user');
+        // If code and state are present, call the API endpoint
+        if (code && state) {
+            try {
+                const result = await this.apiService.handleGoogleCallback(code, state);
+                // Store user
+                this.currentUser = result.user;
+                await this.storage.setItem(STORAGE_KEYS.USER, result.user);
+                // Tokens are already stored by ApiService.handleGoogleCallback
+                // Now call whoami API to get user details and store the response
+                // whoami MUST succeed for the login to be considered successful
+                await this.callWhoami();
+                // After whoami succeeds, check if isPolicy is false and call PROXY if needed
+                const isPolicy = Boolean(this.currentUser.isPolicy);
+                if (!isPolicy) {
+                    try {
+                        await this.callProxyAfterVerification('google');
+                    }
+                    catch (proxyError) {
+                        // Log error but don't fail the login if PROXY call fails
+                        console.warn('PROXY call after Google login failed:', proxyError);
+                    }
+                }
+                // Verify whoami response exists before returning user
+                const whoamiResponse = await this.getWhoami();
+                if (!whoamiResponse) {
+                    throw new AuthenticationError('Whoami response not available after successful call');
+                }
+                return result.user;
+            }
+            catch (error) {
+                throw new AuthenticationError(error instanceof Error ? error.message : 'Failed to handle Google callback');
+            }
+        }
+        // Legacy flow: tokens in URL params
+        if (accessToken && refreshToken && userJson) {
+            // Store tokens
+            await this.tokenService.setTokens({ accessToken, refreshToken });
+            // Parse and store user
+            try {
+                const user = JSON.parse(userJson);
+                this.currentUser = user;
+                await this.storage.setItem(STORAGE_KEYS.USER, user);
+                // Call whoami API to get user details and store the response
+                // whoami MUST succeed for the login to be considered successful
+                await this.callWhoami();
+                // After whoami succeeds, check if isPolicy is false and call PROXY if needed
+                const isPolicy = Boolean(this.currentUser.isPolicy);
+                if (!isPolicy) {
+                    try {
+                        await this.callProxyAfterVerification('google');
+                    }
+                    catch (proxyError) {
+                        // Log error but don't fail the login if PROXY call fails
+                        console.warn('PROXY call after Google login failed (legacy flow):', proxyError);
+                    }
+                }
+                // Verify whoami response exists before returning user
+                const whoamiResponse = await this.getWhoami();
+                if (!whoamiResponse) {
+                    throw new AuthenticationError('Whoami response not available after successful call');
+                }
+                return user;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                throw new AuthenticationError(`Failed to parse user data: ${errorMessage}`);
+            }
+        }
+        // No valid authentication data found
+        return null;
+    }
+    /**
+     * Handle Discord OAuth callback
+     */
+    async handleDiscordCallback() {
+        await this.turnkeyService.init();
+        const params = new URLSearchParams(window.location.search);
+        if (params.get('error')) {
+            throw new AuthenticationError(params.get('error') || 'Discord authentication failed');
+        }
+        const code = params.get('code');
+        const state = params.get('state');
+        const accessToken = params.get('accessToken');
+        const refreshToken = params.get('refreshToken');
+        const userJson = params.get('user');
+        if (code && state) {
+            try {
+                const result = await this.apiService.handleDiscordCallback(code, state);
+                this.currentUser = result.user;
+                await this.storage.setItem(STORAGE_KEYS.USER, result.user);
+                const isPolicy = Boolean(this.currentUser.isPolicy);
+                if (!isPolicy) {
+                    try {
+                        await this.callProxyAfterVerification('discord');
+                    }
+                    catch (proxyError) {
+                        console.warn('PROXY call after Discord login failed:', proxyError);
+                    }
+                }
+                else {
+                    try {
+                        await this.callWhoami();
+                    }
+                    catch (whoamiError) {
+                        console.warn('Whoami call after Discord login failed:', whoamiError);
+                    }
+                }
+                const whoamiResponse = await this.getWhoami();
+                if (!whoamiResponse) {
+                    throw new AuthenticationError('Whoami response not available after successful call');
+                }
+                return result.user;
+            }
+            catch (error) {
+                throw new AuthenticationError(error instanceof Error ? error.message : 'Failed to handle Discord callback');
+            }
+        }
+        if (accessToken && refreshToken && userJson) {
+            await this.tokenService.setTokens({ accessToken, refreshToken });
+            try {
+                const user = JSON.parse(userJson);
+                this.currentUser = user;
+                await this.storage.setItem(STORAGE_KEYS.USER, user);
+                await this.callWhoami();
+                const whoamiResponse = await this.getWhoami();
+                if (!whoamiResponse) {
+                    throw new AuthenticationError('Whoami response not available after successful call');
+                }
+                return user;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                throw new AuthenticationError(`Failed to parse user data: ${errorMessage}`);
+            }
+        }
+        return null;
+    }
+    /**
+     * Handle X (Twitter) OAuth callback
+     */
+    async handleTwitterCallback() {
+        await this.turnkeyService.init();
+        const params = new URLSearchParams(window.location.search);
+        if (params.get('error')) {
+            throw new AuthenticationError(params.get('error') || 'X (Twitter) authentication failed');
+        }
+        const code = params.get('code');
+        const state = params.get('state');
+        const accessToken = params.get('accessToken');
+        const refreshToken = params.get('refreshToken');
+        const userJson = params.get('user');
+        if (code && state) {
+            try {
+                const result = await this.apiService.handleTwitterCallback(code, state);
+                this.currentUser = result.user;
+                await this.storage.setItem(STORAGE_KEYS.USER, result.user);
+                const isPolicy = Boolean(this.currentUser.isPolicy);
+                if (!isPolicy) {
+                    try {
+                        await this.callProxyAfterVerification('twitter');
+                    }
+                    catch (proxyError) {
+                        console.warn('PROXY call after Twitter login failed:', proxyError);
+                    }
+                }
+                else {
+                    try {
+                        await this.callWhoami();
+                    }
+                    catch (whoamiError) {
+                        console.warn('Whoami call after Twitter login failed:', whoamiError);
+                    }
+                }
+                const whoamiResponse = await this.getWhoami();
+                if (!whoamiResponse) {
+                    throw new AuthenticationError('Whoami response not available after successful call');
+                }
+                return result.user;
+            }
+            catch (error) {
+                throw new AuthenticationError(error instanceof Error ? error.message : 'Failed to handle X (Twitter) callback');
+            }
+        }
+        if (accessToken && refreshToken && userJson) {
+            await this.tokenService.setTokens({ accessToken, refreshToken });
+            try {
+                const user = JSON.parse(userJson);
+                this.currentUser = user;
+                await this.storage.setItem(STORAGE_KEYS.USER, user);
+                await this.callWhoami();
+                const whoamiResponse = await this.getWhoami();
+                if (!whoamiResponse) {
+                    throw new AuthenticationError('Whoami response not available after successful call');
+                }
+                return user;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                throw new AuthenticationError(`Failed to parse user data: ${errorMessage}`);
+            }
+        }
+        return null;
+    }
+    /**
+     * Logout
+     */
+    async logout() {
+        this.currentUser = null;
+        await this.tokenService.clearTokens();
+        // Clear all storage items
+        await this.storage.removeItem(STORAGE_KEYS.USER);
+        await this.storage.removeItem(STORAGE_KEYS.WHOAMI);
+        await this.storage.removeItem(STORAGE_KEYS.VERIFY_RESPONSE);
+        await this.storage.removeItem(STORAGE_KEYS.WALLET_CONFIG);
+        // Clear all localStorage
+        await this.storage.clear();
+    }
+    /**
+     * Refresh access token
+     */
+    async refreshToken() {
+        return await this.apiService.refreshToken();
+    }
+    /**
+     * Get current user
+     */
+    getCurrentUser() {
+        return this.currentUser;
+    }
+    /**
+     * Check if authenticated
+     */
+    async isAuthenticated() {
+        if (this.currentUser) {
+            return true;
+        }
+        // Try to load user from storage
+        const user = await this.storage.getItem(STORAGE_KEYS.USER);
+        if (user) {
+            this.currentUser = user;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Load user from storage
+     */
+    async loadUserFromStorage() {
+        const user = await this.storage.getItem(STORAGE_KEYS.USER);
+        if (user) {
+            this.currentUser = user;
+        }
+    }
+    /**
+     * Get stored verification response
+     * Returns the full OTP verification response that was saved
+     */
+    async getVerifyResponse() {
+        return await this.storage.getItem(STORAGE_KEYS.VERIFY_RESPONSE);
+    }
+    /**
+     * Call whoami API and store the response
+     * This is called after successful OTP verification
+     * Always calls backend endpoint with access token (backend handles Turnkey call)
+     */
+    async callWhoami() {
+        if (!this.currentUser?.subOrganizationId) {
+            return;
+        }
+        // If whoami is already being called, wait for the existing call to complete
+        // This prevents duplicate API calls
+        if (this.whoamiPromise) {
+            try {
+                await this.whoamiPromise;
+                // If the existing call succeeded, we're done
+                return;
+            }
+            catch (error) {
+                // If the existing call failed, clear the promise and continue to retry
+                this.whoamiPromise = null;
+            }
+        }
+        // Check if we already have a cached response (avoid unnecessary API call)
+        const cachedWhoami = await this.getWhoami();
+        if (cachedWhoami) {
+            return;
+        }
+        // Create and store the promise for this call
+        this.whoamiPromise = (async () => {
+            try {
+                // Ensure storage is initialized before calling whoami
+                // This is critical for createStamp to work in getWhoami
+                await this.turnkeyService.init();
+                // Call whoami via backend endpoint with access token
+                // Backend will handle the Turnkey call internally
+                const whoamiResponse = await this.apiService.getWhoami(this.currentUser.subOrganizationId);
+                // Store whoami response in localStorage
+                await this.storage.setItem(STORAGE_KEYS.WHOAMI, whoamiResponse);
+            }
+            catch (error) {
+                console.error('Failed to get whoami information:', error);
+                // Clear promise on error so it can be retried
+                this.whoamiPromise = null;
+                throw error;
+            }
+            finally {
+                // Only clear if it's still the same promise (in case of concurrent calls)
+                if (this.whoamiPromise) {
+                    this.whoamiPromise = null;
+                }
+            }
+        })();
+        return await this.whoamiPromise;
+    }
+    /**
+     * Get stored whoami response
+     */
+    async getWhoami() {
+        return await this.storage.getItem(STORAGE_KEYS.WHOAMI);
+    }
+    /**
+     * Refresh whoami by making a fresh API call
+     * This bypasses the cache and always calls the API
+     */
+    async refreshWhoami() {
+        if (!this.currentUser?.subOrganizationId) {
+            throw new AuthenticationError('User not authenticated');
+        }
+        // Clear any existing promise to force a fresh call
+        this.whoamiPromise = null;
+        try {
+            // Ensure storage is initialized before calling whoami
+            await this.turnkeyService.init();
+            // Call whoami via backend endpoint with access token
+            // Backend will handle the Turnkey call internally
+            const whoamiResponse = await this.apiService.getWhoami(this.currentUser.subOrganizationId);
+            // Store whoami response in localStorage
+            await this.storage.setItem(STORAGE_KEYS.WHOAMI, whoamiResponse);
+            return whoamiResponse;
+        }
+        catch (error) {
+            console.error('Failed to refresh whoami information:', error);
+            throw error;
+        }
+    }
+    /**
+     * Signup with passkey
+     * Creates a WebAuthn credential and registers the user
+     */
+    async signupWithPasskey() {
+        try {
+            // Clear previous IndexedDB data and reset TurnkeyService before starting new signup
+            await this.turnkeyService.reset();
+            // Initialize storage if not already initialized
+            await this.turnkeyService.init();
+            // Get public key from storage (internal - users don't see this)
+            const targetPublicKey = await this.turnkeyService.getPublicKey();
+            if (!targetPublicKey) {
+                throw new AuthenticationError('Failed to get public key from storage');
+            }
+            // Get rpId from current hostname
+            const rpId = typeof window !== 'undefined' ? window.location.hostname : 'localhost';
+            // Generate challenge
+            const challengeBase64 = generateChallenge();
+            // Create passkey credential
+            const passkeyData = await createPasskeyCredential(rpId, challengeBase64);
+            // Generate authenticator name
+            const authenticatorName = generateAuthenticatorName(rpId);
+            // Generate user and organization names
+            const userName = generateUserName();
+            const organizationName = generateOrganizationName();
+            // Format the attestation data
+            const authenticator = {
+                authenticatorName,
+                challenge: passkeyData.challenge,
+                attestation: {
+                    credentialId: passkeyData.credentialId,
+                    attestationObject: passkeyData.attestationObject,
+                    clientDataJson: passkeyData.clientDataJson,
+                    transports: passkeyData.transports,
+                },
+            };
+            // Call passkey signup API
+            const response = await this.apiService.passkeySignup({
+                userName,
+                authenticators: [authenticator],
+                organizationName,
+                targetPublicKey,
+            });
+            if (!response.result?.user) {
+                throw new AuthenticationError('Failed to get user information from passkey signup');
+            }
+            // Set user in memory
+            this.currentUser = response.result.user;
+            // Store user in storage
+            await this.storage.setItem(STORAGE_KEYS.USER, this.currentUser);
+            // For passkey signup, skip proxy and call whoami directly
+            try {
+                await this.callWhoami();
+            }
+            catch (error) {
+                console.warn('Whoami call after passkey signup failed:', error);
+            }
+            return this.currentUser;
+        }
+        catch (error) {
+            // If passkey signup API fails, reset IndexedDB
+            // This allows the user to retry with a fresh key
+            try {
+                await this.turnkeyService.reset();
+            }
+            catch (resetError) {
+                // Log reset error but don't fail - we still want to throw the original error
+                console.warn('Failed to reset IndexedDB after passkey signup error:', resetError);
+            }
+            // Re-throw the original error
+            throw error;
+        }
+    }
+    /**
+     * Login with passkey
+     * Uses WebauthnStamper to authenticate with existing passkey
+     */
+    async loginWithPasskey() {
+        try {
+            const rpId = typeof window !== 'undefined' ? window.location.hostname : 'localhost';
+            // Create WebauthnStamper
+            const stamper = new WebauthnStamper({
+                rpId: rpId,
+                userVerification: 'required',
+            });
+            // Create Turnkey client with WebauthnStamper
+            const httpClient = new TurnkeyClient({ baseUrl: TURNKEY_CONFIG.BASE_URL }, stamper);
+            // Root organization ID for stamping (provided)
+            const rootOrganizationId = '0ba77025-ceba-4093-b5b3-a22c838d2e28';
+            // Initialize storage and try to get public key from Turnkey IndexedDB stamper
+            await this.turnkeyService.init();
+            const storagePublicKey = await this.turnkeyService.getPublicKey();
+            const storedUser = await this.storage.getItem(STORAGE_KEYS.USER);
+            const publicKey = storagePublicKey || storedUser?.publicKey || this.currentUser?.publicKey;
+            if (!publicKey) {
+                throw new AuthenticationError('Failed to get public key for passkey login. Please complete passkey signup first.');
+            }
+            // Create stamp + body using Turnkey stampStampLogin
+            const { body, stamp } = await httpClient.stampStampLogin({
+                type: 'ACTIVITY_TYPE_STAMP_LOGIN',
+                timestampMs: new Date().getTime().toString(),
+                organizationId: rootOrganizationId,
+                parameters: {
+                    publicKey,
+                    expirationSeconds: '86400',
+                    invalidateExisting: true,
+                },
+            });
+            // Call backend PASSKEY_LOGIN endpoint with stamp + body
+            const parsedBody = typeof body === 'string' ? JSON.parse(body) : body;
+            const stampValue = stamp?.stampHeaderValue ?? stamp;
+            const response = await this.apiService.passkeyLogin({ body: parsedBody, stamp: stampValue });
+            if (!response.result?.user) {
+                throw new AuthenticationError('Failed to get user information from passkey login');
+            }
+            // Set user and store
+            this.currentUser = response.result.user;
+            await this.storage.setItem(STORAGE_KEYS.USER, this.currentUser);
+            // Fetch whoami directly (no proxy for passkey)
+            try {
+                await this.callWhoami();
+            }
+            catch (error) {
+                console.warn('Whoami call after passkey login failed:', error);
+            }
+            return this.currentUser;
+        }
+        catch (error) {
+            if (error instanceof AuthenticationError) {
+                throw error;
+            }
+            throw new AuthenticationError(error instanceof Error ? error.message : 'Failed to login with passkey');
+        }
+    }
+}
+//# sourceMappingURL=AuthManager.js.map