@seams/wallet 0.6.1 → 0.7.1

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

@@ -1,72 +1,15 @@
 import { base64Encode, base64UrlDecode } from "../../../../shared-ts/src/utils/base64.js";
 import { resolveNearNetwork } from "../../../config/chains.js";
 import { normalizeThresholdEd25519ParticipantIds } from "../../../../shared-ts/src/threshold/participants.js";
-import { SigningOperationIntent, SigningSessionIds, SigningSessionPlanKind } from "../../session/operationState/types.js";
-import { nearEd25519SignerBindingFromBoundaryFields } from "../../session/identity/exactSigningLaneIdentity.js";
+import { SigningOperationIntent, SigningSessionIds } from "../../session/operationState/types.js";
 import { PASSKEY_MANAGER_DEFAULT_CONFIGS } from "../../../config/defaultConfigs.js";
 import { resolveNearSigningMaterials } from "./shared/signingMaterials.js";
 import { thresholdEd25519Nep413OperationFingerprint } from "../../../../shared-ts/src/threshold/ed25519OperationFingerprint.js";
 import { SigningOperationCommandKind, runSigningOperationCommand } from "../shared/signingStateMachine.js";
-import { requireNearStepUpAuth, signingAuthPlanForNearMaterialRequirement } from "./requireNearStepUpAuth.js";
-import { buildSigningConfirmationAuthParams } from "../../stepUpConfirmation/confirmOperation.js";
-import { confirmationConfigForSigningAuthPlan, runSigningConfirmationCommand } from "../shared/signingConfirmation.js";
-import { emitNearSigningConfirmationProgress } from "./shared/confirmationProgress.js";
-import { buildNearEd25519StepUpAuthorization } from "./stepUpAuthorization.js";
 import { WorkerResponseType } from "../../../types/signer-worker.js";
 import { computeThresholdEd25519Nep413SigningDigestWasm } from "../../chains/near/nearSignerWasm.js";
-import { parseSigningOperationFingerprintDigest } from "../../../../shared-ts/src/authorization/operationFingerprint.js";
-import { clearNearOperationStepUpBuilder, consumePreparedNearOperationStepUp, registerNearOperationStepUpBuilder } from "./shared/operationStepUpPreparation.js";
-import { buildNearEd25519OperationStepUpProof, prepareRouterAbEd25519SignatureOnlyOperationStepUp, requireIssuedNearEd25519OperationStepUpAuthorization, requireNearEd25519OperationStepUpProof, tryFinalizeRouterAbEd25519SignatureOnlyNormalSigning } from "./shared/ed25519YaoNormalSigning.js";
-import { nearOperationStepUpMaterialFacts, prepareNearOperationStepUpMaterial, resolveConfirmedNearEd25519YaoCapability, resolveNearOperationStepUpMaterial } from "./shared/ed25519YaoCapabilityResolution.js";
-import { buildNearSigningSessionAuthPlan, resolveNearSigningSessionAuthContext } from "./shared/signingSessionAuthMode.js";
-import { planSigningSession } from "../../session/planning/planner.js";
+import { authorizeNearSignatureOnlyOperation, confirmNearSignatureOnlyOperation, prepareNearSignatureOnlyStepUp, resolveNearSignatureOnlySigningMaterial, resolveNearSignatureOnlySigningPlans, runNearSignatureOnlySignCommand, signNearSignatureOnlyOperation } from "./shared/signatureOnlySigning.js";
 //#region src/core/signingEngine/flows/signNear/signNep413.ts
-function requireNearNep413OperationStepUpPreparation(value) {
-	if (!value) throw new Error("[SigningEngine][near] NEP-413 operation step-up preparation is missing");
-	return value;
-}
-function requirePreparedNearNep413OperationStepUp(value) {
-	if (!value || value.kind !== "near_signature_only") throw new Error("[SigningEngine][near] NEP-413 operation step-up preparation kind changed");
-	return value;
-}
-function requireNearNep413OperationStepUpMaterial(value) {
-	if (!value) throw new Error("[SigningEngine][near] NEP-413 operation step-up material is missing");
-	return value;
-}
-function requireNearNep413SigningDigest(value) {
-	if (!value) throw new Error("[SigningEngine][near] NEP-413 operation signing digest is missing");
-	return value;
-}
-function requireAuthorizedNearNep413WalletSessionState(value) {
-	if (!value) throw new Error("[SigningEngine][near] reusable Wallet Session authorization is unavailable");
-	return value;
-}
-async function resolveNearNep413OperationStepUpCapability(args) {
-	if (args.authorization.kind === "passkey") {
-		if (args.material.kind !== "passkey_live" && args.material.kind !== "passkey_sealed") throw new Error("[SigningEngine][near] passkey NEP-413 material changed factor");
-		return await resolveNearOperationStepUpMaterial({
-			kind: "passkey",
-			material: args.material,
-			expectedActivation: args.prepared.materialActivation,
-			credential: args.authorization.credential
-		});
-	}
-	if (args.material.kind !== "email_otp_live" && args.material.kind !== "email_otp_sealed") throw new Error("[SigningEngine][near] Email OTP NEP-413 material changed factor");
-	if (!args.emailOtpProof) throw new Error("[SigningEngine][near] Email OTP NEP-413 proof is missing");
-	if (args.material.kind === "email_otp_live") return await resolveNearOperationStepUpMaterial({
-		kind: "email_otp_live",
-		material: args.material,
-		expectedActivation: args.prepared.materialActivation
-	});
-	return await resolveNearOperationStepUpMaterial({
-		kind: "email_otp_sealed",
-		material: args.material,
-		expectedActivation: args.prepared.materialActivation,
-		normalSigningRequest: args.prepared.prepare.request,
-		displayDigest: args.displayDigest,
-		proof: args.emailOtpProof
-	});
-}
 async function signNep413Message({ ctx, commandSubject, nearAccount, signingSessionCoordinator, payload, forceFreshAuth, passkeyEd25519OperationStepUp, emailOtpEd25519StepUp, yaoSigningPreparation, yaoMaterialExecutor, selection, onEvent }) {
 	const selectionAuth = selection.kind === "authorized" ? selection.selectedLane.auth : selection.candidate.auth;
 	const selectedSignerSlot = selection.kind === "authorized" ? selection.selectedLane.identity.signer.signerSlot : selection.candidate.signerSlot;
@@ -75,62 +18,12 @@ async function signNep413Message({ ctx, commandSubject, nearAccount, signingSess
 	const nearAccountId = nearAccount.accountId;
 	const touchConfirm = ctx.touchConfirm;
 	if (!touchConfirm) throw new Error("UiConfirm bridge not available for NEP-413 signing");
-	const requiredSignatureUses = 1;
-	let signingAuthPlan;
-	let signingSessionPlan;
-	if (selection.kind === "authorized") {
-		const signingSessionAuthContext = resolveNearSigningSessionAuthContext({
-			requiredSignatureUses,
-			commandSubject,
-			forceFreshAuth,
-			selectedLane: selection.selectedLane,
-			preparation: yaoSigningPreparation
-		});
-		const resolvedSigningSession = {
-			signingSessionPlan: planSigningSession({
-				lane: signingSessionAuthContext.coordinatorInput.lane,
-				readiness: signingSessionAuthContext.coordinatorInput.readiness,
-				forceFreshAuth: signingSessionAuthContext.coordinatorInput.forceFreshAuth
-			}),
-			readiness: signingSessionAuthContext.coordinatorInput.readiness,
-			expiresAtMs: signingSessionAuthContext.coordinatorInput.expiresAtMs || 0,
-			remainingUses: signingSessionAuthContext.coordinatorInput.remainingUses || 0
-		};
-		signingAuthPlan = buildNearSigningSessionAuthPlan({
-			context: signingSessionAuthContext,
-			resolvedSigningSession
-		}).signingAuthPlan;
-		signingSessionPlan = resolvedSigningSession.signingSessionPlan;
-	} else {
-		const candidate = selection.candidate;
-		signingAuthPlan = signingAuthPlanForNearMaterialRequirement(selectionAuth);
-		const deferredIdentity = {
-			kind: "deferred_ed25519_material_identity",
-			signer: nearEd25519SignerBindingFromBoundaryFields({
-				walletId: candidate.walletId,
-				nearAccountId: candidate.nearAccountId,
-				nearEd25519SigningKeyId: candidate.nearEd25519SigningKeyId,
-				signerSlot: candidate.signerSlot
-			}),
-			materialActivation: candidate.materialActivation,
-			thresholdSessionId: SigningSessionIds.thresholdEd25519Session(candidate.thresholdSessionId)
-		};
-		signingSessionPlan = {
-			kind: SigningSessionPlanKind.OperationStepUp,
-			lane: {
-				identity: deferredIdentity,
-				auth: candidate.auth,
-				curve: "ed25519",
-				keyKind: "threshold_ed25519",
-				chainFamily: "near",
-				sessionOrigin: "per_operation",
-				storageSource: "sealed_restore",
-				retention: "single_use",
-				materialActivation: deferredIdentity.materialActivation,
-				thresholdSessionId: deferredIdentity.thresholdSessionId
-			}
-		};
-	}
+	const { signingAuthPlan, signingSessionPlan } = resolveNearSignatureOnlySigningPlans({
+		selection,
+		commandSubject,
+		forceFreshAuth,
+		preparation: yaoSigningPreparation
+	});
 	const { thresholdKeyMaterial } = await resolveNearSigningMaterials({
 		materialExecutor: yaoMaterialExecutor,
 		nearAccount,
@@ -157,208 +50,68 @@ async function signNep413Message({ ctx, commandSubject, nearAccount, signingSess
 		})),
 		intent: SigningOperationIntent.TransactionSign
 	};
-	const runSharedNearNep413Command = async (args) => await runSigningOperationCommand({
+	const operation = {
+		label: "NEP-413",
+		ctx,
+		walletId: commandSubject.walletSession.walletId,
+		nearAccountId,
+		auth: selectionAuth,
 		signingSessionPlan,
 		signingOperation,
-		commandKind: args.commandKind,
-		execute: args.execute
-	});
-	const preparedStepUp = await requireNearStepUpAuth({
-		signingAuthPlan,
-		signingLaneAuth: selectionAuth,
-		requiredSignatureUses,
-		operationFingerprintDigest: parseSigningOperationFingerprintDigest(signingOperation.operationFingerprint),
-		passkeyEd25519OperationStepUp,
-		emailOtpEd25519StepUp
-	});
-	const signatureOnlyIntent = {
-		kind: "nep413_message_v1",
-		message: payload.message,
-		recipient: payload.recipient,
-		nonce: payload.nonce,
-		...payload.state ? { state: payload.state } : {}
-	};
-	let operationStepUpMaterial = null;
-	let operationStepUpSigningDigestB64u = null;
-	if (preparedStepUp.kind !== "warm_session") {
-		operationStepUpMaterial = await prepareNearOperationStepUpMaterial({
-			method: preparedStepUp.kind,
-			preparation: yaoSigningPreparation,
-			executor: yaoMaterialExecutor
-		});
-		const material = operationStepUpMaterial;
-		const materialFacts = nearOperationStepUpMaterialFacts(material);
-		const signingDigest = await computeThresholdEd25519Nep413SigningDigestWasm({
+		thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
+		preparation: yaoSigningPreparation,
+		executor: yaoMaterialExecutor,
+		intent: {
+			kind: "nep413_message_v1",
 			message: payload.message,
 			recipient: payload.recipient,
 			nonce: payload.nonce,
-			...payload.state ? { state: payload.state } : {},
-			workerCtx: ctx
-		});
-		operationStepUpSigningDigestB64u = signingDigest.signingDigestB64u;
-		registerNearOperationStepUpBuilder({
-			requestId: String(operationId),
-			build: async (preparation) => {
-				if (preparation.kind !== "near_signature_only") throw new Error("[SigningEngine][near] NEP-413 operation step-up preparation kind changed");
-				return await prepareRouterAbEd25519SignatureOnlyOperationStepUp({
-					ctx,
-					thresholdSessionId: materialFacts.thresholdSessionId,
-					materialFacts,
-					thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
-					walletId: commandSubject.walletSession.walletId,
-					nearAccountId,
-					materialActivation: material.materialActivation,
-					operationId: signingOperation.operationId,
-					operationFingerprint: signingOperation.operationFingerprint,
-					displayDigest: preparation.displayDigest,
-					signingDigestB64u: signingDigest.signingDigestB64u,
-					intent: signatureOnlyIntent
-				});
-			}
-		});
-	}
-	let confirmation;
-	try {
-		confirmation = await runSigningConfirmationCommand({
-			signingSessionPlan,
-			signingOperation,
-			runtime: touchConfirm,
-			request: {
-				ctx: { touchConfirm },
-				sessionId: String(operationId),
-				chain: "near",
-				kind: "nep413",
-				...buildSigningConfirmationAuthParams({ signingAuthPlan: preparedStepUp.confirmationAuthPayload.signingAuthPlan }),
-				walletId: String(commandSubject.walletSession.walletId),
-				nearAccountId,
-				nearPublicKeyStr: signingContext.nearPublicKey,
-				message: payload.message,
-				recipient: payload.recipient,
-				title: payload.title,
-				body: payload.body,
-				confirmationConfigOverride: confirmationConfigForSigningAuthPlan({
-					signingAuthPlan: preparedStepUp.confirmationAuthPayload.signingAuthPlan,
-					override: payload.confirmationConfigOverride
-				}),
-				onProgress: emitNearSigningConfirmationProgress.bind(void 0, {
-					onEvent,
-					nearAccountId,
-					signingAuthPlan: preparedStepUp.confirmationAuthPayload.signingAuthPlan
-				})
-			}
-		});
-	} finally {
-		clearNearOperationStepUpBuilder(String(operationId));
-	}
-	const stepUpAuthorization = buildNearEd25519StepUpAuthorization({
-		prepared: preparedStepUp,
-		confirmation
-	});
-	const operationStepUpProof = stepUpAuthorization.kind === "warm_session" ? null : buildNearEd25519OperationStepUpProof({
-		authorization: stepUpAuthorization,
-		preparation: yaoSigningPreparation,
-		auth: selectionAuth,
-		walletId: commandSubject.walletSession.walletId
-	});
-	const preparedOperationStepUp = stepUpAuthorization.kind === "warm_session" ? null : requirePreparedNearNep413OperationStepUp(consumePreparedNearOperationStepUp({
-		requestId: String(operationId),
-		ref: requireNearNep413OperationStepUpPreparation(confirmation.operationStepUpPreparation)
-	}));
-	const preparedMaterial = await runSharedNearNep413Command({
-		commandKind: SigningOperationCommandKind.PreparePayload,
-		execute: async () => {
-			return stepUpAuthorization.kind === "warm_session" ? {
-				kind: "warm_session",
-				resolved: await resolveConfirmedNearEd25519YaoCapability({
-					authorization: stepUpAuthorization,
-					preparation: yaoSigningPreparation,
-					executor: yaoMaterialExecutor
-				})
-			} : {
-				kind: "operation_step_up",
-				thresholdSessionId: nearOperationStepUpMaterialFacts(requireNearNep413OperationStepUpMaterial(operationStepUpMaterial)).thresholdSessionId,
-				resolved: await resolveNearNep413OperationStepUpCapability({
-					material: requireNearNep413OperationStepUpMaterial(operationStepUpMaterial),
-					prepared: requirePreparedNearNep413OperationStepUp(preparedOperationStepUp),
-					displayDigest: confirmation.intentDigest,
-					authorization: stepUpAuthorization,
-					emailOtpProof: operationStepUpProof?.kind === "email_otp" ? operationStepUpProof : null
-				})
-			};
-		}
-	});
-	const canonicalThresholdSessionId = preparedMaterial.kind === "warm_session" ? preparedMaterial.resolved.thresholdSessionId : preparedMaterial.thresholdSessionId;
-	const executeNep413Request = async () => {
-		const signingDigestB64u = stepUpAuthorization.kind === "warm_session" ? (await computeThresholdEd25519Nep413SigningDigestWasm({
+			...payload.state ? { state: payload.state } : {}
+		},
+		computeSigningDigestB64u: async () => (await computeThresholdEd25519Nep413SigningDigestWasm({
 			message: payload.message,
 			recipient: payload.recipient,
 			nonce: payload.nonce,
 			...payload.state ? { state: payload.state } : {},
 			workerCtx: ctx
-		})).signingDigestB64u : requireNearNep413SigningDigest(operationStepUpSigningDigestB64u);
-		const routerAbNormalSigningResult = preparedMaterial.kind === "warm_session" ? await tryFinalizeRouterAbEd25519SignatureOnlyNormalSigning({
-			ctx,
-			thresholdSessionId: canonicalThresholdSessionId,
-			activeClient: preparedMaterial.resolved.material.activeClient,
-			walletSessionState: requireAuthorizedNearNep413WalletSessionState(await signingSessionCoordinator.resolveActiveAuthorizedRouterAbEd25519WalletSessionState({
-				state: preparedMaterial.resolved.walletSessionState,
-				nowMs: Date.now()
-			})),
-			walletId: commandSubject.walletSession.walletId,
-			thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
-			nearAccountId,
-			operationId: signingOperation.operationId,
-			operationFingerprint: signingOperation.operationFingerprint,
-			displayDigest: confirmation.intentDigest,
-			signingDigestB64u,
-			intent: signatureOnlyIntent,
-			authorization: { kind: "reusable_wallet_session" }
-		}) : await tryFinalizeRouterAbEd25519SignatureOnlyNormalSigning({
-			ctx,
-			thresholdSessionId: canonicalThresholdSessionId,
-			activeClient: preparedMaterial.resolved.material.activeClient,
-			materialFacts: preparedMaterial.resolved.material.facts,
-			walletId: commandSubject.walletSession.walletId,
-			thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
-			nearAccountId,
-			operationId: signingOperation.operationId,
-			operationFingerprint: signingOperation.operationFingerprint,
-			displayDigest: confirmation.intentDigest,
-			signingDigestB64u,
-			intent: signatureOnlyIntent,
-			authorization: {
-				kind: "operation_step_up",
-				prepared: requirePreparedNearNep413OperationStepUp(preparedOperationStepUp),
-				proof: requireNearEd25519OperationStepUpProof(operationStepUpProof),
-				issuedAuthorization: preparedMaterial.resolved.issuedAuthorization
-			}
-		});
-		if (routerAbNormalSigningResult) {
-			if (preparedMaterial.kind === "operation_step_up" && routerAbNormalSigningResult.authorization === "operation_step_up") requireIssuedNearEd25519OperationStepUpAuthorization({
-				prepared: requirePreparedNearNep413OperationStepUp(preparedOperationStepUp),
-				issuedAuthorization: routerAbNormalSigningResult.issuedAuthorization
-			});
-			return {
-				type: WorkerResponseType.SignNep413MessageSuccess,
-				payload: {
-					accountId: nearAccountId,
-					publicKey: routerAbNormalSigningResult.signerPublicKey,
-					signature: base64Encode(base64UrlDecode(routerAbNormalSigningResult.signatureB64u)),
-					state: payload.state || void 0
-				}
-			};
-		}
-		throw new Error("[SigningEngine][near] Router A/B Ed25519 NEP-413 signing is unavailable");
+		})).signingDigestB64u
 	};
-	const okResponse = await runSharedNearNep413Command({
-		commandKind: SigningOperationCommandKind.Sign,
-		execute: async () => {
-			try {
-				return await executeNep413Request();
-			} catch (e) {
-				throw e instanceof Error ? e : new Error(String(e));
-			}
+	const stepUp = await prepareNearSignatureOnlyStepUp(operation, {
+		signingAuthPlan,
+		passkeyEd25519OperationStepUp,
+		emailOtpEd25519StepUp
+	});
+	const authorization = authorizeNearSignatureOnlyOperation(operation, stepUp, await confirmNearSignatureOnlyOperation(operation, {
+		touchConfirm,
+		signingAuthPlan: stepUp.preparedStepUp.confirmationAuthPayload.signingAuthPlan,
+		nearPublicKeyStr: signingContext.nearPublicKey,
+		onEvent,
+		title: payload.title,
+		body: payload.body,
+		confirmationConfigOverride: payload.confirmationConfigOverride,
+		request: {
+			kind: "nep413",
+			message: payload.message,
+			recipient: payload.recipient
 		}
+	}));
+	const signingMaterial = await runSigningOperationCommand({
+		signingSessionPlan,
+		signingOperation,
+		commandKind: SigningOperationCommandKind.PreparePayload,
+		execute: async () => await resolveNearSignatureOnlySigningMaterial(operation, authorization)
+	});
+	const okResponse = await runNearSignatureOnlySignCommand(operation, async () => {
+		const signed = await signNearSignatureOnlyOperation(operation, signingMaterial, signingSessionCoordinator);
+		return {
+			type: WorkerResponseType.SignNep413MessageSuccess,
+			payload: {
+				accountId: nearAccountId,
+				publicKey: signed.signerPublicKey,
+				signature: base64Encode(base64UrlDecode(signed.signatureB64u)),
+				state: payload.state || void 0
+			}
+		};
 	});
 	return {
 		success: true,

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

@@ -9,7 +9,7 @@ import { SignedTransaction } from "../../../rpcClients/near/NearClient.js";
 import { PASSKEY_MANAGER_DEFAULT_CONFIGS } from "../../../config/defaultConfigs.js";
 import { resolveNearSigningMaterials } from "./shared/signingMaterials.js";
 import { buildNearTransactionSigningPayload } from "../../chains/near/payloads.js";
-import { createSigningBoundaryTraceEvent, emitSigningBoundaryTrace } from "../../session/operationState/trace.js";
+import { createSigningBoundaryTraceEvent, emitEd25519SigningTiming, emitSigningBoundaryTrace } from "../../session/operationState/trace.js";
 import { parseThresholdEd25519NearTransaction, thresholdEd25519NearTransactionPlanningOperationFingerprint } from "../../../../shared-ts/src/threshold/ed25519OperationFingerprint.js";
 import { SigningOperationCommandKind, isSigningOperationReviewApprovedState, runSigningOperationCommand } from "../shared/signingStateMachine.js";
 import { requireNearStepUpAuth, signingAuthPlanForNearMaterialRequirement } from "./requireNearStepUpAuth.js";
@@ -45,6 +45,16 @@ function disposeOwnedNearOperationStepUpMaterialAndRethrow(args, error) {
 	disposeOwnedNearOperationStepUpMaterial(args);
 	throw error;
 }
+async function resolveWarmNearSigningMaterial(args) {
+	return {
+		material: await resolvePreparedNearEd25519YaoMaterial(args.preparation, args.executor),
+		walletSessionState: await args.executor.resolveWalletSessionState()
+	};
+}
+function requireWarmNearSigningMaterialTask(task) {
+	if (!task) throw new Error("[SigningEngine][near] warm signing material was not prepared");
+	return task;
+}
 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");
@@ -81,13 +91,20 @@ function emitNearSigningEvent(onEvent, accountId, event) {
 	} catch {}
 }
 async function requireActiveAuthorizedWalletSessionState(args) {
-	if (!args.state) throw new Error("[SigningEngine][near] reusable Wallet Session state is unavailable");
-	const authorized = await args.coordinator.resolveActiveAuthorizedRouterAbEd25519WalletSessionState({
-		state: args.state,
-		nowMs: Date.now()
-	});
-	if (!authorized) throw new Error("[SigningEngine][near] reusable Wallet Session authorization is unavailable");
-	return authorized;
+	const startedAt = performance.now();
+	let outcome = "failed";
+	try {
+		if (!args.state) throw new Error("[SigningEngine][near] reusable Wallet Session state is unavailable");
+		const authorized = await args.coordinator.resolveActiveAuthorizedRouterAbEd25519WalletSessionState({
+			state: args.state,
+			nowMs: Date.now()
+		});
+		if (!authorized) throw new Error("[SigningEngine][near] reusable Wallet Session authorization is unavailable");
+		outcome = "succeeded";
+		return authorized;
+	} finally {
+		emitEd25519SigningTiming(args.operationId, "wallet_session_authorization", startedAt, outcome);
+	}
 }
 async function prepareNearTransactionConfirmationReadiness(args) {
 	const material = await prepareNearOperationStepUpMaterial({
@@ -285,10 +302,7 @@ async function runNearAuthorizationRequiredTransactionSigning(payload) {
 				}),
 				title,
 				body,
-				confirmationReadiness: {
-					promise: operationStepUpReadiness,
-					body: "Preparing secure signing session…"
-				},
+				confirmationReadiness: { promise: operationStepUpReadiness },
 				onProgress: emitNearSigningConfirmationProgress.bind(void 0, {
 					onEvent,
 					nearAccountId,
@@ -381,10 +395,13 @@ async function runNearAuthorizationRequiredTransactionSigning(payload) {
 	}
 }
 async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubject, nearAccount, transaction, rpcCall, onEvent, confirmationConfigOverride, title, body, signerSlot, signingOperationState, signingSessionCoordinator: sessionCoordinator, transactionOperation, ed25519SigningBoundary, passkeyEd25519OperationStepUp, emailOtpEd25519StepUp, yaoSigningPreparation, yaoMaterialExecutor }) {
+	const preConfirmationStartedAt = performance.now();
 	const signingOperationId = signingOperationState.operationId;
 	const nearAccountId = toAccountId(nearAccount.accountId);
 	const relayerUrl = ctx.relayerUrl;
 	const warnings = [];
+	const durableLeaseRecovery = ctx.nonceCoordinator.recoverDurableLeases({ walletId: String(commandSubject.walletSession.walletId) });
+	durableLeaseRecovery.catch(() => {});
 	emitNearSigningEvent(onEvent, nearAccountId, {
 		phase: SigningEventPhase.STEP_02_REQUEST_PREPARED,
 		status: "running",
@@ -484,6 +501,11 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 		...passkeyEd25519OperationStepUp ? { passkeyEd25519OperationStepUp } : {},
 		...emailOtpEd25519StepUp ? { emailOtpEd25519StepUp } : {}
 	});
+	const warmSigningMaterialTask = preparedStepUp.kind === "warm_session" ? resolveWarmNearSigningMaterial({
+		preparation: yaoSigningPreparation,
+		executor: yaoMaterialExecutor
+	}) : null;
+	warmSigningMaterialTask?.catch(() => {});
 	const confirmationAuthPayload = preparedStepUp.confirmationAuthPayload;
 	if (isWarmSessionSigningAuthPlan(confirmationAuthPayload.signingAuthPlan)) emitNearSigningEvent(onEvent, nearAccountId, {
 		phase: SigningEventPhase.STEP_06_AUTH_WARM_SESSION_CLAIMED,
@@ -530,6 +552,8 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 			signatureUses: requiredSignatureUses
 		}
 	});
+	emitEd25519SigningTiming(String(signingOperationId), "pre_confirmation", preConfirmationStartedAt);
+	const confirmationStartedAt = performance.now();
 	let confirmation;
 	try {
 		confirmation = await runTransactionSigningConfirmationCommand({
@@ -565,10 +589,7 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 				}),
 				title,
 				body,
-				...operationStepUpReadiness ? { confirmationReadiness: {
-					promise: operationStepUpReadiness,
-					body: "Preparing secure signing session…"
-				} } : {},
+				...operationStepUpReadiness ? { confirmationReadiness: { promise: operationStepUpReadiness } } : {},
 				onProgress: emitUiConfirmProgress
 			}
 		});
@@ -578,6 +599,8 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 			readiness: operationStepUpReadiness
 		});
 	}
+	const confirmationCompletedAt = performance.now();
+	emitEd25519SigningTiming(String(signingOperationId), "confirmation", confirmationStartedAt);
 	const operationStepUpMaterial = operationStepUpReadiness ? await operationStepUpReadiness : null;
 	if (transactionReviewRequired) emitNearSigningEvent(onEvent, nearAccountId, {
 		phase: SigningEventPhase.STEP_05_CONFIRMATION_APPROVED,
@@ -609,9 +632,12 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 		proof: requireNearEd25519OperationStepUpProof(operationStepUpProof)
 	});
 	const ownsResolvedOperationStepUpMaterial = operationStepUpMaterial?.kind === "passkey_sealed" || operationStepUpMaterial?.kind === "email_otp_sealed";
+	const durableLeaseRecoveryWaitStartedAt = performance.now();
 	try {
-		await ctx.nonceCoordinator.recoverDurableLeases({ walletId: String(signingLane.identity.signer.account.wallet.walletId) });
+		await durableLeaseRecovery;
+		emitEd25519SigningTiming(String(signingOperation.operationId), "durable_lease_recovery_wait", durableLeaseRecoveryWaitStartedAt);
 	} catch (error) {
+		emitEd25519SigningTiming(String(signingOperation.operationId), "durable_lease_recovery_wait", durableLeaseRecoveryWaitStartedAt, "failed");
 		disposeOwnedNearOperationStepUpMaterial({
 			resolved: resolvedOperationStepUpMaterial,
 			owned: ownsResolvedOperationStepUpMaterial
@@ -631,16 +657,19 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 					overlay: "none"
 				}
 			});
+			const materialResolutionStartedAt = performance.now();
 			const resolvedMaterial = stepUpAuthorization.kind === "warm_session" ? {
 				kind: "warm_session",
-				material: await resolvePreparedNearEd25519YaoMaterial(yaoSigningPreparation, yaoMaterialExecutor)
+				resolved: await requireWarmNearSigningMaterialTask(warmSigningMaterialTask)
 			} : {
 				kind: "operation_step_up",
 				resolved: resolvedOperationStepUpMaterial
 			};
-			const canonicalThresholdSessionId = resolvedMaterial.kind === "warm_session" ? resolvedMaterial.material.facts.thresholdSessionId : resolvedMaterial.resolved.material.facts.thresholdSessionId;
-			const activeYaoClient = resolvedMaterial.kind === "warm_session" ? resolvedMaterial.material.activeClient : resolvedMaterial.resolved.material.activeClient;
-			const activeWalletSessionState = resolvedMaterial.kind === "warm_session" ? await yaoMaterialExecutor.resolveWalletSessionState() : null;
+			emitEd25519SigningTiming(String(signingOperation.operationId), "material_resolution_wait", materialResolutionStartedAt);
+			const canonicalThresholdSessionId = resolvedMaterial.kind === "warm_session" ? resolvedMaterial.resolved.material.facts.thresholdSessionId : resolvedMaterial.resolved.material.facts.thresholdSessionId;
+			const activeYaoClient = resolvedMaterial.kind === "warm_session" ? resolvedMaterial.resolved.material.activeClient : resolvedMaterial.resolved.material.activeClient;
+			const activeWalletSessionState = resolvedMaterial.kind === "warm_session" ? resolvedMaterial.resolved.walletSessionState : null;
+			const transactionContextStartedAt = performance.now();
 			const confirmedNearContext = resolvedMaterial.kind === "warm_session" ? await resolveConfirmedNearTransactionContext({
 				confirmation,
 				ctx,
@@ -652,6 +681,7 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 			}) : confirmation.readiness.kind === "context_ready" ? confirmation.readiness : (() => {
 				throw new Error("[SigningEngine][near] operation step-up confirmation did not resolve a transaction context");
 			})();
+			emitEd25519SigningTiming(String(signingOperation.operationId), "transaction_context", transactionContextStartedAt);
 			emitNearSigningEvent(onEvent, nearAccountId, {
 				phase: SigningEventPhase.STEP_07_AUTHENTICATION_COMPLETE,
 				status: "succeeded",
@@ -743,7 +773,8 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 			activeClient: yaoClient,
 			walletSessionState: await requireActiveAuthorizedWalletSessionState({
 				state: walletSessionState,
-				coordinator: sessionCoordinator
+				coordinator: sessionCoordinator,
+				operationId: String(signingOperation.operationId)
 			}),
 			thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
 			walletId: commandSubject.walletSession.walletId,
@@ -764,13 +795,18 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 			try {
 				const okResponse = await executeSignRequest(preparedActiveClient);
 				thresholdSignatureCreated = true;
+				const nonceLeaseCommitStartedAt = performance.now();
 				await markNearNonceLeasesSigned(ctx, nonceLeaseRefs);
+				emitEd25519SigningTiming(String(signingOperation.operationId), "nonce_lease_commit", nonceLeaseCommitStartedAt);
+				const transactionAssemblyStartedAt = performance.now();
 				const signedResult = toSignedTransactionResult({
 					okResponse,
 					nearAccountId,
 					warnings,
 					nonceLeases: nonceLeaseRefs
 				});
+				emitEd25519SigningTiming(String(signingOperation.operationId), "transaction_assembly", transactionAssemblyStartedAt);
+				emitEd25519SigningTiming(String(signingOperation.operationId), "confirmed_to_signed", confirmationCompletedAt);
 				emitNearSigningEvent(onEvent, nearAccountId, {
 					phase: SigningEventPhase.STEP_11_TRANSACTION_SIGNED,
 					status: "succeeded",

package/dist/esm/core/signingEngine/interfaces/accountAuthMetadata.js

@@ -1,4 +1,3 @@
-import "../../../shared-ts/src/utils/signerDomain.js";
 //#region src/core/signingEngine/interfaces/accountAuthMetadata.ts
 function resolveAccountAuthMetadataForSignerAuthMethod(args) {
 	const primaryAuthMethod = args.authMethod;

package/dist/esm/core/signingEngine/nonce/nearNonceLane.js

@@ -393,22 +393,6 @@ var NearImplicitAccountFundingRequiredError = class extends Error {
 		});
 	}
 };
-async function readImplicitNearAccountFundingState(input) {
-	try {
-		await input.nearClient.viewAccount(input.subject.nearAccountId);
-		return { kind: "funded" };
-	} catch (error) {
-		if (!isMissingNearAccessKeyError(errorMessage(error))) throw error;
-	}
-	return {
-		kind: "needs_funding",
-		error: new NearImplicitAccountFundingRequiredError({
-			walletId: input.subject.walletId,
-			nearAccountId: input.subject.nearAccountId,
-			nearPublicKeyStr: input.subject.publicKey
-		})
-	};
-}
 var NearAccountLookupFailedError = class extends Error {
 	constructor(args) {
 		super(args.message || `NEAR account ${args.nearAccountId} access key lookup failed.`);
@@ -442,16 +426,11 @@ async function fetchNearFreshDataForState(input) {
 			let txBlockHash = previousTransactionContext?.txBlockHash;
 			const fetchAccessKey = isNonceStale || !accessKeyInfo;
 			const fetchBlock = isBlockStale || !txBlockHeight || !txBlockHash;
-			const fetchImplicitAccountFunding = isImplicitNearAccountId(capturedSubject.nearAccountId) && (input.force || fetchAccessKey || !readyContext);
 			let maybeAccessKey = accessKeyInfo ?? null;
 			let maybeBlock = null;
 			let accessKeyError = null;
 			let blockError = null;
 			const tasks = [];
-			const implicitFundingPromise = fetchImplicitAccountFunding ? readImplicitNearAccountFundingState({
-				nearClient: input.nearClient,
-				subject: capturedSubject
-			}) : null;
 			if (fetchAccessKey) tasks.push((async () => {
 				try {
 					maybeAccessKey = await input.nearClient.viewAccessKey(capturedSubject.nearAccountId, capturedSubject.publicKey);
@@ -485,14 +464,6 @@ async function fetchNearFreshDataForState(input) {
 				}
 			})());
 			if (tasks.length > 0) await Promise.all(tasks);
-			const implicitFunding = implicitFundingPromise ? await implicitFundingPromise : null;
-			if (implicitFunding?.kind === "needs_funding") {
-				setNearImplicitUnfunded({
-					state,
-					subject: capturedSubject
-				});
-				throw implicitFunding.error;
-			}
 			if (accessKeyError) {
 				if (accessKeyError instanceof NearImplicitAccountFundingRequiredError) setNearImplicitUnfunded({
 					state,