@seams/wallet 0.8.0 → 0.9.0

package/dist/esm/core/signingEngine/session/passkey/ecdsaRecovery.js

@@ -1,84 +0,0 @@
-import { mpcMaterialActivationRefsEqual } from "../../../../shared-ts/src/utils/domainIds.js";
-import { thresholdEcdsaChainTargetsEqual, toWalletId } from "../../interfaces/ecdsaChainTarget.js";
-import { parseSigningSessionSealKeyVersion } from "../../../../shared-ts/src/threshold/keyMaterialBrands.js";
-//#region src/core/signingEngine/session/passkey/ecdsaRecovery.ts
-function shouldDeletePasskeyEcdsaSealedRecordAfterRestoreFailure(status) {
-	if (status.ok) return false;
-	switch (status.code) {
-		case "expired":
-		case "exhausted": return false;
-		case "not_found":
-		case "invalid_args":
-		case "invalid_response": return true;
-		default: return false;
-	}
-}
-async function checkCurrentPasskeyEcdsaRuntime(args) {
-	const resolution = await args.resolveCurrentEcdsaCapabilityRuntime({
-		walletId: toWalletId(args.record.walletId),
-		chainTarget: args.record.chainTarget
-	});
-	if (resolution.kind === "resolved" && mpcMaterialActivationRefsEqual(resolution.runtime.materialActivation, args.record.roleLocalMaterialRef.materialActivation)) return { kind: "current" };
-	return {
-		kind: "superseded",
-		status: {
-			ok: false,
-			code: "superseded",
-			message: `Passkey ECDSA sealed recovery was superseded (${resolution.kind === "blocked" ? resolution.reason : "material_activation_mismatch"})`
-		}
-	};
-}
-async function restorePasskeyEcdsaSealedRecordForWallet(args) {
-	if (!thresholdEcdsaChainTargetsEqual(args.record.chainTarget, args.purpose.chainTarget)) return null;
-	const thresholdSessionId = String(args.purpose.thresholdSessionId || "").trim();
-	if (!thresholdSessionId || !args.groupId) return null;
-	const currentBeforeWorker = await checkCurrentPasskeyEcdsaRuntime({
-		record: args.record,
-		resolveCurrentEcdsaCapabilityRuntime: args.resolveCurrentEcdsaCapabilityRuntime
-	});
-	if (currentBeforeWorker.kind === "superseded") return currentBeforeWorker.status;
-	const rehydrated = await args.rehydrateWarmSessionMaterial({
-		thresholdSessionId,
-		sealedSecretB64u: args.record.sealedSecretB64u,
-		signingSessionSealKeyVersion: parseSigningSessionSealKeyVersion(args.record.keyVersion),
-		expiresAtMs: args.record.expiresAtMs,
-		remainingUses: args.record.remainingUses,
-		transport: {
-			...args.transport,
-			groupId: args.groupId
-		}
-	});
-	if (!rehydrated.ok) {
-		const currentBeforeFailureWrites = await checkCurrentPasskeyEcdsaRuntime({
-			record: args.record,
-			resolveCurrentEcdsaCapabilityRuntime: args.resolveCurrentEcdsaCapabilityRuntime
-		});
-		if (currentBeforeFailureWrites.kind === "superseded") return currentBeforeFailureWrites.status;
-		if (shouldDeletePasskeyEcdsaSealedRecordAfterRestoreFailure(rehydrated)) await args.deletePersistedRecord().catch(() => void 0);
-		await args.recordSessionMaterialRestored(rehydrated);
-		return rehydrated;
-	}
-	const parsed = await args.readWarmSessionStatusFromWorker(thresholdSessionId);
-	if (!parsed) return {
-		ok: false,
-		code: "worker_error",
-		message: "Warm-session status read failed after rehydrate"
-	};
-	const currentBeforeDurableWrites = await checkCurrentPasskeyEcdsaRuntime({
-		record: args.record,
-		resolveCurrentEcdsaCapabilityRuntime: args.resolveCurrentEcdsaCapabilityRuntime
-	});
-	if (currentBeforeDurableWrites.kind === "superseded") return currentBeforeDurableWrites.status;
-	if (parsed.ok) await args.updatePersistedPolicy({
-		expiresAtMs: parsed.expiresAtMs,
-		remainingUses: parsed.remainingUses,
-		updatedAtMs: Date.now()
-	}).catch(() => void 0);
-	else if (shouldDeletePasskeyEcdsaSealedRecordAfterRestoreFailure(parsed)) await args.deletePersistedRecord().catch(() => void 0);
-	await args.recordSessionMaterialRestored(parsed);
-	return parsed;
-}
-//#endregion
-export { restorePasskeyEcdsaSealedRecordForWallet };
-
-//# sourceMappingURL=ecdsaRecovery.js.map

package/dist/esm/core/signingEngine/session/passkey/ecdsaSessionProvision.js

@@ -1,224 +0,0 @@
-import { toWalletId } from "../../interfaces/ecdsaChainTarget.js";
-import { evmFamilyEcdsaWalletKeyToIdentity } from "../identity/evmFamilyEcdsaIdentity.js";
-import { ecdsaRoleLocalReadyRecordStorageKeyFacts } from "../persistence/ecdsaRoleLocalRecords.js";
-import { emailOtpAuthContextRetention } from "../identity/laneIdentity.js";
-import { bootstrapEcdsaSessionValue, bootstrapEmailOtpExplicitExportEcdsaSessionValue, bootstrapExplicitKeyExportEcdsaSessionValue, ecdsaBootstrapWalletId } from "./ecdsaBootstrap.js";
-import { withThresholdEcdsaBootstrapQueue } from "../warmCapabilities/ecdsaBootstrapQueue.js";
-//#region src/core/signingEngine/session/passkey/ecdsaSessionProvision.ts
-function applyOptionalActivationFields(request, args) {
-	if (args.runtimeScopeBootstrap) request.runtimeScopeBootstrap = args.runtimeScopeBootstrap;
-	if (args.operationIntent) request.operationIntent = args.operationIntent;
-	if (typeof args.ttlMs === "number") request.ttlMs = args.ttlMs;
-	return request;
-}
-function buildEmailOtpEcdsaActivationRequest(args) {
-	return applyOptionalActivationFields({
-		kind: "email_otp_ecdsa_activation",
-		purpose: "transaction_signing",
-		walletKey: args.walletKey,
-		lanePolicy: args.lanePolicy,
-		publicCapability: args.publicCapability,
-		existingRoleLocalMaterial: args.existingRoleLocalMaterial,
-		source: args.source,
-		relayerUrl: args.relayerUrl,
-		sessionIdentity: args.sessionIdentity,
-		sessionKind: args.sessionKind,
-		sessionBudgetUses: args.sessionBudgetUses,
-		runtimePolicy: args.runtimePolicy,
-		emailOtpWorkerSessionHandle: args.emailOtpWorkerSessionHandle,
-		emailOtpAuthContext: args.emailOtpAuthContext,
-		..."preauthorizedSessionActivation" in args ? { preauthorizedSessionActivation: args.preauthorizedSessionActivation } : { walletSessionRouteAuth: args.walletSessionRouteAuth }
-	}, args);
-}
-function assertEmailOtpActivationRetention(args) {
-	if (emailOtpAuthContextRetention(args.context) !== args.expected) throw new Error(`Email OTP ${args.label} activation requires ${args.expected} retention`);
-}
-function buildEmailOtpSessionBootstrapEcdsaActivation(args) {
-	assertEmailOtpActivationRetention({
-		context: args.emailOtpAuthContext,
-		expected: "session",
-		label: "session bootstrap"
-	});
-	return buildEmailOtpEcdsaActivationRequest(args);
-}
-function buildEmailOtpRecoveredSessionEcdsaActivation(args) {
-	assertEmailOtpActivationRetention({
-		context: args.emailOtpAuthContext,
-		expected: "session",
-		label: "recovered session"
-	});
-	return buildEmailOtpEcdsaActivationRequest(args);
-}
-function buildEmailOtpPreauthorizedSessionBootstrapEcdsaActivation(args) {
-	assertEmailOtpActivationRetention({
-		context: args.emailOtpAuthContext,
-		expected: "session",
-		label: "preauthorized session bootstrap"
-	});
-	return buildEmailOtpEcdsaActivationRequest(args);
-}
-function buildEmailOtpPerOperationReauthEcdsaActivation(args) {
-	assertEmailOtpActivationRetention({
-		context: args.emailOtpAuthContext,
-		expected: "single_use",
-		label: "per-operation reauth"
-	});
-	return buildEmailOtpEcdsaActivationRequest(args);
-}
-function buildEmailOtpExplicitExportEcdsaActivation(args) {
-	return {
-		kind: "email_otp_ecdsa_export_activation",
-		purpose: "explicit_key_export",
-		existingRoleLocalMaterial: args.existingRoleLocalMaterial,
-		relayerUrl: args.relayerUrl,
-		authorization: args.authorization
-	};
-}
-function buildEcdsaExportActivation(args) {
-	return {
-		kind: "passkey_ecdsa_export_activation",
-		purpose: "explicit_key_export",
-		existingRoleLocalMaterial: args.existingRoleLocalMaterial,
-		relayerUrl: args.relayerUrl,
-		authorization: args.authorization
-	};
-}
-function toOptionalRuntimePolicyScope(policy) {
-	switch (policy.kind) {
-		case "default_policy": return;
-		case "scoped_policy": return policy.scope;
-	}
-	throw new Error("[SigningEngine][ecdsa] unsupported ECDSA activation policy");
-}
-function applyCommonActivationRequestFields(args, request) {
-	if (request.runtimeScopeBootstrap) args.runtimeScopeBootstrap = request.runtimeScopeBootstrap;
-	if (request.operationIntent) args.operationIntent = request.operationIntent;
-	const runtimePolicyScope = toOptionalRuntimePolicyScope(request.runtimePolicy);
-	if ("walletId" in args) {
-		if (typeof request.ttlMs === "number") args.ttlMs = request.ttlMs;
-		if (runtimePolicyScope) args.runtimePolicyScope = runtimePolicyScope;
-	}
-	return args;
-}
-function toEcdsaBootstrapLifecycleCommand(request) {
-	switch (request.kind) {
-		case "passkey_ecdsa_activation": return {
-			kind: "passkey_existing_session_activation",
-			request
-		};
-		case "email_otp_ecdsa_activation": return {
-			kind: "email_otp_existing_session_activation",
-			request
-		};
-	}
-	throw new Error("[SigningEngine][ecdsa] unsupported activation request");
-}
-function passkeyCredentialIdFromActivation(request) {
-	const credentialId = String(request.webauthnAuthentication.rawId || request.webauthnAuthentication.id || "").trim();
-	if (!credentialId) throw new Error("[SigningEngine][ecdsa] passkey activation requires credential identity");
-	return credentialId;
-}
-function toBootstrapEcdsaSessionRequest(request) {
-	const command = toEcdsaBootstrapLifecycleCommand(request);
-	switch (command.kind) {
-		case "passkey_existing_session_activation": return applyCommonActivationRequestFields({
-			kind: "passkey_fresh_ecdsa_bootstrap",
-			keyHandle: command.request.walletKey.keyHandle,
-			key: evmFamilyEcdsaWalletKeyToIdentity(command.request.walletKey),
-			lanePolicy: command.request.lanePolicy,
-			publicCapability: command.request.publicCapability,
-			existingRoleLocalMaterial: command.request.existingRoleLocalMaterial,
-			source: command.request.source,
-			relayerUrl: command.request.relayerUrl,
-			requestId: command.request.requestId,
-			passkeyCredentialIdB64u: passkeyCredentialIdFromActivation(command.request),
-			routeAuth: command.request.walletSessionRouteAuth
-		}, command.request);
-		case "email_otp_existing_session_activation": {
-			const common = {
-				kind: "email_otp_ecdsa_bootstrap",
-				keyHandle: command.request.walletKey.keyHandle,
-				key: evmFamilyEcdsaWalletKeyToIdentity(command.request.walletKey),
-				lanePolicy: command.request.lanePolicy,
-				publicCapability: command.request.publicCapability,
-				existingRoleLocalMaterial: command.request.existingRoleLocalMaterial,
-				source: "email_otp",
-				relayerUrl: command.request.relayerUrl,
-				emailOtpWorkerSessionHandle: command.request.emailOtpWorkerSessionHandle,
-				emailOtpAuthContext: command.request.emailOtpAuthContext
-			};
-			return command.request.preauthorizedSessionActivation ? applyCommonActivationRequestFields({
-				...common,
-				sessionActivation: command.request.preauthorizedSessionActivation
-			}, command.request) : applyCommonActivationRequestFields({
-				...common,
-				routeAuth: command.request.walletSessionRouteAuth
-			}, command.request);
-		}
-	}
-	throw new Error("[SigningEngine][ecdsa] unsupported activation request");
-}
-function toExplicitKeyExportEcdsaBootstrapRequest(request) {
-	return {
-		kind: "passkey_ecdsa_export_bootstrap",
-		purpose: "explicit_key_export",
-		existingRoleLocalMaterial: request.existingRoleLocalMaterial,
-		relayerUrl: request.relayerUrl,
-		authorization: request.authorization
-	};
-}
-async function persistEcdsaRoleLocalReadyRecordForBootstrap(args) {
-	const binding = args.bootstrap.thresholdEcdsaKeyRef.backendBinding;
-	if (!binding) throw new Error("[WarmSessionStore] threshold ECDSA bootstrap is missing its backend binding");
-	const record = roleLocalReadyRecordForPersistence(binding);
-	if (!record) return;
-	const persisted = await args.deps.persistEcdsaRoleLocalReadyRecord({
-		record,
-		storageKeyFacts: ecdsaRoleLocalReadyRecordStorageKeyFacts(record)
-	});
-	if (!persisted.ok) throw new Error(`[WarmSessionStore] threshold ECDSA role-local ready record persistence failed (${persisted.code}): ${persisted.message}`);
-}
-function roleLocalReadyRecordForPersistence(binding) {
-	switch (binding.materialKind) {
-		case "role_local_ready_state_blob": return binding.ecdsaRoleLocalReadyRecord;
-		case "role_local_worker_handle":
-		case "role_local_durable_public_anchor":
-		case "role_local_durable_sealed_ref":
-		case "metadata_only": return null;
-		default: {
-			const exhaustive = binding;
-			throw new Error(`[WarmSessionStore] unsupported threshold ECDSA backend binding: ${JSON.stringify(exhaustive)}`);
-		}
-	}
-}
-async function provisionThresholdEcdsaSessionFromBootstrapArgs(deps, request) {
-	const walletId = toWalletId(ecdsaBootstrapWalletId(request));
-	return await withThresholdEcdsaBootstrapQueue(deps.queueByWallet, walletId, async () => {
-		const bootstrap = await bootstrapEcdsaSessionValue(deps.activationDeps, request);
-		await persistEcdsaRoleLocalReadyRecordForBootstrap({
-			deps,
-			bootstrap
-		});
-		return bootstrap;
-	});
-}
-async function provisionThresholdEcdsaSession(deps, request) {
-	return await provisionThresholdEcdsaSessionFromBootstrapArgs(deps, toBootstrapEcdsaSessionRequest(request));
-}
-async function provisionPasskeyEcdsaExplicitExportSession(deps, request) {
-	return await bootstrapExplicitKeyExportEcdsaSessionValue(deps.activationDeps, toExplicitKeyExportEcdsaBootstrapRequest(request));
-}
-async function provisionEmailOtpEcdsaExplicitExportSession(deps, request) {
-	const bootstrapRequest = {
-		kind: "email_otp_ecdsa_export_bootstrap",
-		purpose: "explicit_key_export",
-		existingRoleLocalMaterial: request.existingRoleLocalMaterial,
-		relayerUrl: request.relayerUrl,
-		authorization: request.authorization
-	};
-	return await bootstrapEmailOtpExplicitExportEcdsaSessionValue(deps.activationDeps, bootstrapRequest);
-}
-//#endregion
-export { buildEcdsaExportActivation, buildEmailOtpExplicitExportEcdsaActivation, buildEmailOtpPerOperationReauthEcdsaActivation, buildEmailOtpPreauthorizedSessionBootstrapEcdsaActivation, buildEmailOtpRecoveredSessionEcdsaActivation, buildEmailOtpSessionBootstrapEcdsaActivation, provisionEmailOtpEcdsaExplicitExportSession, provisionPasskeyEcdsaExplicitExportSession, provisionThresholdEcdsaSession, provisionThresholdEcdsaSessionFromBootstrapArgs };
-
-//# sourceMappingURL=ecdsaSessionProvision.js.map

package/dist/esm/core/signingEngine/session/passkey/ecdsaWarmCapabilityBootstrap.js

@@ -1,147 +0,0 @@
-import { thresholdEcdsaChainTargetKey, toWalletId } from "../../interfaces/ecdsaChainTarget.js";
-import { SigningOperationIntent } from "../operationState/types.js";
-import { walletSessionFailureFromError } from "../lifecycle/walletSessionFailure.js";
-import { ensureSealedRefreshStartupParityForThresholdEcdsaBootstrap } from "../warmCapabilities/sealedRefreshParity.js";
-import { ecdsaBootstrapChainTarget, ecdsaBootstrapWalletId } from "./ecdsaBootstrap.js";
-import { provisionThresholdEcdsaSessionFromBootstrapArgs } from "./ecdsaSessionProvision.js";
-//#region src/core/signingEngine/session/passkey/ecdsaWarmCapabilityBootstrap.ts
-function createProvisionThresholdEcdsaSessionDeps(deps) {
-	return {
-		queueByWallet: deps.queueByWallet,
-		activationDeps: deps.activationDeps,
-		persistEcdsaRoleLocalReadyRecord: deps.persistEcdsaRoleLocalReadyRecord
-	};
-}
-function createNoPromptWarmSessionDeps(deps) {
-	return {
-		getWarmSession: (walletId) => deps.capabilityReader.getWarmSession(walletId),
-		discoverPersistedSessionsForWallet: deps.passkeyMpcSession.discoverPersistedSessionsForWallet.bind(deps.passkeyMpcSession)
-	};
-}
-function parityArgsFromBootstrapRequest(request) {
-	const walletId = ecdsaBootstrapWalletId(request);
-	const chainTarget = ecdsaBootstrapChainTarget(request);
-	if (request.source === "registration") return {
-		kind: "key_enrollment_bootstrap_parity",
-		walletId,
-		chainTarget
-	};
-	if (request.operationIntent === SigningOperationIntent.TransactionSign) return {
-		kind: "transaction_bootstrap_parity",
-		walletId,
-		chainTarget,
-		operationIntent: SigningOperationIntent.TransactionSign
-	};
-	if (request.kind === "email_otp_ecdsa_bootstrap") return {
-		kind: "email_otp_bootstrap_parity",
-		walletId,
-		chainTarget,
-		authMethod: "email_otp"
-	};
-	return {
-		kind: "default_bootstrap_parity",
-		walletId,
-		chainTarget
-	};
-}
-async function bootstrapDirectEcdsaRequest(deps, request) {
-	return await provisionThresholdEcdsaSessionFromBootstrapArgs(createProvisionThresholdEcdsaSessionDeps(deps), request);
-}
-function sealedRestoreFailureFromError(args) {
-	const errorMessage = args.error instanceof Error ? args.error.message : String(args.error || "unknown error");
-	return {
-		ok: false,
-		code: sealedRestoreFailureCodeFromError(args.error),
-		chainTargetKey: args.chainTargetKey,
-		errorMessage
-	};
-}
-function sealedRestoreFailureCodeFromError(error) {
-	const walletSessionFailure = walletSessionFailureFromError(error);
-	if (walletSessionFailure) switch (walletSessionFailure.kind) {
-		case "expired": return "sealed_record_expired";
-		case "exhausted": return "sealed_record_exhausted";
-		case "missing":
-		case "invalid":
-		case "unavailable": return "sealed_restore_failed";
-	}
-	switch (error && typeof error === "object" ? Reflect.get(error, "code") : void 0) {
-		case "expired": return "sealed_record_expired";
-		case "exhausted": return "sealed_record_exhausted";
-		default: return "sealed_restore_failed";
-	}
-}
-async function bootstrapReuseWarmEcdsaCapabilityNoPrompt(deps, walletId, request) {
-	const chainTarget = request.chainTarget;
-	const chainTargetKey = thresholdEcdsaChainTargetKey(chainTarget);
-	if ((await deps.getWarmSession(walletId)).capabilities.ed25519.state !== "ready") return {
-		ok: false,
-		code: "missing_exact_material",
-		chainTargetKey
-	};
-	try {
-		await deps.discoverPersistedSessionsForWallet({
-			kind: "discover_wallet_ecdsa_signing_sessions",
-			walletId,
-			ecdsaChainTargets: [chainTarget],
-			maxRecords: 1
-		});
-	} catch (error) {
-		console.warn("[SigningEngine][ecdsa] reuse warm sealed discovery failed", {
-			walletId,
-			chainTarget,
-			error: error instanceof Error ? error.message : String(error || "unknown error")
-		});
-		return sealedRestoreFailureFromError({
-			chainTargetKey,
-			error
-		});
-	}
-	return {
-		ok: false,
-		code: "missing_exact_material",
-		chainTargetKey
-	};
-}
-function reuseWarmEcdsaBootstrapFailureMessage(result) {
-	switch (result.code) {
-		case "missing_exact_material": return `[SigningEngine][ecdsa] reuse_warm_ecdsa_bootstrap requires restored passkey ECDSA material for ${result.chainTargetKey}`;
-		case "sealed_restore_failed": return `[SigningEngine][ecdsa] reuse_warm_ecdsa_bootstrap sealed restore failed for ${result.chainTargetKey}: ${result.errorMessage || "unknown error"}`;
-		case "sealed_record_expired": return `[SigningEngine][ecdsa] reuse_warm_ecdsa_bootstrap sealed record expired for ${result.chainTargetKey}`;
-		case "sealed_record_exhausted": return `[SigningEngine][ecdsa] reuse_warm_ecdsa_bootstrap sealed record exhausted for ${result.chainTargetKey}`;
-	}
-	return "[SigningEngine][ecdsa] reuse_warm_ecdsa_bootstrap failed";
-}
-function reuseWarmEcdsaBootstrapFailureToError(result) {
-	return new Error(reuseWarmEcdsaBootstrapFailureMessage(result));
-}
-async function bootstrapWarmEcdsaCapabilityResult(deps, request) {
-	await ensureSealedRefreshStartupParityForThresholdEcdsaBootstrap(deps.ensureSealedRefreshStartupParity, parityArgsFromBootstrapRequest(request));
-	const walletId = toWalletId(ecdsaBootstrapWalletId(request));
-	switch (request.kind) {
-		case "reuse_warm_ecdsa_bootstrap": {
-			const result = await bootstrapReuseWarmEcdsaCapabilityNoPrompt(createNoPromptWarmSessionDeps(deps), walletId, request);
-			if (result.ok) return {
-				ok: true,
-				bootstrap: result.bootstrap
-			};
-			return {
-				ok: false,
-				kind: "reuse_failed",
-				failure: result
-			};
-		}
-		case "passkey_fresh_ecdsa_bootstrap":
-		case "passkey_preauthorized_ecdsa_bootstrap":
-		case "wallet_session_reconnect_ecdsa_bootstrap":
-		case "email_otp_ecdsa_bootstrap": return {
-			ok: true,
-			bootstrap: await bootstrapDirectEcdsaRequest(deps, request)
-		};
-	}
-	throw new Error("[SigningEngine][ecdsa] unsupported warm bootstrap request");
-}
-//#endregion
-export { bootstrapWarmEcdsaCapabilityResult, reuseWarmEcdsaBootstrapFailureToError };
-
-//# sourceMappingURL=ecdsaWarmCapabilityBootstrap.js.map

package/dist/esm/core/signingEngine/session/passkey/ed25519Provisioner.js

@@ -1,55 +0,0 @@
-import { toAccountId } from "../../../types/accountIds.js";
-import { toWalletId } from "../../interfaces/ecdsaChainTarget.js";
-import { nearProtocolProjectionFromExactLane } from "../identity/exactSigningLaneIdentity.js";
-import { emitWarmSessionTransition, summarizeWarmSessionTransition } from "../warmCapabilities/transitions.js";
-//#region src/core/signingEngine/session/passkey/ed25519Provisioner.ts
-function toOptionalNonEmptyString(value) {
-	return String(value || "").trim() || void 0;
-}
-function assertPersistedEd25519WarmSessionRecord(args) {
-	const persistedSessionId = String(args.persistedSessionIdRaw || "").trim();
-	if (persistedSessionId === args.expectedThresholdSessionId) return;
-	throw new Error(`[WarmSessionStore] provisioned Ed25519 capability was not persisted for ${args.walletId} (expected thresholdSessionId=${args.expectedThresholdSessionId}, found=${persistedSessionId || "missing"})`);
-}
-function walletIdFromEd25519ProvisionArgs(args) {
-	if (args.kind === "exact_ed25519_provisioning") return toWalletId(nearProtocolProjectionFromExactLane(args.laneIdentity, "exact Ed25519 capability provisioning").walletId);
-	return toWalletId(args.walletId);
-}
-function nearAccountIdFromEd25519ProvisionArgs(args) {
-	return toAccountId(args.kind === "exact_ed25519_provisioning" ? nearProtocolProjectionFromExactLane(args.laneIdentity, "exact Ed25519 capability provisioning").nearAccountId : args.nearAccountId);
-}
-async function provisionWarmEd25519Capability(deps, args) {
-	const nearAccountId = nearAccountIdFromEd25519ProvisionArgs(args);
-	const walletId = walletIdFromEd25519ProvisionArgs(args);
-	if (!walletId) throw new Error("[WarmSessionStore] walletId is required to provision Ed25519 capability");
-	if (typeof deps.provisionThresholdEd25519Session !== "function") throw new Error("[WarmSessionStore] provisionThresholdEd25519Session is required to provision Ed25519 capability");
-	const beforeWarmSession = await deps.getWarmSession(walletId);
-	await args.beforeProvision?.();
-	args.assertNotCancelled?.();
-	const provisioned = await deps.provisionThresholdEd25519Session(args);
-	args.assertNotCancelled?.();
-	if (!provisioned.ok) return provisioned;
-	const expectedThresholdSessionId = toOptionalNonEmptyString(provisioned.thresholdSessionId);
-	if (!expectedThresholdSessionId) throw new Error(`[WarmSessionStore] provisioned Ed25519 capability is missing thresholdSessionId for ${nearAccountId}`);
-	const afterWarmSession = await deps.getWarmSession(walletId);
-	assertPersistedEd25519WarmSessionRecord({
-		walletId,
-		expectedThresholdSessionId,
-		persistedSessionIdRaw: afterWarmSession.capabilities.ed25519.runtime?.thresholdSessionId
-	});
-	emitWarmSessionTransition({
-		onTransition: deps.onTransition,
-		event: {
-			type: "ed25519_capability_provisioned",
-			walletId,
-			thresholdSessionId: expectedThresholdSessionId,
-			before: summarizeWarmSessionTransition(beforeWarmSession),
-			after: summarizeWarmSessionTransition(afterWarmSession)
-		}
-	});
-	return provisioned;
-}
-//#endregion
-export { provisionWarmEd25519Capability };
-
-//# sourceMappingURL=ed25519Provisioner.js.map