@seams/wallet 0.9.0 → 0.9.2

package/README.md

@@ -1,18 +1,18 @@
 # Seams Wallet SDK
 
-`@seams/wallet` **0.9.0** provides browser wallet lifecycle, NEAR and EVM-family
+`@seams/wallet` **0.9.2** provides browser wallet lifecycle, NEAR and EVM-family
 threshold signing, React components, and hosted wallet runtime assets.
 
 ## Install
 
 ```sh
-pnpm add @seams/wallet@0.9.0
+pnpm add @seams/wallet@0.9.2
 ```
 
 React integrations support React 18 and 19. Import the provider and UI from
 `@seams/wallet/react` and its stylesheet from `@seams/wallet/react/styles`.
 Keep the application package, wallet-origin assets, and
-`@seams/wallet-server@0.9.0` on the matching release.
+`@seams/wallet-server@0.9.2` on the matching release.
 
 ## Next release migration (unreleased)
 

package/dist/.build-inputs.sha256

@@ -1 +1 @@
-b17394151f88cd47fcc785945c545b600a58769c4ccb3ce56aa76fc6fcd46cef
+392dfb0f192f2256956e72a6ec24a6d93a8c39e38b83581ad6c62f1dd73df7a5

package/dist/esm/core/signingEngine/chains/evm/bytes.js

@@ -1,8 +1,22 @@
 //#region src/core/signingEngine/chains/evm/bytes.ts
+function hexToBytes(hex) {
+	const raw = String(hex || "");
+	const normalized = raw.startsWith("0x") ? raw.slice(2) : raw;
+	if (normalized.length === 0) return new Uint8Array();
+	if (normalized.length % 2 !== 0) throw new Error(`Invalid hex (odd length): ${hex}`);
+	const bytes = new Uint8Array(normalized.length / 2);
+	for (let i = 0; i < bytes.length; i++) {
+		const byte = normalized.slice(i * 2, i * 2 + 2);
+		const value = Number.parseInt(byte, 16);
+		if (!Number.isFinite(value)) throw new Error(`Invalid hex: ${hex}`);
+		bytes[i] = value;
+	}
+	return bytes;
+}
 function bytesToHex(bytes) {
 	return `0x${Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
 }
 //#endregion
-export { bytesToHex };
+export { bytesToHex, hexToBytes };
 
 //# sourceMappingURL=bytes.js.map

package/dist/esm/core/signingEngine/flows/signEvmFamily/signingFlow.js

@@ -4,9 +4,9 @@ import { parseDigestB64u, sha256Utf8DigestB64u } from "../../../../shared-ts/src
 import { SigningEventPhase, createSigningFlowEvent } from "../../../types/sdkSentEvents.js";
 import { SigningSessionIds } from "../../session/operationState/types.js";
 import { normalizeAuthenticationCredential } from "../../webauthnAuth/credentials/helpers.js";
+import { bytesToHex } from "../../chains/evm/bytes.js";
 import { isActiveWalletAuthoritySigningAuthPlan, isWarmSessionSigningAuthPlan } from "../../stepUpConfirmation/types.js";
 import { toManagedNonceReservationSnapshot } from "../../../rpcClients/evm/nonceBackend.js";
-import { bytesToHex } from "../../chains/evm/bytes.js";
 import { emitEcdsaSigningTiming } from "../../session/operationState/trace.js";
 import { parseSigningOperationFingerprintDigest } from "../../../../shared-ts/src/authorization/operationFingerprint.js";
 import { SigningOperationCommandKind, buildSigningOperationCommandSteps, createSigningOperationPlan, runSigningOperationCommandSteps, runUnplannedSigningOperationCommandSequence } from "../shared/signingStateMachine.js";

package/dist/esm/core/signingEngine/flows/signNear/shared/ed25519YaoNormalSigning.js

@@ -725,6 +725,82 @@ function routerAbEd25519NormalSigningMaterialFacts(args) {
 		relayerUrl: args.walletSessionState.relayerUrl
 	};
 }
+async function nearTransactionPrepareInputs(args, unsigned) {
+	const nearNetworkId = normalizeNearNetworkId(args.ctx);
+	const parsedTransaction = parseThresholdEd25519NearTransaction(args.txSigningRequest, "txSigningRequest");
+	return {
+		nearNetworkId,
+		parsedTransaction,
+		operationFingerprint: SigningSessionIds.signingOperationFingerprint(await thresholdEd25519NearTransactionOperationFingerprint({
+			nearAccountId: args.nearAccountId,
+			nearNetworkId,
+			relayerKeyId: args.thresholdKeyMaterial.relayerKeyId,
+			signerPublicKey: args.thresholdKeyMaterial.publicKey,
+			transactions: [parsedTransaction],
+			unsignedTransactionBorshB64u: unsigned.unsignedTransactionBorshB64u,
+			signingDigestB64u: unsigned.signingDigestB64u
+		}))
+	};
+}
+async function buildRouterAbEd25519NearTransactionWarmPrepare(args, unsigned, inputs) {
+	const scope = buildRouterAbNormalSigningScope({
+		activeClient: args.activeClient,
+		walletSessionState: args.walletSessionState,
+		walletId: args.walletId,
+		operationId: args.operationId
+	});
+	if (!scope) throw new Error("[SigningEngine][near] Router A/B Ed25519 signing scope is missing");
+	return await buildRouterAbEd25519NearTransactionPrepareRequestV2({
+		scope,
+		expiresAtMs: routerAbNormalSigningExpiresAtMs({
+			walletSessionExpiresAtMs: args.walletSessionState.signingWalletSession.expiresAtMs,
+			requestedTtlMs: ROUTER_AB_NORMAL_SIGNING_REQUEST_TTL_MS
+		}),
+		operationId: args.operationId,
+		operationFingerprint: inputs.operationFingerprint,
+		displayDigestB64u: args.displayDigest,
+		nearAccountId: args.nearAccountId,
+		nearNetworkId: inputs.nearNetworkId,
+		transactions: [{
+			receiverId: inputs.parsedTransaction.receiverId,
+			actionFingerprint: await routerAbNormalSigningActionFingerprint(inputs.parsedTransaction.actions)
+		}],
+		unsignedTransactionBorshB64u: unsigned.unsignedTransactionBorshB64u,
+		expectedSigningDigestB64u: unsigned.signingDigestB64u
+	});
+}
+/**
+* Sends the prepare of a warm-session transaction while the confirmation
+* dialog is open. The transaction context is the one the dialog reserved.
+*/
+async function startRouterAbEd25519NearTransactionPrepare(args) {
+	const unsigned = await buildThresholdEd25519NearTxUnsignedBorshWasm({
+		txSigningRequest: args.txSigningRequest,
+		transactionContext: args.transactionContext,
+		workerCtx: args.ctx
+	});
+	const prepare = await buildRouterAbEd25519NearTransactionWarmPrepare(args, unsigned, await nearTransactionPrepareInputs(args, unsigned));
+	const ready = requireRouterAbEd25519NormalSigningReadyState({
+		state: args.walletSessionState,
+		thresholdSessionId: args.thresholdSessionId,
+		nearAccountId: args.nearAccountId,
+		thresholdKeyMaterial: args.thresholdKeyMaterial
+	});
+	const sentAt = performance.now();
+	const response = prepareRouterAbNormalSigningV2({
+		relayServerUrl: args.walletSessionState.relayerUrl,
+		credential: ready.credential,
+		request: prepare.request
+	});
+	response.catch(() => {});
+	emitEd25519SigningTiming(String(args.operationId), "prepare_sent", sentAt);
+	return {
+		prepare,
+		displayDigest: args.displayDigest,
+		signingDigestB64u: unsigned.signingDigestB64u,
+		response
+	};
+}
 async function tryFinalizeRouterAbEd25519NearTransactionNormalSigning(args) {
 	const materialFacts = routerAbEd25519NormalSigningMaterialFacts(args);
 	if (!materialFacts.routerAbNormalSigning) throw new Error("[SigningEngine][near] Router A/B Ed25519 normal-signing state is missing");
@@ -739,17 +815,8 @@ async function tryFinalizeRouterAbEd25519NearTransactionNormalSigning(args) {
 		workerCtx: args.ctx
 	});
 	if (base64UrlDecode(unsigned.signingDigestB64u).length !== 32) throw new Error("Router A/B normal-signing NEAR payload digest must be 32 bytes");
-	const nearNetworkId = normalizeNearNetworkId(args.ctx);
-	const parsedTransaction = parseThresholdEd25519NearTransaction(args.txSigningRequest, "txSigningRequest");
-	const operationFingerprint = SigningSessionIds.signingOperationFingerprint(await thresholdEd25519NearTransactionOperationFingerprint({
-		nearAccountId: args.nearAccountId,
-		nearNetworkId,
-		relayerKeyId: args.thresholdKeyMaterial.relayerKeyId,
-		signerPublicKey: args.thresholdKeyMaterial.publicKey,
-		transactions: [parsedTransaction],
-		unsignedTransactionBorshB64u: unsigned.unsignedTransactionBorshB64u,
-		signingDigestB64u: unsigned.signingDigestB64u
-	}));
+	const prepareInputs = await nearTransactionPrepareInputs(args, unsigned);
+	let started = null;
 	let prepare;
 	let credential;
 	let issuedAuthorization;
@@ -772,31 +839,9 @@ async function tryFinalizeRouterAbEd25519NearTransactionNormalSigning(args) {
 		if (prepare.request.scope.authorization.kind !== "operation_step_up" || issued.kind !== "verified_step_up") throw new Error("[SigningEngine][near] issued operation step-up evidence changed identity");
 		issuedAuthorization = issued;
 	} else {
-		const scope = buildRouterAbNormalSigningScope({
-			activeClient: args.activeClient,
-			walletSessionState: args.walletSessionState,
-			walletId: args.walletId,
-			operationId: args.operationId
-		});
-		if (!scope) throw new Error("[SigningEngine][near] Router A/B Ed25519 signing scope is missing");
-		prepare = await buildRouterAbEd25519NearTransactionPrepareRequestV2({
-			scope,
-			expiresAtMs: routerAbNormalSigningExpiresAtMs({
-				walletSessionExpiresAtMs: args.walletSessionState.signingWalletSession.expiresAtMs,
-				requestedTtlMs: ROUTER_AB_NORMAL_SIGNING_REQUEST_TTL_MS
-			}),
-			operationId: args.operationId,
-			operationFingerprint,
-			displayDigestB64u: args.displayDigest,
-			nearAccountId: args.nearAccountId,
-			nearNetworkId,
-			transactions: [{
-				receiverId: parsedTransaction.receiverId,
-				actionFingerprint: await routerAbNormalSigningActionFingerprint(parsedTransaction.actions)
-			}],
-			unsignedTransactionBorshB64u: unsigned.unsignedTransactionBorshB64u,
-			expectedSigningDigestB64u: unsigned.signingDigestB64u
-		});
+		started = args.startedPrepare && args.startedPrepare.displayDigest === args.displayDigest && args.startedPrepare.signingDigestB64u === unsigned.signingDigestB64u ? args.startedPrepare : null;
+		if (args.startedPrepare && !started) abandonRouterAbEd25519StartedPrepare(args.startedPrepare);
+		prepare = started ? started.prepare : await buildRouterAbEd25519NearTransactionWarmPrepare(args, unsigned, prepareInputs);
 		credential = requireRouterAbEd25519NormalSigningReadyState({
 			state: args.walletSessionState,
 			thresholdSessionId: args.thresholdSessionId,
@@ -829,7 +874,8 @@ async function tryFinalizeRouterAbEd25519NearTransactionNormalSigning(args) {
 		signingPayloadLabel: "NEAR payload digest",
 		prepare,
 		credential,
-		authorization: "reusable_wallet_session"
+		authorization: "reusable_wallet_session",
+		startedResponse: started?.response
 	});
 	const finalized = await finalizeThresholdEd25519NearTxFromSignatureWasm({
 		unsignedTransactionBorshB64u: unsigned.unsignedTransactionBorshB64u,
@@ -871,6 +917,6 @@ async function tryFinalizeRouterAbEd25519NearTransactionNormalSigning(args) {
 	};
 }
 //#endregion
-export { abandonRouterAbEd25519StartedPrepare, buildNearEd25519OperationStepUpProof, buildNearEmailOtpEd25519OperationStepUpProof, finalizeThresholdEd25519DelegateSignatureResult, prepareRouterAbEd25519NearTransactionOperationStepUp, prepareRouterAbEd25519SignatureOnlyOperationStepUp, requireIssuedNearEd25519OperationStepUpAuthorization, requireNearEd25519OperationStepUpProof, startRouterAbEd25519SignatureOnlyPrepare, tryFinalizeRouterAbEd25519NearTransactionNormalSigning, tryFinalizeRouterAbEd25519SignatureOnlyNormalSigning };
+export { abandonRouterAbEd25519StartedPrepare, buildNearEd25519OperationStepUpProof, buildNearEmailOtpEd25519OperationStepUpProof, finalizeThresholdEd25519DelegateSignatureResult, prepareRouterAbEd25519NearTransactionOperationStepUp, prepareRouterAbEd25519SignatureOnlyOperationStepUp, requireIssuedNearEd25519OperationStepUpAuthorization, requireNearEd25519OperationStepUpProof, startRouterAbEd25519NearTransactionPrepare, startRouterAbEd25519SignatureOnlyPrepare, tryFinalizeRouterAbEd25519NearTransactionNormalSigning, tryFinalizeRouterAbEd25519SignatureOnlyNormalSigning };
 
 //# sourceMappingURL=ed25519YaoNormalSigning.js.map

package/dist/esm/core/signingEngine/flows/signNear/signTransactions.js

@@ -6,6 +6,7 @@ import { toAccountId } from "../../../types/accountIds.js";
 import { SigningEventPhase, createSigningFlowEvent } from "../../../types/sdkSentEvents.js";
 import { SigningOperationIntent, SigningSessionIds, SigningSessionPlanKind } from "../../session/operationState/types.js";
 import { nearEd25519SignerBindingFromBoundaryFields } from "../../session/identity/exactSigningLaneIdentity.js";
+import { computeUiIntentDigestFromTxs, orderActionForDigest } from "../../../../utils/intentDigest.js";
 import { isWarmSessionSigningAuthPlan } from "../../stepUpConfirmation/types.js";
 import { createSigningBoundaryTraceEvent, emitEd25519SigningTiming, emitSigningBoundaryTrace } from "../../session/operationState/trace.js";
 import { parseSigningOperationFingerprintDigest } from "../../../../shared-ts/src/authorization/operationFingerprint.js";
@@ -20,7 +21,7 @@ import { emitNearSigningConfirmationProgress } from "./shared/confirmationProgre
 import { buildNearEd25519StepUpAuthorization } from "./stepUpAuthorization.js";
 import { requiredNearTransactionSignatureUses } from "./signatureUses.js";
 import { clearNearOperationStepUpBuilder, consumePreparedNearOperationStepUp, registerNearOperationStepUpBuilder } from "./shared/operationStepUpPreparation.js";
-import { buildNearEd25519OperationStepUpProof, buildNearEmailOtpEd25519OperationStepUpProof, prepareRouterAbEd25519NearTransactionOperationStepUp, requireIssuedNearEd25519OperationStepUpAuthorization, requireNearEd25519OperationStepUpProof, tryFinalizeRouterAbEd25519NearTransactionNormalSigning } from "./shared/ed25519YaoNormalSigning.js";
+import { buildNearEd25519OperationStepUpProof, buildNearEmailOtpEd25519OperationStepUpProof, prepareRouterAbEd25519NearTransactionOperationStepUp, requireIssuedNearEd25519OperationStepUpAuthorization, requireNearEd25519OperationStepUpProof, startRouterAbEd25519NearTransactionPrepare, tryFinalizeRouterAbEd25519NearTransactionNormalSigning } from "./shared/ed25519YaoNormalSigning.js";
 import { fundNearImplicitAccountForOperationStepUp, resolveConfirmedNearTransactionContext } from "./implicitAccountFunding.js";
 import { clearNearImplicitAccountFunder, registerNearImplicitAccountFunder } from "./shared/implicitAccountFundingPort.js";
 import { nearOperationStepUpMaterialFacts, prepareNearOperationStepUpMaterial, resolveNearOperationStepUpMaterial, resolvePreparedNearEd25519YaoMaterial } from "./shared/ed25519YaoCapabilityResolution.js";
@@ -55,6 +56,34 @@ function requireWarmNearSigningMaterialTask(task) {
 	if (!task) throw new Error("[SigningEngine][near] warm signing material was not prepared");
 	return task;
 }
+async function startWarmNearTransactionPrepare(args) {
+	const resolved = await args.warmMaterial;
+	const walletSessionState = await args.sessionCoordinator.resolveActiveAuthorizedRouterAbEd25519WalletSessionState({
+		state: resolved.walletSessionState,
+		nowMs: Date.now()
+	});
+	if (!walletSessionState) return null;
+	const displayDigest = await computeUiIntentDigestFromTxs([{
+		receiverId: args.confirmationTransaction.receiverId,
+		actions: args.confirmationTransaction.actions.map(orderActionForDigest)
+	}]);
+	return await startRouterAbEd25519NearTransactionPrepare({
+		ctx: args.ctx,
+		thresholdSessionId: resolved.material.facts.thresholdSessionId,
+		thresholdKeyMaterial: args.thresholdKeyMaterial,
+		walletId: args.walletId,
+		nearAccountId: args.nearAccountId,
+		activeClient: resolved.material.activeClient,
+		walletSessionState,
+		operationId: args.operationId,
+		displayDigest,
+		txSigningRequest: args.txSigningRequest,
+		transactionContext: args.readiness.transactionContext
+	});
+}
+function ignoreStartedPrepareFailure() {
+	return null;
+}
 async function resolveNearTransactionOperationStepUpMaterial(args) {
 	if (args.authorization.kind === "passkey") {
 		if (args.material.kind !== "passkey_live" && args.material.kind !== "passkey_sealed") throw new Error("[SigningEngine][near] passkey transaction material changed factor");
@@ -553,6 +582,22 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 		}
 	});
 	emitEd25519SigningTiming(String(signingOperationId), "pre_confirmation", preConfirmationStartedAt);
+	let startedPrepareTask = null;
+	const startTransactionPrepare = (readiness) => {
+		if (startedPrepareTask || !warmSigningMaterialTask) return;
+		startedPrepareTask = startWarmNearTransactionPrepare({
+			ctx,
+			warmMaterial: warmSigningMaterialTask,
+			sessionCoordinator,
+			thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
+			walletId: commandSubject.walletSession.walletId,
+			nearAccountId,
+			operationId: signingOperation.operationId,
+			txSigningRequest,
+			confirmationTransaction,
+			readiness
+		}).catch(ignoreStartedPrepareFailure);
+	};
 	const confirmationStartedAt = performance.now();
 	let confirmation;
 	try {
@@ -567,6 +612,7 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 				chain: "near",
 				kind: "transaction",
 				...buildSigningConfirmationAuthParams({ signingAuthPlan: confirmationAuthPayload.signingAuthPlan }),
+				...warmSigningMaterialTask ? { onNearTransactionContextReady: startTransactionPrepare } : {},
 				walletId: String(signingLane.identity.signer.account.wallet.walletId),
 				txSigningRequests: [confirmationTransaction],
 				rpcCall: resolvedRpcCall,
@@ -785,7 +831,8 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 			displayDigest: confirmation.intentDigest,
 			txSigningRequest,
 			transactionContext,
-			authorization: { kind: "reusable_wallet_session" }
+			authorization: { kind: "reusable_wallet_session" },
+			startedPrepare: startedPrepareTask ? await startedPrepareTask : null
 		});
 		if (routerAbNormalSigningResult) return routerAbNormalSigningResult.okResponse;
 		throw new Error("[SigningEngine][near] Router A/B Ed25519 signing is unavailable");

package/dist/esm/core/signingEngine/uiConfirm/ui/confirm-surface-resize.js

@@ -1,4 +1,4 @@
-import { dispatchSurfaceResizeBegin } from "./surface-resize-events.js";
+import { addSurfaceResizeBeginListener, dispatchSurfaceResizeBegin } from "./surface-resize-events.js";
 //#region src/core/signingEngine/uiConfirm/ui/confirm-surface-resize.ts
 /**
 * Host-driven height changes for wallet-iframe confirmations.
@@ -25,6 +25,10 @@ import { dispatchSurfaceResizeBegin } from "./surface-resize-events.js";
 *
 * The module owns the rules for iframe-hosted confirmation reflow.
 */
+const CONFIRM_SURFACE_MODE_ATTR = "data-seams-confirm-surface";
+const CONFIRM_SURFACE_MODE_WALLET_IFRAME = "wallet-iframe";
+/** Marks the confirmer host while its height is held at a motion's target. */
+const CONFIRM_SURFACE_PINNED_CLASS = "seams-confirm-surface-pinned";
 /**
 * Marks the document root for the same span. It is a second class rather than
 * the one above because the host rule must match any element that hosts a
@@ -37,6 +41,24 @@ const CONFIRM_SURFACE_PINNED_ROOT_CLASS = "seams-confirm-surface-pinned-root";
 const CONFIRM_SURFACE_HEIGHT_DRIVEN_CLASS = "seams-surface-height-driven";
 /** The CSS variable the class above reads. Components own the write (CSP). */
 const CONFIRM_SURFACE_HEIGHT_DRIVEN_VAR = "--seams-surface-height-driven-target";
+/** Frames the box may sit still, after it has moved, before its motion counts as over. */
+const SETTLED_FRAMES_AFTER_MOTION = 8;
+/** Frames to wait for the parent to react at all before giving up on it. */
+const SETTLED_FRAMES_WITHOUT_MOTION = 20;
+/**
+* The parent writes the destination box and forces a layout BEFORE it starts
+* its ease, and a cross-origin iframe can receive that destination size for one
+* frame before the animation snaps it back to the origin. Landing on that
+* frame finishes the interior instantly and leaves the box to ease on its
+* own — the exact jank this module exists to remove. A box that jumps straight
+* to the target therefore has to stay there this many frames before the
+* content lands on it; a box that eased through intermediate sizes lands at
+* once. The parent pins the iframe to the origin for that read
+* (`overlay-styles.ts pinDialogIframe`), so this is the second of two guards.
+*/
+const LANDING_CONFIRM_FRAMES = 3;
+/** The parent rounds the measured size; allow that much slack when asking whether the box hugs the host. */
+const HUG_TOLERANCE_CSS_PX = 1;
 /** A host that claims a motion and never lands it must not leave content clamped. */
 const ANNOUNCE_SAFETY_MS = 1500;
 /** Height changes below this are not worth a motion, and round to nothing. */
@@ -169,7 +191,156 @@ function announceClampedSurfaceResize(args) {
 	if (!claimed) element.classList.remove(...addedClasses);
 	return claimed;
 }
+let diagnosticHost = null;
+const surfaceMotionDiagnostics = {
+	blipFrames: 0,
+	trace(durationMs = 2e3) {
+		return new Promise((resolve) => {
+			const lines = [];
+			const startedAt = performance.now();
+			const tick = () => {
+				const host = diagnosticHost;
+				const pinned = host?.classList.contains(CONFIRM_SURFACE_PINNED_CLASS) ? "*" : "";
+				lines.push(`${Math.round(performance.now() - startedAt)}: box=${document.documentElement.clientHeight} content=${host ? Math.round(host.getBoundingClientRect().height) : "-"}${pinned}`);
+				if (performance.now() - startedAt < durationMs) requestAnimationFrame(tick);
+				else resolve(lines);
+			};
+			requestAnimationFrame(tick);
+		});
+	}
+};
+function publishDiagnostics(element) {
+	diagnosticHost = element;
+	try {
+		window.__seamsSurfaceMotion = surfaceMotionDiagnostics;
+	} catch {}
+}
+function defaultViewportHeightCssPx() {
+	const height = document.documentElement?.clientHeight ?? 0;
+	return height > 0 ? height : window.innerHeight;
+}
+function clamp(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
+function isWalletIframeConfirmSurface(element) {
+	return element.getAttribute(CONFIRM_SURFACE_MODE_ATTR) === CONFIRM_SURFACE_MODE_WALLET_IFRAME;
+}
+function createHostHeightPin(element) {
+	if (typeof CSSStyleSheet !== "function" || !("adoptedStyleSheets" in document)) return null;
+	let sheet = null;
+	const release = () => {
+		element.classList.remove(CONFIRM_SURFACE_PINNED_CLASS);
+		document.documentElement.classList.remove(CONFIRM_SURFACE_PINNED_ROOT_CLASS);
+	};
+	return {
+		set(px) {
+			try {
+				if (!sheet) sheet = new CSSStyleSheet();
+				sheet.replaceSync(`.${CONFIRM_SURFACE_PINNED_CLASS}{height:${Math.max(0, Math.round(px))}px}.${CONFIRM_SURFACE_PINNED_ROOT_CLASS}{overflow:hidden}`);
+				if (!document.adoptedStyleSheets.includes(sheet)) document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet];
+			} catch {
+				return false;
+			}
+			element.classList.add(CONFIRM_SURFACE_PINNED_CLASS);
+			document.documentElement.classList.add(CONFIRM_SURFACE_PINNED_ROOT_CLASS);
+			return true;
+		},
+		release,
+		dispose() {
+			release();
+			if (!sheet) return;
+			const retired = sheet;
+			sheet = null;
+			try {
+				document.adoptedStyleSheets = document.adoptedStyleSheets.filter((s) => s !== retired);
+			} catch {}
+		}
+	};
+}
+function attachConfirmSurfaceResizeChoreographer(element, options = {}) {
+	const readViewportHeightCssPx = options.viewportHeightCssPx ?? defaultViewportHeightCssPx;
+	const pin = createHostHeightPin(element);
+	publishDiagnostics(element);
+	let active = null;
+	const settle = () => {
+		const current = active;
+		if (!current) return;
+		active = null;
+		if (current.frame !== null) cancelAnimationFrame(current.frame);
+		current.driver.setProgress(1);
+		current.driver.finish();
+		pin?.release();
+	};
+	const step = () => {
+		const current = active;
+		if (!current) return;
+		current.frame = null;
+		const viewportPx = readViewportHeightCssPx();
+		if (viewportPx !== current.lastViewportPx) {
+			current.lastViewportPx = viewportPx;
+			current.framesSinceChange = 0;
+			current.moved = true;
+		} else current.framesSinceChange += 1;
+		const progress = clamp((viewportPx - current.originHostPx) / current.deltaCssPx, 0, 1);
+		if (progress >= 1) {
+			current.framesAtTarget += 1;
+			if (current.sawIntermediate || current.framesAtTarget >= LANDING_CONFIRM_FRAMES) {
+				settle();
+				return;
+			}
+			current.frame = requestAnimationFrame(step);
+			return;
+		}
+		if (current.framesAtTarget > 0) surfaceMotionDiagnostics.blipFrames += 1;
+		current.framesAtTarget = 0;
+		if (progress > 0) current.sawIntermediate = true;
+		current.driver.setProgress(progress);
+		const settledFrames = current.moved ? SETTLED_FRAMES_AFTER_MOTION : SETTLED_FRAMES_WITHOUT_MOTION;
+		if (current.framesSinceChange >= settledFrames) {
+			settle();
+			return;
+		}
+		current.frame = requestAnimationFrame(step);
+	};
+	const onSurfaceResizeBegin = (event) => {
+		const detail = event.detail;
+		if (!pin || !detail || !isWalletIframeConfirmSurface(element)) return;
+		const deltaCssPx = detail.deltaCssPx;
+		if (!Number.isFinite(deltaCssPx) || Math.abs(deltaCssPx) < MIN_ANNOUNCED_DELTA_CSS_PX) return;
+		settle();
+		const viewportPx = readViewportHeightCssPx();
+		const hostPx = element.getBoundingClientRect().height;
+		if (!(viewportPx > 0) || !(hostPx > 0) || Math.abs(viewportPx - hostPx) > HUG_TOLERANCE_CSS_PX) return;
+		const originHostPx = Math.round(hostPx);
+		const targetHostPx = originHostPx + deltaCssPx;
+		if (!(targetHostPx > 0)) return;
+		if (!pin.set(targetHostPx)) return;
+		const driver = detail.claim();
+		if (!driver) {
+			pin.release();
+			return;
+		}
+		active = {
+			driver,
+			originHostPx,
+			deltaCssPx,
+			lastViewportPx: viewportPx,
+			framesSinceChange: 0,
+			moved: false,
+			sawIntermediate: false,
+			framesAtTarget: 0,
+			frame: null
+		};
+		active.frame = requestAnimationFrame(step);
+	};
+	const removeListener = addSurfaceResizeBeginListener(element, onSurfaceResizeBegin);
+	return { dispose() {
+		removeListener();
+		settle();
+		pin?.dispose();
+	} };
+}
 //#endregion
-export { CONFIRM_SURFACE_HEIGHT_DRIVEN_VAR, announceClampedSurfaceResize, createSurfaceHeightReflow };
+export { CONFIRM_SURFACE_HEIGHT_DRIVEN_VAR, CONFIRM_SURFACE_MODE_ATTR, announceClampedSurfaceResize, announceSurfaceResize, attachConfirmSurfaceResizeChoreographer, createSurfaceHeightReflow };
 
 //# sourceMappingURL=confirm-surface-resize.js.map

package/dist/esm/core/signingEngine/uiConfirm/ui/surface-resize-events.js

@@ -7,7 +7,12 @@ function dispatchSurfaceResizeBegin(target, detail) {
 		detail
 	}));
 }
+function addSurfaceResizeBeginListener(target, listener, options) {
+	const handler = listener;
+	target.addEventListener(SURFACE_RESIZE_BEGIN_EVENT, handler, options);
+	return () => target.removeEventListener(SURFACE_RESIZE_BEGIN_EVENT, handler, options);
+}
 //#endregion
-export { dispatchSurfaceResizeBegin };
+export { addSurfaceResizeBeginListener, dispatchSurfaceResizeBegin };
 
 //# sourceMappingURL=surface-resize-events.js.map