@seams/wallet 0.8.0 → 0.9.1

package/dist/esm/SeamsWeb/operations/authMethods/emailOtp/googleEmailOtpWalletAuthFlow.js

@@ -1,568 +0,0 @@
-import { walletIdFromString } from "../../../../shared-ts/src/utils/registrationIds.js";
-import { walletSessionRefFromSession } from "../../../../core/signingEngine/interfaces/ecdsaChainTarget.js";
-import { DEFAULT_UNLOCK_REMAINING_USES } from "../../../../core/signingEngine/threshold/sessionPolicy.js";
-import { listConfiguredThresholdEcdsaPublicationTargets, listThresholdEcdsaProvisionTargets } from "../../session/thresholdEcdsaProvisioning.js";
-import { buildNearWalletRegistrationSignerSetSelection } from "../../registration/registrationSignerSet.js";
-import { parseGoogleEmailOtpRegistrationOffer } from "./registrationOffer.js";
-//#region src/SeamsWeb/operations/authMethods/emailOtp/googleEmailOtpWalletAuthFlow.ts
-const DEFAULT_FLOW_TTL_MS = 600 * 1e3;
-function ok(value) {
-	return {
-		ok: true,
-		value
-	};
-}
-function fail(code, error) {
-	const message = error instanceof Error && error.message ? error.message : String(error || code);
-	const retryAfterMs = error && typeof error === "object" && "retryAfterMs" in error ? Number(error.retryAfterMs) : NaN;
-	return {
-		ok: false,
-		error: {
-			code,
-			message,
-			...Number.isFinite(retryAfterMs) && retryAfterMs >= 0 ? { retryAfterMs: Math.floor(retryAfterMs) } : {}
-		}
-	};
-}
-function failWithMessage(code, message, error) {
-	const base = fail(code, error);
-	if (base.ok) return base;
-	return {
-		ok: false,
-		error: {
-			...base.error,
-			message
-		}
-	};
-}
-function classifyEmailOtpSubmitError(error) {
-	const code = error && typeof error === "object" && "code" in error ? String(error.code || "") : "";
-	if (code.includes("rate")) return "email_otp_rate_limited";
-	if (code.includes("expired")) return "email_otp_expired";
-	if (code.includes("invalid") || code.includes("otp")) return "email_otp_invalid_code";
-	const message = error instanceof Error ? error.message.toLowerCase() : "";
-	if (message.includes("backup")) return "recovery_code_backup_incomplete";
-	if (message.includes("expired")) return "email_otp_expired";
-	if (message.includes("invalid") || message.includes("code")) return "email_otp_invalid_code";
-	return "unlock_failed";
-}
-function classifyRegistrationError(error) {
-	if ((error && typeof error === "object" && "code" in error ? String(error.code || "") : "") === "already_finalized_restore_required") return "registration_restore_required";
-	const message = error instanceof Error ? error.message.toLowerCase() : "";
-	if (message.includes("already finalized") || message.includes("restore or unlock")) return "registration_restore_required";
-	if (message.includes("backup")) return "recovery_code_backup_incomplete";
-	if (message.includes("expired")) return "flow_expired";
-	return "registration_failed";
-}
-function requireWalletId(resolution) {
-	const walletId = String(resolution.walletId || "").trim();
-	if (!walletId) throw new Error("Google verification did not return a wallet id");
-	return walletIdFromString(walletId);
-}
-function requireProviderSubject(resolution) {
-	const providerSubject = String(resolution.providerSubject || "").trim();
-	if (!providerSubject) throw new Error("Google verification did not return a provider subject");
-	return providerSubject;
-}
-function requireEmail(resolution) {
-	const email = String(resolution.email || "").trim();
-	if (!email) throw new Error("Google verification did not return an email address");
-	return email;
-}
-function parseOptionalExpiresAtMs(value) {
-	const parsed = typeof value === "number" ? value : typeof value === "string" ? Date.parse(value) : NaN;
-	return Number.isFinite(parsed) && parsed > Date.now() ? parsed : Date.now() + DEFAULT_FLOW_TTL_MS;
-}
-function requireRegistrationExpiresAtMs(value) {
-	const parsed = typeof value === "number" ? value : typeof value === "string" ? Date.parse(value) : NaN;
-	if (!Number.isFinite(parsed) || parsed <= Date.now()) throw new Error("Google Email OTP registration offer is expired or missing expiry");
-	return Math.floor(parsed);
-}
-function buildPrompt(input) {
-	if (input.mode === "register") return {
-		title: "Create your Email OTP wallet",
-		description: `Google verified ${input.emailHint}.`,
-		submitLabel: "Create wallet",
-		helperText: ""
-	};
-	return {
-		title: "Check your email to unlock your wallet",
-		description: `Enter the 6-digit code we sent to ${input.emailHint}.`,
-		submitLabel: "Unlock wallet",
-		helperText: ""
-	};
-}
-function resolveGoogleEmailOtpAuthMode(resolutionMode) {
-	return resolutionMode === "register_started" ? "register" : "login";
-}
-function isMissingGoogleEmailOtpEnrollment(error) {
-	if (!error || typeof error !== "object" || !("code" in error)) return false;
-	const code = String(error.code || "").trim();
-	const message = error instanceof Error ? error.message : String(error.message || "").trim();
-	return code === "not_found" && /Email OTP enrollment not found/i.test(message);
-}
-function googleAccountRegistrationRequiredMessage() {
-	return "Account doesn't exist. Create your account to continue.";
-}
-function classifyGoogleEmailOtpVerificationError(error) {
-	if (!error || typeof error !== "object" || !("code" in error)) return "google_verification_failed";
-	return Reflect.get(error, "code") === "stale_identity_mapping" ? "google_account_registration_required" : "google_verification_failed";
-}
-function googleEmailOtpProviderResolutionRequest(input, accountMode) {
-	if (input.replaceExistingWallet === true && accountMode !== "register") throw new Error("replaceExistingWallet is only valid with register mode");
-	return {
-		idToken: input.idToken,
-		accountMode,
-		relayUrl: input.relayUrl,
-		restartRegistrationOffer: accountMode === "register" && input.replaceExistingWallet === true,
-		...input.mode === "login" && input.loginTarget.kind === "wallet" ? { loginWalletId: String(input.loginTarget.walletId) } : {}
-	};
-}
-function emailOtpProviderForResolvedSubject(input) {
-	return input.providerSubject.toLowerCase() === input.verifiedEmail.toLowerCase() ? "email" : "google";
-}
-async function resolveGoogleEmailOtpProviderForAuthFlow(args) {
-	return await args.deps.resolveGoogleEmailOtpProvider(googleEmailOtpProviderResolutionRequest(args.input, args.input.mode));
-}
-function resolveSessionState(input) {
-	const walletId = input.authInput.mode === "login" && input.authInput.loginTarget.kind === "wallet" ? walletIdFromString(String(input.authInput.loginTarget.walletId)) : requireWalletId(input.resolution);
-	const emailHint = requireEmail(input.resolution);
-	const resolution = input.resolution;
-	const mode = resolveGoogleEmailOtpAuthMode(resolution.mode);
-	const offer = resolution.mode === "register_started" ? parseGoogleEmailOtpRegistrationOffer({
-		kind: "google_email_otp_registration_offer_v1",
-		offerId: resolution?.offer?.offerId,
-		expiresAtMs: requireRegistrationExpiresAtMs(resolution.expiresAtMs),
-		emailHint,
-		candidates: resolution?.offer?.candidates,
-		selectedCandidateId: resolution?.offer?.selectedCandidateId
-	}) : void 0;
-	return {
-		walletId: offer ? selectedGoogleEmailOtpRegistrationCandidate(offer).walletId : walletId,
-		...offer ? { offer } : {},
-		providerSubject: requireProviderSubject(input.resolution),
-		emailHint,
-		requestedMode: input.authInput.mode,
-		mode,
-		expiresAtMs: resolution.mode === "register_started" ? requireRegistrationExpiresAtMs(resolution.expiresAtMs) : parseOptionalExpiresAtMs(void 0),
-		...resolution.mode === "register_started" ? { registrationAttemptId: resolution.registrationAttemptId } : {}
-	};
-}
-async function selectLinkedEmailOtpWalletAuth(args) {
-	if (args.state.mode !== "login" || !args.deps.resolveLinkedEmailOtpWalletAuth) return args.state;
-	const selection = await args.deps.resolveLinkedEmailOtpWalletAuth({
-		walletId: String(args.state.walletId),
-		email: args.state.emailHint,
-		provider: emailOtpProviderForResolvedSubject({
-			providerSubject: args.state.providerSubject,
-			verifiedEmail: args.state.emailHint
-		}),
-		providerSubjectId: args.state.providerSubject
-	});
-	switch (selection.kind) {
-		case "none": return args.state;
-		case "selected": return {
-			...args.state,
-			linkedEmailOtpSelection: selection
-		};
-		case "rejected": throw new Error(selection.message);
-		default: throw new Error("Google Email OTP linked auth selection is invalid");
-	}
-}
-function rotateOfferCandidate(args) {
-	const currentIndex = args.offer.candidates.findIndex((candidate) => candidate.walletId === args.currentWalletId);
-	if (currentIndex < 0 || args.offer.candidates.length < 2) return null;
-	return args.offer.candidates[(currentIndex + 1) % args.offer.candidates.length] || null;
-}
-function selectedGoogleEmailOtpRegistrationCandidate(offer) {
-	const candidate = offer.candidates.find((entry) => entry.candidateId === offer.selectedCandidateId);
-	if (!candidate) throw new Error("Google Email OTP registration offer selected candidate is missing");
-	return candidate;
-}
-async function requestLoginChallenge(args) {
-	const result = await args.deps.requestEmailOtpChallenge({
-		walletId: args.state.walletId,
-		...args.state.linkedEmailOtpSelection ? { walletAuthMethodId: args.state.linkedEmailOtpSelection.walletAuthMethodId } : {},
-		...args.relayUrl ? { relayUrl: args.relayUrl } : {},
-		...args.onEvent ? { onEvent: args.onEvent } : {}
-	});
-	return {
-		challengeId: result.challengeId,
-		emailHint: result.delivery.emailHint,
-		delivery: result.delivery,
-		walletAuthMethodId: result.walletAuthMethodId,
-		signerSelection: result.signerSelection
-	};
-}
-function emitDemoEmailOtpCode(args) {
-	switch (args.delivery.kind) {
-		case "provider": return;
-		case "demo_code_response":
-		case "provider_and_demo_code":
-			args.onDemoOtp?.(args.delivery);
-			return;
-	}
-}
-function resolveRegistrationEcdsaTargets(args) {
-	const policy = args.policy || { kind: "configured" };
-	if (policy.kind === "none") return [];
-	if (policy.kind === "explicit") return policy.targets;
-	return listThresholdEcdsaProvisionTargets({
-		signerOptions: args.configs.signing.thresholdEcdsa.provisioningDefaults,
-		chains: args.configs.network.chains
-	}).map((target) => target.chainTarget);
-}
-function resolveLoginEcdsaTargets(args) {
-	const policy = args.policy || { kind: "configured" };
-	if (policy.kind === "none") return [];
-	if (policy.kind === "explicit") return policy.targets;
-	return listConfiguredThresholdEcdsaPublicationTargets(args.configs.network.chains).map((target) => target.chainTarget);
-}
-function registrationOptionsFromInput(args) {
-	return {
-		...args.onEvent ? { onEvent: args.onEvent } : {},
-		...args.recoveryCodeBackup ? { recoveryCodeBackup: args.recoveryCodeBackup } : {}
-	};
-}
-function resolveGoogleEmailOtpEd25519RemainingUses(configs) {
-	const configured = Math.floor(Number(configs.signing.sessionDefaults?.remainingUses) || 0);
-	if (configured <= 0) return DEFAULT_UNLOCK_REMAINING_USES;
-	return Math.min(configured, DEFAULT_UNLOCK_REMAINING_USES);
-}
-async function loginWithConfiguredTargets(args) {
-	const walletSession = walletSessionRefFromSession({ walletId: args.state.walletId });
-	const authoritySelector = {
-		kind: "wallet_auth_method",
-		walletAuthMethodId: args.challenge.walletAuthMethodId
-	};
-	const [primaryTarget] = args.targets;
-	if (!primaryTarget) {
-		if (args.challenge.signerSelection.kind !== "ed25519_only") throw new Error("Selected Email OTP authority requires an ECDSA chain target");
-		await args.deps.loginWithEmailOtpEd25519YaoCapability({
-			walletSession,
-			authoritySelector,
-			providerSubjectId: args.state.providerSubject,
-			emailOtpAuthorityEmail: args.state.emailHint,
-			challengeId: args.challenge.challengeId,
-			otpCode: args.otpCode,
-			remainingUses: resolveGoogleEmailOtpEd25519RemainingUses(args.deps.configs),
-			ed25519Selection: args.challenge.signerSelection
-		});
-		return;
-	}
-	const common = {
-		walletSession,
-		walletAuthMethodId: authoritySelector.walletAuthMethodId,
-		providerIdentity: {
-			provider: emailOtpProviderForResolvedSubject({
-				providerSubject: args.state.providerSubject,
-				verifiedEmail: args.state.emailHint
-			}),
-			providerSubjectId: args.state.providerSubject
-		},
-		challengeId: args.challenge.challengeId,
-		emailOtpAuthorityEmail: args.state.emailHint,
-		otpCode: args.otpCode,
-		...args.input.relayUrl ? { relayUrl: args.input.relayUrl } : {},
-		...args.input.emailOtpAuthPolicy ? { emailOtpAuthPolicy: args.input.emailOtpAuthPolicy } : {},
-		...args.input.onEvent ? { onEvent: args.input.onEvent } : {}
-	};
-	if (args.challenge.signerSelection.kind !== "ecdsa") throw new Error("Selected Email OTP authority has no ECDSA signer");
-	await args.deps.loginWithEmailOtpEcdsaCapability({
-		...common,
-		chainTarget: primaryTarget,
-		publicationChainTargets: args.targets,
-		keyHandle: args.challenge.signerSelection.keyHandle,
-		ed25519Selection: args.challenge.signerSelection.ed25519
-	});
-}
-function registrationOptionsForNoEcdsa(args) {
-	return {
-		...args.options,
-		signerOptions: {
-			tempo: {
-				enabled: false,
-				signingSession: {
-					kind: "jwt",
-					ttlMs: 0,
-					remainingUses: 0
-				}
-			},
-			evm: {
-				enabled: false,
-				signingSession: {
-					kind: "jwt",
-					ttlMs: 0,
-					remainingUses: 0
-				}
-			}
-		}
-	};
-}
-async function assertLoggedIn(deps, walletId) {
-	const session = await deps.getWalletSession(walletId);
-	if (session.appIdentity.kind !== "resolved" || String(session.appIdentity.walletId) !== String(walletId) || session.authentication.kind !== "authenticated" || String(session.authentication.walletId) !== String(walletId)) throw new Error("Wallet auth completed, but the local signing session is not ready yet.");
-	return session;
-}
-async function assertRegistrationPersisted(deps, walletId) {
-	const session = await deps.getWalletSession(walletId);
-	if (session.appIdentity.kind !== "resolved" || String(session.appIdentity.walletId) !== String(walletId)) throw new Error("Wallet registration completed, but the local wallet identity is not ready.");
-	return session;
-}
-function startGoogleEmailOtpRegistrationPrewarm(deps) {
-	return {
-		kind: "started",
-		completion: deps.prewarmEmailOtpYao().catch(() => void 0)
-	};
-}
-async function beginGoogleEmailOtpWalletAuth(deps, input) {
-	let sessionState;
-	try {
-		sessionState = resolveSessionState({
-			authInput: input,
-			resolution: await resolveGoogleEmailOtpProviderForAuthFlow({
-				deps,
-				input
-			})
-		});
-		sessionState = await selectLinkedEmailOtpWalletAuth({
-			deps,
-			state: sessionState
-		});
-	} catch (error) {
-		return fail(classifyGoogleEmailOtpVerificationError(error), error);
-	}
-	if (sessionState.mode === "register") return ok(createGoogleEmailOtpWalletRegistrationFlow(deps, {
-		state: sessionState,
-		input,
-		prewarm: { kind: "not_started" }
-	}));
-	try {
-		const challenge = await requestLoginChallenge({
-			deps,
-			state: sessionState,
-			...input.relayUrl ? { relayUrl: input.relayUrl } : {},
-			...input.onEvent ? { onEvent: input.onEvent } : {}
-		});
-		return ok(createGoogleEmailOtpWalletLoginFlow(deps, {
-			state: sessionState,
-			challenge,
-			input
-		}));
-	} catch (error) {
-		if (isMissingGoogleEmailOtpEnrollment(error)) return failWithMessage("google_account_registration_required", googleAccountRegistrationRequiredMessage(), error);
-		return fail("email_otp_challenge_failed", error);
-	}
-}
-function createFlowLiveness(args) {
-	let active = true;
-	return {
-		ensureActive() {
-			if (!active) throw new Error("Google Email OTP wallet auth flow is no longer active");
-			if (Date.now() > args.state.expiresAtMs) {
-				active = false;
-				throw new Error("Google Email OTP wallet auth flow expired");
-			}
-		},
-		burn() {
-			active = false;
-		}
-	};
-}
-function relayerUrlFromInput(args) {
-	return String(args.input.relayUrl || args.deps.configs.network.relayer?.url || "").trim();
-}
-function createGoogleEmailOtpWalletRegistrationFlow(deps, args) {
-	const registrationAttemptId = String(args.state.registrationAttemptId || "").trim();
-	if (!registrationAttemptId) throw new Error("Google Email OTP registration requires a registration attempt id");
-	if (!args.state.offer) throw new Error("Google Email OTP registration requires an offer");
-	const offer = args.state.offer;
-	const requiredTargets = resolveRegistrationEcdsaTargets({
-		configs: deps.configs,
-		policy: args.input.ecdsaTargets
-	});
-	const hookOptions = registrationOptionsFromInput({
-		onEvent: args.input.onEvent,
-		recoveryCodeBackup: args.input.recoveryCodeBackup
-	});
-	const registrationOptions = requiredTargets.length ? hookOptions : registrationOptionsForNoEcdsa({ options: hookOptions });
-	const selectedWalletId = selectedGoogleEmailOtpRegistrationCandidate(offer).walletId;
-	const registrationAuthMethod = {
-		kind: "email_otp",
-		proofKind: "google_sso_registration",
-		email: args.state.emailHint,
-		providerSubject: args.state.providerSubject,
-		googleEmailOtpRegistrationAttemptId: registrationAttemptId,
-		googleEmailOtpRegistrationOfferId: offer.offerId,
-		googleEmailOtpRegistrationCandidateId: offer.selectedCandidateId
-	};
-	const registrationArgs = {
-		wallet: {
-			kind: "provided",
-			walletId: selectedWalletId
-		},
-		authMethod: registrationAuthMethod,
-		signerSelection: args.input.signerSelection ?? buildNearWalletRegistrationSignerSetSelection({
-			configs: deps.configs,
-			options: registrationOptions,
-			ecdsaChainTargets: requiredTargets
-		}),
-		options: registrationOptions
-	};
-	const prewarm = args.prewarm.kind === "not_started" ? startGoogleEmailOtpRegistrationPrewarm(deps) : args.prewarm;
-	const liveness = createFlowLiveness({ state: args.state });
-	return {
-		kind: "google_email_otp_wallet_auth_flow_v1",
-		state: "registration_ready",
-		flowId: `google-email-otp-registration:${selectedWalletId}:${registrationAttemptId}`,
-		requestedMode: args.state.requestedMode,
-		mode: "register",
-		walletId: selectedWalletId,
-		emailHint: args.state.emailHint,
-		prompt: buildPrompt({
-			mode: "register",
-			emailHint: args.state.emailHint
-		}),
-		expiresAtMs: args.state.expiresAtMs,
-		completeRegistration: async () => {
-			try {
-				liveness.ensureActive();
-				const result = await deps.registerWallet(registrationArgs);
-				if (!result.success) {
-					const error = Object.assign(new Error(result.error || "Wallet registration failed"), { code: result.errorCode });
-					return fail(classifyRegistrationError(error), error);
-				}
-				liveness.burn();
-				return ok({
-					walletId: selectedWalletId,
-					mode: "register",
-					session: await assertRegistrationPersisted(deps, selectedWalletId),
-					registration: result
-				});
-			} catch (error) {
-				return fail(classifyRegistrationError(error), error);
-			}
-		},
-		rerollWalletId: async () => {
-			try {
-				liveness.ensureActive();
-				if (!args.state.offer) return fail("google_verification_failed", /* @__PURE__ */ new Error("Google Email OTP registration offer is missing wallet candidates"));
-				const nextCandidate = rotateOfferCandidate({
-					offer: args.state.offer,
-					currentWalletId: selectedWalletId
-				});
-				if (!nextCandidate) return fail("google_verification_failed", /* @__PURE__ */ new Error("Google Email OTP registration offer has no alternate wallet candidate"));
-				liveness.burn();
-				return ok(createGoogleEmailOtpWalletRegistrationFlow(deps, {
-					state: {
-						...args.state,
-						walletId: nextCandidate.walletId,
-						offer: {
-							...args.state.offer,
-							selectedCandidateId: nextCandidate.candidateId
-						}
-					},
-					input: args.input,
-					prewarm
-				}));
-			} catch (error) {
-				return fail("google_verification_failed", error);
-			}
-		},
-		cancel: async () => {
-			liveness.burn();
-		}
-	};
-}
-function createGoogleEmailOtpWalletLoginFlow(deps, args) {
-	const liveness = createFlowLiveness({ state: args.state });
-	const flowId = `google-email-otp-login:${args.state.walletId}:${args.challenge.challengeId}`;
-	emitDemoEmailOtpCode({
-		delivery: args.challenge.delivery,
-		onDemoOtp: args.input.onDemoOtp
-	});
-	return {
-		kind: "google_email_otp_wallet_auth_flow_v1",
-		state: "challenge_sent",
-		flowId,
-		requestedMode: args.state.requestedMode,
-		mode: "login",
-		walletId: args.state.walletId,
-		emailHint: args.challenge.emailHint,
-		prompt: buildPrompt({
-			mode: "login",
-			emailHint: args.challenge.emailHint
-		}),
-		delivery: args.challenge.delivery,
-		expiresAtMs: args.state.expiresAtMs,
-		resend: async () => {
-			try {
-				liveness.ensureActive();
-				const challenge = await requestLoginChallenge({
-					deps,
-					state: args.state,
-					...args.input.relayUrl ? { relayUrl: args.input.relayUrl } : {},
-					...args.input.onEvent ? { onEvent: args.input.onEvent } : {}
-				});
-				liveness.burn();
-				return ok(createGoogleEmailOtpWalletLoginFlow(deps, {
-					state: args.state,
-					challenge,
-					input: args.input
-				}));
-			} catch (error) {
-				return fail("email_otp_challenge_failed", error);
-			}
-		},
-		submit: async (submitInput) => {
-			try {
-				liveness.ensureActive();
-				const otpCode = String(submitInput.otpCode || "").trim();
-				if (!/^\d{6}$/.test(otpCode)) return fail("email_otp_invalid_code", /* @__PURE__ */ new Error("Enter the 6-digit code from your email."));
-				const configuredTargets = resolveLoginEcdsaTargets({
-					configs: deps.configs,
-					policy: args.input.ecdsaTargets
-				});
-				const requiredTargets = args.challenge.signerSelection.kind === "ed25519_only" ? [] : configuredTargets;
-				if (args.state.linkedEmailOtpSelection?.execution === "authority") {
-					if (!deps.loginWithLinkedEmailOtpWallet) throw new Error("Exact linked Email OTP wallet unlock is unavailable");
-					await deps.loginWithLinkedEmailOtpWallet({
-						walletId: String(args.state.walletId),
-						walletAuthMethodId: args.state.linkedEmailOtpSelection.walletAuthMethodId,
-						email: args.state.emailHint,
-						providerSubjectId: args.state.providerSubject,
-						challengeId: args.challenge.challengeId,
-						otpCode,
-						relayUrl: relayerUrlFromInput({
-							deps,
-							input: args.input
-						})
-					});
-				} else await loginWithConfiguredTargets({
-					deps,
-					state: args.state,
-					input: args.input,
-					challenge: args.challenge,
-					otpCode,
-					targets: requiredTargets
-				});
-				liveness.burn();
-				const session = await assertLoggedIn(deps, args.state.walletId);
-				return ok({
-					walletId: args.state.walletId,
-					mode: "login",
-					session
-				});
-			} catch (error) {
-				return fail(classifyEmailOtpSubmitError(error), error);
-			}
-		},
-		cancel: async () => {
-			liveness.burn();
-		}
-	};
-}
-//#endregion
-export { beginGoogleEmailOtpWalletAuth };
-
-//# sourceMappingURL=googleEmailOtpWalletAuthFlow.js.map

package/dist/esm/SeamsWeb/operations/authMethods/emailOtp/localEmailOtpProjection.js

@@ -1,69 +0,0 @@
-import { parseVerifiedEmailAddress, parseWalletAuthMethodId, parseWalletAuthorityId } from "../../../../shared-ts/src/utils/domainIds.js";
-import { isEmailOtpWalletAuthAuthority } from "../../../../shared-ts/src/utils/walletAuthAuthority.js";
-import { buildWalletAuthMethodRecordV2 } from "../../../../shared-ts/src/utils/walletAuthMethodRecord.js";
-import { IndexedDBManager } from "../../../../core/indexedDB/index.js";
-//#region src/SeamsWeb/operations/authMethods/emailOtp/localEmailOtpProjection.ts
-/**
-* The local projection of an Email OTP factor the server has already accepted.
-*
-* A cache of the server's record, written after the finalize that produced it
-* rather than inside it. A finalize that succeeded but whose local write did
-* not is recoverable: replaying it returns the same response, and the
-* projection can be written again.
-*
-* Both shapes are written, and they are not redundant. The V1 record is what
-* the local unlock path reads to know this wallet can be opened with an email
-* code at all; the V2 record is what names the method and the authority it
-* belongs to, which is what makes two active methods on one authority
-* distinguishable.
-*/
-/** Writes the projection for a factor the server has already accepted. */
-async function persistFinalizedEmailOtpAuthMethodV1(args) {
-	if (!isEmailOtpWalletAuthAuthority(args.authority)) throw new Error("Wallet add-email-code finalize returned a non-Email authority");
-	const walletAuthMethodId = parseWalletAuthMethodId(args.walletAuthMethodId);
-	if (!walletAuthMethodId.ok) throw new Error(walletAuthMethodId.error.message);
-	const walletAuthorityId = parseWalletAuthorityId(args.walletAuthorityId);
-	if (!walletAuthorityId.ok) throw new Error(walletAuthorityId.error.message);
-	const emailHashHex = String(args.authority.verifier.emailHashHex || "").trim();
-	if (!emailHashHex) throw new Error("Wallet add-email-code finalize returned no verified email digest");
-	const registrationAuthorityId = String(args.authority.factor.providerUserId || "").trim();
-	if (!registrationAuthorityId) throw new Error("Wallet add-email-code finalize returned no provider identity");
-	const emailAddress = parseVerifiedEmailAddress(args.emailAddress);
-	if (!emailAddress.ok) throw new Error(emailAddress.error.message);
-	const nowMs = Date.now();
-	await IndexedDBManager.upsertWalletAuthMethod({
-		version: "wallet_auth_method_v1",
-		kind: "email_otp",
-		status: "active",
-		localStatus: "synced",
-		walletId: args.walletId,
-		emailHashHex,
-		registrationAuthorityId,
-		authority: args.authority,
-		createdAtMs: nowMs,
-		updatedAtMs: nowMs
-	});
-	await IndexedDBManager.upsertWalletAuthMethodV2(buildWalletAuthMethodRecordV2({
-		version: "wallet_auth_method_v2",
-		walletAuthMethodId: walletAuthMethodId.value,
-		walletId: args.walletId,
-		walletAuthorityId: walletAuthorityId.value,
-		kind: "email_otp",
-		status: "active",
-		emailHashHex,
-		registrationAuthorityId,
-		createdAtMs: nowMs,
-		updatedAtMs: nowMs,
-		activatedAtMs: nowMs
-	}));
-	const retained = await IndexedDBManager.retainVerifiedEmailOtpLocalPresentation({
-		walletId: args.walletId,
-		walletAuthMethodId: walletAuthMethodId.value,
-		emailAddress: emailAddress.value
-	});
-	if (retained.kind !== "retained") throw new Error(`Verified Email OTP presentation was not retained: ${retained.reason}`);
-}
-//#endregion
-export { persistFinalizedEmailOtpAuthMethodV1 };
-
-//# sourceMappingURL=localEmailOtpProjection.js.map