@seams/wallet 0.6.0 → 0.6.2

package/dist/.build-inputs.sha256

@@ -1 +1 @@
-0336dd8ca4ccfb1d8170242ca859f4bbb4da136e023a6e80ab04d4f3f7a48258
+0d1577c2c1b97c7654920198df26f4d567031af57e0d5e0fb0262a294a65493a

package/dist/esm/SeamsWeb/SeamsWeb.js

@@ -763,6 +763,7 @@ var SeamsWeb = class {
 				account: nearAccountBinding
 			} : { kind: "none" };
 			tasks.push(this.signingEngine.warmCriticalResources(accountContext));
+			tasks.push(this.signingEngine.prewarmEcdsaRegistrationCrypto());
 		}
 		if (tasks.length === 0) return;
 		let status = "succeeded";

package/dist/esm/SeamsWeb/operations/registration/registration.js

@@ -5,7 +5,7 @@ import { alphabetizeStringify, sha256BytesUtf8, sha256HexUtf8 } from "../../../s
 import { base58Encode } from "../../../shared-ts/src/utils/base58.js";
 import { deriveImplicitNearAccountIdFromEd25519PublicKey } from "../../../shared-ts/src/utils/near.js";
 import { findRegistrationSignerPlanEvmFamilyEcdsaBranch, findRegistrationSignerPlanNearEd25519Branch, parseNearEd25519SigningKeyId, registrationSignerPlanFromSelection, walletIdFromString } from "../../../shared-ts/src/utils/registrationIntent.js";
-import { ROUTER_AB_ED25519_YAO_EMAIL_OTP_RECOVERY_BOOTSTRAP_KIND_V1 } from "../../../shared-ts/src/utils/routerAbEd25519Yao.js";
+import { ROUTER_AB_ED25519_YAO_EMAIL_OTP_RECOVERY_BOOTSTRAP_KIND_V1, sameRouterAbEd25519YaoRegistrationAdmissionRequestV1 } from "../../../shared-ts/src/utils/routerAbEd25519Yao.js";
 import { requireEvmFamilySigningKeySlotId } from "../../../shared-ts/src/signing-lanes/evmFamilySigningKeySlotId.js";
 import { parseSdkEcdsaDerivationSigningRootId, parseSdkEcdsaDerivationSigningRootVersion } from "../../../shared-ts/src/threshold/ecdsaDerivationRoleLocalBootstrap.js";
 import { isObject } from "../../../shared-ts/src/utils/validation.js";
@@ -48,7 +48,7 @@ import { establishUnlockedWalletEd25519ExportRootCapabilityV1, walletCustodyCere
 import { rememberPasskeyCustodySessionEnvelope } from "../../../core/signingEngine/session/passkey/passkeyCustodySessionCache.js";
 import { listConfiguredThresholdEcdsaPublicationTargets } from "../session/thresholdEcdsaProvisioning.js";
 import { openWalletCustodyEd25519ActiveClientV1, walletCustodyCacheEnvelopeFromRecordV1 } from "../../../core/signingEngine/walletCustody/openCustodyCache.js";
-import { RegistrationTimingRecorder, assertNever, createFailedRegistrationTimingSummary, createSucceededRegistrationTimingSummary, emitNearRegistrationTiming, emitRegistrationTimingSpan, emitRegistrationTimingSummary, recordNearRegistrationSessionTiming, recordStrictEcdsaServerTimingBuckets, registrationTimingSignerSetFromPlan, roundDurationMs, zeroEmailOtpYaoPrewarmDiagnostics } from "./registrationTiming.js";
+import { RegistrationTimingRecorder, assertNever, createFailedRegistrationTimingSummary, createSucceededRegistrationTimingSummary, emitNearRegistrationTiming, emitRegistrationTimingSpan, emitRegistrationTimingSummary, recordNearRegistrationSessionTiming, recordRegistrationServerTimingBuckets, recordStrictEcdsaServerTimingBuckets, registrationTimingSignerSetFromPlan, roundDurationMs, zeroEmailOtpYaoPrewarmDiagnostics } from "./registrationTiming.js";
 import { joinCustodyWireFromEnvelopeRecord } from "../../../core/signingEngine/walletCustody/joinCustodyWire.js";
 import { buildStrictRegistrationClientBootstrap, closeStrictEcdsaRegistrationCeremony, finalizeStrictEcdsaFamilyLocalActivation, measureStrictEcdsaCeremonyStep, registrationRouteHeaders, requireIssuedRegistrationEstablishedSession, runStrictEcdsaFamilyCeremony } from "./registrationStrictEcdsa.js";
 import { admitDeferredNearRegistration, buildRegistrationEmailOtpEd25519SessionState, passkeyWalletAuthAuthorityFromCredential, registrationEd25519MaterialFacts, registrationEstablishedEd25519Session, requireEd25519YaoRegistrationPublicResultMatches, requireEmailOtpEd25519YaoRegistrationPublicResultMatches, requireEmailOtpRegistrationEnrollmentMaterial, requirePasskeyRegistrationIntent } from "./registrationEd25519Yao.js";
@@ -472,6 +472,42 @@ function registrationThreeRouteAuthorityPayload(authority) {
 		default: return assertNever(authority);
 	}
 }
+async function startNearRegistrationAdmission(args) {
+	const startedAt = performance.now();
+	try {
+		const admissionReceipt = await admitDeferredNearRegistration(args.deferredNear, {
+			routerOrigin: new URL(args.relayerUrl).origin,
+			authorization: {
+				kind: "bearer",
+				value: `Bearer ${args.signedSetup}`
+			},
+			fetch: globalThis.fetch,
+			...args.traceContext ? { traceContext: args.traceContext } : {}
+		});
+		emitNearRegistrationTiming({
+			ceremonyId: args.registrationCeremonyId,
+			stage: "early_admission",
+			startedAt,
+			outcome: "success"
+		});
+		return {
+			deferredNear: args.deferredNear,
+			admissionReceipt
+		};
+	} catch (error) {
+		emitNearRegistrationTiming({
+			ceremonyId: args.registrationCeremonyId,
+			stage: "early_admission",
+			startedAt,
+			outcome: "failure"
+		});
+		throw error;
+	}
+}
+function requireNearRegistrationAdmission(admission) {
+	if (!admission) throw new Error("Mixed registration did not start NEAR admission");
+	return admission;
+}
 function registrationEd25519LaneAuthorization(auth, passkeyCredentialIdB64u, session) {
 	switch (auth.kind) {
 		case "passkey": return { auth: {
@@ -602,6 +638,32 @@ async function setupRegistrationForPasskeyExecution(args) {
 	}) !== state.binding || String(intent.walletId) !== String(args.passkeyExecution.prepared.walletId) || challengeB64u !== args.passkeyExecution.prepared.challengeB64u) throw new Error("Hosted passkey registration preparation binding changed");
 	return setup;
 }
+function ecdsaRegistrationClientCeremonyForExecution(args) {
+	if (args.passkeyExecution.kind === "collect_during_registration") return { kind: "create_after_authority" };
+	const state = hostedPasskeyRegistrationState(args.passkeyExecution.prepared);
+	if (state.ecdsaClientCeremony.kind !== "started" || state.ecdsaClientCeremony.ceremonyId !== args.ceremonyId) throw new Error("Hosted passkey registration has no matching ECDSA client ceremony");
+	return {
+		kind: "use_hosted_preparation",
+		ceremonyId: state.ecdsaClientCeremony.ceremonyId,
+		operation: state.ecdsaClientCeremony.operation
+	};
+}
+async function awaitHostedPreparedEcdsaClientCeremony(operation) {
+	return await operation;
+}
+function ecdsaRegistrationClientCeremonyOperation(args) {
+	switch (args.clientCeremony.kind) {
+		case "create_after_authority": return args.context.signingEngine.createRouterAbEcdsaRegistrationCeremony.bind(args.context.signingEngine, {
+			kind: "create_router_ab_ecdsa_registration_ceremony_v1",
+			ceremonyId: args.ceremonyId,
+			registration: args.registration
+		});
+		case "use_hosted_preparation":
+			if (args.clientCeremony.ceremonyId !== args.ceremonyId) throw new Error("Prepared ECDSA client ceremony identity changed");
+			return awaitHostedPreparedEcdsaClientCeremony.bind(void 0, args.clientCeremony.operation);
+		default: return assertNever(args.clientCeremony);
+	}
+}
 async function runEcdsaEnabledThreeRouteRegistrationCeremony(args) {
 	const [firstChainTarget, ...remainingChainTargets] = args.ecdsaPrepare.chainTargets;
 	if (!firstChainTarget) throw new Error("Strict ECDSA ceremony requires at least one EVM-family target");
@@ -612,10 +674,11 @@ async function runEcdsaEnabledThreeRouteRegistrationCeremony(args) {
 		const created = await measureStrictEcdsaCeremonyStep({
 			registrationTiming: args.registrationTiming,
 			bucket: "ecdsaRegistrationClientCreateMs",
-			operation: args.context.signingEngine.createRouterAbEcdsaRegistrationCeremony.bind(args.context.signingEngine, {
-				kind: "create_router_ab_ecdsa_registration_ceremony_v1",
+			operation: ecdsaRegistrationClientCeremonyOperation({
+				context: args.context,
 				ceremonyId,
-				registration: args.ecdsaPrepare.strictRegistration
+				registration: args.ecdsaPrepare.strictRegistration,
+				clientCeremony: args.clientCeremony
 			})
 		});
 		const responded = await measureStrictEcdsaCeremonyStep({
@@ -638,6 +701,14 @@ async function runEcdsaEnabledThreeRouteRegistrationCeremony(args) {
 		});
 		if (responded.kind === "near_ed25519") throw new Error("ECDSA registration ceremony received an Ed25519-only respond result");
 		const deferredNear = responded.kind === "near_ed25519_and_evm_family_ecdsa" ? responded.ed25519 : null;
+		const nearAdmission = deferredNear ? startNearRegistrationAdmission({
+			relayerUrl: args.relayerUrl,
+			registrationCeremonyId: ceremonyId,
+			signedSetup: args.signedSetup,
+			deferredNear,
+			traceContext: args.traceContext
+		}) : null;
+		nearAdmission?.catch(ignoreNearCustodyFailure);
 		const verified = await measureStrictEcdsaCeremonyStep({
 			registrationTiming: args.registrationTiming,
 			bucket: "ecdsaRegistrationClientProofVerifyMs",
@@ -698,7 +769,7 @@ async function runEcdsaEnabledThreeRouteRegistrationCeremony(args) {
 						deferredNear
 					});
 					deferredNearCustodyWork = args.startDeferredNearCustody({
-						deferredNear,
+						admission: requireNearRegistrationAdmission(nearAdmission),
 						establishedEvmCustodyCommit: bootstrap.preActivationCommitPayload
 					});
 					deferredNearCustodyWork.catch(ignoreNearCustodyFailure);
@@ -996,13 +1067,23 @@ async function startDeferredNearWalletCustody(base, input) {
 			operation: "near_provisioning"
 		});
 		if (!pending || pending.operation !== "near_provisioning" || pending.phase !== "planned") throw new Error("NEAR registration has no planned continuation");
+		let preAdmittedReceipt;
+		try {
+			const admitted = await input.admission;
+			if (!sameRouterAbEd25519YaoRegistrationAdmissionRequestV1(admitted.deferredNear.admissionRequest, pending.admissionRequest)) throw new Error("NEAR admission changed the authorized request");
+			preAdmittedReceipt = admitted.admissionReceipt;
+		} catch (error) {
+			if (error instanceof Error && error.message === "NEAR admission changed the authorized request") throw error;
+			preAdmittedReceipt = void 0;
+		}
 		const { joined, admissionReceipt } = await continueNearRegistrationCustody({
 			pending,
 			signingEngine: base.context.signingEngine,
 			relayerUrl: base.relayerUrl,
 			credential: base.signedSetup,
 			traceContext: base.traceContext,
-			factorSecret
+			factorSecret,
+			...preAdmittedReceipt ? { admitted: preAdmittedReceipt } : {}
 		});
 		outcome = "success";
 		return {
@@ -1028,16 +1109,12 @@ async function startDeferredNearWalletCustody(base, input) {
 		});
 	}
 }
-async function continueNearRegistrationCustody(args) {
-	const journal = args.pending;
-	if (journal.phase === "joined" && journal.completion.kind !== "encrypted_checkpoint") throw new Error("Joined material has no encrypted execution checkpoint");
-	const pending = journal.phase === "joined" && journal.completion.kind === "encrypted_checkpoint" ? journal.completion.prepared : journal;
-	if (pending.phase === "joined") throw new Error("Invalid NEAR continuation phase");
-	const admission = pending.admissionRequest;
-	const admissionStartedAt = performance.now();
-	const admissionReceipt = pending.phase === "execution_prepared" ? pending.admissionReceipt : await admitDeferredNearRegistration({
+async function resolveNearRegistrationAdmissionReceipt(args) {
+	if (args.pending.phase === "execution_prepared") return args.pending.admissionReceipt;
+	if (args.admitted) return args.admitted;
+	return await admitDeferredNearRegistration({
 		status: "deferred",
-		admissionRequest: pending.admissionRequest
+		admissionRequest: args.pending.admissionRequest
 	}, {
 		routerOrigin: new URL(args.relayerUrl).origin,
 		authorization: {
@@ -1047,6 +1124,21 @@ async function continueNearRegistrationCustody(args) {
 		fetch: globalThis.fetch,
 		traceContext: args.traceContext
 	});
+}
+async function continueNearRegistrationCustody(args) {
+	const journal = args.pending;
+	if (journal.phase === "joined" && journal.completion.kind !== "encrypted_checkpoint") throw new Error("Joined material has no encrypted execution checkpoint");
+	const pending = journal.phase === "joined" && journal.completion.kind === "encrypted_checkpoint" ? journal.completion.prepared : journal;
+	if (pending.phase === "joined") throw new Error("Invalid NEAR continuation phase");
+	const admission = pending.admissionRequest;
+	const admissionStartedAt = performance.now();
+	const admissionReceipt = await resolveNearRegistrationAdmissionReceipt({
+		pending,
+		relayerUrl: args.relayerUrl,
+		credential: args.credential,
+		traceContext: args.traceContext,
+		...args.admitted ? { admitted: args.admitted } : {}
+	});
 	recordWalletCustodyTiming(pending.registrationCeremonyId, "admission", admissionStartedAt);
 	const joined = await args.signingEngine.joinWalletCustodyNearEd25519KeySet({
 		...pending.phase === "planned" ? {
@@ -1217,6 +1309,7 @@ async function resumeNearRegistrationAfterUnlock(args) {
 				walletId: pending.walletId,
 				commit: {
 					context: args.context,
+					registrationTiming: null,
 					registrationStartedAt: startedAt,
 					clientPrewarm: Promise.resolve(),
 					relayerUrl,
@@ -1466,8 +1559,30 @@ async function commitDeferredEd25519Registration(args) {
 			thresholdSessionId: joined.metadata.scope.threshold_session_id,
 			prfFirstB64u: auth.prfFirstB64u
 		});
+		let preparedSessionSeal;
+		if (preparation.kind === "preparing") {
+			const preparationWaitStartedAt = performance.now();
+			const prepared = await preparation.result;
+			emitNearRegistrationTiming({
+				ceremonyId: args.registrationCeremonyId,
+				stage: "session_seal_preparation_wait",
+				startedAt: preparationWaitStartedAt,
+				outcome: prepared.kind === "completed" ? "success" : "failure"
+			});
+			if (prepared.kind === "failed") throw prepared.error;
+			await requireCurrentNearRegistrationSession(args.sessionAuthority);
+			const clientSeal = await args.context.signingEngine.readPreparedSigningSessionHydration({
+				thresholdSessionId: preparation.thresholdSessionId,
+				preparationId: preparation.preparationId
+			});
+			preparedSessionSeal = {
+				preparationId: preparation.preparationId,
+				thresholdSessionId: preparation.thresholdSessionId,
+				ciphertext: clientSeal.ciphertext
+			};
+		}
 		const finalizationStartedAt = performance.now();
-		const completed = await completeWalletRegistrationNearProvisioning({
+		const nearProvisioningRequest = {
 			relayerUrl: args.relayerUrl,
 			registrationCeremonyId: args.registrationCeremonyId,
 			signedSetup: args.signedSetup,
@@ -1477,8 +1592,23 @@ async function commitDeferredEd25519Registration(args) {
 			},
 			idempotencyKey: nearProvisioningIdempotencyKey,
 			ed25519: { activationReference },
-			auth: args.authMaterial,
-			walletCustodyCommit: joined.commitPayload
+			walletCustodyCommit: joined.commitPayload,
+			onServerTiming: recordRegistrationServerTimingBuckets.bind(void 0, args.registrationTiming)
+		};
+		let completed;
+		if (preparedSessionSeal) {
+			if (args.authMaterial.kind !== "passkey") throw new Error("Prepared session sealing requires a passkey authority");
+			completed = await completeWalletRegistrationNearProvisioning({
+				...nearProvisioningRequest,
+				auth: { kind: "passkey" },
+				sessionSeal: {
+					thresholdSessionId: preparedSessionSeal.thresholdSessionId,
+					ciphertext: preparedSessionSeal.ciphertext
+				}
+			});
+		} else completed = await completeWalletRegistrationNearProvisioning({
+			...nearProvisioningRequest,
+			auth: args.authMaterial
 		});
 		if (!completed.ok) throw new Error("Deferred NEAR provisioning did not complete");
 		const finalized = completed;
@@ -1487,6 +1617,7 @@ async function commitDeferredEd25519Registration(args) {
 			const status = finalized.walletCustody?.status ?? "not_reported";
 			throw new Error(`Deferred NEAR custody join did not commit (${status})`);
 		}
+		if (preparedSessionSeal && !finalized.sessionSeal) throw new Error("Deferred NEAR finalization did not return the prepared session seal");
 		emitNearRegistrationTiming({
 			ceremonyId: args.registrationCeremonyId,
 			stage: "server_finalize",
@@ -1567,18 +1698,6 @@ async function commitDeferredEd25519Registration(args) {
 		});
 		await requireCurrentNearRegistrationSession(args.sessionAuthority);
 		if (args.authMaterial.kind === "passkey" && registrationSession.remainingUses > 0) {
-			if (preparation.kind === "preparing") {
-				const preparationWaitStartedAt = performance.now();
-				const prepared = await preparation.result;
-				emitNearRegistrationTiming({
-					ceremonyId: args.registrationCeremonyId,
-					stage: "session_seal_preparation_wait",
-					startedAt: preparationWaitStartedAt,
-					outcome: prepared.kind === "completed" ? "success" : "failure"
-				});
-				if (prepared.kind === "failed") throw prepared.error;
-				await requireCurrentNearRegistrationSession(args.sessionAuthority);
-			}
 			const registrationEd25519Session = registrationEstablishedEd25519Session(registrationSession);
 			hydration = hydrateDeferredNearRegistrationSession({
 				signingEngine: args.context.signingEngine,
@@ -1589,6 +1708,10 @@ async function commitDeferredEd25519Registration(args) {
 					prfFirstB64u: args.authMaterial.prfFirstB64u,
 					expiresAtMs: registrationSession.expiresAtMs,
 					remainingUses: registrationSession.remainingUses,
+					...preparedSessionSeal && finalized.sessionSeal ? { preparedServerSeal: {
+						preparationId: preparedSessionSeal.preparationId,
+						...finalized.sessionSeal
+					} } : {},
 					transport: {
 						curve: "ed25519",
 						authMethod: "passkey",
@@ -1887,7 +2010,11 @@ async function registerEcdsaOrMixedWallet(args) {
 			warmup: prepared.registrationWarmup
 		});
 		const { relayerUrl, setup } = prepared;
-		const ecdsaSetup = requireEcdsaRegistrationSetup(setup, args.kind);
+		const ecdsaPrepare = materializeWalletRegistrationSetupEcdsaPrepare(requireEcdsaRegistrationSetup(setup, args.kind).ecdsa);
+		const ecdsaClientCeremony = ecdsaRegistrationClientCeremonyForExecution({
+			passkeyExecution: args.passkeyExecution,
+			ceremonyId: setup.registrationCeremonyId
+		});
 		const intentResponse = {
 			intent: setup.intent,
 			registrationIntentDigestB64u: setup.registrationIntentDigestB64u
@@ -2022,7 +2149,8 @@ async function registerEcdsaOrMixedWallet(args) {
 				registrationCeremonyId: setup.registrationCeremonyId,
 				signerPlanKind: args.kind,
 				signedSetup: setup.signedSetup,
-				ecdsaPrepare: materializeWalletRegistrationSetupEcdsaPrepare(ecdsaSetup.ecdsa),
+				ecdsaPrepare,
+				clientCeremony: ecdsaClientCeremony,
 				authority: startAuthority,
 				materialAuthority,
 				idempotencyKey: finalizeIdempotencyKey,
@@ -2223,6 +2351,7 @@ async function registerEcdsaOrMixedWallet(args) {
 					walletId: deferredWalletId,
 					commit: {
 						context,
+						registrationTiming,
 						registrationStartedAt: startedAt,
 						clientPrewarm,
 						relayerUrl,

package/dist/esm/SeamsWeb/operations/registration/registrationTiming.js

@@ -62,7 +62,14 @@ const YAO_SERVER_TIMING_BUCKET_BY_METRIC = new Map(Object.entries({
 	ecdsa_b_total: "ecdsaDeriverBTotalMs",
 	ecdsa_sw_parse: "ecdsaSigningWorkerParseMs",
 	ecdsa_sw_activate: "ecdsaSigningWorkerActivateMs",
-	ecdsa_sw_total: "ecdsaSigningWorkerTotalMs"
+	ecdsa_sw_total: "ecdsaSigningWorkerTotalMs",
+	near_finalize_authority: "nearFinalizeAuthorityMs",
+	near_finalize_fingerprint: "nearFinalizeFingerprintMs",
+	near_finalize_side_effect: "nearFinalizeSideEffectMs",
+	near_finalize_cleanup: "nearFinalizeCleanupMs",
+	near_finalize_session_projection: "nearFinalizeSessionProjectionMs",
+	near_finalize_session_seal: "nearFinalizeSessionSealMs",
+	near_finalize_total: "nearFinalizeTotalMs"
 }));
 /**
 * Parses a `Server-Timing` header into bucket durations. Diagnostics only: a
@@ -84,6 +91,9 @@ function recordStrictEcdsaServerTimingBuckets(recorder, leg, header) {
 	});
 	recordServerTimingBuckets(recorder, header);
 }
+function recordRegistrationServerTimingBuckets(recorder, header) {
+	recordServerTimingBuckets(recorder, header);
+}
 function parseYaoServerTimingBuckets(header) {
 	if (!header) return [];
 	const parsed = [];
@@ -304,6 +314,13 @@ function createZeroRegistrationTimingBucketValues() {
 		ecdsaSigningWorkerParseMs: 0,
 		ecdsaSigningWorkerActivateMs: 0,
 		ecdsaSigningWorkerTotalMs: 0,
+		nearFinalizeAuthorityMs: 0,
+		nearFinalizeFingerprintMs: 0,
+		nearFinalizeSideEffectMs: 0,
+		nearFinalizeCleanupMs: 0,
+		nearFinalizeSessionProjectionMs: 0,
+		nearFinalizeSessionSealMs: 0,
+		nearFinalizeTotalMs: 0,
 		walletRegisterStartMs: 0,
 		ecdsaClientBootstrapMs: 0,
 		ecdsaRegistrationTotalMs: 0,
@@ -428,6 +445,13 @@ function copyRegistrationTimingBucketValues(buckets) {
 		ecdsaSigningWorkerParseMs: buckets.ecdsaSigningWorkerParseMs,
 		ecdsaSigningWorkerActivateMs: buckets.ecdsaSigningWorkerActivateMs,
 		ecdsaSigningWorkerTotalMs: buckets.ecdsaSigningWorkerTotalMs,
+		nearFinalizeAuthorityMs: buckets.nearFinalizeAuthorityMs,
+		nearFinalizeFingerprintMs: buckets.nearFinalizeFingerprintMs,
+		nearFinalizeSideEffectMs: buckets.nearFinalizeSideEffectMs,
+		nearFinalizeCleanupMs: buckets.nearFinalizeCleanupMs,
+		nearFinalizeSessionProjectionMs: buckets.nearFinalizeSessionProjectionMs,
+		nearFinalizeSessionSealMs: buckets.nearFinalizeSessionSealMs,
+		nearFinalizeTotalMs: buckets.nearFinalizeTotalMs,
 		walletRegisterStartMs: buckets.walletRegisterStartMs,
 		ecdsaClientBootstrapMs: buckets.ecdsaClientBootstrapMs,
 		ecdsaRegistrationTotalMs: buckets.ecdsaRegistrationTotalMs,
@@ -769,6 +793,13 @@ function buildRegistrationTimingBuckets(input) {
 		ecdsaSigningWorkerParseMs: buckets.ecdsaSigningWorkerParseMs,
 		ecdsaSigningWorkerActivateMs: buckets.ecdsaSigningWorkerActivateMs,
 		ecdsaSigningWorkerTotalMs: buckets.ecdsaSigningWorkerTotalMs,
+		nearFinalizeAuthorityMs: buckets.nearFinalizeAuthorityMs,
+		nearFinalizeFingerprintMs: buckets.nearFinalizeFingerprintMs,
+		nearFinalizeSideEffectMs: buckets.nearFinalizeSideEffectMs,
+		nearFinalizeCleanupMs: buckets.nearFinalizeCleanupMs,
+		nearFinalizeSessionProjectionMs: buckets.nearFinalizeSessionProjectionMs,
+		nearFinalizeSessionSealMs: buckets.nearFinalizeSessionSealMs,
+		nearFinalizeTotalMs: buckets.nearFinalizeTotalMs,
 		walletRegisterStartMs: buckets.walletRegisterStartMs,
 		ecdsaClientBootstrapMs: buckets.ecdsaClientBootstrapMs,
 		ecdsaRegistrationTotalMs: buckets.ecdsaRegistrationTotalMs,
@@ -991,6 +1022,6 @@ function emitRegistrationTimingSpan(input) {
 	} catch {}
 }
 //#endregion
-export { REGISTRATION_TIMING_LABEL, RegistrationTimingRecorder, WALLET_IFRAME_TRANSPORT_TIMING_LABEL, assertNever, createFailedRegistrationTimingSummary, createSucceededRegistrationTimingSummary, emitNearRegistrationTiming, emitRegistrationTimingSpan, emitRegistrationTimingSummary, parseYaoServerTimingBuckets, recordNearRegistrationSessionTiming, recordStrictEcdsaServerTimingBuckets, registrationTimingSignerSetFromPlan, roundDurationMs, zeroEmailOtpYaoPrewarmDiagnostics };
+export { REGISTRATION_TIMING_LABEL, RegistrationTimingRecorder, WALLET_IFRAME_TRANSPORT_TIMING_LABEL, assertNever, createFailedRegistrationTimingSummary, createSucceededRegistrationTimingSummary, emitNearRegistrationTiming, emitRegistrationTimingSpan, emitRegistrationTimingSummary, parseYaoServerTimingBuckets, recordNearRegistrationSessionTiming, recordRegistrationServerTimingBuckets, recordStrictEcdsaServerTimingBuckets, registrationTimingSignerSetFromPlan, roundDurationMs, zeroEmailOtpYaoPrewarmDiagnostics };
 
 //# sourceMappingURL=registrationTiming.js.map

package/dist/esm/SeamsWeb/signingSurface/BrowserSigningSurface.js

@@ -3376,6 +3376,9 @@ var BrowserSigningSurface = class {
 	prepareSigningSessionHydration(input) {
 		return this.passkeyMpcSession.prepareSigningSessionHydration(input);
 	}
+	readPreparedSigningSessionHydration(input) {
+		return this.passkeyMpcSession.readPreparedSigningSessionHydration(input);
+	}
 	discardSigningSessionHydration(input) {
 		return this.passkeyMpcSession.discardSigningSessionHydration(input);
 	}

package/dist/esm/SeamsWeb/walletIframe/client/overlay/overlay-controller.js

@@ -2,6 +2,7 @@ import { walletIframeSurfaceGeometryEqual } from "../surface/geometry.js";
 import { OverlayStyleClasses, clearDialogGeometry, clearTransactionReviewAppearance, ensureOverlayDialog, pinDialogIframe, releaseDialogIframe, setDialogAuthMenu, setDialogGeometry, setDialogPresentation, setHidden, setTransactionReviewAppearance, setVisible } from "./overlay-styles.js";
 //#region src/SeamsWeb/walletIframe/client/overlay/overlay-controller.ts
 const SURFACE_RESIZE_DURATION_MS = 180;
+const REVIEW_HANDOFF_DURATION_MS = 320;
 function finiteSurfaceRect(rect) {
 	if (!Number.isFinite(rect.top) || !Number.isFinite(rect.left) || !Number.isFinite(rect.width) || !Number.isFinite(rect.height) || rect.width <= 0 || rect.height <= 0) return null;
 	return {
@@ -208,6 +209,11 @@ var OverlayController = class {
 	}
 	applyVisible(mode) {
 		const { dialog, iframe } = this.ensureDialog();
+		const iframeSize = {
+			widthCssPx: iframe.clientWidth,
+			heightCssPx: iframe.clientHeight
+		};
+		let requestResizeDestination = null;
 		const identityChanged = !sameIdentity(this.mode, mode);
 		const handoffFromReview = !identityChanged && this.mode.kind === "compact_transaction_review" && mode.kind === "compact_request_modal";
 		const returnToReview = !identityChanged && this.mode.kind === "compact_request_modal" && mode.kind === "compact_transaction_review";
@@ -243,8 +249,8 @@ var OverlayController = class {
 			setDialogGeometry(dialog, mode.geometry, authMenu ? this.authMenuVisualScale : 1);
 			this.lastAppliedGeometry = mode.geometry;
 			this.lastAppliedAuthMenuVisualScale = authMenu ? this.authMenuVisualScale : 1;
-			const requestResizeDestination = requestResizeOrigin ? finiteSurfaceRect(dialog.getBoundingClientRect()) : null;
-			if (requestResizeOrigin && requestResizeDestination) this.startSurfaceResize(requestResizeOrigin, requestResizeDestination);
+			requestResizeDestination = requestResizeOrigin ? finiteSurfaceRect(dialog.getBoundingClientRect()) : null;
+			if (requestResizeOrigin && requestResizeDestination) this.startSurfaceResize(requestResizeOrigin, requestResizeDestination, handoffFromReview || returnToReview ? REVIEW_HANDOFF_DURATION_MS : SURFACE_RESIZE_DURATION_MS);
 			if (requestResizeOrigin) releaseDialogIframe(dialog);
 		}
 		const reviewing = mode.kind === "compact_transaction_review";
@@ -253,6 +259,10 @@ var OverlayController = class {
 		if (handoffFromReview) this.startReviewHandoff("wallet");
 		if (returnToReview) this.startReviewHandoff("review");
 		const handingOff = this.reviewHandoff.kind === "animating";
+		if (handingOff && requestResizeDestination) pinDialogIframe(dialog, reviewing ? iframeSize : {
+			widthCssPx: requestResizeDestination.width,
+			heightCssPx: requestResizeDestination.height
+		});
 		iframe.inert = reviewing || handingOff;
 		iframe.classList.toggle("seams-review-wallet-inactive", reviewing);
 		iframe.setAttribute("aria-hidden", String(reviewing || handingOff));
@@ -282,22 +292,63 @@ var OverlayController = class {
 		this.cancelReviewHandoff();
 		if (!this.iframe || window.matchMedia("(prefers-reduced-motion: reduce)").matches) return;
 		const options = {
-			duration: SURFACE_RESIZE_DURATION_MS,
-			easing: "linear",
+			duration: REVIEW_HANDOFF_DURATION_MS,
+			easing: "cubic-bezier(0.22, 1, 0.36, 1)",
 			fill: "both"
 		};
 		const review = this.getTransactionReviewSlot().firstElementChild;
 		if (!review) return;
 		const outgoingElement = destination === "wallet" ? review : this.iframe;
 		const incomingElement = destination === "wallet" ? this.iframe : review;
-		const outgoing = outgoingElement.animate([{ opacity: 1 }, { opacity: 0 }], options);
-		const incoming = incomingElement.animate([{ opacity: 0 }, { opacity: 1 }], options);
+		const direction = destination === "wallet" ? 1 : -1;
+		const outgoing = outgoingElement.animate([
+			{
+				opacity: 1,
+				transform: "translateY(0)"
+			},
+			{
+				opacity: 0,
+				transform: `translateY(${-8 * direction}px)`,
+				offset: .55
+			},
+			{
+				opacity: 0,
+				transform: `translateY(${-8 * direction}px)`
+			}
+		], options);
+		const incoming = incomingElement.animate([{
+			opacity: 0,
+			transform: `translateY(${12 * direction}px)`
+		}, {
+			opacity: 1,
+			transform: "translateY(0)"
+		}], options);
+		const sections = [];
+		let order = 0;
+		for (const section of review.children) {
+			const entering = destination === "review";
+			const delay = Math.min(order, 3) * 25;
+			sections.push(section.animate([{
+				opacity: entering ? 0 : 1,
+				transform: entering ? "translateY(8px)" : "translateY(0)"
+			}, {
+				opacity: entering ? 1 : 0,
+				transform: entering ? "translateY(0)" : "translateY(-6px)"
+			}], {
+				duration: entering ? 220 : 140,
+				delay,
+				easing: "ease-out",
+				fill: "both"
+			}));
+			order += 1;
+		}
 		this.reviewHandoff = {
 			kind: "animating",
 			destination,
 			outgoing,
 			incoming,
-			timer: setTimeout(this.finishReviewHandoff.bind(this), SURFACE_RESIZE_DURATION_MS),
+			sections,
+			timer: setTimeout(this.finishReviewHandoff.bind(this), REVIEW_HANDOFF_DURATION_MS),
 			onReady: null
 		};
 		incoming.addEventListener("finish", this.handleReviewHandoffFinished, { once: true });
@@ -327,22 +378,24 @@ var OverlayController = class {
 		clearTimeout(this.reviewHandoff.timer);
 		this.reviewHandoff.outgoing.cancel();
 		this.reviewHandoff.incoming.cancel();
+		for (const animation of this.reviewHandoff.sections) animation.cancel();
+		if (this.dialog) releaseDialogIframe(this.dialog);
 		this.reviewHandoff = { kind: "idle" };
 	}
 	scheduleMeasuredReveal() {
 		this.cancelPendingReveal();
 		this.pendingRevealFrame = window.requestAnimationFrame(this.revealMeasuredSurface);
 	}
-	startSurfaceResize(origin, destination) {
+	startSurfaceResize(origin, destination, duration) {
 		const dialog = this.dialog;
 		if (!dialog || window.matchMedia("(prefers-reduced-motion: reduce)").matches) return;
 		this.cancelSurfaceResize();
 		const animation = dialog.animate(surfaceResizeKeyframes(origin, destination), {
-			duration: SURFACE_RESIZE_DURATION_MS,
+			duration,
 			easing: "cubic-bezier(0.2, 0.7, 0.2, 1)"
 		});
 		this.surfaceResizeAnimation = animation;
-		this.surfaceResizeTimer = setTimeout(this.cancelSurfaceResize.bind(this), SURFACE_RESIZE_DURATION_MS);
+		this.surfaceResizeTimer = setTimeout(this.cancelSurfaceResize.bind(this), duration);
 		animation.addEventListener("finish", this.handleSurfaceResizeFinished, { once: true });
 	}
 	cancelPendingReveal() {

package/dist/esm/core/rpcClients/relayer/walletRegistration.js

@@ -1938,6 +1938,31 @@ async function activateWalletRegistration(args) {
 		onServerTiming: args.onServerTiming
 	}));
 }
+function parseWalletRegistrationSessionSealResponse(value) {
+	const responseName = "Wallet registration session seal";
+	const record = requireWalletRegistrationResponseObject({
+		responseName,
+		field: "body",
+		value
+	});
+	assertWalletRegistrationResponseKeys(record, [
+		"ciphertext",
+		"keyVersion",
+		"expiresAtMs",
+		"remainingUses"
+	], responseName);
+	const ciphertext = readWalletRegistrationResponseField(record, "ciphertext", responseName);
+	const keyVersion = readWalletRegistrationResponseField(record, "keyVersion", responseName);
+	const expiresAtMs = readWalletRegistrationResponseField(record, "expiresAtMs", responseName);
+	const remainingUses = readWalletRegistrationResponseField(record, "remainingUses", responseName);
+	if (typeof ciphertext !== "string" || !ciphertext.trim() || typeof keyVersion !== "string" || !keyVersion.trim() || typeof expiresAtMs !== "number" || !Number.isSafeInteger(expiresAtMs) || expiresAtMs <= 0 || typeof remainingUses !== "number" || !Number.isSafeInteger(remainingUses) || remainingUses < 0) throw new Error(`${responseName} is invalid`);
+	return {
+		ciphertext,
+		keyVersion,
+		expiresAtMs,
+		remainingUses
+	};
+}
 function parseWalletRegistrationNearProvisioningResponseV2(value) {
 	const responseName = "Wallet registration NEAR provisioning";
 	const record = requireWalletRegistrationResponseObject({
@@ -1994,7 +2019,8 @@ function parseWalletRegistrationNearProvisioningResponseV2(value) {
 		"ed25519",
 		"authorityScope",
 		"nearProvisioning",
-		"registrationEstablishedSession"
+		"registrationEstablishedSession",
+		"sessionSeal"
 	], responseName);
 	const provisioning = requireWalletRegistrationResponseObject({
 		responseName,
@@ -2008,10 +2034,25 @@ function parseWalletRegistrationNearProvisioningResponseV2(value) {
 		expectedKind: "near_ed25519"
 	});
 	if (!finalized.ok || finalized.kind !== "near_ed25519") throw new Error(`${responseName} did not return a finalized Ed25519 wallet`);
-	return {
+	const sessionSeal = readOptionalWalletRegistrationResponseField(record, "sessionSeal", responseName);
+	const registrationEstablishedSession = parseRegistrationEstablishedSessionResult(readWalletRegistrationResponseField(record, "registrationEstablishedSession", responseName), finalized.walletId);
+	if (isEmailOtpWalletRegistrationFinalizeResponse(finalized)) {
+		if (sessionSeal !== void 0) throw new Error(`${responseName} returned a session seal for an Email OTP authority`);
+		return {
+			...finalized,
+			nearProvisioning: { status: "near_ready" },
+			registrationEstablishedSession
+		};
+	}
+	const success = {
 		...finalized,
 		nearProvisioning: { status: "near_ready" },
-		registrationEstablishedSession: parseRegistrationEstablishedSessionResult(readWalletRegistrationResponseField(record, "registrationEstablishedSession", responseName), finalized.walletId)
+		registrationEstablishedSession
+	};
+	if (sessionSeal === void 0) return success;
+	return {
+		...success,
+		sessionSeal: parseWalletRegistrationSessionSealResponse(sessionSeal)
 	};
 }
 async function completeWalletRegistrationNearProvisioning(args) {
@@ -2023,6 +2064,7 @@ async function completeWalletRegistrationNearProvisioning(args) {
 	};
 	if (args.auth.kind === "email_otp") body.emailOtpEnrollment = args.auth.enrollment;
 	if (args.walletCustodyCommit) body.walletCustodyCommit = args.walletCustodyCommit;
+	if (args.sessionSeal) body.sessionSeal = args.sessionSeal;
 	return parseWalletRegistrationNearProvisioningResponseV2(await postJson({
 		relayerUrl: args.relayerUrl,
 		path: WALLET_REGISTRATION_NEAR_PROVISIONING_PATH,