@seams/wallet 0.6.2 → 0.7.3

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

@@ -3,28 +3,18 @@ import { toAccountId } from "../../../types/accountIds.js";
 import { SigningEventPhase, createSigningFlowEvent } from "../../../types/sdkSentEvents.js";
 import { resolveNearNetwork, resolvePrimaryNearRpcUrl } 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 { isWarmSessionSigningAuthPlan } from "../../stepUpConfirmation/types.js";
 import { PASSKEY_MANAGER_DEFAULT_CONFIGS } from "../../../config/defaultConfigs.js";
 import { resolveNearSigningMaterials } from "./shared/signingMaterials.js";
 import { buildNearDelegateSigningPayloads } from "../../chains/near/payloads.js";
 import { parseThresholdEd25519NearAction, thresholdEd25519DelegateActionOperationFingerprint } 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 { computeThresholdEd25519DelegateSigningDigestWasm } from "../../chains/near/nearSignerWasm.js";
-import { parseSigningOperationFingerprintDigest } from "../../../../shared-ts/src/authorization/operationFingerprint.js";
-import { clearNearOperationStepUpBuilder, consumePreparedNearOperationStepUp, registerNearOperationStepUpBuilder } from "./shared/operationStepUpPreparation.js";
-import { buildNearEd25519OperationStepUpProof, finalizeThresholdEd25519DelegateSignatureResult, prepareRouterAbEd25519SignatureOnlyOperationStepUp, requireIssuedNearEd25519OperationStepUpAuthorization, requireNearEd25519OperationStepUpProof, tryFinalizeRouterAbEd25519SignatureOnlyNormalSigning } from "./shared/ed25519YaoNormalSigning.js";
-import { nearOperationStepUpMaterialFacts, prepareNearOperationStepUpMaterial, resolveConfirmedNearEd25519YaoCapability, resolveNearOperationStepUpMaterial } from "./shared/ed25519YaoCapabilityResolution.js";
+import { finalizeThresholdEd25519DelegateSignatureResult } from "./shared/ed25519YaoNormalSigning.js";
 import { toPublicKeyString } from "../../workerManager/validation.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/signDelegate.ts
 function emitNearSigningEvent(onEvent, accountId, event) {
 	try {
@@ -46,52 +36,6 @@ function nearPreparedStepUpEventAuthMethod(preparedStepUp) {
 function assertNeverNearPreparedStepUp(value) {
 	throw new Error(`[SigningEngine][near] unsupported prepared step-up: ${String(value)}`);
 }
-function requireNearDelegateOperationStepUpPreparation(value) {
-	if (!value) throw new Error("[SigningEngine][near] delegate operation step-up preparation is missing");
-	return value;
-}
-function requirePreparedNearDelegateOperationStepUp(value) {
-	if (!value || value.kind !== "near_signature_only") throw new Error("[SigningEngine][near] delegate operation step-up preparation kind changed");
-	return value;
-}
-function requireNearDelegateOperationStepUpMaterial(value) {
-	if (!value) throw new Error("[SigningEngine][near] delegate operation step-up material is missing");
-	return value;
-}
-function requireNearDelegateSigningDigest(value) {
-	if (!value) throw new Error("[SigningEngine][near] delegate operation signing digest is missing");
-	return value;
-}
-function requireAuthorizedNearDelegateWalletSessionState(value) {
-	if (!value) throw new Error("[SigningEngine][near] reusable Wallet Session authorization is unavailable");
-	return value;
-}
-async function resolveNearDelegateOperationStepUpCapability(args) {
-	if (args.authorization.kind === "passkey") {
-		if (args.material.kind !== "passkey_live" && args.material.kind !== "passkey_sealed") throw new Error("[SigningEngine][near] passkey delegate 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 delegate material changed factor");
-	if (!args.emailOtpProof) throw new Error("[SigningEngine][near] Email OTP delegate 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 runNearDelegateActionSigning({ ctx, commandSubject, nearAccount, delegate, rpcCall, onEvent, confirmationConfigOverride, title, body, operationId, signerSlot, signingSessionCoordinator, forceFreshAuth, passkeyEd25519OperationStepUp, emailOtpEd25519StepUp, yaoSigningPreparation, yaoMaterialExecutor, selection }) {
 	const selectionAuth = selection.kind === "authorized" ? selection.selectedLane.auth : selection.candidate.auth;
 	const selectedSignerSlot = selection.kind === "authorized" ? selection.selectedLane.identity.signer.signerSlot : selection.candidate.signerSlot;
@@ -104,63 +48,12 @@ async function runNearDelegateActionSigning({ ctx, commandSubject, nearAccount,
 	const warnings = [];
 	const touchConfirm = ctx.touchConfirm;
 	if (!touchConfirm) throw new Error("UiConfirm bridge not available for delegate signing");
-	const requiredSignatureUses = 1;
-	let signingAuthPlan;
-	let signingSessionPlan;
-	if (selection.kind === "authorized") {
-		const selectedLane = selection.selectedLane;
-		const signingSessionAuthContext = resolveNearSigningSessionAuthContext({
-			requiredSignatureUses,
-			commandSubject,
-			forceFreshAuth,
-			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
-		};
-		signingSessionPlan = resolvedSigningSession.signingSessionPlan;
-		signingAuthPlan = buildNearSigningSessionAuthPlan({
-			context: signingSessionAuthContext,
-			resolvedSigningSession
-		}).signingAuthPlan;
-	} else {
-		signingAuthPlan = signingAuthPlanForNearMaterialRequirement(selectionAuth);
-		const candidate = selection.candidate;
-		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
+	});
 	emitNearSigningEvent(onEvent, nearAccountId, {
 		phase: SigningEventPhase.STEP_02_REQUEST_PREPARED,
 		status: "running",
@@ -205,61 +98,32 @@ async function runNearDelegateActionSigning({ ctx, commandSubject, nearAccount,
 		})),
 		intent: SigningOperationIntent.TransactionSign
 	};
-	const runSharedNearDelegateCommand = async (args) => await runSigningOperationCommand({
+	const operation = {
+		label: "delegate",
+		ctx,
+		walletId: commandSubject.walletSession.walletId,
+		nearAccountId,
+		auth: selectionAuth,
 		signingSessionPlan,
 		signingOperation,
-		commandKind: args.commandKind,
-		execute: args.execute
-	});
-	const preparedStepUp = await requireNearStepUpAuth({
+		thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
+		preparation: yaoSigningPreparation,
+		executor: yaoMaterialExecutor,
+		intent: {
+			kind: "near_delegate_action_v1",
+			delegate: delegateIntent
+		},
+		computeSigningDigestB64u: async () => (await computeThresholdEd25519DelegateSigningDigestWasm({
+			delegate: delegateSigningPayloads.workerDelegate,
+			workerCtx: ctx
+		})).signingDigestB64u
+	};
+	const stepUp = await prepareNearSignatureOnlyStepUp(operation, {
 		signingAuthPlan,
-		signingLaneAuth: selectionAuth,
-		requiredSignatureUses,
-		operationFingerprintDigest: parseSigningOperationFingerprintDigest(signingOperation.operationFingerprint),
 		passkeyEd25519OperationStepUp,
 		emailOtpEd25519StepUp
 	});
-	const signatureOnlyIntent = {
-		kind: "near_delegate_action_v1",
-		delegate: delegateIntent
-	};
-	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 computeThresholdEd25519DelegateSigningDigestWasm({
-			delegate: delegateSigningPayloads.workerDelegate,
-			workerCtx: ctx
-		});
-		operationStepUpSigningDigestB64u = signingDigest.signingDigestB64u;
-		registerNearOperationStepUpBuilder({
-			requestId: String(operationId),
-			build: async (preparation) => {
-				if (preparation.kind !== "near_signature_only") throw new Error("[SigningEngine][near] delegate 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
-				});
-			}
-		});
-	}
-	const confirmationAuthPayload = preparedStepUp.confirmationAuthPayload;
+	const confirmationAuthPayload = stepUp.preparedStepUp.confirmationAuthPayload;
 	if (isWarmSessionSigningAuthPlan(confirmationAuthPayload.signingAuthPlan)) emitNearSigningEvent(onEvent, nearAccountId, {
 		phase: SigningEventPhase.STEP_06_AUTH_WARM_SESSION_CLAIMED,
 		status: "succeeded",
@@ -282,39 +146,20 @@ async function runNearDelegateActionSigning({ ctx, commandSubject, nearAccount,
 			overlay: "show"
 		}
 	});
-	let confirmation;
-	try {
-		confirmation = await runSigningConfirmationCommand({
-			signingSessionPlan,
-			signingOperation,
-			runtime: touchConfirm,
-			request: {
-				ctx: { touchConfirm },
-				sessionId: String(operationId),
-				chain: "near",
-				kind: "delegate",
-				...buildSigningConfirmationAuthParams({ signingAuthPlan: confirmationAuthPayload.signingAuthPlan }),
-				walletId: String(commandSubject.walletSession.walletId),
-				nearAccountId,
-				delegate: delegateSigningPayloads.confirmationDelegate,
-				rpcCall: resolvedRpcCall,
-				nearPublicKeyStr: signingContext.signingNearPublicKeyStr,
-				confirmationConfigOverride: confirmationConfigForSigningAuthPlan({
-					signingAuthPlan: confirmationAuthPayload.signingAuthPlan,
-					override: confirmationConfigOverride
-				}),
-				onProgress: emitNearSigningConfirmationProgress.bind(void 0, {
-					onEvent,
-					nearAccountId,
-					signingAuthPlan: confirmationAuthPayload.signingAuthPlan
-				}),
-				title,
-				body
-			}
-		});
-	} finally {
-		clearNearOperationStepUpBuilder(String(operationId));
-	}
+	const confirmation = await confirmNearSignatureOnlyOperation(operation, {
+		touchConfirm,
+		signingAuthPlan: confirmationAuthPayload.signingAuthPlan,
+		nearPublicKeyStr: signingContext.signingNearPublicKeyStr,
+		onEvent,
+		title,
+		body,
+		confirmationConfigOverride,
+		request: {
+			kind: "delegate",
+			delegate: delegateSigningPayloads.confirmationDelegate,
+			rpcCall: resolvedRpcCall
+		}
+	});
 	emitNearSigningEvent(onEvent, nearAccountId, {
 		phase: SigningEventPhase.STEP_05_CONFIRMATION_APPROVED,
 		status: "succeeded",
@@ -323,21 +168,10 @@ async function runNearDelegateActionSigning({ ctx, commandSubject, nearAccount,
 			overlay: "hide"
 		}
 	});
-	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 : requirePreparedNearDelegateOperationStepUp(consumePreparedNearOperationStepUp({
-		requestId: String(operationId),
-		ref: requireNearDelegateOperationStepUpPreparation(confirmation.operationStepUpPreparation)
-	}));
-	const { canonicalThresholdSessionId, delegatePayload, resolvedMaterial } = await runSharedNearDelegateCommand({
+	const authorization = authorizeNearSignatureOnlyOperation(operation, stepUp, confirmation);
+	const signingMaterial = await runSigningOperationCommand({
+		signingSessionPlan,
+		signingOperation,
 		commandKind: SigningOperationCommandKind.PreparePayload,
 		execute: async () => {
 			emitNearSigningEvent(onEvent, nearAccountId, {
@@ -349,24 +183,7 @@ async function runNearDelegateActionSigning({ ctx, commandSubject, nearAccount,
 					overlay: "none"
 				}
 			});
-			const resolvedMaterial = stepUpAuthorization.kind === "warm_session" ? {
-				kind: "warm_session",
-				resolved: await resolveConfirmedNearEd25519YaoCapability({
-					authorization: stepUpAuthorization,
-					preparation: yaoSigningPreparation,
-					executor: yaoMaterialExecutor
-				})
-			} : {
-				kind: "operation_step_up",
-				thresholdSessionId: nearOperationStepUpMaterialFacts(requireNearDelegateOperationStepUpMaterial(operationStepUpMaterial)).thresholdSessionId,
-				resolved: await resolveNearDelegateOperationStepUpCapability({
-					material: requireNearDelegateOperationStepUpMaterial(operationStepUpMaterial),
-					prepared: requirePreparedNearDelegateOperationStepUp(preparedOperationStepUp),
-					displayDigest: confirmation.intentDigest,
-					authorization: stepUpAuthorization,
-					emailOtpProof: operationStepUpProof?.kind === "email_otp" ? operationStepUpProof : null
-				})
-			};
+			const material = await resolveNearSignatureOnlySigningMaterial(operation, authorization);
 			emitNearSigningEvent(onEvent, nearAccountId, {
 				phase: SigningEventPhase.STEP_07_AUTHENTICATION_COMPLETE,
 				status: "succeeded",
@@ -374,10 +191,8 @@ async function runNearDelegateActionSigning({ ctx, commandSubject, nearAccount,
 					kind: "none",
 					overlay: "none"
 				},
-				authMethod: nearPreparedStepUpEventAuthMethod(preparedStepUp)
+				authMethod: nearPreparedStepUpEventAuthMethod(stepUp.preparedStepUp)
 			});
-			const delegatePayload = delegateSigningPayloads.workerDelegate;
-			const canonicalThresholdSessionId = resolvedMaterial.kind === "warm_session" ? resolvedMaterial.resolved.thresholdSessionId : resolvedMaterial.thresholdSessionId;
 			emitNearSigningEvent(onEvent, nearAccountId, {
 				phase: SigningEventPhase.STEP_08_SIGNER_PREPARE_SUCCEEDED,
 				status: "succeeded",
@@ -388,18 +203,14 @@ async function runNearDelegateActionSigning({ ctx, commandSubject, nearAccount,
 				},
 				data: {
 					signer: "threshold-ed25519",
-					thresholdSessionId: canonicalThresholdSessionId,
+					thresholdSessionId: material.thresholdSessionId,
 					clientBaseSource: "yao_active_client"
 				}
 			});
-			return {
-				canonicalThresholdSessionId,
-				delegatePayload,
-				resolvedMaterial
-			};
+			return material;
 		}
 	});
-	const executeDelegateRequest = async () => {
+	const okResponse = await runNearSignatureOnlySignCommand(operation, async () => {
 		emitNearSigningEvent(onEvent, nearAccountId, {
 			phase: SigningEventPhase.STEP_10_COMMIT_STARTED,
 			status: "running",
@@ -408,80 +219,23 @@ async function runNearDelegateActionSigning({ ctx, commandSubject, nearAccount,
 				overlay: "none"
 			}
 		});
-		const signingDigestB64u = stepUpAuthorization.kind === "warm_session" ? (await computeThresholdEd25519DelegateSigningDigestWasm({
-			delegate: delegatePayload,
-			workerCtx: ctx
-		})).signingDigestB64u : requireNearDelegateSigningDigest(operationStepUpSigningDigestB64u);
-		const routerAbNormalSigningResult = resolvedMaterial.kind === "warm_session" ? await tryFinalizeRouterAbEd25519SignatureOnlyNormalSigning({
-			ctx,
-			thresholdSessionId: canonicalThresholdSessionId,
-			activeClient: resolvedMaterial.resolved.material.activeClient,
-			walletSessionState: requireAuthorizedNearDelegateWalletSessionState(await signingSessionCoordinator.resolveActiveAuthorizedRouterAbEd25519WalletSessionState({
-				state: resolvedMaterial.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({
+		const signed = await signNearSignatureOnlyOperation(operation, signingMaterial, signingSessionCoordinator);
+		const delegateResult = await finalizeThresholdEd25519DelegateSignatureResult({
 			ctx,
-			thresholdSessionId: canonicalThresholdSessionId,
-			activeClient: resolvedMaterial.resolved.material.activeClient,
-			materialFacts: resolvedMaterial.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: requirePreparedNearDelegateOperationStepUp(preparedOperationStepUp),
-				proof: requireNearEd25519OperationStepUpProof(operationStepUpProof),
-				issuedAuthorization: resolvedMaterial.resolved.issuedAuthorization
-			}
+			delegate: delegateSigningPayloads.workerDelegate,
+			signingDigestB64u: signed.signingDigestB64u,
+			signatureB64u: signed.signatureB64u
 		});
-		if (routerAbNormalSigningResult) {
-			if (resolvedMaterial.kind === "operation_step_up" && routerAbNormalSigningResult.authorization === "operation_step_up") requireIssuedNearEd25519OperationStepUpAuthorization({
-				prepared: requirePreparedNearDelegateOperationStepUp(preparedOperationStepUp),
-				issuedAuthorization: routerAbNormalSigningResult.issuedAuthorization
-			});
-			const delegateResult = await finalizeThresholdEd25519DelegateSignatureResult({
-				ctx,
-				delegate: delegatePayload,
-				signingDigestB64u,
-				signatureB64u: routerAbNormalSigningResult.signatureB64u
-			});
-			return {
-				type: WorkerResponseType.SignDelegateActionSuccess,
-				payload: {
-					success: true,
-					hash: delegateResult.hash,
-					signedDelegate: delegateResult.signedDelegate,
-					logs: ["Delegate action signed through Router A/B normal signing"],
-					error: void 0
-				}
-			};
-		}
-		throw new Error("[SigningEngine][near] Router A/B Ed25519 delegate signing is unavailable");
-	};
-	const okResponse = await runSharedNearDelegateCommand({
-		commandKind: SigningOperationCommandKind.Sign,
-		execute: async () => {
-			try {
-				return await executeDelegateRequest();
-			} catch (e) {
-				throw e instanceof Error ? e : new Error(String(e));
+		return {
+			type: WorkerResponseType.SignDelegateActionSuccess,
+			payload: {
+				success: true,
+				hash: delegateResult.hash,
+				signedDelegate: delegateResult.signedDelegate,
+				logs: ["Delegate action signed through Router A/B normal signing"],
+				error: void 0
 			}
-		}
+		};
 	});
 	emitNearSigningEvent(onEvent, nearAccountId, {
 		phase: SigningEventPhase.STEP_11_TRANSACTION_SIGNED,

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

@@ -1,4 +1,3 @@
-import { parsePasskeyWalletAuthAuthority, walletAuthAuthorityRef } from "../../../../shared-ts/src/utils/walletAuthAuthority.js";
 import { toAccountId } from "../../../types/accountIds.js";
 import { SENSITIVE_OPERATION_POLICIES, SIGNER_AUTH_METHODS } from "../../../../shared-ts/src/utils/signerDomain.js";
 import { SIGNING_SESSION_EXPIRY_DETECTION_SOURCES, SigningEventPhase, createSigningFlowEvent } from "../../../types/sdkSentEvents.js";
@@ -8,10 +7,11 @@ import { SigningOperationIntent, SigningSessionIds, SigningSessionPlanKind } fro
 import { exactEd25519SigningLaneIdentityFromSelectedLane, exactSigningLaneIdentityKey, nearEd25519SignerBindingFromBoundaryFields } from "../../session/identity/exactSigningLaneIdentity.js";
 import { secureRandomBase64Url } from "../../../../shared-ts/src/utils/secureRandomId.js";
 import { parseSignerSlot } from "../../../../shared-ts/src/utils/signerSlot.js";
+import { parsePasskeyWalletAuthAuthority, walletAuthAuthorityRef } from "../../../../shared-ts/src/utils/walletAuthAuthority.js";
 import { reviewAdmissionForBinding } from "../../uiConfirm/transactionReviewAdmission.js";
 import { SigningAuthPlanKind } from "../../stepUpConfirmation/types.js";
-import { buildNearDisplayModel } from "../../chains/near/display.js";
-import { createSigningBoundaryTraceEvent, emitSigningBoundaryTrace, emitSigningLaneResolutionTrace, emitSigningPlannerDecisionTrace } from "../../session/operationState/trace.js";
+import { buildNearPreparationDisplayModel } from "../../chains/near/display.js";
+import { createSigningBoundaryTraceEvent, emitEd25519SigningTiming, emitSigningBoundaryTrace, emitSigningLaneResolutionTrace, emitSigningPlannerDecisionTrace } from "../../session/operationState/trace.js";
 import { createSigningOperationStateRef } from "../shared/signingStateMachine.js";
 import { signingAuthPlanFromSigningSessionPlan } from "../shared/signingConfirmation.js";
 import { requiredNearTransactionSignatureUses } from "./signatureUses.js";
@@ -19,7 +19,7 @@ import { WalletSessionQuotaAdmissionError, buildWalletSessionQuotaAdmissionQueue
 import { walletSessionFailureFromError } from "../../session/lifecycle/walletSessionFailure.js";
 import { resolveNearSigningSessionAuthContext } from "./shared/signingSessionAuthMode.js";
 import { signNearWithUiConfirm } from "./nearSigningFlow.js";
-import { resolveThresholdEd25519CommitQueueKey } from "../../threshold/ed25519/commitQueue.js";
+import { resolveThresholdCommitQueueKey } from "../../threshold/commitQueueShared.js";
 import { demoEmailOtpCodeFromDelivery } from "../../session/emailOtp/challengeDelivery.js";
 import { requireAuthoritativeExpiredWalletSessionAuthorizationBoundary } from "../../session/identity/clientSessionPersistenceState.js";
 import { receiveTransactionIntent, recordAvailableSigningLanesRead, selectNearEd25519MaterialCandidate, selectTransactionLaneFromAvailableLanes } from "../../session/identity/selectLane.js";
@@ -446,7 +446,7 @@ async function prepareNearAdHocSigningSession(args) {
 	};
 }
 async function withThresholdEd25519CommitQueue(args) {
-	const queueKey = resolveThresholdEd25519CommitQueueKey({ materialActivation: args.materialActivation });
+	const queueKey = resolveThresholdCommitQueueKey({ materialActivation: args.materialActivation });
 	return await args.deps.withThresholdEd25519CommitQueue({
 		queueKey,
 		nearAccountId: args.nearAccountId,
@@ -759,35 +759,24 @@ async function prepareNearEd25519TransactionSigningSession(args) {
 		transactionOperation
 	};
 }
-function buildNearTransactionPreparationDisplayModel(args) {
-	const signerAccount = String(args.commandSubject.nearAccount.accountId);
-	try {
-		return buildNearDisplayModel({
-			txSigningRequests: [args.transaction],
-			signerAccount,
-			title: args.title,
-			subtitle: args.body
-		});
-	} catch {
-		return {
-			chain: "near",
-			signerAccount,
-			...args.title ? { title: args.title } : {},
-			...args.body ? { subtitle: args.body } : {},
-			operations: []
-		};
-	}
-}
 async function signTransactionWithActions(deps, args) {
+	const modalStartedAt = performance.now();
 	await deps.touchConfirm.openTransactionPreparationModal({
 		chain: "near",
 		walletLabel: String(args.commandSubject.nearAccount.accountId),
 		txSigningRequests: [args.transaction],
-		model: buildNearTransactionPreparationDisplayModel(args),
+		model: buildNearPreparationDisplayModel({
+			txSigningRequests: [args.transaction],
+			signerAccount: String(args.commandSubject.nearAccount.accountId),
+			title: args.title,
+			subtitle: args.body
+		}),
 		confirmationConfigOverride: args.confirmationConfigOverride
 	});
 	try {
-		return await signTransactionWithActionsAttempt(deps, args, { signingOperationState: createSigningOperationStateRef({ operationId: createNearTransactionSigningOperationId() }) });
+		const operationId = createNearTransactionSigningOperationId();
+		emitEd25519SigningTiming(String(operationId), "preparation_modal", modalStartedAt);
+		return await signTransactionWithActionsAttempt(deps, args, { signingOperationState: createSigningOperationStateRef({ operationId }) });
 	} finally {
 		deps.touchConfirm.closeTransactionPreparationModal();
 	}
@@ -804,12 +793,14 @@ async function signTransactionWithActionsAttempt(deps, args, attempt) {
 	};
 	const confirmationOperationId = attempt.signingOperationState.operationId;
 	const signingSessionCoordinator = attempt.signingSessionCoordinator || deps.signingSessionCoordinator;
+	const authorizationProbeStartedAt = performance.now();
 	const authorizationRequired = await prepareNearAuthorizationRequiredTransaction({
 		deps,
 		input: args,
 		commandSubject: args.commandSubject,
 		operationId: confirmationOperationId
 	});
+	emitEd25519SigningTiming(String(confirmationOperationId), "authorization_probe", authorizationProbeStartedAt);
 	if (authorizationRequired) {
 		const ctx = deps.getSignerWorkerContext();
 		return await withThresholdEd25519CommitQueue({
@@ -845,6 +836,7 @@ async function signTransactionWithActionsAttempt(deps, args, attempt) {
 			})
 		});
 	}
+	const lanePreparationStartedAt = performance.now();
 	const preparedSigningSession = await prepareNearEd25519TransactionSigningSession({
 		deps,
 		input: args,
@@ -853,6 +845,8 @@ async function signTransactionWithActionsAttempt(deps, args, attempt) {
 		operationId: confirmationOperationId,
 		forceFreshAuth: attempt.forceFreshAuth === true
 	});
+	emitEd25519SigningTiming(String(confirmationOperationId), "lane_preparation", lanePreparationStartedAt);
+	const executionSetupStartedAt = performance.now();
 	const preparationAuthorization = preparedSigningSession.preparation.authorization;
 	const signingAuthPlan = preparedSigningSession.signingAuthPlan;
 	const signingLane = preparedSigningSession.signingLane;
@@ -901,33 +895,35 @@ async function signTransactionWithActionsAttempt(deps, args, attempt) {
 					signingAuthPlan: executionState.signingAuthPlan,
 					signingLane: executionState.signingLane
 				};
+				const payload = {
+					ctx,
+					commandSubject: args.commandSubject,
+					nearAccount,
+					transaction: args.transaction,
+					rpcCall: args.rpcCall,
+					signerSlot: publicOptions.signerSlot,
+					confirmationConfigOverride: publicOptions.confirmationConfigOverride,
+					title: publicOptions.title,
+					body: publicOptions.body,
+					onEvent: publicOptions.onEvent,
+					signingOperationState: attempt.signingOperationState,
+					signingSessionCoordinator: executionState.signingSessionCoordinator,
+					selection: {
+						kind: "authorized",
+						selectedLane: transactionLane
+					},
+					transactionOperation: executionState.transactionOperation,
+					ed25519SigningBoundary,
+					yaoSigningPreparation: materialBoundary.preparation,
+					yaoMaterialExecutor: materialBoundary.executor,
+					...executionState.passkeyEd25519OperationStepUp ? { passkeyEd25519OperationStepUp: executionState.passkeyEd25519OperationStepUp } : {},
+					...executionState.emailOtpEd25519StepUp ? { emailOtpEd25519StepUp: executionState.emailOtpEd25519StepUp } : {}
+				};
+				emitEd25519SigningTiming(String(confirmationOperationId), "execution_setup", executionSetupStartedAt);
 				return await signNearWithUiConfirm({
 					chain: "near",
 					kind: "transactionWithActions",
-					payload: {
-						ctx,
-						commandSubject: args.commandSubject,
-						nearAccount,
-						transaction: args.transaction,
-						rpcCall: args.rpcCall,
-						signerSlot: publicOptions.signerSlot,
-						confirmationConfigOverride: publicOptions.confirmationConfigOverride,
-						title: publicOptions.title,
-						body: publicOptions.body,
-						onEvent: publicOptions.onEvent,
-						signingOperationState: attempt.signingOperationState,
-						signingSessionCoordinator: executionState.signingSessionCoordinator,
-						selection: {
-							kind: "authorized",
-							selectedLane: transactionLane
-						},
-						transactionOperation: executionState.transactionOperation,
-						ed25519SigningBoundary,
-						yaoSigningPreparation: materialBoundary.preparation,
-						yaoMaterialExecutor: materialBoundary.executor,
-						...executionState.passkeyEd25519OperationStepUp ? { passkeyEd25519OperationStepUp: executionState.passkeyEd25519OperationStepUp } : {},
-						...executionState.emailOtpEd25519StepUp ? { emailOtpEd25519StepUp: executionState.emailOtpEd25519StepUp } : {}
-					}
+					payload
 				});
 			}
 		});