@seams/wallet 0.8.0 → 0.9.1

package/dist/esm/core/signingEngine/flows/recovery/ecdsaExportMaterial.js

@@ -1,249 +0,0 @@
-import { mpcMaterialActivationRefsEqual } from "../../../../shared-ts/src/utils/domainIds.js";
-import { thresholdEcdsaChainTargetsEqual } from "../../interfaces/ecdsaChainTarget.js";
-import { assertMatchingVerifiedEcdsaPublicFacts } from "../../session/identity/evmFamilyEcdsaIdentity.js";
-import { routerAbMpcMaterialActivationRefFromWire } from "../../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
-import { isEmailOtpWalletAuthAuthority, isPasskeyWalletAuthAuthority } from "../../../../shared-ts/src/utils/walletAuthAuthority.js";
-import { isConcreteAvailableSigningLane } from "../../session/availability/availableSigningLanes.js";
-import { buildPersistedEcdsaRoleLocalMaterial } from "../../session/material/ecdsaRoleLocalMaterialResolver.js";
-//#region src/core/signingEngine/flows/recovery/ecdsaExportMaterial.ts
-function ecdsaExportBoundaryChain(lane) {
-	return lane.chainTarget.kind;
-}
-function ecdsaSigningTargetFromChainTarget(chainTarget) {
-	return chainTarget;
-}
-function isConcreteEcdsaExportLane(lane) {
-	if (!lane || lane.curve !== "ecdsa" || !lane.chainTarget || !isConcreteAvailableSigningLane(lane) || !String(lane.publicFacts.keyHandle || "").trim()) return false;
-	if (lane.source === "active_wallet_authority") return lane.runtime.requiredCapability === "export_keys" && lane.state === "deferred" && lane.authorizationState === "authorization_required";
-	if (lane.authorization) return true;
-	return lane.state === "deferred";
-}
-function exactEcdsaParticipantIds(value) {
-	if (value.length !== 2) throw new Error("[SigningEngine][ecdsa-export] ECDSA participant set must contain two parties");
-	const first = value[0];
-	const second = value[1];
-	if (!Number.isSafeInteger(first) || !Number.isSafeInteger(second) || first <= 0 || second <= 0 || first === second) throw new Error("[SigningEngine][ecdsa-export] ECDSA participant set is invalid");
-	return [first, second];
-}
-function requireCanonicalEcdsaExportLane(args) {
-	const { exportLane, label } = args;
-	const capability = exportLane.capability;
-	const signer = capability.manifest.signer;
-	if (signer.walletId !== exportLane.key.walletId || !signer.scope.targetMemberships.some((target) => thresholdEcdsaChainTargetsEqual(target, exportLane.chainTarget))) throw new Error(`[SigningEngine][ecdsa-export] ${label} capability target mismatch`);
-	if (!args.authMatches()) throw new Error(`[SigningEngine][ecdsa-export] ${label} capability auth mismatch`);
-	if (!mpcMaterialActivationRefsEqual(capability.manifest.activation.materialActivation, exportLane.laneIdentity.signer.materialActivation)) throw new Error(`[SigningEngine][ecdsa-export] ${label} material activation mismatch`);
-	assertMatchingVerifiedEcdsaPublicFacts({
-		expected: exportLane.publicFacts,
-		actual: signer.registeredPublicFacts,
-		context: `canonical ${label} export lane`
-	});
-	const materialFacts = capability.material.publicFacts;
-	if (materialFacts.walletId !== signer.walletId || String(materialFacts.keyHandle) !== String(exportLane.publicFacts.keyHandle) || String(materialFacts.groupPublicKey33B64u) !== String(exportLane.publicFacts.publicKeyB64u) || String(materialFacts.ethereumAddress) !== String(exportLane.publicFacts.thresholdOwnerAddress) || materialFacts.participantIds.length !== exportLane.publicFacts.participantIds.length || materialFacts.participantIds.some((participantId, index) => participantId !== exportLane.publicFacts.participantIds[index])) throw new Error(`[SigningEngine][ecdsa-export] canonical ${label} export material mismatch`);
-	const durable = capability.manifest.durableMaterial;
-	const runtimePolicyScope = durable.runtimePolicyScope;
-	const relayerUrl = String(args.deps.relayerUrl).trim().replace(/\/+$/g, "");
-	if (!runtimePolicyScope) throw new Error(`[SigningEngine][ecdsa-export] ${label} runtime policy scope is missing`);
-	if (!relayerUrl) throw new Error(`[SigningEngine][ecdsa-export] ${label} export relayer URL is missing`);
-	return {
-		durable,
-		runtimePolicyScope,
-		relayerUrl
-	};
-}
-function resolveCanonicalEmailOtpEcdsaExportMaterialForLane(args) {
-	const { exportLane } = args;
-	const capability = exportLane.capability;
-	const authority = capability.authority;
-	if (!isEmailOtpWalletAuthAuthority(authority)) throw new Error("[SigningEngine][ecdsa-export] Email OTP capability authority mismatch");
-	const { durable, runtimePolicyScope, relayerUrl } = requireCanonicalEcdsaExportLane({
-		deps: args.deps,
-		exportLane,
-		label: "Email OTP",
-		authMatches: () => exportLane.laneIdentity.auth.kind === "email_otp" && exportLane.laneIdentity.auth.providerSubjectId === authority.factor.providerUserId
-	});
-	return {
-		source: "canonical_capability",
-		kind: "fresh_email_otp_route_auth_ready",
-		chainTarget: exportLane.chainTarget,
-		publicFacts: exportLane.publicFacts,
-		runtimePolicyScope,
-		persistedMaterial: capability.material,
-		normalSigning: durable.routerAbEcdsaDerivationNormalSigning,
-		relayerKeyId: String(durable.roleLocalBinding.relayerKeyId),
-		participantIds: exactEcdsaParticipantIds(durable.roleLocalBinding.participantIds),
-		relayerUrl,
-		authorization: {
-			kind: "fresh_operation_authorization_required",
-			authority
-		}
-	};
-}
-function resolveCanonicalPasskeyEcdsaExportMaterialForLane(args) {
-	const { exportLane } = args;
-	const capability = exportLane.capability;
-	const authority = capability.authority;
-	if (!isPasskeyWalletAuthAuthority(authority)) throw new Error("[SigningEngine][ecdsa-export] passkey capability authority mismatch");
-	const { durable, runtimePolicyScope, relayerUrl } = requireCanonicalEcdsaExportLane({
-		deps: args.deps,
-		exportLane,
-		label: "passkey",
-		authMatches: () => exportLane.laneIdentity.auth.kind === "passkey" && exportLane.laneIdentity.auth.credentialIdB64u === authority.factor.credentialIdB64u
-	});
-	return {
-		source: "canonical_capability",
-		kind: "fresh_passkey_needs_authorization",
-		chainTarget: exportLane.chainTarget,
-		publicFacts: exportLane.publicFacts,
-		runtimePolicyScope,
-		publicCapability: durable.roleLocalPublicFacts.publicCapability,
-		existingRoleLocalMaterial: capability.material,
-		normalSigning: durable.routerAbEcdsaDerivationNormalSigning,
-		relayerKeyId: String(durable.roleLocalBinding.relayerKeyId),
-		participantIds: exactEcdsaParticipantIds(durable.roleLocalBinding.participantIds),
-		relayerUrl
-	};
-}
-function sealedEmailOtpExportMaterial(args) {
-	const { exportLane, resolution } = args;
-	if (exportLane.laneIdentity.auth.kind !== "email_otp") throw new Error("[SigningEngine][ecdsa-export] Email OTP runtime auth mismatch");
-	if (resolution.runtime.authBinding.kind !== "email_otp") throw new Error("[SigningEngine][ecdsa-export] Email OTP runtime authority mismatch");
-	if (exportLane.laneIdentity.auth.providerSubjectId !== resolution.runtime.authBinding.providerSubjectId) throw new Error("[SigningEngine][ecdsa-export] Email OTP runtime auth mismatch");
-	if (!mpcMaterialActivationRefsEqual(resolution.runtime.materialActivation, exportLane.laneIdentity.signer.materialActivation)) throw new Error("[SigningEngine][ecdsa-export] Email OTP material activation mismatch");
-	const runtimePolicyScope = resolution.runtime.runtimePolicyScope;
-	if (!runtimePolicyScope) throw new Error("[SigningEngine][ecdsa-export] Email OTP runtime policy scope is missing");
-	const persistedMaterial = buildPersistedEcdsaRoleLocalMaterial({
-		authority: resolution.manifest.signer.authority,
-		materialActivation: resolution.manifest.activation.materialActivation,
-		publicFacts: resolution.manifest.durableMaterial.roleLocalPublicFacts
-	});
-	return {
-		source: "canonical_capability",
-		kind: "fresh_email_otp_route_auth_ready",
-		chainTarget: exportLane.chainTarget,
-		publicFacts: exportLane.publicFacts,
-		runtimePolicyScope,
-		persistedMaterial,
-		normalSigning: resolution.runtime.normalSigning,
-		relayerKeyId: resolution.runtime.relayerKeyId,
-		participantIds: resolution.runtime.participantIds,
-		relayerUrl: resolution.runtime.relayerUrl,
-		authorization: {
-			kind: "fresh_operation_authorization_required",
-			authority: resolution.runtime.authBinding.emailOtpAuthority
-		}
-	};
-}
-function resolveActiveWalletAuthorityEcdsaExportMaterialForLane(args) {
-	const { exportLane } = args;
-	const runtime = exportLane.runtime;
-	if (runtime.requiredCapability !== "export_keys") throw new Error("[SigningEngine][ecdsa-export] active Wallet Authority lane lacks export_keys capability");
-	if (runtime.walletId !== exportLane.key.walletId) throw new Error("[SigningEngine][ecdsa-export] active Wallet Authority wallet mismatch");
-	if (!mpcMaterialActivationRefsEqual(runtime.materialActivation, exportLane.laneIdentity.signer.materialActivation)) throw new Error("[SigningEngine][ecdsa-export] active Wallet Authority material activation mismatch");
-	assertMatchingVerifiedEcdsaPublicFacts({
-		expected: exportLane.publicFacts,
-		actual: runtime.publicFacts,
-		context: "active Wallet Authority ECDSA export lane"
-	});
-	const normalSigning = runtime.normalSigning;
-	const normalScope = normalSigning.scope;
-	if (normalScope.wallet_id !== String(runtime.walletId) || normalScope.ecdsa_threshold_key_id !== runtime.ecdsaThresholdKeyId || normalScope.public_identity.threshold_public_key33_b64u !== runtime.publicFacts.publicKeyB64u || !mpcMaterialActivationRefsEqual(routerAbMpcMaterialActivationRefFromWire(normalScope.material_activation), runtime.materialActivation)) throw new Error("[SigningEngine][ecdsa-export] active Wallet Authority normal-signing identity mismatch");
-	const relayerUrl = String(args.deps.relayerUrl).trim().replace(/\/+$/g, "");
-	if (!relayerUrl) throw new Error("[SigningEngine][ecdsa-export] active Wallet Authority export relayer URL is missing");
-	const participantIds = exactEcdsaParticipantIds(runtime.publicFacts.participantIds);
-	if (runtime.auth.kind === "passkey") {
-		if (!isPasskeyWalletAuthAuthority(runtime.factorAuthority)) throw new Error("[SigningEngine][ecdsa-export] active passkey factor authority mismatch");
-		if (runtime.factorAuthority.factor.credentialIdB64u !== runtime.auth.credentialIdB64u || runtime.factorAuthority.bindingId !== runtime.walletAuthMethodId) throw new Error("[SigningEngine][ecdsa-export] active passkey factor identity mismatch");
-		return {
-			source: "active_wallet_authority",
-			kind: "active_wallet_authority_passkey_needs_authorization",
-			chainTarget: exportLane.chainTarget,
-			publicFacts: runtime.publicFacts,
-			normalSigning,
-			relayerKeyId: runtime.relayerKeyId,
-			participantIds,
-			relayerUrl,
-			runtime,
-			factorAuthority: runtime.factorAuthority,
-			authMethod: "passkey"
-		};
-	}
-	if (!isEmailOtpWalletAuthAuthority(runtime.factorAuthority)) throw new Error("[SigningEngine][ecdsa-export] active Email OTP factor authority mismatch");
-	if (runtime.factorAuthority.factor.providerUserId !== runtime.auth.providerSubjectId || runtime.factorAuthority.bindingId !== runtime.walletAuthMethodId) throw new Error("[SigningEngine][ecdsa-export] active Email OTP factor identity mismatch");
-	return {
-		source: "active_wallet_authority",
-		kind: "active_wallet_authority_email_otp_needs_authorization",
-		chainTarget: exportLane.chainTarget,
-		publicFacts: runtime.publicFacts,
-		normalSigning,
-		relayerKeyId: runtime.relayerKeyId,
-		participantIds,
-		relayerUrl,
-		runtime,
-		factorAuthority: runtime.factorAuthority,
-		authMethod: "email_otp"
-	};
-}
-async function resolveFreshEmailOtpEcdsaExportMaterialForLane(deps, exportLane) {
-	if (exportLane.source !== "canonical_capability") throw new Error("[SigningEngine][ecdsa-export] active Wallet Authority Email OTP material uses its holder runtime");
-	if (exportLane.authMethod !== "email_otp") throw new Error("[SigningEngine][ecdsa-export] fresh Email OTP export requires Email OTP lane");
-	const resolution = await deps.resolveActiveEcdsaCapabilityRuntime({
-		walletId: exportLane.key.walletId,
-		chainTarget: exportLane.chainTarget
-	});
-	if (resolution.kind === "blocked" && resolution.reason === "missing_material") return resolveCanonicalEmailOtpEcdsaExportMaterialForLane({
-		deps,
-		exportLane
-	});
-	if (resolution.kind !== "resolved") throw new Error(`[SigningEngine][ecdsa-export] Email OTP capability runtime unavailable: ${resolution.reason}`);
-	return sealedEmailOtpExportMaterial({
-		exportLane,
-		resolution
-	});
-}
-async function resolveEcdsaExportMaterialForLane(deps, exportLane) {
-	if (exportLane.source === "active_wallet_authority") return resolveActiveWalletAuthorityEcdsaExportMaterialForLane({
-		deps,
-		exportLane
-	});
-	if (exportLane.authMethod === "email_otp") return await resolveFreshEmailOtpEcdsaExportMaterialForLane(deps, exportLane);
-	const resolution = await deps.resolveActiveEcdsaCapabilityRuntime({
-		walletId: exportLane.key.walletId,
-		chainTarget: exportLane.chainTarget
-	});
-	if (resolution.kind === "blocked" && resolution.reason === "missing_material") return resolveCanonicalPasskeyEcdsaExportMaterialForLane({
-		deps,
-		exportLane
-	});
-	if (resolution.kind !== "resolved") throw new Error(`[SigningEngine][ecdsa-export] passkey capability runtime unavailable: ${resolution.reason}`);
-	if (!mpcMaterialActivationRefsEqual(resolution.runtime.materialActivation, exportLane.laneIdentity.signer.materialActivation)) throw new Error("[SigningEngine][ecdsa-export] passkey material activation mismatch");
-	if (resolution.runtime.authBinding.kind !== "passkey") throw new Error("[SigningEngine][ecdsa-export] passkey authority binding mismatch");
-	const publicFacts = resolution.manifest.signer.registeredPublicFacts;
-	assertMatchingVerifiedEcdsaPublicFacts({
-		expected: exportLane.publicFacts,
-		actual: publicFacts,
-		context: "canonical passkey export lane"
-	});
-	const runtimePolicyScope = resolution.runtime.runtimePolicyScope;
-	if (!runtimePolicyScope) throw new Error("[SigningEngine][ecdsa-export] durable passkey export requires runtimePolicyScope");
-	return {
-		source: "canonical_capability",
-		kind: "fresh_passkey_needs_authorization",
-		chainTarget: exportLane.chainTarget,
-		publicFacts,
-		runtimePolicyScope,
-		publicCapability: resolution.manifest.durableMaterial.roleLocalPublicFacts.publicCapability,
-		existingRoleLocalMaterial: buildPersistedEcdsaRoleLocalMaterial({
-			authority: resolution.manifest.signer.authority,
-			materialActivation: resolution.manifest.durableMaterial.materialActivation,
-			publicFacts: resolution.manifest.durableMaterial.roleLocalPublicFacts
-		}),
-		normalSigning: resolution.runtime.normalSigning,
-		relayerKeyId: resolution.runtime.relayerKeyId,
-		participantIds: resolution.runtime.participantIds,
-		relayerUrl: resolution.runtime.relayerUrl
-	};
-}
-//#endregion
-export { ecdsaExportBoundaryChain, ecdsaSigningTargetFromChainTarget, isConcreteEcdsaExportLane, resolveEcdsaExportMaterialForLane, resolveFreshEmailOtpEcdsaExportMaterialForLane };
-
-//# sourceMappingURL=ecdsaExportMaterial.js.map

package/dist/esm/core/signingEngine/flows/recovery/ed25519YaoExportFlow.js

@@ -1,353 +0,0 @@
-import { mpcMaterialActivationRefsEqual } from "../../../../shared-ts/src/utils/domainIds.js";
-import { base58Encode } from "../../../../shared-ts/src/utils/base58.js";
-import { KeyExportEventPhase } from "../../../types/sdkSentEvents.js";
-import { routerAbMpcMaterialActivationRefToWire } from "../../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
-import { resolveThresholdCommitQueueKey } from "../../threshold/commitQueueShared.js";
-import { isExportViewerSessionOpen, removeExportViewerHostIfPresent } from "../../uiConfirm/ui/export-viewer-host.js";
-import { createExportUiRequestId, emitKeyExportEvent } from "./keyExportFlow.js";
-import { requestEmailOtpEd25519KeyExportAuthorization, showEd25519ExportViewer } from "./keyExportConfirmation.js";
-import { ROUTER_AB_ED25519_YAO_EXPORT_ARTIFACT_KIND_V1 } from "../../../types/secure-confirm-worker.js";
-//#region src/core/signingEngine/flows/recovery/ed25519YaoExportFlow.ts
-function passkeyEd25519ExportMaterialActivation(resolved) {
-	return resolved.capability.materialActivation;
-}
-function emailOtpEd25519ExportMaterialActivation(context) {
-	return context.material.materialActivation;
-}
-function isExactPasskeyEd25519SigningLaneIdentity(laneIdentity) {
-	return laneIdentity.auth.kind === "passkey";
-}
-function requirePasskeyExportLaneIdentity(args) {
-	if (!isExactPasskeyEd25519SigningLaneIdentity(args.laneIdentity)) throw new Error("[SigningEngine][ed25519-export] export requires a passkey Yao lane");
-	if (args.laneIdentity.signer.account.wallet.walletId !== args.walletId || String(args.laneIdentity.signer.account.nearAccountId) !== String(args.nearAccountId)) throw new Error("[SigningEngine][ed25519-export] exact lane subject mismatch");
-	return args.laneIdentity;
-}
-function isExactEmailOtpEd25519SigningLaneIdentity(laneIdentity) {
-	return laneIdentity.auth.kind === "email_otp";
-}
-function requireEmailOtpExportLaneIdentity(args) {
-	if (!isExactEmailOtpEd25519SigningLaneIdentity(args.laneIdentity)) throw new Error("[SigningEngine][ed25519-export] export requires an Email OTP Yao lane");
-	if (args.laneIdentity.signer.account.wallet.walletId !== args.walletId || String(args.laneIdentity.signer.account.nearAccountId) !== String(args.nearAccountId)) throw new Error("[SigningEngine][ed25519-export] exact lane subject mismatch");
-	return args.laneIdentity;
-}
-function passkeyExportMaterialIdentityMatches(args) {
-	const signer = args.selected.signer;
-	const material = args.context.material;
-	return String(signer.account.wallet.walletId) === String(material.walletId) && String(signer.account.nearAccountId) === String(material.nearAccountId) && String(signer.nearEd25519SigningKeyId) === String(material.nearEd25519SigningKeyId) && signer.signerSlot === material.signerSlot && String(args.selected.auth.rpId) === args.context.rpId && args.selected.auth.credentialIdB64u === material.credentialIdB64u;
-}
-function requireDurablePasskeyExportContext(args) {
-	if (!passkeyExportMaterialIdentityMatches({
-		selected: args.selectedLaneIdentity,
-		context: args.context
-	})) throw new Error("[SigningEngine][ed25519-export] durable Yao context identity mismatch");
-	const descriptor = args.context.material;
-	if (!mpcMaterialActivationRefsEqual(args.selectedMaterialActivation, args.context.selectedLaneMaterialActivation)) throw new Error("[SigningEngine][ed25519-export] durable Yao context activation mismatch");
-	const walletSessionToken = args.context.authorization.operationCredential.token;
-	if (!walletSessionToken) throw new Error("[SigningEngine][ed25519-export] active Wallet Session authorization is unavailable");
-	const lifecycle = descriptor.capability.lifecycle;
-	return {
-		laneIdentity: args.selectedLaneIdentity,
-		relayerUrl: args.context.relayerUrl,
-		walletSessionToken,
-		walletCustodyEnvelope: args.context.walletCustodyEnvelope,
-		capability: {
-			materialActivation: descriptor.capability.materialActivation,
-			scope: {
-				lifecycle_id: lifecycle.lifecycleId,
-				root_share_epoch: lifecycle.rootShareEpoch,
-				account_id: lifecycle.accountId,
-				threshold_session_id: lifecycle.thresholdSessionId,
-				signer_set_id: lifecycle.signerSetId,
-				signing_worker_id: lifecycle.signingWorkerId,
-				material_activation: routerAbMpcMaterialActivationRefToWire(descriptor.capability.materialActivation)
-			},
-			applicationBinding: descriptor.capability.applicationBinding,
-			participantIds: descriptor.capability.participantIds,
-			registeredPublicKey: descriptor.capability.registeredPublicKey,
-			stateEpoch: descriptor.capability.stateEpoch,
-			activeCapabilityBinding: descriptor.capability.activeCapabilityBinding,
-			runtimePolicyScope: descriptor.capability.runtimePolicyScope
-		}
-	};
-}
-async function resolveExactPasskeyExportContext(deps, args) {
-	const laneIdentity = requirePasskeyExportLaneIdentity(args);
-	const durableContext = await deps.resolvePasskeyExportContext({
-		laneIdentity,
-		materialActivation: args.materialActivation
-	});
-	switch (durableContext.kind) {
-		case "ready": return requireDurablePasskeyExportContext({
-			context: durableContext.context,
-			selectedLaneIdentity: laneIdentity,
-			selectedMaterialActivation: args.materialActivation
-		});
-		case "capability_recovery_required": throw new Error("[SigningEngine][ed25519-export] passkey material recovery did not publish durable context");
-	}
-	throw new Error("[SigningEngine][ed25519-export] unsupported passkey export context state");
-}
-async function resolveExactEmailOtpExportContext(deps, args) {
-	const laneIdentity = requireEmailOtpExportLaneIdentity(args);
-	const context = await deps.emailOtp.resolveExportContext({
-		laneIdentity,
-		materialActivation: args.materialActivation
-	});
-	if (!mpcMaterialActivationRefsEqual(args.materialActivation, context.material.materialActivation) && context.material.kind !== "sealed_export_root") throw new Error("[SigningEngine][ed25519-export] Email OTP Yao context activation mismatch");
-	return {
-		context,
-		laneIdentity
-	};
-}
-function buildWorkerPayload(args) {
-	const signer = args.resolved.laneIdentity.signer;
-	return {
-		artifactKind: ROUTER_AB_ED25519_YAO_EXPORT_ARTIFACT_KIND_V1,
-		walletId: String(args.input.walletId),
-		nearAccountId: String(args.input.nearAccountId),
-		relayerUrl: args.resolved.relayerUrl,
-		authorization: {
-			kind: "opaque_wallet_session",
-			walletSessionToken: args.resolved.walletSessionToken
-		},
-		flowId: args.input.flowId,
-		viewerSessionId: args.viewerSessionId,
-		exactLane: {
-			nearEd25519SigningKeyId: String(signer.nearEd25519SigningKeyId),
-			signerSlot: signer.signerSlot,
-			credentialIdB64u: args.resolved.laneIdentity.auth.credentialIdB64u,
-			materialActivation: passkeyEd25519ExportMaterialActivation(args.resolved)
-		},
-		walletCustodyEnvelope: args.resolved.walletCustodyEnvelope,
-		capability: args.resolved.capability,
-		variant: args.input.options.variant,
-		theme: args.input.options.theme ?? args.theme
-	};
-}
-function emitEd25519ExportViewerLifecycle(context, event) {
-	const accountId = String(context.walletId);
-	emitKeyExportEvent(context.onEvent, {
-		phase: event === "opened" ? KeyExportEventPhase.STEP_04_VIEWER_OPENED : KeyExportEventPhase.STEP_05_VIEWER_CLOSED,
-		status: event === "opened" ? "waiting_for_user" : "succeeded",
-		flowId: context.flowId,
-		accountId,
-		interaction: {
-			kind: "key_export_viewer",
-			overlay: event === "opened" ? "show" : "hide"
-		},
-		data: {
-			chain: "near",
-			curve: "ed25519"
-		}
-	});
-	if (event !== "closed") return;
-	emitKeyExportEvent(context.onEvent, {
-		phase: KeyExportEventPhase.STEP_06_COMPLETED,
-		status: "succeeded",
-		flowId: context.flowId,
-		accountId,
-		interaction: {
-			kind: "none",
-			overlay: "hide"
-		},
-		data: {
-			chain: "near",
-			curve: "ed25519"
-		}
-	});
-}
-async function exportEd25519YaoKeyWithFreshAuthorization(deps, args) {
-	switch (args.laneIdentity.auth.kind) {
-		case "passkey": break;
-		case "email_otp": return await exportEd25519YaoKeyWithFreshEmailOtp(deps, args);
-		default:
-			args.laneIdentity.auth;
-			throw new Error("[SigningEngine][ed25519-export] unsupported lane authorization method");
-	}
-	const contextResolution = resolveExactPasskeyExportContext(deps, args);
-	const uiInitialization = deps.touchConfirm.initialize();
-	const [resolved] = await Promise.all([contextResolution, uiInitialization]);
-	const eventAccountId = String(args.walletId);
-	const viewerSessionId = createExportUiRequestId("export-ed25519-yao-viewer-session");
-	const onViewerLifecycle = emitEd25519ExportViewerLifecycle.bind(void 0, {
-		flowId: args.flowId,
-		walletId: args.walletId,
-		onEvent: args.onEvent
-	});
-	emitKeyExportEvent(args.onEvent, {
-		phase: KeyExportEventPhase.STEP_02_AUTH_PASSKEY_PROMPT_STARTED,
-		status: "waiting_for_user",
-		flowId: args.flowId,
-		accountId: eventAccountId,
-		authMethod: "passkey",
-		interaction: {
-			kind: "passkey_assert",
-			overlay: "show"
-		},
-		data: {
-			intent: "ed25519_export",
-			chain: "near",
-			curve: "ed25519"
-		}
-	});
-	emitKeyExportEvent(args.onEvent, {
-		phase: KeyExportEventPhase.STEP_03_MATERIAL_PREPARE_STARTED,
-		status: "running",
-		flowId: args.flowId,
-		accountId: eventAccountId,
-		interaction: {
-			kind: "none",
-			overlay: "none"
-		},
-		data: {
-			chain: "near",
-			curve: "ed25519"
-		}
-	});
-	const result = await deps.withThresholdEd25519CommitQueue({
-		queueKey: resolveThresholdCommitQueueKey({ materialActivation: passkeyEd25519ExportMaterialActivation(resolved) }),
-		nearAccountId: args.nearAccountId,
-		enabled: true,
-		task: () => deps.passkeyMpcExport.exportPrivateKeysWithUi(buildWorkerPayload({
-			resolved,
-			viewerSessionId,
-			input: args,
-			theme: deps.theme
-		}), { onViewerLifecycle })
-	});
-	if (result.kind !== "completed") throw new Error(result.error);
-	if (result.exportedSchemes.length !== 1 || result.exportedSchemes[0] !== "ed25519") throw new Error("[SigningEngine][ed25519-export] secure export failed");
-	emitKeyExportEvent(args.onEvent, {
-		phase: KeyExportEventPhase.STEP_02_AUTH_PASSKEY_PROMPT_SUCCEEDED,
-		status: "succeeded",
-		flowId: args.flowId,
-		accountId: eventAccountId,
-		authMethod: "passkey",
-		interaction: {
-			kind: "passkey_assert",
-			overlay: "none"
-		},
-		data: {
-			intent: "ed25519_export",
-			chain: "near",
-			curve: "ed25519"
-		}
-	});
-	emitKeyExportEvent(args.onEvent, {
-		phase: KeyExportEventPhase.STEP_03_MATERIAL_PREPARE_SUCCEEDED,
-		status: "succeeded",
-		flowId: args.flowId,
-		accountId: eventAccountId,
-		interaction: {
-			kind: "none",
-			overlay: "none"
-		},
-		data: {
-			chain: "near",
-			curve: "ed25519"
-		}
-	});
-	return {
-		accountId: String(args.nearAccountId),
-		exportedSchemes: ["ed25519"]
-	};
-}
-async function exportEd25519YaoKeyWithFreshEmailOtp(deps, args) {
-	const resolved = await resolveExactEmailOtpExportContext(deps, args);
-	const publicKey = `ed25519:${base58Encode(Uint8Array.from(resolved.context.material.capability.registeredPublicKey))}`;
-	const authorization = await requestEmailOtpEd25519KeyExportAuthorization({
-		touchConfirm: deps.touchConfirm,
-		requestExportChallenge: deps.emailOtp.requestExportChallenge
-	}, {
-		kind: "email_otp_ed25519_export_auth",
-		walletId: args.walletId,
-		nearAccountId: String(args.nearAccountId),
-		nearEd25519SigningKeyId: String(resolved.laneIdentity.signer.nearEd25519SigningKeyId),
-		signerSlot: resolved.laneIdentity.signer.signerSlot,
-		publicKey,
-		curve: "ed25519",
-		chain: "near",
-		flowId: args.flowId,
-		onEvent: args.onEvent
-	});
-	emitKeyExportEvent(args.onEvent, {
-		phase: KeyExportEventPhase.STEP_03_MATERIAL_PREPARE_STARTED,
-		status: "running",
-		flowId: args.flowId,
-		accountId: String(args.nearAccountId),
-		interaction: {
-			kind: "none",
-			overlay: "none"
-		},
-		data: {
-			chain: "near",
-			curve: "ed25519"
-		}
-	});
-	const viewerSessionId = createExportUiRequestId("export-ed25519-yao-viewer-session");
-	try {
-		await showEd25519ExportViewer({
-			touchConfirm: deps.touchConfirm,
-			theme: deps.theme
-		}, {
-			state: "loading",
-			walletId: String(args.walletId),
-			nearAccountId: String(args.nearAccountId),
-			publicKey,
-			variant: args.options.variant,
-			theme: args.options.theme,
-			viewerSessionId,
-			flowId: args.flowId,
-			onEvent: args.onEvent
-		});
-		const artifact = await deps.withThresholdEd25519CommitQueue({
-			queueKey: resolveThresholdCommitQueueKey({ materialActivation: emailOtpEd25519ExportMaterialActivation(resolved.context) }),
-			nearAccountId: args.nearAccountId,
-			enabled: resolved.context.material.kind === "active_capability",
-			task: () => deps.emailOtp.exportSeedWithFreshAuthorization({
-				challengeId: authorization.challengeId,
-				otpCode: authorization.otpCode,
-				exportContext: resolved.context
-			})
-		});
-		emitKeyExportEvent(args.onEvent, {
-			phase: KeyExportEventPhase.STEP_03_MATERIAL_PREPARE_SUCCEEDED,
-			status: "succeeded",
-			flowId: args.flowId,
-			accountId: String(args.nearAccountId),
-			interaction: {
-				kind: "none",
-				overlay: "none"
-			},
-			data: {
-				chain: "near",
-				curve: "ed25519"
-			}
-		});
-		if (isExportViewerSessionOpen(viewerSessionId)) await showEd25519ExportViewer({
-			touchConfirm: deps.touchConfirm,
-			theme: deps.theme
-		}, {
-			state: "ready",
-			walletId: String(args.walletId),
-			nearAccountId: String(args.nearAccountId),
-			publicKey: artifact.publicKey,
-			privateKey: artifact.privateKey,
-			variant: args.options.variant,
-			theme: args.options.theme,
-			viewerSessionId,
-			flowId: args.flowId,
-			onEvent: args.onEvent
-		});
-		return {
-			accountId: String(args.nearAccountId),
-			exportedSchemes: ["ed25519"]
-		};
-	} catch (error) {
-		removeExportViewerHostIfPresent();
-		throw error;
-	}
-}
-//#endregion
-export { exportEd25519YaoKeyWithFreshAuthorization };
-
-//# sourceMappingURL=ed25519YaoExportFlow.js.map