@seams/wallet 0.7.3 → 0.8.0

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

@@ -1,1238 +0,0 @@
-import { secureRandomBase64Url } from "../../../../shared-ts/src/utils/secureRandomId.js";
-import { parsePasskeyWalletAuthAuthority, walletAuthAuthorityRef } from "../../../../shared-ts/src/utils/walletAuthAuthority.js";
-import { SENSITIVE_OPERATION_POLICIES, SIGNER_AUTH_METHODS } from "../../../../shared-ts/src/utils/signerDomain.js";
-import { signingLaneAuthBindingKey, signingLaneAuthMethod } from "../../session/identity/signingLaneAuthBinding.js";
-import { SigningOperationIntent, SigningSessionIds, SigningSessionPlanKind } from "../../session/operationState/types.js";
-import { toWalletId } from "../../interfaces/ecdsaChainTarget.js";
-import { exactEd25519SigningLaneIdentityFromSelectedLane, exactSigningLaneIdentityKey, nearEd25519SignerBindingFromBoundaryFields } from "../../session/identity/exactSigningLaneIdentity.js";
-import { parseSignerSlot } from "../../../../shared-ts/src/utils/signerSlot.js";
-import { toAccountId } from "../../../types/accountIds.js";
-import { SIGNING_SESSION_EXPIRY_DETECTION_SOURCES, SigningEventPhase, createSigningFlowEvent } from "../../../types/sdkSentEvents.js";
-import { reviewAdmissionForBinding } from "../../uiConfirm/transactionReviewAdmission.js";
-import { SigningAuthPlanKind } from "../../stepUpConfirmation/types.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";
-import { WalletSessionQuotaAdmissionError, buildWalletSessionQuotaAdmissionQueueKey, classifyWalletSessionQuotaAdmissionFailure, decideWalletSessionQuotaAdmissionFailure, waitForWalletSessionQuotaAdmissionRetry } from "../../session/operationState/authorizationAdmission.js";
-import { walletSessionFailureFromError } from "../../session/lifecycle/walletSessionFailure.js";
-import { resolveNearSigningSessionAuthContext } from "./shared/signingSessionAuthMode.js";
-import { signNearWithUiConfirm } from "./nearSigningFlow.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";
-import { classifyTransactionReadiness, prepareTransactionOperationFromReadiness, prepareTransactionSigningOperation } from "../../session/operationState/transactionState.js";
-//#region src/core/signingEngine/flows/signNear/signNear.ts
-function nearOwnerOperationAuthorizationDecisionFromError(error) {
-	if (!(error instanceof WalletSessionQuotaAdmissionError)) return void 0;
-	const decision = error.authorizationDecision;
-	if (!decision || decision.kind !== "step_up_required" || !("request_id" in decision.step_up)) return;
-	return {
-		kind: "step_up_required",
-		reason: decision.reason,
-		step_up: decision.step_up
-	};
-}
-function nearWalletSessionQuotaAdmissionDecisionFromError(error) {
-	const ownerDecision = nearOwnerOperationAuthorizationDecisionFromError(error);
-	const failure = classifyWalletSessionQuotaAdmissionFailure(error);
-	if (ownerDecision) return decideWalletSessionQuotaAdmissionFailure(failure ?? {
-		kind: "exhausted",
-		source: "server_prepare",
-		detail: "Server requires owner operation step-up"
-	});
-	return failure?.kind === "in_flight" ? decideWalletSessionQuotaAdmissionFailure(failure) : null;
-}
-async function invalidateAuthoritativeNearWalletSessionExpiry(args) {
-	if (args.failure?.kind !== "expired") return;
-	const state = requireAuthoritativeExpiredWalletSessionAuthorizationBoundary({
-		source: {
-			kind: "ed25519",
-			laneIdentity: exactEd25519SigningLaneIdentityFromSelectedLane(args.lane)
-		},
-		expiresAtMs: args.expiresAtMs,
-		detectedAtMs: Date.now()
-	});
-	if ((await args.coordinator.invalidateExpiredWalletSession({
-		state,
-		source: SIGNING_SESSION_EXPIRY_DETECTION_SOURCES.serverRejection
-	})).kind === "unavailable") throw new Error("[SigningEngine][near] expired Wallet Session cleanup failed");
-}
-async function signNear(deps, request) {
-	if (request.kind === "transactionWithActions") {
-		const context = deps.getSignerWorkerContext();
-		const admission = reviewAdmissionForBinding(context.touchConfirm?.getContext().surfaceMeasurementBinding);
-		if (admission) {
-			admission.assertPending();
-			deps = {
-				...deps,
-				getSignerWorkerContext: reviewedNearContext.bind(null, context, admission.beforeSigning)
-			};
-		}
-		return await signTransactionWithActions(deps, request.args);
-	}
-	if (request.kind === "delegateAction") return await signDelegateAction(deps, request.args);
-	if (request.kind === "nep413") return await signNEP413Message(deps, request.args);
-	throw new Error(`[SigningEngine] unsupported near signing intent: ${String(request.kind || "")}`);
-}
-function createNearTransactionSigningOperationId() {
-	const randomId = secureRandomBase64Url(32, "NEAR transaction signing operation IDs");
-	return SigningSessionIds.signingOperation(`near-transaction-sign:${randomId}`);
-}
-function summarizeNearEd25519Lane(lane) {
-	if (lane.state === "missing") return {
-		state: lane.state,
-		curve: lane.curve,
-		chain: lane.chain
-	};
-	return {
-		authMethod: signingLaneAuthMethod(lane.auth),
-		walletId: lane.walletId,
-		nearAccountId: lane.nearAccountId,
-		nearEd25519SigningKeyId: lane.nearEd25519SigningKeyId,
-		signerSlot: lane.signerSlot,
-		state: lane.state,
-		source: lane.source || "unknown",
-		...lane.authorizationState === "authorized" ? {
-			walletSessionId: lane.authorization.operationCredential.walletSessionId,
-			quotaId: lane.authorization.session.quotaId
-		} : {},
-		thresholdSessionId: lane.thresholdSessionId,
-		remainingUses: lane.remainingUses,
-		expiresAtMs: lane.expiresAtMs
-	};
-}
-function summarizeNearEd25519AvailableLanes(availableLanes) {
-	const candidates = availableLanes?.candidates.ed25519.near || [];
-	return {
-		generation: availableLanes?.generation || 0,
-		candidateCount: candidates.length,
-		candidates: candidates.map(summarizeNearEd25519Lane)
-	};
-}
-function emitNearSigningEvent(onEvent, accountId, event) {
-	try {
-		onEvent?.(createSigningFlowEvent({
-			...event,
-			flowId: `signing:near:${String(accountId)}:${event.phase}`,
-			accountId: String(accountId)
-		}));
-	} catch {}
-}
-function assertSigningLaneMatchesSelectedTransactionLane(args) {
-	if (exactSigningLaneIdentityKey(args.signingLane.identity) !== exactSigningLaneIdentityKey(args.transactionLane.identity)) throw new Error("[SigningEngine][near] prepared signing lane drifted from selected transaction lane");
-}
-function selectedEd25519LanesHaveSameSignerAndAuth(left, right) {
-	const leftSigner = left.identity.signer;
-	const rightSigner = right.identity.signer;
-	return String(leftSigner.account.wallet.walletId) === String(rightSigner.account.wallet.walletId) && String(leftSigner.account.nearAccountId) === String(rightSigner.account.nearAccountId) && String(leftSigner.nearEd25519SigningKeyId) === String(rightSigner.nearEd25519SigningKeyId) && leftSigner.signerSlot === rightSigner.signerSlot && signingLaneAuthBindingKey(left.auth) === signingLaneAuthBindingKey(right.auth);
-}
-function transactionReadinessFromPlannerInput(readiness) {
-	const status = readiness.readiness.status;
-	if (status === "ready") return {
-		status: "ready",
-		remainingUses: Math.max(0, Math.floor(Number(readiness.readiness.remainingUses) || 0)),
-		expiresAtMs: Math.max(0, Math.floor(Number(readiness.readiness.expiresAtMs) || 0))
-	};
-	if (status === "expired" || status === "exhausted" || status === "status_unknown") return status === "status_unknown" ? {
-		status,
-		reason: "trusted wallet budget status is unavailable"
-	} : { status };
-	if (status === "auth_unavailable" || status === "status_unavailable") return {
-		status,
-		reason: status
-	};
-	return {
-		status: "status_unavailable",
-		reason: status
-	};
-}
-function requireResolvedNearEd25519SigningLane(lane) {
-	if (lane.curve !== "ed25519" || lane.keyKind !== "threshold_ed25519") throw new Error("[SigningEngine][near] prepared signing lane is not Ed25519");
-	if (lane.chainFamily !== "near") throw new Error("[SigningEngine][near] prepared Ed25519 lane must target NEAR");
-	const thresholdSessionId = String(lane.thresholdSessionId || "").trim();
-	const walletSessionId = String(lane.walletSessionId || "").trim();
-	const quotaId = String(lane.quotaId || "").trim();
-	if (!thresholdSessionId || !walletSessionId || !quotaId) throw new Error("[SigningEngine][near] prepared Ed25519 lane is missing session identity");
-	return {
-		...lane,
-		curve: "ed25519",
-		keyKind: "threshold_ed25519",
-		chainFamily: "near",
-		walletSessionId: SigningSessionIds.walletSession(walletSessionId),
-		quotaId: SigningSessionIds.walletSessionQuota(quotaId),
-		thresholdSessionId: SigningSessionIds.thresholdEd25519Session(thresholdSessionId)
-	};
-}
-function walletSessionStatusIdentityFromNearPreparation(preparation) {
-	if (preparation.authorization.kind !== "authorized") return null;
-	const authorization = preparation.authorization.authorization;
-	return {
-		walletSessionId: authorization.operationCredential.walletSessionId,
-		quotaId: authorization.session.quotaId
-	};
-}
-async function resolveNearTransactionWalletAuth(args) {
-	const preparedOperation = args.preparedOperation;
-	const lane = preparedOperation.lane;
-	emitSigningLaneResolutionTrace("near", lane, { reason: "near_transaction_auth_planning" });
-	const nearAccountId = args.commandSubject.nearAccount.accountId;
-	const authInput = {
-		accountId: nearAccountId,
-		intent: SigningOperationIntent.TransactionSign,
-		curve: "ed25519"
-	};
-	const plan = preparedOperation.signingSessionPlan;
-	if (plan.kind === SigningSessionPlanKind.NotReady) {
-		console.warn("[SigningEngine][near][ed25519] transaction auth planning not ready", {
-			nearAccountId,
-			authMethod: signingLaneAuthMethod(lane.auth),
-			reason: plan.reason,
-			readiness: preparedOperation.readiness.status,
-			walletSessionId: lane.walletSessionId,
-			quotaId: lane.quotaId,
-			thresholdSessionId: lane.thresholdSessionId,
-			retention: lane.retention,
-			remainingUses: preparedOperation.remainingUses,
-			expiresAtMs: preparedOperation.expiresAtMs
-		});
-		if (plan.reason === "policy_blocked") throw new Error("[SigningEngine] NEAR operation requires passkey authentication after Email OTP login");
-		throw new Error(`[SigningEngine][near] signing session is not ready: ${plan.reason}`);
-	}
-	return {
-		signingAuthPlan: signingAuthPlanFromSigningSessionPlan({
-			plan,
-			accountId: authInput.accountId,
-			intent: authInput.intent,
-			curve: authInput.curve,
-			expiresAtMs: preparedOperation.expiresAtMs,
-			remainingUses: preparedOperation.remainingUses
-		}),
-		signingLane: lane
-	};
-}
-function resolvePreparedSigningRequestSessionId(args) {
-	const provided = String(args.providedThresholdSessionId || "").trim();
-	const prepared = String(args.identity.thresholdSessionId || "").trim();
-	if (provided && provided !== prepared) throw new Error("[SigningEngine][near] transaction thresholdSessionId must match prepared Ed25519 identity");
-	return prepared;
-}
-function nearEd25519PreparationRequiresAuthorization(preparation) {
-	switch (preparation.authorization.kind) {
-		case "authorized": return false;
-		case "authorization_required": return true;
-		default:
-			preparation.authorization;
-			throw new Error("[SigningEngine][near] unsupported material authorization state");
-	}
-}
-function requireNearReusableAuthorizationExpiry(preparation) {
-	if (preparation.authorization.kind !== "authorized") throw new Error("[SigningEngine][near] reusable Wallet Session authorization is unavailable");
-	return preparation.authorization.authorization.status.expiresAtMs;
-}
-async function prepareNearEd25519YaoMaterialBoundary(args) {
-	const base = {
-		walletId: toWalletId(args.commandSubject.walletSession.walletId),
-		nearAccountId: toAccountId(args.commandSubject.nearAccount.accountId)
-	};
-	if (args.materialIdentity) return await args.deps.prepareNearEd25519YaoMaterialBoundary({
-		...base,
-		materialIdentity: args.materialIdentity
-	});
-	return await args.deps.prepareNearEd25519YaoMaterialBoundary({
-		...base,
-		laneIdentity: args.selectedLane.identity,
-		auth: args.selectedLane.auth
-	});
-}
-function createAdHocNearSigningOperationId(deps, kind) {
-	return SigningSessionIds.signingOperation(deps.createSigningSessionId(`near-${kind}-operation`));
-}
-function buildPreparedNearTransactionExecutionState(args) {
-	return {
-		kind: "prepared_near_transaction_execution",
-		thresholdSessionId: args.thresholdSessionId,
-		signingSessionPlan: args.preparedSigningSession.preparedOperation.signingSessionPlan,
-		signingAuthPlan: args.preparedSigningSession.signingAuthPlan,
-		signingLane: args.preparedSigningSession.signingLane,
-		signingSessionCoordinator: args.signingSessionCoordinator,
-		transactionOperation: args.preparedSigningSession.transactionOperation,
-		passkeyEd25519OperationStepUp: args.passkeyEd25519OperationStepUp,
-		emailOtpEd25519StepUp: args.emailOtpEd25519StepUp
-	};
-}
-function nearEd25519WalletSessionQuotaAdmissionQueueKey(args) {
-	return buildWalletSessionQuotaAdmissionQueueKey({
-		walletId: String(args.walletId),
-		curve: "ed25519",
-		walletSessionId: String(args.prepared.signingLane.walletSessionId),
-		quotaId: String(args.prepared.signingLane.quotaId),
-		projectionVersion: "server-owned",
-		authorityKey: signingLaneAuthBindingKey(args.prepared.signingLane.auth),
-		targetKey: `near:${String(args.nearAccountId)}`
-	});
-}
-function nearAdHocEd25519WalletSessionQuotaAdmissionQueueKey(args) {
-	if (args.prepared.kind !== "authorized") throw new Error("[SigningEngine][near] deferred Ed25519 material has no reusable session");
-	return buildWalletSessionQuotaAdmissionQueueKey({
-		walletId: String(args.walletId),
-		curve: "ed25519",
-		walletSessionId: String(args.prepared.selectedLane.walletSessionId),
-		quotaId: String(args.prepared.selectedLane.quotaId),
-		projectionVersion: "projection-unadmitted",
-		authorityKey: signingLaneAuthBindingKey(args.prepared.selectedLane.auth),
-		targetKey: `near:${String(args.nearAccountId)}`
-	});
-}
-function buildNearPasskeyEd25519OperationStepUp(args) {
-	if (args.auth.kind !== "passkey") return void 0;
-	const auth = args.auth;
-	return { prepare: async () => {
-		const signer = args.signer;
-		const authority = await exactPasskeyStepUpAuthority({
-			authorityRef: nearPasskeyPreparationAuthority(args.preparation),
-			walletId: signer.account.wallet.walletId,
-			rpId: auth.rpId,
-			credentialIdB64u: auth.credentialIdB64u
-		});
-		return {
-			thresholdSessionId: args.thresholdSessionId,
-			authority
-		};
-	} };
-}
-function nearPasskeyPreparationAuthority(preparation) {
-	switch (preparation.hydration.kind) {
-		case "use_live_runtime":
-		case "rehydrate_material_activation":
-		case "reauthorize_public_anchor": return preparation.hydration.authority;
-		case "blocked": throw new Error("[SigningEngine][near] blocked Passkey material has no authority");
-		default:
-			preparation.hydration;
-			throw new Error("[SigningEngine][near] unsupported Passkey material authority");
-	}
-}
-async function exactPasskeyStepUpAuthority(args) {
-	const authority = parsePasskeyWalletAuthAuthority({
-		walletId: args.walletId,
-		factor: {
-			kind: "passkey",
-			credentialIdB64u: args.credentialIdB64u
-		},
-		verifier: {
-			kind: "webauthn",
-			rpId: args.rpId
-		},
-		bindingId: args.authorityRef.walletAuthMethodId
-	});
-	if (!authority) throw new Error("[SigningEngine][near] exact Passkey step-up authority is invalid");
-	const resolvedRef = await walletAuthAuthorityRef({ authority });
-	if (resolvedRef.walletId !== args.authorityRef.walletId || resolvedRef.walletAuthMethodId !== args.authorityRef.walletAuthMethodId || resolvedRef.authorityDigest !== args.authorityRef.authorityDigest) throw new Error("[SigningEngine][near] exact Passkey step-up authority changed");
-	return authority;
-}
-function buildNearEmailOtpEd25519StepUp(args) {
-	if (args.auth.kind !== SIGNER_AUTH_METHODS.emailOtp || typeof args.deps.requestEmailOtpEd25519SigningChallenge !== "function") return;
-	if (!args.preparation.hydration.materialActivation) return;
-	if (String(args.signer.account.wallet.walletId) !== String(args.commandSubject.walletSession.walletId) || String(args.signer.account.nearAccountId) !== String(args.commandSubject.nearAccount.accountId)) throw new Error("[SigningEngine][near] Email OTP step-up lane changed subject");
-	const requestChallenge = async (challengeArgs) => {
-		const challenge = await args.deps.requestEmailOtpEd25519SigningChallenge({
-			walletSession: args.commandSubject.walletSession,
-			operationFingerprintDigest: challengeArgs.operationFingerprintDigest
-		});
-		emitNearSigningEvent(args.onEvent, args.commandSubject.nearAccount.accountId, {
-			phase: SigningEventPhase.STEP_06_AUTH_EMAIL_OTP_INPUT_REQUIRED,
-			status: "waiting_for_user",
-			interaction: {
-				kind: "otp_input",
-				overlay: "show"
-			},
-			data: {
-				emailHint: challenge.emailHint,
-				demoOtpCode: demoEmailOtpCodeFromDelivery(challenge.delivery)
-			}
-		});
-		return challenge;
-	};
-	return {
-		prepare: requestChallenge,
-		resend: requestChallenge
-	};
-}
-async function prepareNearAdHocSigningSession(args) {
-	const materialSelection = selectNearEd25519MaterialCandidate({
-		availableLanes: await readNearEd25519AvailableSigningLanes({
-			deps: args.deps,
-			commandSubject: args.commandSubject,
-			authMethod: null
-		}),
-		intent: nearEd25519TransactionSigningIntent({
-			commandSubject: args.commandSubject,
-			signerSlot: args.signerSlot,
-			authSelectionPolicy: { kind: "any" },
-			operationUsesNeeded: 1
-		})
-	});
-	if (!materialSelection.ok) throw new Error("[SigningEngine][near] signature-only signing requires exact Ed25519 material");
-	if (materialSelection.kind === "authorization_required") {
-		const candidate = materialSelection.candidate;
-		const signer = nearEd25519SignerBindingFromBoundaryFields({
-			walletId: candidate.walletId,
-			nearAccountId: candidate.nearAccountId,
-			nearEd25519SigningKeyId: candidate.nearEd25519SigningKeyId,
-			signerSlot: candidate.signerSlot
-		});
-		const materialIdentity = {
-			kind: "near_ed25519_material_identity",
-			signer,
-			auth: candidate.auth,
-			thresholdSessionId: SigningSessionIds.thresholdEd25519Session(candidate.thresholdSessionId)
-		};
-		const materialBoundary = await prepareNearEd25519YaoMaterialBoundary({
-			deps: args.deps,
-			commandSubject: args.commandSubject,
-			materialIdentity
-		});
-		return {
-			kind: "authorization_required",
-			candidate,
-			materialIdentity,
-			forceFreshAuth: true,
-			passkeyEd25519OperationStepUp: buildNearPasskeyEd25519OperationStepUp({
-				auth: candidate.auth,
-				signer,
-				thresholdSessionId: materialIdentity.thresholdSessionId,
-				preparation: materialBoundary.preparation
-			}) || null,
-			emailOtpEd25519StepUp: buildNearEmailOtpEd25519StepUp({
-				deps: args.deps,
-				commandSubject: args.commandSubject,
-				auth: candidate.auth,
-				signer,
-				preparation: materialBoundary.preparation,
-				onEvent: args.onEvent
-			}) || null,
-			yaoSigningPreparation: materialBoundary.preparation,
-			yaoMaterialExecutor: materialBoundary.executor
-		};
-	}
-	const selectedLane = materialSelection.lane;
-	const materialBoundary = await prepareNearEd25519YaoMaterialBoundary({
-		deps: args.deps,
-		commandSubject: args.commandSubject,
-		selectedLane
-	});
-	return {
-		kind: "authorized",
-		selectedLane,
-		forceFreshAuth: args.attempt.forceFreshAuth || nearEd25519PreparationRequiresAuthorization(materialBoundary.preparation),
-		passkeyEd25519OperationStepUp: buildNearPasskeyEd25519OperationStepUp({
-			auth: selectedLane.auth,
-			signer: selectedLane.identity.signer,
-			thresholdSessionId: selectedLane.identity.thresholdSessionId,
-			preparation: materialBoundary.preparation
-		}) || null,
-		emailOtpEd25519StepUp: buildNearEmailOtpEd25519StepUp({
-			deps: args.deps,
-			commandSubject: args.commandSubject,
-			auth: selectedLane.auth,
-			signer: selectedLane.identity.signer,
-			preparation: materialBoundary.preparation,
-			onEvent: args.onEvent
-		}) || null,
-		yaoSigningPreparation: materialBoundary.preparation,
-		yaoMaterialExecutor: materialBoundary.executor
-	};
-}
-async function withThresholdEd25519CommitQueue(args) {
-	const queueKey = resolveThresholdCommitQueueKey({ materialActivation: args.materialActivation });
-	return await args.deps.withThresholdEd25519CommitQueue({
-		queueKey,
-		nearAccountId: args.nearAccountId,
-		enabled: true,
-		task: args.task
-	});
-}
-async function prepareNearAuthorizationRequiredTransaction(args) {
-	const materialSelection = selectNearEd25519MaterialCandidate({
-		availableLanes: await readNearEd25519AvailableSigningLanes({
-			deps: args.deps,
-			commandSubject: args.commandSubject,
-			authMethod: null
-		}),
-		intent: nearEd25519TransactionSigningIntent({
-			commandSubject: args.commandSubject,
-			signerSlot: args.input.signerSlot,
-			authSelectionPolicy: { kind: "any" },
-			operationUsesNeeded: requiredNearTransactionSignatureUses(args.input.transaction)
-		})
-	});
-	if (!materialSelection.ok || materialSelection.kind !== "authorization_required") return null;
-	const candidate = materialSelection.candidate;
-	const signer = nearEd25519SignerBindingFromBoundaryFields({
-		walletId: candidate.walletId,
-		nearAccountId: candidate.nearAccountId,
-		nearEd25519SigningKeyId: candidate.nearEd25519SigningKeyId,
-		signerSlot: candidate.signerSlot
-	});
-	const materialIdentity = {
-		kind: "near_ed25519_material_identity",
-		signer,
-		auth: candidate.auth,
-		thresholdSessionId: SigningSessionIds.thresholdEd25519Session(candidate.thresholdSessionId)
-	};
-	const materialBoundary = await prepareNearEd25519YaoMaterialBoundary({
-		deps: args.deps,
-		commandSubject: args.commandSubject,
-		materialIdentity
-	});
-	return {
-		candidate,
-		preparation: materialBoundary.preparation,
-		executor: materialBoundary.executor,
-		passkeyEd25519OperationStepUp: buildNearPasskeyEd25519OperationStepUp({
-			auth: candidate.auth,
-			signer,
-			thresholdSessionId: materialIdentity.thresholdSessionId,
-			preparation: materialBoundary.preparation
-		}) || null,
-		emailOtpEd25519StepUp: buildNearEmailOtpEd25519StepUp({
-			deps: args.deps,
-			commandSubject: args.commandSubject,
-			auth: candidate.auth,
-			signer,
-			preparation: materialBoundary.preparation,
-			onEvent: args.input.onEvent
-		}) || null
-	};
-}
-function requireNearEd25519CommitMaterialActivation(preparation) {
-	switch (preparation.hydration.kind) {
-		case "use_live_runtime":
-		case "rehydrate_material_activation": return preparation.hydration.materialActivation;
-		case "reauthorize_public_anchor": throw new Error("[SigningEngine][near] retired public material cannot enter the material commit queue");
-		case "blocked": throw new Error(`[SigningEngine][near] blocked material cannot enter the material commit queue: ${preparation.hydration.reason}`);
-	}
-	preparation.hydration;
-	throw new Error("[SigningEngine][near] unsupported material hydration plan");
-}
-function selectNearEd25519TransactionCandidate(args) {
-	const authSelectionPolicy = args.authSelectionPolicy || null;
-	if (!authSelectionPolicy) return null;
-	const selectionState = selectTransactionLaneFromAvailableLanes(recordAvailableSigningLanesRead(receiveTransactionIntent(nearEd25519TransactionSigningIntent({
-		commandSubject: args.commandSubject,
-		signerSlot: args.signerSlot,
-		authSelectionPolicy,
-		operationUsesNeeded: args.operationUsesNeeded
-	})), { availableLanes: args.availableLanes }));
-	if (selectionState.tag === "LaneSelected") {
-		if (selectionState.lane.curve !== "ed25519" || selectionState.availableLane.curve !== "ed25519") throw new Error("[SigningEngine][near] Ed25519 selector returned a non-Ed25519 lane");
-		return selectionState;
-	}
-	if (selectionState.failure.kind === "no_candidate") return null;
-	throw new Error(`[SigningEngine][near] Ed25519 transaction lane selection failed: ${selectionState.failure.kind}`);
-}
-function nearEd25519TransactionSigningIntent(args) {
-	return {
-		walletId: toWalletId(args.commandSubject.walletSession.walletId),
-		curve: "ed25519",
-		chain: "near",
-		signerSelection: nearEd25519TransactionSignerSelection({
-			nearAccountId: args.commandSubject.nearAccount.accountId,
-			signerSlot: args.signerSlot
-		}),
-		authSelectionPolicy: args.authSelectionPolicy,
-		operationUsesNeeded: args.operationUsesNeeded
-	};
-}
-function nearEd25519TransactionSignerSelection(args) {
-	if (args.signerSlot === void 0) return {
-		kind: "near_account",
-		nearAccountId: args.nearAccountId
-	};
-	const signerSlot = parseSignerSlot(args.signerSlot);
-	if (signerSlot === null) throw new Error("[SigningEngine][near] signerSlot must be a positive safe integer");
-	return {
-		kind: "signer_slot",
-		nearAccountId: args.nearAccountId,
-		signerSlot
-	};
-}
-function selectSelectedEd25519LaneFromAvailableLanes(args) {
-	return selectNearEd25519TransactionCandidate({
-		availableLanes: args.availableLanes,
-		authSelectionPolicy: { kind: "any" },
-		commandSubject: args.commandSubject,
-		signerSlot: args.signerSlot,
-		operationUsesNeeded: args.operationUsesNeeded
-	});
-}
-async function readNearEd25519AvailableSigningLanes(args) {
-	const nearAccountId = args.commandSubject.nearAccount.accountId;
-	const walletId = args.commandSubject.walletSession.walletId;
-	if (typeof args.deps.readAvailableSigningLanesForSigning !== "function") throw new Error("[SigningEngine][near] transaction signing requires available signing lanes reader");
-	const ownerScope = await args.deps.resolveOwnerLaneScope(walletId);
-	return await args.deps.readAvailableSigningLanesForSigning({
-		walletId,
-		curve: "ed25519",
-		ownerScope,
-		...args.authMethod ? { authMethod: args.authMethod } : {}
-	}).catch((error) => {
-		console.warn("[SigningEngine][near] available signing lanes read failed", {
-			nearAccountId,
-			error: error instanceof Error ? error.message : String(error || "unknown error")
-		});
-		return null;
-	});
-}
-async function prepareNearEd25519TransactionOperation(args) {
-	const nearAccountId = args.commandSubject.nearAccount.accountId;
-	const operationUsesNeeded = Math.max(1, Math.floor(Number(args.operationUsesNeeded) || 1));
-	const selectedSessionLane = args.selectedLane.lane;
-	const authContext = resolveNearSigningSessionAuthContext({
-		commandSubject: args.commandSubject,
-		selectedLane: selectedSessionLane,
-		preparation: args.preparation,
-		forceFreshAuth: args.forceFreshAuth,
-		requiredSignatureUses: operationUsesNeeded
-	});
-	const lane = authContext.lane;
-	assertSigningLaneMatchesSelectedTransactionLane({
-		signingLane: lane,
-		transactionLane: args.selectedLane.lane
-	});
-	const readiness = {
-		readiness: authContext.coordinatorInput.readiness,
-		expiresAtMs: authContext.coordinatorInput.expiresAtMs,
-		remainingUses: authContext.coordinatorInput.remainingUses
-	};
-	if (selectedSessionLane.auth.kind === "email_otp" && readiness.readiness.status !== "ready") console.warn("[SigningEngine][near][email-otp] Ed25519 pre-confirm readiness is not ready", {
-		nearAccountId,
-		readiness: readiness.readiness.status,
-		thresholdSessionId: selectedSessionLane.thresholdSessionId,
-		walletSessionId: selectedSessionLane.walletSessionId,
-		quotaId: selectedSessionLane.quotaId,
-		retention: lane.retention,
-		remainingUses: readiness.remainingUses,
-		expiresAtMs: readiness.expiresAtMs,
-		requiredSignatureUses: operationUsesNeeded
-	});
-	emitSigningBoundaryTrace("near", createSigningBoundaryTraceEvent({
-		event: "pre_confirm_readiness_checked",
-		lane,
-		readinessStatus: readiness.readiness.status,
-		phase: "pre_confirm"
-	}));
-	const transactionReadinessState = classifyTransactionReadiness(args.selectedLane, transactionReadinessFromPlannerInput({
-		readiness: readiness.readiness,
-		expiresAtMs: readiness.expiresAtMs,
-		remainingUses: readiness.remainingUses,
-		usesNeeded: operationUsesNeeded
-	}));
-	const transactionOperation = prepareTransactionOperationFromReadiness(transactionReadinessState);
-	const identity = requireResolvedNearEd25519SigningLane(lane);
-	const trustedStatusAuth = walletSessionStatusIdentityFromNearPreparation(args.preparation);
-	const readinessInput = {
-		readiness: readiness.readiness,
-		expiresAtMs: readiness.expiresAtMs,
-		remainingUses: readiness.remainingUses,
-		usesNeeded: operationUsesNeeded,
-		...trustedStatusAuth ? { trustedStatusAuth } : {}
-	};
-	return {
-		lane,
-		transactionLane: args.selectedLane.lane,
-		transactionIntent: args.selectedLane.intent,
-		readiness: readinessInput,
-		availableLanesGeneration: args.availableLanes?.generation || 0,
-		metadata: {
-			transactionLane: args.selectedLane.lane,
-			transactionOperation,
-			transactionReadinessState,
-			identity,
-			availableLanesGeneration: args.availableLanes?.generation || 0,
-			readiness: readinessInput
-		}
-	};
-}
-async function prepareNearEd25519TransactionSigningSession(args) {
-	const nearAccountId = args.commandSubject.nearAccount.accountId;
-	const operationUsesNeeded = requiredNearTransactionSignatureUses(args.input.transaction);
-	let availableLanes = await readNearEd25519AvailableSigningLanes({
-		deps: args.deps,
-		commandSubject: args.commandSubject,
-		authMethod: null
-	});
-	let selectedLane = selectSelectedEd25519LaneFromAvailableLanes({
-		commandSubject: args.commandSubject,
-		availableLanes,
-		signerSlot: args.input.signerSlot,
-		operationUsesNeeded
-	});
-	if (!selectedLane) {
-		console.warn(`[SigningEngine][near][ed25519] exact transaction lane selection failed ${JSON.stringify({
-			nearAccountId,
-			signerSlot: args.input.signerSlot ?? null,
-			requiredSignatureUses: operationUsesNeeded,
-			availableLanes: summarizeNearEd25519AvailableLanes(availableLanes)
-		})}`);
-		throw new Error("[SigningEngine][near] Ed25519 transaction signing requires an exact selected lane");
-	}
-	const initialAuthSelectionPolicy = {
-		kind: "account_class",
-		authMethod: signingLaneAuthMethod(selectedLane.lane.auth)
-	};
-	const initialMaterialBoundary = await prepareNearEd25519YaoMaterialBoundary({
-		deps: args.deps,
-		commandSubject: args.commandSubject,
-		selectedLane: selectedLane.lane
-	});
-	if (initialMaterialBoundary.preparation.authorization.kind === "authorized") {
-		const authorization = initialMaterialBoundary.preparation.authorization.authorization;
-		if (selectedLane.lane.walletSessionId !== authorization.operationCredential.walletSessionId || selectedLane.lane.quotaId !== authorization.session.quotaId) {
-			availableLanes = await readNearEd25519AvailableSigningLanes({
-				deps: args.deps,
-				commandSubject: args.commandSubject,
-				authMethod: signingLaneAuthMethod(selectedLane.lane.auth)
-			});
-			const refreshedLane = selectSelectedEd25519LaneFromAvailableLanes({
-				commandSubject: args.commandSubject,
-				availableLanes,
-				signerSlot: args.input.signerSlot,
-				operationUsesNeeded
-			});
-			if (!refreshedLane || !selectedEd25519LanesHaveSameSignerAndAuth(selectedLane.lane, refreshedLane.lane) || refreshedLane.lane.walletSessionId !== authorization.operationCredential.walletSessionId || refreshedLane.lane.quotaId !== authorization.session.quotaId) throw new Error("[SigningEngine][near] material restoration changed the Wallet Session without an exact refreshed lane");
-			selectedLane = refreshedLane;
-		}
-	}
-	const forceFreshAuth = args.forceFreshAuth === true || nearEd25519PreparationRequiresAuthorization(initialMaterialBoundary.preparation);
-	const preparedTransaction = await prepareTransactionSigningOperation({
-		intent: nearEd25519TransactionSigningIntent({
-			commandSubject: args.commandSubject,
-			signerSlot: args.input.signerSlot,
-			authSelectionPolicy: initialAuthSelectionPolicy,
-			operationUsesNeeded
-		}),
-		coordinator: args.signingSessionCoordinator,
-		forceFreshAuth,
-		sensitiveOperationPolicy: args.input.sensitivePolicy || SENSITIVE_OPERATION_POLICIES.inheritSessionPolicy,
-		onPlannerTrace: (event) => emitSigningPlannerDecisionTrace("near", event),
-		lifecycleAdapter: { prepare: async () => {
-			const lifecycle = await prepareNearEd25519TransactionOperation({
-				deps: args.deps,
-				commandSubject: args.commandSubject,
-				signingSessionCoordinator: args.signingSessionCoordinator,
-				availableLanes,
-				selectedLane,
-				preparation: initialMaterialBoundary.preparation,
-				forceFreshAuth,
-				operationUsesNeeded
-			});
-			return {
-				...lifecycle,
-				metadata: lifecycle.metadata
-			};
-		} }
-	});
-	const preparedOperation = preparedTransaction.thresholdOperation;
-	const transactionOperation = preparedTransaction.transactionOperation;
-	const signingLane = preparedOperation.lane;
-	const transactionLane = transactionOperation.lane;
-	const identity = preparedOperation.metadata.identity;
-	const { signingAuthPlan } = await resolveNearTransactionWalletAuth({
-		commandSubject: args.commandSubject,
-		preparedOperation
-	});
-	return {
-		preparation: initialMaterialBoundary.preparation,
-		signingAuthPlan,
-		signingLane,
-		transactionLane,
-		identity,
-		thresholdSessionId: SigningSessionIds.thresholdEd25519Session(resolvePreparedSigningRequestSessionId({
-			providedThresholdSessionId: args.input.thresholdSessionId,
-			identity
-		})),
-		availableLanesGeneration: preparedOperation.availableLanesGeneration,
-		preparedOperation,
-		transactionOperation
-	};
-}
-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: buildNearPreparationDisplayModel({
-			txSigningRequests: [args.transaction],
-			signerAccount: String(args.commandSubject.nearAccount.accountId),
-			title: args.title,
-			subtitle: args.body
-		}),
-		confirmationConfigOverride: args.confirmationConfigOverride
-	});
-	try {
-		const operationId = createNearTransactionSigningOperationId();
-		emitEd25519SigningTiming(String(operationId), "preparation_modal", modalStartedAt);
-		return await signTransactionWithActionsAttempt(deps, args, { signingOperationState: createSigningOperationStateRef({ operationId }) });
-	} finally {
-		deps.touchConfirm.closeTransactionPreparationModal();
-	}
-}
-async function signTransactionWithActionsAttempt(deps, args, attempt) {
-	const nearAccount = args.commandSubject.nearAccount;
-	const nearAccountId = toAccountId(nearAccount.accountId);
-	const publicOptions = {
-		signerSlot: args.signerSlot,
-		confirmationConfigOverride: args.confirmationConfigOverride,
-		title: args.title,
-		body: args.body,
-		onEvent: args.onEvent
-	};
-	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({
-			deps,
-			nearAccountId,
-			materialActivation: requireNearEd25519CommitMaterialActivation(authorizationRequired.preparation),
-			task: async () => 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,
-					selection: {
-						kind: "authorization_required",
-						candidate: authorizationRequired.candidate
-					},
-					passkeyEd25519OperationStepUp: authorizationRequired.passkeyEd25519OperationStepUp || void 0,
-					emailOtpEd25519StepUp: authorizationRequired.emailOtpEd25519StepUp || void 0,
-					sensitivePolicy: args.sensitivePolicy,
-					yaoSigningPreparation: authorizationRequired.preparation,
-					yaoMaterialExecutor: authorizationRequired.executor
-				}
-			})
-		});
-	}
-	const lanePreparationStartedAt = performance.now();
-	const preparedSigningSession = await prepareNearEd25519TransactionSigningSession({
-		deps,
-		input: args,
-		commandSubject: args.commandSubject,
-		signingSessionCoordinator,
-		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;
-	const transactionLane = preparedSigningSession.transactionLane;
-	const thresholdSessionId = preparedSigningSession.thresholdSessionId;
-	assertSigningLaneMatchesSelectedTransactionLane({
-		signingLane,
-		transactionLane
-	});
-	try {
-		return await withThresholdEd25519CommitQueue({
-			deps,
-			nearAccountId,
-			materialActivation: requireNearEd25519CommitMaterialActivation(preparedSigningSession.preparation),
-			task: async () => {
-				const ctx = deps.getSignerWorkerContext();
-				const materialBoundary = await prepareNearEd25519YaoMaterialBoundary({
-					deps,
-					commandSubject: args.commandSubject,
-					selectedLane: transactionLane
-				});
-				const passkeyEd25519OperationStepUp = buildNearPasskeyEd25519OperationStepUp({
-					auth: transactionLane.auth,
-					signer: transactionLane.identity.signer,
-					thresholdSessionId,
-					preparation: materialBoundary.preparation
-				});
-				const emailOtpEd25519StepUp = buildNearEmailOtpEd25519StepUp({
-					deps,
-					commandSubject: args.commandSubject,
-					auth: transactionLane.auth,
-					signer: transactionLane.identity.signer,
-					preparation: materialBoundary.preparation,
-					onEvent: publicOptions.onEvent
-				});
-				const executionState = buildPreparedNearTransactionExecutionState({
-					preparedSigningSession,
-					thresholdSessionId,
-					signingSessionCoordinator,
-					passkeyEd25519OperationStepUp: passkeyEd25519OperationStepUp || null,
-					emailOtpEd25519StepUp: emailOtpEd25519StepUp || null
-				});
-				const ed25519SigningBoundary = {
-					thresholdSessionId: executionState.thresholdSessionId,
-					signingSessionPlan: executionState.signingSessionPlan,
-					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
-				});
-			}
-		});
-	} catch (error) {
-		const alreadyAttemptedFreshAuth = signingAuthPlan.kind === SigningAuthPlanKind.PasskeyReauth || signingAuthPlan.kind === SigningAuthPlanKind.EmailOtpReauth;
-		const ownerDecision = nearOwnerOperationAuthorizationDecisionFromError(error);
-		const admissionDecision = nearWalletSessionQuotaAdmissionDecisionFromError(error);
-		const walletSessionFailure = walletSessionFailureFromError(error);
-		const walletSessionRequiresStepUp = ownerDecision?.kind === "step_up_required";
-		if (!attempt.retryingFreshAuth && !alreadyAttemptedFreshAuth && preparationAuthorization.kind === "authorized" && (walletSessionRequiresStepUp || admissionDecision)) {
-			if (admissionDecision?.kind === "wait_and_retry_admission") {
-				await waitForWalletSessionQuotaAdmissionRetry(admissionDecision.retryAfterMs);
-				return await signTransactionWithActionsAttempt(deps, args, {
-					forceFreshAuth: false,
-					signingOperationState: attempt.signingOperationState,
-					retryingFreshAuth: attempt.retryingFreshAuth,
-					signingSessionCoordinator
-				});
-			}
-			await invalidateAuthoritativeNearWalletSessionExpiry({
-				failure: walletSessionFailure,
-				coordinator: signingSessionCoordinator,
-				lane: preparedSigningSession.transactionLane,
-				expiresAtMs: preparationAuthorization.authorization.status.expiresAtMs
-			});
-			const isEmailOtpSession = transactionLane.auth.kind === "email_otp";
-			const ownerStepUpReason = ownerDecision?.kind === "step_up_required" ? ownerDecision.reason : void 0;
-			const reason = admissionDecision ? admissionDecision.reason === "stale_projection" ? "wallet_signing_budget_stale_projection" : "wallet_signing_budget_exhausted" : ownerStepUpReason === "wallet_session_missing" ? "threshold_session_missing" : "threshold_session_expired";
-			emitNearSigningEvent(publicOptions.onEvent, nearAccountId, {
-				phase: isEmailOtpSession ? SigningEventPhase.STEP_06_AUTH_EMAIL_OTP_CHALLENGE_STARTED : SigningEventPhase.STEP_09_THRESHOLD_SESSION_RECONNECT_STARTED,
-				status: "running",
-				message: isEmailOtpSession ? "Signing session needs reauthorization; requesting Email OTP" : "Signing session needs reauthorization; requesting passkey",
-				interaction: {
-					kind: "none",
-					overlay: "none"
-				},
-				data: {
-					chain: "near",
-					reason
-				}
-			});
-			if (admissionDecision?.kind === "request_fresh_step_up") {
-				const queueKey = nearEd25519WalletSessionQuotaAdmissionQueueKey({
-					walletId: args.commandSubject.walletSession.walletId,
-					nearAccountId,
-					prepared: preparedSigningSession
-				});
-				return await signingSessionCoordinator.runWalletSessionQuotaAdmissionRetry({
-					queueKey,
-					refresh: async () => await signTransactionWithActionsAttempt(deps, args, {
-						forceFreshAuth: true,
-						signingOperationState: attempt.signingOperationState,
-						retryingFreshAuth: true,
-						signingSessionCoordinator
-					}),
-					retryAfterRefresh: async () => await signTransactionWithActionsAttempt(deps, args, {
-						forceFreshAuth: false,
-						signingOperationState: attempt.signingOperationState,
-						retryingFreshAuth: attempt.retryingFreshAuth,
-						signingSessionCoordinator
-					})
-				});
-			}
-			return await signTransactionWithActionsAttempt(deps, args, {
-				forceFreshAuth: true,
-				signingOperationState: attempt.signingOperationState,
-				retryingFreshAuth: true,
-				signingSessionCoordinator
-			});
-		}
-		throw error;
-	}
-}
-async function runPreparedNearDelegateSigning(args) {
-	return await signNearWithUiConfirm({
-		chain: "near",
-		kind: "delegateAction",
-		payload: {
-			ctx: args.deps.getSignerWorkerContext(),
-			commandSubject: args.input.commandSubject,
-			nearAccount: args.input.commandSubject.nearAccount,
-			delegate: args.input.delegate,
-			rpcCall: args.normalizedRpcCall,
-			signingSessionCoordinator: args.deps.signingSessionCoordinator,
-			signerSlot: args.input.signerSlot,
-			confirmationConfigOverride: args.input.confirmationConfigOverride,
-			title: args.input.title,
-			body: args.input.body,
-			onEvent: args.input.onEvent,
-			operationId: args.operationId,
-			forceFreshAuth: args.prepared.forceFreshAuth,
-			selection: args.prepared.kind === "authorized" ? {
-				kind: "authorized",
-				selectedLane: args.prepared.selectedLane
-			} : {
-				kind: "authorization_required",
-				candidate: args.prepared.candidate
-			},
-			passkeyEd25519OperationStepUp: args.prepared.passkeyEd25519OperationStepUp,
-			emailOtpEd25519StepUp: args.prepared.emailOtpEd25519StepUp,
-			yaoSigningPreparation: args.prepared.yaoSigningPreparation,
-			yaoMaterialExecutor: args.prepared.yaoMaterialExecutor
-		}
-	});
-}
-async function executeNearDelegateSigningAttempt(args) {
-	const nearAccountId = toAccountId(args.input.commandSubject.nearAccount.accountId);
-	const prepared = await prepareNearAdHocSigningSession({
-		deps: args.deps,
-		commandSubject: args.input.commandSubject,
-		signerSlot: args.input.signerSlot,
-		operationId: args.operationId,
-		onEvent: args.input.onEvent,
-		attempt: args.attempt
-	});
-	const normalizedRpcCall = {
-		nearRpcUrl: args.input.rpcCall.nearRpcUrl || args.deps.nearRpcUrl,
-		nearAccountId
-	};
-	try {
-		return await withThresholdEd25519CommitQueue({
-			deps: args.deps,
-			nearAccountId,
-			materialActivation: requireNearEd25519CommitMaterialActivation(prepared.yaoSigningPreparation),
-			task: runPreparedNearDelegateSigning.bind(void 0, {
-				deps: args.deps,
-				input: args.input,
-				operationId: args.operationId,
-				prepared,
-				normalizedRpcCall
-			})
-		});
-	} catch (error) {
-		const ownerDecision = nearOwnerOperationAuthorizationDecisionFromError(error);
-		const admissionDecision = nearWalletSessionQuotaAdmissionDecisionFromError(error);
-		if (args.attempt.kind === "initial" && admissionDecision) {
-			if (admissionDecision.kind === "wait_and_retry_admission") {
-				await waitForWalletSessionQuotaAdmissionRetry(admissionDecision.retryAfterMs);
-				return await executeNearDelegateSigningAttempt(args);
-			}
-			const queueKey = nearAdHocEd25519WalletSessionQuotaAdmissionQueueKey({
-				walletId: args.input.commandSubject.walletSession.walletId,
-				nearAccountId,
-				prepared
-			});
-			return await args.deps.signingSessionCoordinator.runWalletSessionQuotaAdmissionRetry({
-				queueKey,
-				refresh: async () => await executeNearDelegateSigningAttempt({
-					...args,
-					attempt: {
-						kind: "fresh_auth_retry",
-						forceFreshAuth: true
-					}
-				}),
-				retryAfterRefresh: async () => await executeNearDelegateSigningAttempt({
-					...args,
-					attempt: {
-						kind: "initial",
-						forceFreshAuth: false
-					}
-				})
-			});
-		}
-		const failure = walletSessionFailureFromError(error);
-		if (args.attempt.kind === "initial" && !prepared.forceFreshAuth && ownerDecision) {
-			await invalidateAuthoritativeNearWalletSessionExpiry({
-				failure,
-				coordinator: args.deps.signingSessionCoordinator,
-				lane: prepared.selectedLane,
-				expiresAtMs: requireNearReusableAuthorizationExpiry(prepared.yaoSigningPreparation)
-			});
-			return await executeNearDelegateSigningAttempt({
-				deps: args.deps,
-				input: args.input,
-				operationId: args.operationId,
-				attempt: {
-					kind: "fresh_auth_retry",
-					forceFreshAuth: true
-				}
-			});
-		}
-		throw error;
-	}
-}
-async function signDelegateAction(deps, args) {
-	try {
-		return await executeNearDelegateSigningAttempt({
-			deps,
-			input: args,
-			operationId: createAdHocNearSigningOperationId(deps, "delegate"),
-			attempt: {
-				kind: "initial",
-				forceFreshAuth: false
-			}
-		});
-	} catch (error) {
-		console.error("[SigningEngine][delegate] failed", error);
-		throw error;
-	}
-}
-async function runPreparedNearNep413Signing(args) {
-	const nearAccount = args.input.commandSubject.nearAccount;
-	return await signNearWithUiConfirm({
-		chain: "near",
-		kind: "nep413",
-		payload: {
-			ctx: args.deps.getSignerWorkerContext(),
-			commandSubject: args.input.commandSubject,
-			nearAccount,
-			signingSessionCoordinator: args.deps.signingSessionCoordinator,
-			onEvent: args.input.onEvent,
-			forceFreshAuth: args.prepared.forceFreshAuth,
-			selection: args.prepared.kind === "authorized" ? {
-				kind: "authorized",
-				selectedLane: args.prepared.selectedLane
-			} : {
-				kind: "authorization_required",
-				candidate: args.prepared.candidate
-			},
-			passkeyEd25519OperationStepUp: args.prepared.passkeyEd25519OperationStepUp,
-			emailOtpEd25519StepUp: args.prepared.emailOtpEd25519StepUp,
-			yaoSigningPreparation: args.prepared.yaoSigningPreparation,
-			yaoMaterialExecutor: args.prepared.yaoMaterialExecutor,
-			payload: {
-				message: args.input.message,
-				recipient: args.input.recipient,
-				nonce: args.input.nonce,
-				state: args.input.state,
-				accountId: nearAccount.accountId,
-				signerSlot: args.input.signerSlot,
-				title: args.input.title,
-				body: args.input.body,
-				confirmationConfigOverride: args.input.confirmationConfigOverride,
-				operationId: args.operationId
-			}
-		}
-	});
-}
-async function executeNearNep413SigningAttempt(args) {
-	const nearAccountId = toAccountId(args.input.commandSubject.nearAccount.accountId);
-	const prepared = await prepareNearAdHocSigningSession({
-		deps: args.deps,
-		commandSubject: args.input.commandSubject,
-		signerSlot: args.input.signerSlot,
-		operationId: args.operationId,
-		onEvent: args.input.onEvent,
-		attempt: args.attempt
-	});
-	try {
-		return await withThresholdEd25519CommitQueue({
-			deps: args.deps,
-			nearAccountId,
-			materialActivation: requireNearEd25519CommitMaterialActivation(prepared.yaoSigningPreparation),
-			task: runPreparedNearNep413Signing.bind(void 0, {
-				deps: args.deps,
-				input: args.input,
-				operationId: args.operationId,
-				prepared
-			})
-		});
-	} catch (error) {
-		const ownerDecision = nearOwnerOperationAuthorizationDecisionFromError(error);
-		const failure = walletSessionFailureFromError(error);
-		if (args.attempt.kind === "initial" && !prepared.forceFreshAuth && ownerDecision !== void 0) {
-			await invalidateAuthoritativeNearWalletSessionExpiry({
-				failure,
-				coordinator: args.deps.signingSessionCoordinator,
-				lane: prepared.selectedLane,
-				expiresAtMs: requireNearReusableAuthorizationExpiry(prepared.yaoSigningPreparation)
-			});
-			return await executeNearNep413SigningAttempt({
-				deps: args.deps,
-				input: args.input,
-				operationId: args.operationId,
-				attempt: {
-					kind: "fresh_auth_retry",
-					forceFreshAuth: true
-				}
-			});
-		}
-		throw error;
-	}
-}
-async function signNEP413Message(deps, payload) {
-	try {
-		return await executeNearNep413SigningAttempt({
-			deps,
-			input: payload,
-			operationId: createAdHocNearSigningOperationId(deps, "nep413"),
-			attempt: {
-				kind: "initial",
-				forceFreshAuth: false
-			}
-		});
-	} catch (error) {
-		console.error("SigningEngine: NEP-413 signing error:", error);
-		return {
-			success: false,
-			error: error instanceof Error ? error.message : String(error || "Unknown error")
-		};
-	}
-}
-function reviewedNearContext(context, beforeSigning) {
-	return {
-		...context,
-		beforeSigning
-	};
-}
-//#endregion
-export { signNear };
-
-//# sourceMappingURL=signNear.js.map