@seams/wallet 0.7.3 → 0.8.0

package/dist/esm/react/core/signingEngine/uiConfirm/handlers/flows/signing.js

@@ -1,684 +0,0 @@
-import { toError } from "../../../../../shared-ts/src/utils/errors.js";
-import { reviewAdmissionForBinding } from "../../transactionReviewAdmission.js";
-import { SigningAuthPlanKind } from "../../../stepUpConfirmation/types.js";
-import { SigningOperationInteractionEventKind, isSigningOperationReviewApprovedStateKind } from "../../../flows/shared/signingStateMachine.js";
-import { walletSessionFailureFromError } from "../../../session/lifecycle/walletSessionFailure.js";
-import { clearIntentDigestPreparation, consumeIntentDigestPreparation } from "../../../stepUpConfirmation/intentDigestPreparation.js";
-import { UserConfirmationType } from "../../../stepUpConfirmation/userConfirmationType.js";
-import { getIntentDigest, getNearAccountId, getSignIntentDigestSubject, getSignTransactionPayload, getSigningAuthMode, getTxCount } from "./adapters/request.js";
-import { ERROR_MESSAGES, isUserCancelledUserConfirm, sendConfirmProgress } from "../../../stepUpConfirmation/channel/confirmCommon.js";
-import { collectAuthenticationCredentialForChallengeB64u, collectAuthenticationCredentialForWalletChallengeB64u } from "../../../webauthnAuth/credentials/collectAuthenticationCredentialForChallengeB64u.js";
-import { computeUiIntentDigestFromNep413 } from "../../../../../utils/intentDigest.js";
-import { formatNearAccountFundingNotice, formatNearAccountFundingProgressNotice } from "../../nearFundingNotice.js";
-import { createConfirmSession, createConfirmTxFlowAdapters } from "./adapters/adapters.js";
-import { consumeConfirmationReadiness } from "../../confirmationReadinessRegistry.js";
-//#region src/core/signingEngine/uiConfirm/handlers/flows/signing.ts
-const TOUCH_CONFIRM_PROGRESS_PHASE = {
-	CONFIRMATION_COMPLETE: "confirmation.complete",
-	PASSKEY_PROMPT_STARTED: "auth.passkey.prompt.started",
-	PASSKEY_PROMPT_SUCCEEDED: "auth.passkey.prompt.succeeded"
-};
-function sendConfirmationCancelledProgress(worker, requestId, message) {
-	sendConfirmProgress(worker, {
-		requestId,
-		step: 2,
-		phase: TOUCH_CONFIRM_PROGRESS_PHASE.CONFIRMATION_COMPLETE,
-		status: "failed",
-		message: message || ERROR_MESSAGES.cancelled
-	});
-}
-function getTransactionSigningAuthMode(request) {
-	if (request.type === UserConfirmationType.SIGN_TRANSACTION) return getSigningAuthMode(request) ?? "webauthn";
-	if (request.type === UserConfirmationType.SIGN_NEP413_MESSAGE) return getSigningAuthMode(request) ?? "webauthn";
-	return "webauthn";
-}
-function shouldRenderNearTransactionReview(args) {
-	return !isSigningOperationReviewApprovedStateKind(args.signingOperationStateKind) || args.signingAuthMode === "emailOtp";
-}
-function requireSigningOperationInteractionCallback(callback) {
-	if (!callback) throw new Error("NEAR transaction signing lifecycle callback is required");
-	return callback;
-}
-function keepPromisePending() {}
-function pendingPromise() {
-	return new Promise(keepPromisePending);
-}
-function readinessCompletedWithoutExpiry() {
-	return pendingPromise();
-}
-function readinessFailedWithPossibleExpiry(error) {
-	const failure = walletSessionFailureFromError(error);
-	if (failure?.kind === "expired") return {
-		kind: "wallet_session_expired",
-		failure
-	};
-	return pendingPromise();
-}
-function waitForWalletSessionExpiry(readiness) {
-	return readiness.then(readinessCompletedWithoutExpiry, readinessFailedWithPossibleExpiry);
-}
-function isWalletSessionExpiredConfirmationOutcome(value) {
-	return "kind" in value && value.kind === "wallet_session_expired";
-}
-function resolveNearSigningReadinessMode(args) {
-	if (args.request.type === UserConfirmationType.SIGN_NEP413_MESSAGE) return { kind: "signature_only" };
-	if (args.request.type === UserConfirmationType.SIGN_TRANSACTION && args.transactionSummary.type === "delegateAction") return { kind: "signature_only" };
-	return { kind: "transaction_access_key" };
-}
-function nearRpcFailureMessage(args) {
-	if (args.error === "NEAR_ACCOUNT_LOOKUP_FAILED") return args.details || "NEAR account access-key lookup failed.";
-	return args.details ? `${ERROR_MESSAGES.nearRpcFailed}: ${args.details}` : ERROR_MESSAGES.nearRpcFailed;
-}
-function buildNearContextFetchInput(args) {
-	if (args.readinessMode.kind !== "transaction_access_key") return void 0;
-	if (args.request.type !== UserConfirmationType.SIGN_TRANSACTION) throw new Error("NEAR transaction readiness requires a transaction confirmation request");
-	const payload = getSignTransactionPayload(args.request);
-	if (payload.signingKind !== "transaction") throw new Error("NEAR transaction readiness cannot use a delegate confirmation payload");
-	const fundingRequest = payload.nearFundingRequest;
-	if (fundingRequest.signatureUses !== args.usesNeeded) throw new Error("NEAR funding request signature use count does not match confirmation request");
-	return fundingRequest;
-}
-function nearReadinessDecisionFields(readiness) {
-	return readiness ? { nearTransactionReadiness: readiness } : {};
-}
-function normalizeSixDigitOtpCode(value) {
-	const code = String(value || "").replace(/\D/g, "").slice(0, 6);
-	if (!/^\d{6}$/.test(code)) throw new Error("Enter the 6-digit Email OTP code to continue");
-	return code;
-}
-function assertPasskeyCredentialLookupAllowed(args) {
-	if (args.signingAuthPlanKind !== SigningAuthPlanKind.EmailOtpReauth) return;
-	console.warn("[SigningEngine][ui-confirm] Email OTP auth plan reached passkey credential lookup", {
-		stage: args.stage,
-		subjectId: args.subjectId,
-		requestId: args.requestId,
-		signingAuthPlanKind: args.signingAuthPlanKind
-	});
-	throw new Error("[SigningEngine] passkey_lookup_for_email_otp");
-}
-function assertNever(value) {
-	throw new Error(`Unsupported WebAuthn challenge branch: ${JSON.stringify(value)}`);
-}
-function cancelNearOperationStepUpPreparation(args) {
-	args.ctx.operationStepUpPreparation.cancel({
-		requestId: args.requestId,
-		...args.preparation ? { handle: args.preparation.handle } : {}
-	});
-}
-function requireBoundChallengeB64u(value) {
-	const challenge = String(value || "").trim();
-	return !challenge || challenge === "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" ? "" : challenge;
-}
-function resolveTypedWebAuthnChallenge(args) {
-	const defaultChallengeB64u = requireBoundChallengeB64u(args.defaultChallengeB64u);
-	if (!args.webauthnChallenge) {
-		if (args.requireTypedChallenge) throw new Error("Missing typed WebAuthn challenge for passkey signing flow");
-		return defaultChallengeB64u;
-	}
-	switch (args.webauthnChallenge.kind) {
-		case "intent_digest": return requireBoundChallengeB64u(args.webauthnChallenge.challengeB64u) || defaultChallengeB64u;
-		case "threshold_session_policy": return String(args.webauthnChallenge.digest32B64u || "").trim();
-		case "ecdsa_role_local_bootstrap": return String(args.webauthnChallenge.digest32B64u || "").trim();
-	}
-	return assertNever(args.webauthnChallenge);
-}
-async function handleTransactionSigningFlow(ctx, request, worker, opts) {
-	const reviewAdmission = reviewAdmissionForBinding(ctx.surfaceMeasurementBinding);
-	const { confirmationConfig, transactionSummary, theme, surface } = opts;
-	const adapters = createConfirmTxFlowAdapters(ctx);
-	const session = createConfirmSession({
-		adapters,
-		worker,
-		request,
-		confirmationConfig,
-		transactionSummary,
-		theme,
-		surface
-	});
-	const nearAccountId = getNearAccountId(request);
-	let operationStepUpPreparation;
-	let resolvedIntentDigestForResponse = String(getIntentDigest(request) || "").trim() || void 0;
-	if (resolvedIntentDigestForResponse === "pending-intent-digest") resolvedIntentDigestForResponse = void 0;
-	try {
-		const signingAuthMode = getTransactionSigningAuthMode(request);
-		const signTransactionPayload = request.type === UserConfirmationType.SIGN_TRANSACTION ? getSignTransactionPayload(request) : null;
-		const nearTransactionReviewPayload = signTransactionPayload?.signingKind === "transaction" ? signTransactionPayload : null;
-		const notifySigningOperationInteraction = nearTransactionReviewPayload ? requireSigningOperationInteractionCallback(opts.onSigningOperationInteractionEvent) : null;
-		const reviewAlreadyApproved = nearTransactionReviewPayload ? isSigningOperationReviewApprovedStateKind(nearTransactionReviewPayload.signingOperationStateKind) : false;
-		const reviewPromptRequired = nearTransactionReviewPayload ? shouldRenderNearTransactionReview({
-			signingOperationStateKind: nearTransactionReviewPayload.signingOperationStateKind,
-			signingAuthMode
-		}) : true;
-		const usesNeeded = getTxCount(request);
-		const intentPreparation = request.type === UserConfirmationType.SIGN_TRANSACTION ? consumeIntentDigestPreparation(request.requestId) : void 0;
-		let resolvedIntentDigest = request.type === UserConfirmationType.SIGN_TRANSACTION ? String(getIntentDigest(request) || "").trim() || void 0 : request.type === UserConfirmationType.SIGN_NEP413_MESSAGE ? String(await computeUiIntentDigestFromNep413({
-			nearAccountId,
-			recipient: request.payload.recipient,
-			message: request.payload.message
-		})).trim() || void 0 : void 0;
-		if (resolvedIntentDigest === "pending-intent-digest") resolvedIntentDigest = void 0;
-		let resolvedChallengeB64u = resolvedIntentDigest;
-		resolvedIntentDigestForResponse = resolvedIntentDigest;
-		const readinessMode = resolveNearSigningReadinessMode({
-			request,
-			transactionSummary
-		});
-		const nearContextFetchInput = buildNearContextFetchInput({
-			request,
-			usesNeeded,
-			readinessMode
-		});
-		const nearContextPromise = nearContextFetchInput ? adapters.near.fetchNearContext(nearContextFetchInput) : void 0;
-		const rpId = adapters.security.getRpId();
-		const baseSecurityContext = rpId ? { rpId } : void 0;
-		let resolvePromptReady;
-		const promptReady = new Promise((resolve) => {
-			resolvePromptReady = resolve;
-		});
-		let decisionResolved = false;
-		let nearContextFailed = false;
-		const confirmationReadiness = consumeConfirmationReadiness(request.requestId);
-		let confirmationReadinessPending = !!confirmationReadiness;
-		const confirmationReadinessPromise = confirmationReadiness ? Promise.resolve(confirmationReadiness.promise) : void 0;
-		const walletSessionExpiryPromise = confirmationReadinessPromise ? waitForWalletSessionExpiry(confirmationReadinessPromise) : void 0;
-		const markPromptReady = () => {
-			resolvePromptReady?.();
-			resolvePromptReady = void 0;
-		};
-		if (signingAuthMode === "emailOtp") notifySigningOperationInteraction?.({ kind: SigningOperationInteractionEventKind.AuthenticationStarted });
-		const promptDecisionPromise = reviewPromptRequired ? session.promptUser({
-			securityContext: baseSecurityContext,
-			loading: false,
-			onMounted: () => {
-				markPromptReady();
-				if (confirmationReadinessPending) session.updateUI({ preparing: true });
-			}
-		}) : Promise.resolve({ confirmed: true });
-		if (reviewPromptRequired) promptDecisionPromise.finally(markPromptReady);
-		else markPromptReady();
-		let nearRpcResolved;
-		const applyPreparedIntentData = (prepared) => {
-			const preparedIntentDigest = String(prepared.intentDigest || "").trim();
-			const preparedChallengeB64u = String(prepared.challengeB64u || "").trim();
-			if (preparedIntentDigest) {
-				resolvedIntentDigest = preparedIntentDigest;
-				resolvedIntentDigestForResponse = preparedIntentDigest;
-			}
-			if (preparedChallengeB64u) resolvedChallengeB64u = preparedChallengeB64u;
-		};
-		const applyPreparedIntentToUi = (prepared) => {
-			applyPreparedIntentData(prepared);
-			session.updateUI({
-				...prepared.displayModel ? { model: prepared.displayModel } : {},
-				...prepared.title ? { title: prepared.title } : {},
-				...prepared.body ? { body: prepared.body } : {},
-				loading: false
-			});
-		};
-		const preparedIntentPromise = intentPreparation ? (async () => {
-			await promptReady;
-			return await intentPreparation;
-		})() : void 0;
-		if (preparedIntentPromise) preparedIntentPromise.then((prepared) => {
-			if (decisionResolved) return;
-			applyPreparedIntentToUi(prepared);
-		}).catch((error) => {
-			if (decisionResolved) return;
-			session.updateUI({
-				loading: false,
-				errorMessage: String(toError(error)?.message || error || "Failed to prepare intent")
-			});
-		});
-		if (confirmationReadinessPromise) confirmationReadinessPromise.then(async () => {
-			confirmationReadinessPending = false;
-			await promptReady;
-			if (decisionResolved) return;
-			session.updateUI({ preparing: false });
-		}).catch(async (error) => {
-			confirmationReadinessPending = false;
-			await promptReady;
-			if (decisionResolved) return;
-			if (nearContextFailed) {
-				session.updateUI({ preparing: false });
-				return;
-			}
-			const message = String(toError(error)?.message || "NEAR signing session could not be finalized");
-			session.updateUI({
-				preparing: false,
-				errorMessage: `NEAR signing session could not be finalized: ${message}`
-			});
-		});
-		if (nearContextPromise) nearContextPromise.then(async (nearRpc) => {
-			nearRpcResolved = nearRpc;
-			await promptReady;
-			if (nearRpc.kind === "failed") {
-				nearContextFailed = true;
-				if (decisionResolved) return;
-				session.updateUI({
-					loading: false,
-					errorMessage: nearRpcFailureMessage(nearRpc)
-				});
-				return;
-			}
-			nearContextFailed = false;
-			if (nearRpc.readiness.kind === "funding_required") {
-				if (decisionResolved) return;
-				session.updateUI({
-					loading: false,
-					body: formatNearAccountFundingNotice(String(nearRpc.readiness.request.subject.nearAccountId)),
-					errorMessage: "",
-					confirmText: "Fund account"
-				});
-				return;
-			}
-			session.setNonceLeases(nearRpc.reservedNonceLeases);
-			const transactionContext = nearRpc.readiness.transactionContext;
-			const securityContext = rpId ? {
-				rpId,
-				blockHeight: transactionContext.txBlockHeight,
-				blockHash: transactionContext.txBlockHash
-			} : void 0;
-			if (decisionResolved) return;
-			session.updateUI({
-				securityContext,
-				loading: false
-			});
-		});
-		const promptDecisionOrExpiry = walletSessionExpiryPromise ? await Promise.race([promptDecisionPromise, walletSessionExpiryPromise]) : await promptDecisionPromise;
-		decisionResolved = true;
-		if (isWalletSessionExpiredConfirmationOutcome(promptDecisionOrExpiry)) {
-			cancelNearOperationStepUpPreparation({
-				ctx,
-				requestId: request.requestId,
-				preparation: operationStepUpPreparation
-			});
-			return session.confirmAndCloseModal({
-				requestId: request.requestId,
-				intentDigest: resolvedIntentDigestForResponse,
-				confirmed: false,
-				walletSessionFailure: promptDecisionOrExpiry.failure
-			});
-		}
-		const { confirmed, error: uiError, otpCode, emailOtpChallengeId } = promptDecisionOrExpiry;
-		if (!confirmed) {
-			sendConfirmationCancelledProgress(worker, request.requestId, uiError);
-			cancelNearOperationStepUpPreparation({
-				ctx,
-				requestId: request.requestId,
-				preparation: operationStepUpPreparation
-			});
-			return session.confirmAndCloseModal({
-				requestId: request.requestId,
-				intentDigest: resolvedIntentDigestForResponse,
-				confirmed: false,
-				error: uiError
-			});
-		}
-		if (notifySigningOperationInteraction && !reviewAlreadyApproved) {
-			notifySigningOperationInteraction({ kind: SigningOperationInteractionEventKind.ReviewApproved });
-			session.dismissReviewSurface();
-		}
-		const nearRpc = nearContextPromise ? nearRpcResolved || await nearContextPromise : void 0;
-		let nearTransactionReadiness;
-		if (nearContextPromise) {
-			if (!nearRpc || nearRpc.kind === "failed") {
-				const failure = nearRpc || {
-					kind: "failed",
-					error: "NEAR_CONTEXT_UNAVAILABLE",
-					details: "NEAR transaction readiness did not resolve"
-				};
-				console.error("[SigningFlow] fetchNearContext failed", failure);
-				cancelNearOperationStepUpPreparation({
-					ctx,
-					requestId: request.requestId,
-					preparation: operationStepUpPreparation
-				});
-				return session.confirmAndCloseModal({
-					requestId: request.requestId,
-					intentDigest: resolvedIntentDigestForResponse,
-					confirmed: false,
-					error: nearRpcFailureMessage(failure)
-				});
-			}
-			nearTransactionReadiness = nearRpc.readiness;
-			if (nearRpc.readiness.kind === "context_ready") session.setNonceLeases(nearRpc.reservedNonceLeases);
-		}
-		if (preparedIntentPromise) applyPreparedIntentData(await preparedIntentPromise);
-		if (confirmationReadinessPromise) try {
-			await confirmationReadinessPromise;
-		} catch (error) {
-			const message = String(toError(error)?.message || "NEAR signing session could not be finalized");
-			cancelNearOperationStepUpPreparation({
-				ctx,
-				requestId: request.requestId,
-				preparation: operationStepUpPreparation
-			});
-			return session.confirmAndCloseModal({
-				requestId: request.requestId,
-				intentDigest: resolvedIntentDigestForResponse,
-				confirmed: false,
-				error: `NEAR signing session could not be finalized: ${message}`
-			});
-		}
-		if (signingAuthMode !== "warmSession" && nearTransactionReadiness?.kind === "funding_required" && nearContextFetchInput) {
-			session.updateUI({
-				body: formatNearAccountFundingProgressNotice(String(nearTransactionReadiness.request.subject.nearAccountId)),
-				errorMessage: "",
-				loading: true
-			});
-			let funded;
-			try {
-				funded = await ctx.nearImplicitAccountFunding.fund({
-					requestId: request.requestId,
-					request: nearTransactionReadiness.request
-				});
-			} catch (error) {
-				cancelNearOperationStepUpPreparation({
-					ctx,
-					requestId: request.requestId,
-					preparation: operationStepUpPreparation
-				});
-				return session.confirmAndCloseModal({
-					requestId: request.requestId,
-					intentDigest: resolvedIntentDigestForResponse,
-					confirmed: false,
-					error: `NEAR account funding failed: ${String(toError(error)?.message || error)}`
-				});
-			}
-			nearTransactionReadiness = funded.readiness;
-			session.setNonceLeases(funded.reservedNonceLeases);
-		}
-		if (signingAuthMode !== "warmSession" && nearTransactionReadiness?.kind === "context_ready") {
-			const fundingRequest = buildNearContextFetchInput({
-				request,
-				usesNeeded,
-				readinessMode
-			});
-			if (!fundingRequest) throw new Error("Operation step-up requires exact NEAR operation facts");
-			operationStepUpPreparation = await ctx.operationStepUpPreparation.prepare({
-				kind: "near_transaction",
-				requestId: request.requestId,
-				transactionContext: nearTransactionReadiness.transactionContext,
-				operationId: fundingRequest.operation.operationId,
-				operationFingerprint: fundingRequest.operation.operationFingerprint,
-				displayDigest: String(resolvedIntentDigestForResponse || "").trim()
-			});
-		} else if (signingAuthMode !== "warmSession" && readinessMode.kind === "signature_only") operationStepUpPreparation = await ctx.operationStepUpPreparation.prepare({
-			kind: "near_signature_only",
-			requestId: request.requestId,
-			displayDigest: String(resolvedIntentDigestForResponse || "").trim()
-		});
-		if (signingAuthMode === "emailOtp") {
-			notifySigningOperationInteraction?.({ kind: SigningOperationInteractionEventKind.AuthenticationCompleted });
-			session.confirmAndCloseModal({
-				requestId: request.requestId,
-				intentDigest: resolvedIntentDigestForResponse,
-				confirmed: true,
-				otpCode: normalizeSixDigitOtpCode(otpCode),
-				...emailOtpChallengeId ? { emailOtpChallengeId } : {},
-				...operationStepUpPreparation ? { operationStepUpPreparation } : {},
-				...nearReadinessDecisionFields(nearTransactionReadiness)
-			});
-			return;
-		}
-		if (signingAuthMode === "warmSession") {
-			session.confirmAndCloseModal({
-				requestId: request.requestId,
-				intentDigest: resolvedIntentDigestForResponse,
-				confirmed: true,
-				...nearReadinessDecisionFields(nearTransactionReadiness)
-			});
-			return;
-		}
-		assertPasskeyCredentialLookupAllowed({
-			stage: "transaction_prompt",
-			subjectId: nearAccountId,
-			requestId: request.requestId,
-			signingAuthPlanKind: request.payload.signingAuthPlan.kind
-		});
-		const challengeB64u = operationStepUpPreparation?.challengeB64u || resolveTypedWebAuthnChallenge({
-			webauthnChallenge: request.payload.webauthnChallenge,
-			defaultChallengeB64u: String(resolvedChallengeB64u || "").trim(),
-			requireTypedChallenge: request.payload.signingAuthPlan.kind === SigningAuthPlanKind.PasskeyReauth && Boolean(request.payload.webauthnChallenge)
-		});
-		if (!challengeB64u) throw new Error("Missing WebAuthn challenge digest for signing flow");
-		notifySigningOperationInteraction?.({ kind: SigningOperationInteractionEventKind.AuthenticationStarted });
-		const serializedCredential = await collectAuthenticationCredentialForWalletChallengeB64u({
-			credentialStore: ctx.webauthnCredentialStore,
-			touchIdPrompt: ctx.touchIdPrompt,
-			onBeforePrompt: reviewAdmission?.beforeCredential,
-			cancellation: reviewAdmission ? {
-				kind: "abort_signal",
-				signal: reviewAdmission.abortController.signal
-			} : { kind: "none" },
-			walletId: request.payload.walletId,
-			challengeB64u
-		});
-		reviewAdmission?.afterCredential();
-		notifySigningOperationInteraction?.({ kind: SigningOperationInteractionEventKind.AuthenticationCompleted });
-		session.confirmAndCloseModal({
-			requestId: request.requestId,
-			intentDigest: resolvedIntentDigestForResponse,
-			confirmed: true,
-			credential: serializedCredential,
-			...operationStepUpPreparation ? { operationStepUpPreparation } : {},
-			...nearReadinessDecisionFields(nearTransactionReadiness)
-		});
-	} catch (err) {
-		cancelNearOperationStepUpPreparation({
-			ctx,
-			requestId: request.requestId,
-			preparation: operationStepUpPreparation
-		});
-		const cancelled = isUserCancelledUserConfirm(err);
-		const msg = String(toError(err)?.message || err || "");
-		if (cancelled) window.parent?.postMessage({ type: "WALLET_UI_CLOSED" }, "*");
-		const isWrongPasskeyError = /multiple passkeys \\(devicenumbers\\) for account/i.test(msg);
-		return session.confirmAndCloseModal({
-			requestId: request.requestId,
-			intentDigest: resolvedIntentDigestForResponse,
-			confirmed: false,
-			error: cancelled ? ERROR_MESSAGES.cancelled : isWrongPasskeyError ? msg : msg || ERROR_MESSAGES.collectCredentialsFailed
-		});
-	}
-}
-function getIntentDigestSigningAuthMode(request) {
-	return getSigningAuthMode(request) ?? "webauthn";
-}
-async function handleIntentDigestSigningFlow(ctx, request, worker, opts) {
-	const reviewAdmission = reviewAdmissionForBinding(ctx.surfaceMeasurementBinding);
-	const { confirmationConfig, transactionSummary, theme, surface } = opts;
-	const adapters = createConfirmTxFlowAdapters(ctx);
-	const session = createConfirmSession({
-		adapters,
-		worker,
-		request,
-		confirmationConfig,
-		transactionSummary,
-		theme,
-		surface
-	});
-	const signingSubject = getSignIntentDigestSubject(request);
-	const subjectId = signingSubject.kind === "near_wallet" ? signingSubject.nearAccountId : signingSubject.walletId;
-	const nearAccountId = signingSubject.kind === "near_wallet" ? signingSubject.nearAccountId : "";
-	const intentPreparation = consumeIntentDigestPreparation(request.requestId);
-	try {
-		const signingAuthMode = getIntentDigestSigningAuthMode(request);
-		let resolvedIntentDigest = String(getIntentDigest(request) || "").trim() || void 0;
-		let resolvedChallengeB64u = String(request.payload.challengeB64u || "").trim();
-		const requiresExplicitConfirmClick = confirmationConfig.kind === "interactive";
-		const rpId = adapters.security.getRpId();
-		const securityContext = rpId ? { rpId } : void 0;
-		if (requiresExplicitConfirmClick) sendConfirmProgress(worker, {
-			requestId: request.requestId,
-			step: 2,
-			phase: "intent-confirmation-required",
-			status: "running",
-			message: "Awaiting confirmation click"
-		});
-		let resolvePromptReady;
-		const promptReady = new Promise((resolve) => {
-			resolvePromptReady = resolve;
-		});
-		const markPromptReady = () => {
-			resolvePromptReady?.();
-			resolvePromptReady = void 0;
-		};
-		const promptDecisionPromise = session.promptUser({
-			securityContext,
-			loading: false,
-			onMounted: () => {
-				markPromptReady();
-			}
-		});
-		promptDecisionPromise.finally(markPromptReady);
-		let decisionResolved = false;
-		let intentPreparationApplied = false;
-		const applyPreparedIntentToUi = (prepared) => {
-			resolvedIntentDigest = String(prepared.intentDigest || "").trim() || resolvedIntentDigest;
-			resolvedChallengeB64u = String(prepared.challengeB64u || "").trim() || resolvedChallengeB64u;
-			session.updateUI({
-				...prepared.displayModel ? { model: prepared.displayModel } : {},
-				...prepared.title ? { title: prepared.title } : {},
-				...prepared.body ? { body: prepared.body } : {},
-				loading: false
-			});
-			intentPreparationApplied = true;
-		};
-		const preparedIntentPromise = intentPreparation ? (async () => {
-			await promptReady;
-			return await intentPreparation;
-		})() : void 0;
-		if (preparedIntentPromise) preparedIntentPromise.then((prepared) => {
-			if (decisionResolved || intentPreparationApplied) return;
-			applyPreparedIntentToUi(prepared);
-		}).catch((error) => {
-			if (decisionResolved) return;
-			session.updateUI({
-				loading: false,
-				errorMessage: String(toError(error)?.message || error || "Failed to prepare intent")
-			});
-		});
-		const { confirmed, error: uiError, otpCode, emailOtpChallengeId } = await promptDecisionPromise;
-		decisionResolved = true;
-		if (!confirmed) {
-			if (requiresExplicitConfirmClick) sendConfirmationCancelledProgress(worker, request.requestId, uiError);
-			return session.confirmAndCloseModal({
-				requestId: request.requestId,
-				intentDigest: resolvedIntentDigest,
-				confirmed: false,
-				error: uiError
-			});
-		}
-		if (preparedIntentPromise) {
-			const prepared = await preparedIntentPromise;
-			if (!intentPreparationApplied) applyPreparedIntentToUi(prepared);
-		}
-		if (signingAuthMode === "emailOtp") {
-			if (requiresExplicitConfirmClick) sendConfirmProgress(worker, {
-				requestId: request.requestId,
-				step: 2,
-				phase: TOUCH_CONFIRM_PROGRESS_PHASE.CONFIRMATION_COMPLETE,
-				status: "succeeded",
-				message: "Email OTP submitted"
-			});
-			return session.confirmAndCloseModal({
-				requestId: request.requestId,
-				intentDigest: resolvedIntentDigest,
-				confirmed: true,
-				otpCode: normalizeSixDigitOtpCode(otpCode),
-				...emailOtpChallengeId ? { emailOtpChallengeId } : {}
-			});
-		}
-		if (signingAuthMode === "warmSession") {
-			if (requiresExplicitConfirmClick) sendConfirmProgress(worker, {
-				requestId: request.requestId,
-				step: 2,
-				phase: TOUCH_CONFIRM_PROGRESS_PHASE.CONFIRMATION_COMPLETE,
-				status: "succeeded",
-				message: "Confirmation complete"
-			});
-			return session.confirmAndCloseModal({
-				requestId: request.requestId,
-				intentDigest: resolvedIntentDigest,
-				confirmed: true
-			});
-		}
-		assertPasskeyCredentialLookupAllowed({
-			stage: "intent_digest_prompt",
-			subjectId,
-			requestId: request.requestId,
-			signingAuthPlanKind: request.payload.signingAuthPlan.kind
-		});
-		const challengeB64u = resolveTypedWebAuthnChallenge({
-			webauthnChallenge: request.payload.webauthnChallenge,
-			defaultChallengeB64u: String(resolvedChallengeB64u || "").trim(),
-			requireTypedChallenge: request.payload.signingAuthPlan.kind === SigningAuthPlanKind.PasskeyReauth
-		});
-		if (!challengeB64u) throw new Error("Missing WebAuthn challenge digest for intent signing flow");
-		sendConfirmProgress(worker, {
-			requestId: request.requestId,
-			step: 3,
-			phase: TOUCH_CONFIRM_PROGRESS_PHASE.PASSKEY_PROMPT_STARTED,
-			status: "running",
-			message: "Authenticating with passkey..."
-		});
-		const serializedCredential = signingSubject.kind === "near_wallet" ? await collectAuthenticationCredentialForChallengeB64u({
-			credentialStore: ctx.webauthnCredentialStore,
-			touchIdPrompt: ctx.touchIdPrompt,
-			onBeforePrompt: reviewAdmission?.beforeCredential,
-			cancellation: reviewAdmission ? {
-				kind: "abort_signal",
-				signal: reviewAdmission.abortController.signal
-			} : { kind: "none" },
-			nearAccountId,
-			challengeB64u
-		}) : await collectAuthenticationCredentialForWalletChallengeB64u({
-			credentialStore: ctx.webauthnCredentialStore,
-			touchIdPrompt: ctx.touchIdPrompt,
-			onBeforePrompt: reviewAdmission?.beforeCredential,
-			cancellation: reviewAdmission ? {
-				kind: "abort_signal",
-				signal: reviewAdmission.abortController.signal
-			} : { kind: "none" },
-			walletId: signingSubject.walletId,
-			challengeB64u
-		});
-		reviewAdmission?.afterCredential();
-		sendConfirmProgress(worker, {
-			requestId: request.requestId,
-			step: 4,
-			phase: TOUCH_CONFIRM_PROGRESS_PHASE.PASSKEY_PROMPT_SUCCEEDED,
-			status: "succeeded",
-			message: "Authentication complete"
-		});
-		return session.confirmAndCloseModal({
-			requestId: request.requestId,
-			intentDigest: resolvedIntentDigest,
-			confirmed: true,
-			credential: serializedCredential
-		});
-	} catch (err) {
-		clearIntentDigestPreparation(request.requestId);
-		sendConfirmProgress(worker, {
-			requestId: request.requestId,
-			step: 4,
-			phase: TOUCH_CONFIRM_PROGRESS_PHASE.PASSKEY_PROMPT_SUCCEEDED,
-			status: "failed",
-			message: String(toError(err)?.message || err || ERROR_MESSAGES.collectCredentialsFailed)
-		});
-		const cancelled = isUserCancelledUserConfirm(err);
-		const msg = String(toError(err)?.message || err || "");
-		if (cancelled) window.parent?.postMessage({ type: "WALLET_UI_CLOSED" }, "*");
-		return session.confirmAndCloseModal({
-			requestId: request.requestId,
-			intentDigest: String(getIntentDigest(request) || "").trim() || void 0,
-			confirmed: false,
-			error: cancelled ? ERROR_MESSAGES.cancelled : msg || ERROR_MESSAGES.collectCredentialsFailed
-		});
-	}
-}
-//#endregion
-export { handleIntentDigestSigningFlow, handleTransactionSigningFlow };
-
-//# sourceMappingURL=signing.js.map