@tatchi-xyz/sdk 0.21.0 → 0.31.0

package/dist/cjs/core/TatchiPasskey/login.js

@@ -1,10 +1,14 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.js');
+const require_errors = require('../../utils/errors.js');
+const require_participants = require('../../threshold/participants.js');
 const require_index = require('../IndexedDBManager/index.js');
 const require_vrf_worker = require('../types/vrf-worker.js');
-const require_errors = require('../../utils/errors.js');
 const require_touchIdPrompt = require('../WebAuthnManager/touchIdPrompt.js');
 const require_sdkSentEvents = require('../types/sdkSentEvents.js');
 const require_rpcCalls = require('../rpcCalls.js');
+const require_getDeviceNumber = require('../WebAuthnManager/SignerWorkerManager/getDeviceNumber.js');
+const require_intentDigest = require('../digests/intentDigest.js');
+const require_thresholdEd25519AuthSession = require('../threshold/thresholdEd25519AuthSession.js');
+const require_thresholdSessionPolicy = require('../threshold/thresholdSessionPolicy.js');
 
 //#region src/core/TatchiPasskey/login.ts
 /**
@@ -38,186 +42,361 @@ async function loginAndCreateSession(context, nearAccountId, options) {
 	try {
 		if (!window.isSecureContext) {
 			const errorMessage = "Passkey operations require a secure context (HTTPS or localhost).";
-			const error = new Error(errorMessage);
-			onError?.(error);
-			onEvent?.({
-				step: 0,
-				phase: require_sdkSentEvents.LoginPhase.LOGIN_ERROR,
-				status: require_sdkSentEvents.LoginStatus.ERROR,
+			return await finalizeLoginError({
 				message: errorMessage,
-				error: errorMessage
+				error: new Error(errorMessage),
+				rollbackVrfOnFailure,
+				onEvent,
+				onError,
+				afterCall,
+				callAfterCall: false
 			});
-			const result = {
-				success: false,
-				error: errorMessage
-			};
-			return result;
 		}
-		const wantsSession = options?.session?.kind == "jwt" || options?.session?.kind == "cookie";
-		const base = await handleLoginUnlockVRF(context, nearAccountId, onEvent, onError, afterCall, true);
+		const session = options?.session;
+		const wantsServerSession = session !== void 0;
+		const deviceNumberHint = require_getDeviceNumber.parseDeviceNumber(options?.deviceNumber, { min: 1 });
+		const base = await handleLoginUnlockVRF(context, nearAccountId, onEvent, onError, afterCall, true, deviceNumberHint);
 		if (!base.result.success) return base.result;
-		const attachSigningSession = async (result) => {
-			if (!result?.success) return result;
-			try {
-				const signingSession = await webAuthnManager.getWarmSigningSessionStatus(nearAccountId);
-				return {
-					...result,
-					signingSession
-				};
-			} catch {
-				return result;
-			}
-		};
-		const ttlMsDefault = context.configs.signingSessionDefaults.ttlMs;
-		const remainingUsesDefault = context.configs.signingSessionDefaults.remainingUses;
-		const ttlMs = options?.signingSession?.ttlMs ?? ttlMsDefault;
-		const remainingUses = options?.signingSession?.remainingUses ?? remainingUsesDefault;
-		if (wantsSession) {
-			const { kind, relayUrl: relayUrlOverride, route: routeOverride } = options.session;
-			const relayUrl = (relayUrlOverride || context.configs.relayer.url).trim();
-			const route = (routeOverride || "/verify-authentication-response").trim();
-			if (!relayUrl) {
-				console.warn("No relayUrl provided for session");
-				await mintWarmSigningSession({
-					context,
-					nearAccountId,
-					onEvent,
-					credential: base.unlockCredential,
-					ttlMs,
-					remainingUses
-				});
-				const finalResult$1 = await attachSigningSession(base.result);
-				onEvent?.({
-					step: 4,
-					phase: require_sdkSentEvents.LoginPhase.STEP_4_LOGIN_COMPLETE,
-					status: require_sdkSentEvents.LoginStatus.SUCCESS,
-					message: "Login completed successfully",
-					nearAccountId,
-					clientNearPublicKey: base.result?.clientNearPublicKey || ""
-				});
-				await afterCall?.(true, finalResult$1);
-				return finalResult$1;
-			}
-			try {
-				const blockInfo = await context.nearClient.viewBlock({ finality: "final" });
-				const txBlockHash = blockInfo?.header?.hash;
-				const txBlockHeight = String(blockInfo.header?.height ?? "");
-				const vrfChallenge = await webAuthnManager.generateVrfChallengeOnce({
-					userId: nearAccountId,
-					rpId: webAuthnManager.getRpId(),
-					blockHash: txBlockHash,
-					blockHeight: txBlockHeight
-				});
-				const authenticators = await webAuthnManager.getAuthenticatorsByUser(nearAccountId);
-				const credential = await webAuthnManager.getAuthenticationCredentialsSerialized({
-					nearAccountId,
-					challenge: vrfChallenge,
-					allowCredentials: require_touchIdPrompt.authenticatorsToAllowCredentials(authenticators)
-				});
-				try {
-					if (authenticators.length > 1) {
-						const rawId = credential.rawId;
-						const matched = authenticators.find((a) => a.credentialId === rawId);
-						if (matched && typeof matched.deviceNumber === "number") await context.webAuthnManager.setLastUser(nearAccountId, matched.deviceNumber);
-					}
-				} catch {}
-				await mintWarmSigningSession({
-					context,
-					nearAccountId,
-					onEvent,
-					credential,
-					ttlMs,
-					remainingUses
-				});
-				const v = await require_rpcCalls.verifyAuthenticationResponse(relayUrl, route, kind, vrfChallenge, credential);
-				if (v.success && v.verified) {
-					const finalResult$1 = await attachSigningSession({
-						...base.result,
-						jwt: v.jwt
-					});
-					onEvent?.({
-						step: 4,
-						phase: require_sdkSentEvents.LoginPhase.STEP_4_LOGIN_COMPLETE,
-						status: require_sdkSentEvents.LoginStatus.SUCCESS,
-						message: "Login completed successfully",
-						nearAccountId,
-						clientNearPublicKey: base.result?.clientNearPublicKey || ""
-					});
-					await afterCall?.(true, finalResult$1);
-					return finalResult$1;
-				}
-				const errMsg = v.error || "Session verification failed";
-				await rollbackVrfOnFailure();
-				onEvent?.({
-					step: 0,
-					phase: require_sdkSentEvents.LoginPhase.LOGIN_ERROR,
-					status: require_sdkSentEvents.LoginStatus.ERROR,
-					message: errMsg,
-					error: errMsg
-				});
-				await afterCall?.(false);
-				return {
-					success: false,
-					error: errMsg
-				};
-			} catch (e) {
-				console.error("Failed to start session: ", e);
-				const errMsg = require_errors.getUserFriendlyErrorMessage(e, "login") || e?.message || "Session verification failed";
-				await rollbackVrfOnFailure();
-				onError?.(e);
-				onEvent?.({
-					step: 0,
-					phase: require_sdkSentEvents.LoginPhase.LOGIN_ERROR,
-					status: require_sdkSentEvents.LoginStatus.ERROR,
-					message: errMsg,
-					error: errMsg
-				});
-				await afterCall?.(false);
-				return {
-					success: false,
-					error: errMsg
-				};
-			}
-		}
+		const preferredDeviceNumber = deviceNumberHint ?? base.activeDeviceNumber;
+		const warmPolicy = resolveWarmSigningSessionPolicy(context, options);
+		const wantsThresholdSession = webAuthnManager.getUserPreferences().getSignerMode().mode === "threshold-signer";
+		const relayUrl = (session?.relayUrl || context.configs.relayer.url).trim();
+		const verifyRoute = (session?.route || "/verify-authentication-response").trim();
+		const thresholdPlan = await prepareThresholdSessionPlan({
+			context,
+			nearAccountId,
+			preferredDeviceNumber,
+			relayUrl,
+			ttlMs: warmPolicy.ttlMs,
+			remainingUses: warmPolicy.remainingUses,
+			wantsThresholdSession
+		});
+		const wantsRelayerSession = wantsServerSession || thresholdPlan !== null;
+		if (wantsRelayerSession && !relayUrl) console.warn("[login] No relayUrl provided for session-style signing");
+		if (wantsRelayerSession && relayUrl) return await runRelayerSessionFlow({
+			context,
+			nearAccountId,
+			baseLoginResult: base.result,
+			baseUnlockCredential: base.unlockCredential,
+			preferredDeviceNumber,
+			session,
+			relayUrl,
+			verifyRoute,
+			thresholdPlan,
+			warmPolicy,
+			rollbackVrfOnFailure,
+			onEvent,
+			onError,
+			afterCall
+		});
 		await mintWarmSigningSession({
 			context,
 			nearAccountId,
 			onEvent,
 			credential: base.unlockCredential,
-			ttlMs,
-			remainingUses
+			ttlMs: warmPolicy.ttlMs,
+			remainingUses: warmPolicy.remainingUses
 		});
-		const finalResult = await attachSigningSession(base.result);
-		onEvent?.({
-			step: 4,
-			phase: require_sdkSentEvents.LoginPhase.STEP_4_LOGIN_COMPLETE,
-			status: require_sdkSentEvents.LoginStatus.SUCCESS,
-			message: "Login completed successfully",
+		return await finalizeLoginSuccess({
+			webAuthnManager,
 			nearAccountId,
-			clientNearPublicKey: base.result?.clientNearPublicKey || ""
+			loginResult: base.result,
+			onEvent,
+			afterCall
 		});
-		await afterCall?.(true, finalResult);
-		return finalResult;
 	} catch (err) {
-		await rollbackVrfOnFailure();
-		onError?.(err);
 		const errorMessage = require_errors.getUserFriendlyErrorMessage(err, "login") || err?.message || "Login failed";
-		onEvent?.({
-			step: 0,
-			phase: require_sdkSentEvents.LoginPhase.LOGIN_ERROR,
-			status: require_sdkSentEvents.LoginStatus.ERROR,
+		return await finalizeLoginError({
 			message: errorMessage,
-			error: errorMessage
+			error: err,
+			rollbackVrfOnFailure,
+			onEvent,
+			onError,
+			afterCall
 		});
-		const result = {
-			success: false,
-			error: errorMessage
+	}
+}
+function resolveWarmSigningSessionPolicy(context, options) {
+	const defaults = context.configs.signingSessionDefaults;
+	return {
+		ttlMs: options?.signingSession?.ttlMs ?? defaults.ttlMs,
+		remainingUses: options?.signingSession?.remainingUses ?? defaults.remainingUses
+	};
+}
+async function attachSigningSessionStatus(args) {
+	const { webAuthnManager, nearAccountId, loginResult } = args;
+	if (!loginResult.success) return loginResult;
+	try {
+		const signingSession = await webAuthnManager.getWarmSigningSessionStatus(nearAccountId);
+		return {
+			...loginResult,
+			signingSession
 		};
-		afterCall?.(false);
-		return result;
+	} catch {
+		return loginResult;
+	}
+}
+async function finalizeLoginSuccess(args) {
+	const { webAuthnManager, nearAccountId, loginResult, onEvent, afterCall } = args;
+	const finalResult = await attachSigningSessionStatus({
+		webAuthnManager,
+		nearAccountId,
+		loginResult
+	});
+	onEvent?.({
+		step: 4,
+		phase: require_sdkSentEvents.LoginPhase.STEP_4_LOGIN_COMPLETE,
+		status: require_sdkSentEvents.LoginStatus.SUCCESS,
+		message: "Login completed successfully",
+		nearAccountId,
+		clientNearPublicKey: loginResult.clientNearPublicKey ?? ""
+	});
+	await afterCall?.(true, finalResult);
+	return finalResult;
+}
+async function finalizeLoginError(args) {
+	const { message, error, rollbackVrfOnFailure, onEvent, onError, afterCall, callOnError = true, callAfterCall = true } = args;
+	try {
+		await rollbackVrfOnFailure();
+	} catch {}
+	if (callOnError) onError?.(error);
+	onEvent?.({
+		step: 0,
+		phase: require_sdkSentEvents.LoginPhase.LOGIN_ERROR,
+		status: require_sdkSentEvents.LoginStatus.ERROR,
+		message,
+		error: message
+	});
+	if (callAfterCall) await afterCall?.(false);
+	return {
+		success: false,
+		error: message
+	};
+}
+async function prepareThresholdSessionPlan(args) {
+	const { context, nearAccountId, preferredDeviceNumber, relayUrl, ttlMs, remainingUses, wantsThresholdSession } = args;
+	if (!wantsThresholdSession || !relayUrl) return null;
+	const { webAuthnManager } = context;
+	try {
+		const rpId = webAuthnManager.getRpId();
+		if (!rpId) throw new Error("Missing rpId for threshold session");
+		const lastUser = await webAuthnManager.getLastUser();
+		const deviceNumber = preferredDeviceNumber ?? (lastUser?.nearAccountId === nearAccountId ? lastUser.deviceNumber : (await require_index.IndexedDBManager.clientDB.getLastDBUpdatedUser(nearAccountId))?.deviceNumber ?? null);
+		if (deviceNumber === null) {
+			console.warn("[login] threshold-signer configured but no threshold key material found; skipping threshold session");
+			return null;
+		}
+		const thresholdKeyMaterial = await require_index.IndexedDBManager.nearKeysDB.getThresholdKeyMaterial(nearAccountId, deviceNumber);
+		const relayerKeyId = thresholdKeyMaterial?.relayerKeyId || null;
+		const participantIds = thresholdKeyMaterial?.participants?.map((p) => p.id) || null;
+		const normalizedParticipantIds = require_participants.normalizeThresholdEd25519ParticipantIds(participantIds);
+		if (!relayerKeyId) {
+			console.warn("[login] threshold-signer configured but no threshold key material found; skipping threshold session");
+			return null;
+		}
+		if (!normalizedParticipantIds || normalizedParticipantIds.length < 2) {
+			console.warn("[login] threshold key material missing/invalid participantIds; skipping threshold session mint");
+			return null;
+		}
+		const policy = await require_thresholdSessionPolicy.buildThresholdSessionPolicy({
+			nearAccountId,
+			rpId,
+			relayerKeyId,
+			...normalizedParticipantIds?.length ? { participantIds: normalizedParticipantIds } : {},
+			ttlMs,
+			remainingUses
+		});
+		const cacheKey = require_thresholdEd25519AuthSession.makeThresholdEd25519AuthSessionCacheKey({
+			nearAccountId,
+			rpId,
+			relayerUrl: relayUrl,
+			relayerKeyId,
+			...normalizedParticipantIds?.length ? { participantIds: normalizedParticipantIds } : {}
+		});
+		return {
+			sessionKind: "jwt",
+			relayerUrl: relayUrl,
+			relayerKeyId,
+			cacheKey,
+			policy,
+			deviceNumber
+		};
+	} catch (e) {
+		console.warn("[login] failed to prepare threshold session policy; skipping threshold session mint:", e?.message || e);
+		return null;
+	}
+}
+async function mintThresholdSessionBestEffort(args) {
+	const { context, nearAccountId, plan, vrfChallenge, credential } = args;
+	const { webAuthnManager } = context;
+	let clientVerifyingShareB64u = null;
+	try {
+		const localKeyMaterial = await require_index.IndexedDBManager.nearKeysDB.getLocalKeyMaterial(nearAccountId, plan.deviceNumber);
+		const wrapKeySalt = String(localKeyMaterial?.wrapKeySalt || "").trim();
+		if (wrapKeySalt) {
+			const derived = await webAuthnManager.deriveThresholdEd25519ClientVerifyingShareFromCredential({
+				credential,
+				nearAccountId,
+				wrapKeySalt
+			});
+			if (derived.success && derived.clientVerifyingShareB64u) clientVerifyingShareB64u = derived.clientVerifyingShareB64u;
+		}
+	} catch (e) {
+		console.warn("[login] failed to derive clientVerifyingShareB64u for threshold session mint:", e?.message || e);
+	}
+	if (!clientVerifyingShareB64u) {
+		console.warn("[login] threshold session mint skipped: missing clientVerifyingShareB64u");
+		return;
+	}
+	const minted = await require_thresholdEd25519AuthSession.mintThresholdEd25519AuthSession({
+		relayerUrl: plan.relayerUrl,
+		sessionKind: plan.sessionKind,
+		relayerKeyId: plan.relayerKeyId,
+		clientVerifyingShareB64u,
+		sessionPolicy: plan.policy.policy,
+		vrfChallenge,
+		webauthnAuthentication: credential
+	});
+	if (minted.ok && minted.jwt) {
+		require_thresholdEd25519AuthSession.putCachedThresholdEd25519AuthSession(plan.cacheKey, {
+			sessionKind: plan.sessionKind,
+			policy: plan.policy.policy,
+			policyJson: plan.policy.policyJson,
+			sessionPolicyDigest32: plan.policy.sessionPolicyDigest32,
+			jwt: minted.jwt,
+			...minted.expiresAtMs ? { expiresAtMs: minted.expiresAtMs } : {}
+		});
+		return;
+	}
+	if (!minted.ok) console.warn("[login] threshold session mint failed:", minted.code || minted.message || "unknown error");
+}
+async function runRelayerSessionFlow(args) {
+	const { context, nearAccountId, baseLoginResult, baseUnlockCredential, preferredDeviceNumber, session, relayUrl, verifyRoute, thresholdPlan, warmPolicy, rollbackVrfOnFailure, onEvent, onError, afterCall } = args;
+	const { webAuthnManager } = context;
+	try {
+		const rpId = webAuthnManager.getRpId();
+		if (!rpId) throw new Error("Missing rpId for VRF challenge generation during login");
+		const blockInfo = await context.nearClient.viewBlock({ finality: "final" });
+		const txBlockHash = blockInfo?.header?.hash;
+		const txBlockHeight = String(blockInfo.header?.height ?? "");
+		const intentDigest = await require_intentDigest.computeLoginIntentDigest({
+			nearAccountId,
+			rpId
+		});
+		const vrfChallenge = await webAuthnManager.generateVrfChallengeOnce({
+			userId: nearAccountId,
+			rpId,
+			blockHash: txBlockHash,
+			blockHeight: txBlockHeight,
+			intentDigest,
+			...thresholdPlan ? { sessionPolicyDigest32: thresholdPlan.policy.sessionPolicyDigest32 } : {}
+		});
+		const authenticators = await webAuthnManager.getAuthenticatorsByUser(nearAccountId);
+		const authenticatorsForPrompt = prioritizeAuthenticatorsByDeviceNumber(authenticators, preferredDeviceNumber);
+		const credential = await webAuthnManager.getAuthenticationCredentialsSerialized({
+			nearAccountId,
+			challenge: vrfChallenge,
+			allowCredentials: require_touchIdPrompt.authenticatorsToAllowCredentials(authenticatorsForPrompt)
+		});
+		const effectiveLoginResult = await bindVrfToSelectedLoginPasskeyDevice({
+			webAuthnManager,
+			nearAccountId,
+			authenticators,
+			credential,
+			baseUnlockCredential,
+			baseLoginResult
+		});
+		await mintWarmSigningSession({
+			context,
+			nearAccountId,
+			onEvent,
+			credential,
+			ttlMs: warmPolicy.ttlMs,
+			remainingUses: warmPolicy.remainingUses
+		});
+		let serverSessionJwt;
+		if (session) {
+			const v = await require_rpcCalls.verifyAuthenticationResponse(relayUrl, verifyRoute, session.kind, vrfChallenge, credential);
+			if (!v.success || !v.verified) {
+				const errMsg = v.error || "Session verification failed";
+				return await finalizeLoginError({
+					message: errMsg,
+					rollbackVrfOnFailure,
+					onEvent,
+					afterCall,
+					callOnError: false
+				});
+			}
+			serverSessionJwt = v.jwt;
+		}
+		if (thresholdPlan) await mintThresholdSessionBestEffort({
+			context,
+			nearAccountId,
+			plan: thresholdPlan,
+			vrfChallenge,
+			credential
+		});
+		const loginResult = serverSessionJwt ? {
+			...effectiveLoginResult,
+			jwt: serverSessionJwt
+		} : effectiveLoginResult;
+		return await finalizeLoginSuccess({
+			webAuthnManager,
+			nearAccountId,
+			loginResult,
+			onEvent,
+			afterCall
+		});
+	} catch (e) {
+		console.error("[login] Failed to start session:", e);
+		const errMsg = require_errors.getUserFriendlyErrorMessage(e, "login") || e?.message || "Session verification failed";
+		return await finalizeLoginError({
+			message: errMsg,
+			error: e,
+			rollbackVrfOnFailure,
+			onEvent,
+			onError,
+			afterCall
+		});
 	}
 }
 /**
+* When multiple passkeys exist for the same account, the user can select any of them in the WebAuthn prompt.
+* If the VRF worker was auto-unlocked using a different device (e.g. Shamir 3-pass based on the "latest" row),
+* we must rebind the VRF worker to the same deviceNumber as the selected credential. Otherwise, WrapKeySeed
+* derivation can mix PRF.first(from selected credential) with vrf_sk(from a different device), which later
+* causes vault decryption failures (e.g. `aead::Error` during private key export).
+*/
+async function bindVrfToSelectedLoginPasskeyDevice(args) {
+	const { webAuthnManager, nearAccountId, authenticators, credential, baseUnlockCredential, baseLoginResult } = args;
+	let effectiveLoginResult = baseLoginResult;
+	if (authenticators.length <= 1) return effectiveLoginResult;
+	const rawId = credential.rawId;
+	const matched = authenticators.find((a) => a.credentialId === rawId);
+	const selectedDeviceNumber = matched?.deviceNumber ?? null;
+	if (selectedDeviceNumber === null) return effectiveLoginResult;
+	const userForDevice = await require_index.IndexedDBManager.clientDB.getUserByDevice(nearAccountId, selectedDeviceNumber).catch(() => null);
+	if (userForDevice?.clientNearPublicKey) effectiveLoginResult = {
+		...effectiveLoginResult,
+		clientNearPublicKey: userForDevice.clientNearPublicKey
+	};
+	const shouldRebindVrf = !baseUnlockCredential || baseUnlockCredential.rawId !== rawId;
+	if (shouldRebindVrf) {
+		const shamir = userForDevice?.serverEncryptedVrfKeypair;
+		if (!shamir?.ciphertextVrfB64u || !shamir?.kek_s_b64u || !shamir?.serverKeyId) throw new Error(`Missing serverEncryptedVrfKeypair for account ${nearAccountId} device ${selectedDeviceNumber}. Open the wallet once online to refresh local state, then try again.`);
+		const unlock = await webAuthnManager.shamir3PassDecryptVrfKeypair({
+			nearAccountId,
+			kek_s_b64u: shamir.kek_s_b64u,
+			ciphertextVrfB64u: shamir.ciphertextVrfB64u,
+			serverKeyId: shamir.serverKeyId
+		});
+		if (!unlock.success) throw new Error(unlock.error || "Failed to bind VRF keypair to the passkey you selected. Please try again.");
+	}
+	await webAuthnManager.setLastUser(nearAccountId, selectedDeviceNumber);
+	await webAuthnManager.updateLastLogin(nearAccountId).catch(() => void 0);
+	return effectiveLoginResult;
+}
+/**
 * Mint or refresh a "warm signing session" in the VRF worker.
 *
 * Notes:
@@ -271,16 +450,19 @@ async function mintWarmSigningSession(args) {
 *      - VRF proof assures WebAuthn challenge is fresh and valid (replay protection)
 *      - WebAuthn verification for origin + biometric credentials + device authenticity
 */
-async function handleLoginUnlockVRF(context, nearAccountId, onEvent, onError, afterCall, deferCompletionHooks) {
+async function handleLoginUnlockVRF(context, nearAccountId, onEvent, onError, afterCall, deferCompletionHooks, deviceNumberHint = null) {
 	const { webAuthnManager } = context;
 	try {
-		const [lastUser, latestByAccount, authenticators] = await Promise.all([
+		const hintUserPromise = deviceNumberHint !== null ? webAuthnManager.getUserByDevice(nearAccountId, deviceNumberHint).catch(() => null) : Promise.resolve(null);
+		const [hintUser, lastUser, latestByAccount, authenticators] = await Promise.all([
+			hintUserPromise,
 			webAuthnManager.getLastUser(),
 			require_index.IndexedDBManager.clientDB.getLastDBUpdatedUser(nearAccountId),
 			webAuthnManager.getAuthenticatorsByUser(nearAccountId)
 		]);
 		let userData = null;
-		if (latestByAccount && latestByAccount.nearAccountId === nearAccountId) userData = latestByAccount;
+		if (hintUser && hintUser.nearAccountId === nearAccountId) userData = hintUser;
+		else if (latestByAccount && latestByAccount.nearAccountId === nearAccountId) userData = latestByAccount;
 		else if (lastUser && lastUser.nearAccountId === nearAccountId) userData = lastUser;
 		else userData = await webAuthnManager.getUserByDevice(nearAccountId, 1);
 		if (!userData) throw new Error(`User data not found for ${nearAccountId} in IndexedDB. Please register an account.`);
@@ -298,11 +480,10 @@ async function handleLoginUnlockVRF(context, nearAccountId, onEvent, onError, af
 		let unlockCredential;
 		let activeDeviceNumber = userData.deviceNumber;
 		let effectiveUserData = userData;
-		const hasServerEncrypted = !!userData.serverEncryptedVrfKeypair;
+		const shamir = userData.serverEncryptedVrfKeypair;
 		const relayerUrl = context.configs.relayer?.url;
-		const useShamir3PassVRFKeyUnlock = hasServerEncrypted && !!relayerUrl && !!userData.serverEncryptedVrfKeypair?.serverKeyId;
-		if (useShamir3PassVRFKeyUnlock) try {
-			const shamir = userData.serverEncryptedVrfKeypair;
+		const useShamir3PassVRFKeyUnlock = !!relayerUrl && !!shamir?.serverKeyId;
+		if (useShamir3PassVRFKeyUnlock && shamir) try {
 			if (!shamir.ciphertextVrfB64u || !shamir.kek_s_b64u) throw new Error("Missing Shamir3Pass fields (ciphertextVrfB64u/kek_s_b64u)");
 			unlockResult = await webAuthnManager.shamir3PassDecryptVrfKeypair({
 				nearAccountId,
@@ -326,10 +507,11 @@ async function handleLoginUnlockVRF(context, nearAccountId, onEvent, onError, af
 			};
 		}
 		if (!unlockResult.success) {
+			const authenticatorsForPrompt = prioritizeAuthenticatorsByDeviceNumber(authenticators, deviceNumberHint);
 			const fallback = await fallbackUnlockVrfKeypairWithTouchId({
 				webAuthnManager,
 				nearAccountId,
-				authenticators,
+				authenticators: authenticatorsForPrompt,
 				userData,
 				onEvent
 			});
@@ -344,7 +526,7 @@ async function handleLoginUnlockVRF(context, nearAccountId, onEvent, onError, af
 			step: 3,
 			phase: require_sdkSentEvents.LoginPhase.STEP_3_VRF_UNLOCK,
 			status: require_sdkSentEvents.LoginStatus.SUCCESS,
-			message: "VRF keypair unlocked successfully"
+			message: "VRF keypair unlocked..."
 		});
 		try {
 			const relayerUrl$1 = context.configs.relayer?.url;
@@ -356,14 +538,13 @@ async function handleLoginUnlockVRF(context, nearAccountId, onEvent, onError, af
 			console.warn("Non-fatal: Failed to refresh serverEncryptedVrfKeypair:", refreshErr?.message || refreshErr);
 		}
 		try {
-			if (typeof activeDeviceNumber === "number" && Number.isFinite(activeDeviceNumber)) await webAuthnManager.setLastUser(nearAccountId, activeDeviceNumber);
-			else if (typeof userData.deviceNumber === "number") await webAuthnManager.setLastUser(nearAccountId, userData.deviceNumber);
+			await webAuthnManager.setLastUser(nearAccountId, activeDeviceNumber);
 		} catch {}
 		await webAuthnManager.updateLastLogin(nearAccountId);
 		const result = {
 			success: true,
 			loggedInNearAccountId: nearAccountId,
-			clientNearPublicKey: effectiveUserData?.clientNearPublicKey,
+			clientNearPublicKey: effectiveUserData.clientNearPublicKey,
 			nearAccountId
 		};
 		if (!deferCompletionHooks) {
@@ -373,14 +554,15 @@ async function handleLoginUnlockVRF(context, nearAccountId, onEvent, onError, af
 				status: require_sdkSentEvents.LoginStatus.SUCCESS,
 				message: "Login completed successfully",
 				nearAccountId,
-				clientNearPublicKey: effectiveUserData?.clientNearPublicKey || ""
+				clientNearPublicKey: effectiveUserData.clientNearPublicKey
 			});
 			afterCall?.(true, result);
 		}
 		return {
 			result,
 			usedFallbackTouchId,
-			unlockCredential
+			unlockCredential,
+			activeDeviceNumber
 		};
 	} catch (error) {
 		const errorMessage = require_errors.getUserFriendlyErrorMessage(error, "login");
@@ -399,7 +581,8 @@ async function handleLoginUnlockVRF(context, nearAccountId, onEvent, onError, af
 		afterCall?.(false);
 		return {
 			result,
-			usedFallbackTouchId: false
+			usedFallbackTouchId: false,
+			activeDeviceNumber: null
 		};
 	}
 }
@@ -553,26 +736,22 @@ async function logoutAndClearSession(context) {
 	try {
 		webAuthnManager.getNonceManager().clear();
 	} catch {}
+	try {
+		require_thresholdEd25519AuthSession.clearAllCachedThresholdEd25519AuthSessions();
+	} catch {}
+}
+function prioritizeAuthenticatorsByDeviceNumber(authenticators, deviceNumber) {
+	if (authenticators.length <= 1) return authenticators;
+	if (deviceNumber === null) return authenticators;
+	const preferred = authenticators.filter((a) => a.deviceNumber === deviceNumber);
+	if (preferred.length === 0) return authenticators;
+	const rest = authenticators.filter((a) => a.deviceNumber !== deviceNumber);
+	return [...preferred, ...rest];
 }
-var init_login = require_rolldown_runtime.__esm({ "src/core/TatchiPasskey/login.ts": (() => {
-	require_sdkSentEvents.init_sdkSentEvents();
-	require_errors.init_errors();
-	require_vrf_worker.init_vrf_worker();
-	require_touchIdPrompt.init_touchIdPrompt();
-	require_index.init_IndexedDBManager();
-	require_rpcCalls.init_rpcCalls();
-}) });
 
 //#endregion
-init_login();
 exports.getLoginSession = getLoginSession;
 exports.getRecentLogins = getRecentLogins;
-Object.defineProperty(exports, 'init_login', {
-  enumerable: true,
-  get: function () {
-    return init_login;
-  }
-});
 exports.loginAndCreateSession = loginAndCreateSession;
 exports.logoutAndClearSession = logoutAndClearSession;
 //# sourceMappingURL=login.js.map