@seams/wallet 0.7.3 → 0.8.0

package/dist/esm/react/core/signingEngine/session/operationState/transactionState.js

@@ -1,106 +0,0 @@
-import { prepareThresholdSigningOperation } from "./preparedOperation.js";
-//#region src/core/signingEngine/session/operationState/transactionState.ts
-function classifyTransactionReadiness(state, readiness) {
-	return {
-		tag: "ReadinessClassified",
-		intent: state.intent,
-		lane: state.lane,
-		candidate: state.candidate,
-		availableLane: state.availableLane,
-		readiness
-	};
-}
-function prepareTransactionOperationFromReadiness(state) {
-	return {
-		intent: state.intent,
-		lane: state.lane,
-		readiness: state.readiness
-	};
-}
-async function prepareTransactionSigningOperation(args) {
-	let transactionLane = null;
-	let transactionIntent = null;
-	let transactionOperation = null;
-	const thresholdOperation = await prepareThresholdSigningOperation({
-		intent: thresholdIntentFromTransactionIntent(args.intent),
-		lifecycleAdapter: { prepare: async (input) => {
-			const lifecycle = await args.lifecycleAdapter.prepare({
-				intent: args.intent,
-				...input.operation ? { operation: input.operation } : {}
-			});
-			transactionLane = lifecycle.transactionLane;
-			transactionIntent = lifecycle.transactionIntent || args.intent;
-			return {
-				lane: lifecycle.lane,
-				readiness: lifecycle.readiness,
-				availableLanesGeneration: lifecycle.availableLanesGeneration,
-				forceFreshAuth: lifecycle.forceFreshAuth,
-				metadata: {
-					...lifecycle.metadata || {},
-					transactionLane: lifecycle.transactionLane,
-					transactionOperation: null
-				}
-			};
-		} },
-		coordinator: args.coordinator,
-		...args.operation ? { operation: args.operation } : {},
-		forceFreshAuth: args.forceFreshAuth,
-		sensitiveOperationPolicy: args.sensitiveOperationPolicy,
-		missingWhenExpiresAtMissing: args.missingWhenExpiresAtMissing,
-		onPlannerTrace: args.onPlannerTrace
-	});
-	if (!transactionLane) throw new Error("[SigningSession] transaction prepare did not return a transaction lane");
-	transactionOperation = {
-		intent: transactionIntent || args.intent,
-		lane: transactionLane,
-		readiness: transactionReadinessFromThresholdOperation(thresholdOperation)
-	};
-	thresholdOperation.metadata.transactionOperation = transactionOperation;
-	return {
-		thresholdOperation,
-		transactionOperation
-	};
-}
-function thresholdIntentFromTransactionIntent(intent) {
-	return {
-		kind: "transaction_sign",
-		chain: intent.chain,
-		curve: intent.curve,
-		walletId: String(intent.walletId),
-		reason: "transaction"
-	};
-}
-function transactionReadinessFromThresholdOperation(operation) {
-	const status = operation.readiness.status;
-	if (status === "ready") return {
-		status: "ready",
-		remainingUses: Math.max(0, Math.floor(Number(operation.remainingUses) || 0)),
-		expiresAtMs: Math.max(0, Math.floor(Number(operation.expiresAtMs) || 0))
-	};
-	if (status === "missing_session") return {
-		status: "status_unavailable",
-		reason: "missing_session"
-	};
-	if (status === "expired") return { status: "expired" };
-	if (status === "exhausted") return { status: "exhausted" };
-	if (status === "auth_unavailable") return {
-		status: "auth_unavailable",
-		reason: "auth_unavailable"
-	};
-	if (status === "status_unavailable") return {
-		status: "status_unavailable",
-		reason: "status_unavailable"
-	};
-	if (status === "status_unknown") return {
-		status: "status_unknown",
-		reason: "status_unknown"
-	};
-	return {
-		status: "policy_blocked",
-		reason: status
-	};
-}
-//#endregion
-export { classifyTransactionReadiness, prepareTransactionOperationFromReadiness, prepareTransactionSigningOperation };
-
-//# sourceMappingURL=transactionState.js.map

package/dist/esm/react/core/signingEngine/session/operationState/types.js

@@ -1,88 +0,0 @@
-import { parseEmailOtpChallengeId, parseThresholdEcdsaSessionId, parseThresholdEd25519SessionId } from "../../../../shared-ts/src/utils/domainIds.js";
-import { parseMpcWalletSigningQuotaId, parseWalletSessionId } from "../../../../shared-ts/src/authorization/capabilityKinds.js";
-import { signingLaneAuthMethod } from "../identity/signingLaneAuthBinding.js";
-//#region src/core/signingEngine/session/operationState/types.ts
-const SigningOperationIntent = { TransactionSign: "transaction_sign" };
-const SigningKeyRefIntentKind = {
-	Cached: "cached",
-	Reauth: "reauth"
-};
-const SigningSessionPlanKind = {
-	WarmSession: "warm_session",
-	EmailOtpReauth: "email_otp_reauth",
-	PasskeyReauth: "passkey_reauth",
-	NotReady: "not_ready",
-	OperationStepUp: "operation_step_up"
-};
-function toRequiredBrandedString(value, label) {
-	const normalized = String(value || "").trim();
-	if (!normalized) throw new Error(`[SigningSession] ${label} is required`);
-	return normalized;
-}
-function requireDomainId(result, label) {
-	if (!result.ok) throw new Error(`[SigningSession] ${result.error.message || `${label} is required`}`);
-	return result.value;
-}
-function requireAuthorizationId(result, label) {
-	if (!result.ok) throw new Error(`[SigningSession] ${result.error.message || `${label} is required`}`);
-	return result.value;
-}
-const SigningSessionIds = {
-	walletSession(value) {
-		return requireAuthorizationId(parseWalletSessionId(value), "walletSessionId");
-	},
-	walletSessionQuota(value) {
-		return requireAuthorizationId(parseMpcWalletSigningQuotaId(value), "quotaId");
-	},
-	thresholdEd25519Session(value) {
-		return requireDomainId(parseThresholdEd25519SessionId(value), "thresholdEd25519SessionId");
-	},
-	thresholdEcdsaSession(value) {
-		return requireDomainId(parseThresholdEcdsaSessionId(value), "thresholdEcdsaSessionId");
-	},
-	emailOtpChallenge(value) {
-		return requireDomainId(parseEmailOtpChallengeId(value), "emailOtpChallengeId");
-	},
-	signingOperation(value) {
-		return toRequiredBrandedString(value, "signingOperationId");
-	},
-	signingOperationFingerprint(value) {
-		return toRequiredBrandedString(value, "signingOperationFingerprint");
-	}
-};
-function summarizeSigningLane(lane) {
-	const signer = lane.identity.signer;
-	const summary = {
-		authMethod: signingLaneAuthMethod(lane.auth),
-		curve: lane.curve,
-		keyKind: lane.keyKind,
-		chainFamily: lane.chainFamily,
-		sessionOrigin: lane.sessionOrigin,
-		storageSource: lane.storageSource,
-		retention: lane.retention
-	};
-	switch (signer.kind) {
-		case "evm_family_ecdsa_signer": return {
-			...summary,
-			curve: "ecdsa",
-			walletId: signer.walletId
-		};
-		case "near_ed25519_signer": return {
-			...summary,
-			curve: "ed25519",
-			walletId: signer.account.wallet.walletId,
-			nearAccountId: signer.account.nearAccountId,
-			nearEd25519SigningKeyId: signer.nearEd25519SigningKeyId
-		};
-	}
-}
-function summarizeSigningSessionPlan(plan) {
-	return {
-		kind: plan.kind,
-		lane: summarizeSigningLane(plan.lane)
-	};
-}
-//#endregion
-export { SigningKeyRefIntentKind, SigningOperationIntent, SigningSessionIds, SigningSessionPlanKind, summarizeSigningLane, summarizeSigningSessionPlan };
-
-//# sourceMappingURL=types.js.map

package/dist/esm/react/core/signingEngine/session/passkey/ecdsaBootstrap.js

@@ -1,187 +0,0 @@
-import { SIGNER_AUTH_METHODS, SIGNER_SOURCES } from "../../../../shared-ts/src/utils/signerDomain.js";
-import { toWalletId } from "../../interfaces/ecdsaChainTarget.js";
-import { toEvmFamilyEcdsaKeyHandle } from "../identity/evmFamilyEcdsaIdentity.js";
-import { walletSessionAuthorizations } from "../../../indexedDB/seamsWalletDB/walletSessionAuthorizationStore.js";
-import { isEcdsaCredentialFreeSessionActivationAuthorization } from "../../threshold/ecdsa/postRegistrationSessionActivation.js";
-import { activateEcdsaSession, activateExplicitKeyExportEcdsaSession } from "../../threshold/ecdsa/activation.js";
-import { persistExactWalletSessionAuthorizationFromEcdsaBootstrap, validateExactWalletSessionAuthorityIdentity, validateExactWalletSessionAuthorization } from "../persistence/walletSessionAuthorizationProjection.js";
-//#region src/core/signingEngine/session/passkey/ecdsaBootstrap.ts
-function resolveRelayerUrl(relayerUrlOverride, defaultRelayerUrl) {
-	const relayerUrl = String(relayerUrlOverride || defaultRelayerUrl || "").trim();
-	if (!relayerUrl) throw new Error("Missing relayer url (configs.network.relayer.url)");
-	return relayerUrl;
-}
-function hasExactEcdsaBootstrapIdentity(request) {
-	return "key" in request && Boolean(request.key) && "keyHandle" in request && Boolean(String(request.keyHandle || "").trim());
-}
-function ecdsaBootstrapWalletId(request) {
-	return hasExactEcdsaBootstrapIdentity(request) ? request.key.walletId : request.walletId;
-}
-function ecdsaBootstrapChainTarget(request) {
-	return hasExactEcdsaBootstrapIdentity(request) ? request.lanePolicy.chainTarget : request.chainTarget;
-}
-function ecdsaBootstrapSignerAuth(request) {
-	if (request.kind === "email_otp_ecdsa_bootstrap") return {
-		authMethod: SIGNER_AUTH_METHODS.emailOtp,
-		signerSource: SIGNER_SOURCES.emailOtpRegistration
-	};
-	return {
-		authMethod: SIGNER_AUTH_METHODS.passkey,
-		signerSource: SIGNER_SOURCES.passkeyRegistration
-	};
-}
-function ecdsaBootstrapAuthorizationAuthority(request) {
-	switch (request.kind) {
-		case "passkey_preauthorized_ecdsa_bootstrap":
-		case "wallet_session_reconnect_ecdsa_bootstrap": return request.authorizationAuthority;
-		case "passkey_fresh_ecdsa_bootstrap":
-		case "email_otp_ecdsa_bootstrap": return request.existingRoleLocalMaterial.authority;
-	}
-}
-function validatePreauthorizedEcdsaBootstrapAuthority(args) {
-	if (!("sessionActivation" in args.request) || !args.request.sessionActivation) return;
-	const preauthorized = args.request.sessionActivation;
-	const activation = isEcdsaCredentialFreeSessionActivationAuthorization(preauthorized) ? preauthorized.activation : preauthorized;
-	const authorization = isEcdsaCredentialFreeSessionActivationAuthorization(preauthorized) ? preauthorized.authorization : {
-		record: preauthorized.session.wallet_session,
-		operationCredential: preauthorized.session.operation_credential
-	};
-	validateExactWalletSessionAuthorization({
-		walletId: args.walletId,
-		authority: args.authority,
-		walletSession: authorization.record,
-		operationCredential: authorization.operationCredential,
-		expectedAuthorizationId: activation.session.authorization_id,
-		expectedWalletSessionId: activation.session.wallet_session_id,
-		expectedQuotaId: activation.session.quota_id,
-		expectedExpiresAtMs: activation.session.expires_at_ms
-	});
-	if (args.request.kind === "passkey_preauthorized_ecdsa_bootstrap") validateExactWalletSessionAuthorityIdentity({
-		expected: args.request.authorizationIdentity,
-		walletSession: authorization.record
-	});
-}
-function toActivateEcdsaSessionRequest(request, relayerUrl) {
-	const exactSessionRequest = (exactRequest, walletSessionRouteAuth, auth) => {
-		return {
-			kind: "session_bootstrap",
-			purpose: "transaction_signing",
-			relayerUrl,
-			keyHandle: toEvmFamilyEcdsaKeyHandle(exactRequest.keyHandle),
-			key: exactRequest.key,
-			lanePolicy: exactRequest.lanePolicy,
-			publicCapability: exactRequest.publicCapability,
-			existingRoleLocalMaterial: exactRequest.existingRoleLocalMaterial,
-			...exactRequest.requestId ? { requestId: exactRequest.requestId } : {},
-			...auth,
-			...walletSessionRouteAuth ? { walletSessionRouteAuth } : {},
-			runtimeScopeBootstrap: exactRequest.runtimeScopeBootstrap
-		};
-	};
-	const preauthorizedExactSessionRequest = (exactRequest) => ({
-		kind: "session_bootstrap",
-		purpose: "transaction_signing",
-		relayerUrl,
-		keyHandle: toEvmFamilyEcdsaKeyHandle(exactRequest.keyHandle),
-		key: exactRequest.key,
-		lanePolicy: exactRequest.lanePolicy,
-		publicCapability: exactRequest.publicCapability,
-		existingRoleLocalMaterial: exactRequest.existingRoleLocalMaterial,
-		...exactRequest.requestId ? { requestId: exactRequest.requestId } : {},
-		authKind: "passkey",
-		passkeyCredentialIdB64u: exactRequest.passkeyCredentialIdB64u,
-		preauthorizedSessionActivation: exactRequest.sessionActivation,
-		runtimeScopeBootstrap: exactRequest.runtimeScopeBootstrap
-	});
-	switch (request.kind) {
-		case "passkey_fresh_ecdsa_bootstrap": return exactSessionRequest(request, request.routeAuth, {
-			authKind: "passkey",
-			passkeyCredentialIdB64u: request.passkeyCredentialIdB64u
-		});
-		case "passkey_preauthorized_ecdsa_bootstrap": return preauthorizedExactSessionRequest(request);
-		case "wallet_session_reconnect_ecdsa_bootstrap": return exactSessionRequest(request, request.routeAuth, {
-			authKind: "passkey",
-			passkeyCredentialIdB64u: request.passkeyCredentialIdB64u
-		});
-		case "email_otp_ecdsa_bootstrap": {
-			const auth = {
-				authKind: "email_otp",
-				emailOtpWorkerSessionHandle: request.emailOtpWorkerSessionHandle
-			};
-			return request.sessionActivation ? {
-				kind: "session_bootstrap",
-				purpose: "transaction_signing",
-				relayerUrl,
-				keyHandle: toEvmFamilyEcdsaKeyHandle(request.keyHandle),
-				key: request.key,
-				lanePolicy: request.lanePolicy,
-				publicCapability: request.publicCapability,
-				existingRoleLocalMaterial: request.existingRoleLocalMaterial,
-				...request.requestId ? { requestId: request.requestId } : {},
-				...auth,
-				preauthorizedSessionActivation: request.sessionActivation,
-				runtimeScopeBootstrap: request.runtimeScopeBootstrap
-			} : exactSessionRequest(request, request.routeAuth, auth);
-		}
-	}
-	throw new Error("[SigningEngine][ecdsa] unsupported ECDSA bootstrap request");
-}
-function toActivateExplicitKeyExportEcdsaSessionRequest(request, relayerUrl) {
-	return {
-		purpose: "explicit_key_export",
-		relayerUrl,
-		existingRoleLocalMaterial: request.existingRoleLocalMaterial,
-		authorization: request.authorization
-	};
-}
-function toActivateEmailOtpExplicitExportBootstrapSessionRequest(request, relayerUrl) {
-	return {
-		purpose: "explicit_key_export",
-		relayerUrl,
-		existingRoleLocalMaterial: request.existingRoleLocalMaterial,
-		authorization: request.authorization
-	};
-}
-async function bootstrapEcdsaSessionValue(deps, request) {
-	if (request.kind === "reuse_warm_ecdsa_bootstrap") throw new Error("[SigningEngine][ecdsa] reuse_warm bootstrap must resolve an existing exact material request before activation");
-	const authority = ecdsaBootstrapAuthorizationAuthority(request);
-	const walletId = toWalletId(ecdsaBootstrapWalletId(request));
-	const chainTarget = ecdsaBootstrapChainTarget(request);
-	const relayerUrl = resolveRelayerUrl(request.relayerUrl, deps.defaultRelayerUrl);
-	const signerWorkerCtx = deps.getSignerWorkerContext();
-	const activationDeps = {
-		touchIdPrompt: deps.touchIdPrompt,
-		workerCtx: signerWorkerCtx,
-		routerAbNormalSigning: deps.routerAbNormalSigning
-	};
-	validatePreauthorizedEcdsaBootstrapAuthority({
-		request,
-		walletId,
-		authority
-	});
-	const canonicalBootstrap = await activateEcdsaSession(activationDeps, toActivateEcdsaSessionRequest(request, relayerUrl));
-	const signerAuth = ecdsaBootstrapSignerAuth(request);
-	await deps.persistThresholdEcdsaBootstrapForWalletTarget({
-		walletId,
-		chainTarget,
-		bootstrap: canonicalBootstrap,
-		signerAuth
-	});
-	await request.beforeAuthorizationPersistence?.();
-	await persistExactWalletSessionAuthorizationFromEcdsaBootstrap(walletSessionAuthorizations, {
-		walletId,
-		authority,
-		bootstrap: canonicalBootstrap
-	});
-	return canonicalBootstrap;
-}
-async function bootstrapExplicitKeyExportEcdsaSessionValue(deps, request) {
-	return await activateExplicitKeyExportEcdsaSession(toActivateExplicitKeyExportEcdsaSessionRequest(request, resolveRelayerUrl(request.relayerUrl, deps.defaultRelayerUrl)));
-}
-async function bootstrapEmailOtpExplicitExportEcdsaSessionValue(deps, request) {
-	return await activateExplicitKeyExportEcdsaSession(toActivateEmailOtpExplicitExportBootstrapSessionRequest(request, resolveRelayerUrl(request.relayerUrl, deps.defaultRelayerUrl)));
-}
-//#endregion
-export { bootstrapEcdsaSessionValue, bootstrapEmailOtpExplicitExportEcdsaSessionValue, bootstrapExplicitKeyExportEcdsaSessionValue, ecdsaBootstrapChainTarget, ecdsaBootstrapWalletId };
-
-//# sourceMappingURL=ecdsaBootstrap.js.map

package/dist/esm/react/core/signingEngine/session/passkey/ecdsaKeyFactsInventory.js

@@ -1,206 +0,0 @@
-import { isObject } from "../../../../shared-ts/src/utils/validation.js";
-import { parseRouterAbEcdsaDerivationPublicCapabilityV1 } from "../../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
-import { SIGNER_AUTH_METHODS, SIGNER_KINDS } from "../../../../shared-ts/src/utils/signerDomain.js";
-import { thresholdEcdsaChainTargetFromRequest, thresholdEcdsaChainTargetKey, thresholdEcdsaChainTargetsEqual, walletIdFromWalletProfile } from "../../interfaces/ecdsaChainTarget.js";
-import { buildEvmFamilyEcdsaWalletKey, parseThresholdSigningRootBinding, resolveThresholdEcdsaKeyIdFromRecord, toEvmFamilyEcdsaKeyHandle, toThresholdEcdsaPublicKeyB64u } from "../identity/evmFamilyEcdsaIdentity.js";
-//#region src/core/signingEngine/session/passkey/ecdsaKeyFactsInventory.ts
-function normalizeEvmOwnerAddress(value) {
-	const candidate = String(value || "").trim().toLowerCase();
-	return /^0x[0-9a-f]{40}$/.test(candidate) ? candidate : "";
-}
-const EVM_FAMILY_ECDSA_KEY_HANDLE_PATTERN = /^ederivation-key-[A-Za-z0-9_-]+$/;
-function parseCurrentEcdsaKeyHandle(value) {
-	const normalized = String(value || "").trim();
-	if (!normalized) return { kind: "missing" };
-	if (!EVM_FAMILY_ECDSA_KEY_HANDLE_PATTERN.test(normalized)) return { kind: "invalid" };
-	return {
-		kind: "resolved",
-		keyHandle: normalized
-	};
-}
-function resolveProfileContinuityEcdsaKeyHandle(metadata) {
-	const directKeyHandle = parseCurrentEcdsaKeyHandle(metadata.keyHandle);
-	const sharedKeyHandle = isObject(metadata.sharedEvmFamilyKey) ? parseCurrentEcdsaKeyHandle(metadata.sharedEvmFamilyKey.keyHandle) : { kind: "missing" };
-	if (directKeyHandle.kind === "missing") return {
-		kind: "blocked",
-		reason: "missing_key_handle"
-	};
-	if (directKeyHandle.kind === "invalid" || sharedKeyHandle.kind === "invalid") return {
-		kind: "blocked",
-		reason: "invalid_key_handle"
-	};
-	if (sharedKeyHandle.kind === "resolved" && directKeyHandle.keyHandle !== sharedKeyHandle.keyHandle) return {
-		kind: "blocked",
-		reason: "duplicate_key_handles"
-	};
-	return {
-		kind: "resolved",
-		keyHandle: directKeyHandle.keyHandle
-	};
-}
-function parseProfileContinuityEvmFamilyEcdsaWalletKey(args) {
-	const keyFacts = (isObject(args.metadata.sharedEvmFamilyKey) ? args.metadata.sharedEvmFamilyKey : null) || args.metadata;
-	const thresholdEcdsaPublicKeyB64u = String(keyFacts.thresholdEcdsaPublicKeyB64u || args.metadata.thresholdEcdsaPublicKeyB64u || "").trim();
-	if (!thresholdEcdsaPublicKeyB64u) return null;
-	const keyWalletId = String(keyFacts.walletId || "").trim();
-	if (!keyWalletId) return null;
-	try {
-		toThresholdEcdsaPublicKeyB64u(thresholdEcdsaPublicKeyB64u);
-		const ecdsaThresholdKeyId = keyFacts.ecdsaThresholdKeyId || args.metadata.ecdsaThresholdKeyId;
-		const signingRootId = keyFacts.signingRootId || args.metadata.signingRootId;
-		const signingRootVersion = keyFacts.signingRootVersion || args.metadata.signingRootVersion;
-		const participantIds = keyFacts.participantIds || args.metadata.participantIds;
-		const thresholdOwnerAddress = keyFacts.thresholdOwnerAddress || args.metadata.thresholdOwnerAddress || args.metadata.ownerAddress;
-		return buildEvmFamilyEcdsaWalletKey({
-			walletId: keyWalletId,
-			keyHandle: args.keyHandle,
-			chainTarget: args.chainTarget,
-			ecdsaThresholdKeyId,
-			signingRootId,
-			signingRootVersion,
-			participantIds,
-			thresholdOwnerAddress,
-			thresholdEcdsaPublicKeyB64u
-		});
-	} catch {
-		return null;
-	}
-}
-function parseProfilePublicCapability(args) {
-	try {
-		const publicCapability = parseRouterAbEcdsaDerivationPublicCapabilityV1(args.raw);
-		if (String(publicCapability.client_id) !== String(args.walletId) || publicCapability.public_identity.threshold_public_key33_b64u !== args.thresholdEcdsaPublicKeyB64u) return null;
-		return publicCapability;
-	} catch {
-		return null;
-	}
-}
-function parseProfileContinuityEcdsaWarmKey(args) {
-	const signer = args.signer;
-	if (signer.status !== "active") return { kind: "skipped" };
-	if (signer.signerKind !== SIGNER_KINDS.thresholdEcdsa) return { kind: "skipped" };
-	if (signer.signerAuthMethod !== SIGNER_AUTH_METHODS.passkey) return { kind: "skipped" };
-	const metadata = isObject(signer.metadata) ? signer.metadata : {};
-	if (!isObject(metadata.chainTarget)) return {
-		kind: "blocked",
-		targetKey: "",
-		reason: "missing_chain_target"
-	};
-	let chainTarget;
-	try {
-		chainTarget = thresholdEcdsaChainTargetFromRequest(metadata.chainTarget);
-	} catch (error) {
-		return {
-			kind: "blocked",
-			targetKey: "",
-			reason: "invalid_chain_target"
-		};
-	}
-	if (!args.configuredTargets.some((target) => thresholdEcdsaChainTargetsEqual(target, chainTarget))) return { kind: "skipped" };
-	const targetKey = thresholdEcdsaChainTargetKey(chainTarget);
-	const keyHandleResolution = resolveProfileContinuityEcdsaKeyHandle(metadata);
-	if (keyHandleResolution.kind === "blocked") return {
-		kind: "blocked",
-		targetKey,
-		reason: keyHandleResolution.reason
-	};
-	const walletKey = parseProfileContinuityEvmFamilyEcdsaWalletKey({
-		walletId: args.walletId,
-		metadata,
-		keyHandle: keyHandleResolution.keyHandle,
-		chainTarget
-	});
-	if (!walletKey) return {
-		kind: "key_facts_inventory_required",
-		chainTarget,
-		targetKey,
-		keyHandle: keyHandleResolution.keyHandle,
-		reason: "missing_key_facts"
-	};
-	const publicCapability = parseProfilePublicCapability({
-		raw: metadata.publicCapability,
-		walletId: args.walletId,
-		thresholdEcdsaPublicKeyB64u: walletKey.keyFacts.thresholdEcdsaPublicKeyB64u
-	});
-	return {
-		kind: "active_wallet_key",
-		chainTarget,
-		targetKey,
-		walletKey,
-		publicCapability: publicCapability ? {
-			kind: "persisted_public_capability",
-			value: publicCapability
-		} : { kind: "missing_public_capability" }
-	};
-}
-function parseThresholdEcdsaKeyIdentityRecord(args) {
-	const { raw } = args;
-	if (!isObject(raw) || !isObject(raw.chainTarget)) return null;
-	const rawKey = isObject(raw.key) ? raw.key : raw;
-	let chainTarget;
-	try {
-		chainTarget = thresholdEcdsaChainTargetFromRequest(raw.chainTarget);
-	} catch {
-		return null;
-	}
-	const keyHandle = parseCurrentEcdsaKeyHandle(raw.keyHandle);
-	const nestedKeyHandle = parseCurrentEcdsaKeyHandle(rawKey.keyHandle);
-	const accountAddress = normalizeEvmOwnerAddress(raw.accountAddress);
-	const ownerAddress = normalizeEvmOwnerAddress(raw.ownerAddress);
-	const keyWalletId = String(rawKey.walletId || "").trim();
-	const rawKeySubjectId = String(rawKey.subjectId || "").trim();
-	const expectedKeySubjectId = String(walletIdFromWalletProfile({ walletId: args.walletId }));
-	const keyRpId = String(rawKey.rpId || "").trim();
-	const thresholdEcdsaPublicKeyB64u = String(rawKey.thresholdEcdsaPublicKeyB64u || raw.thresholdEcdsaPublicKeyB64u || "").trim();
-	const thresholdOwnerAddress = normalizeEvmOwnerAddress(rawKey.thresholdOwnerAddress || raw.ownerAddress || raw.accountAddress || raw.ethereumAddress);
-	if (keyHandle.kind !== "resolved" || nestedKeyHandle.kind !== "resolved" || nestedKeyHandle.keyHandle !== keyHandle.keyHandle || !thresholdEcdsaPublicKeyB64u || !ownerAddress || !accountAddress || !thresholdOwnerAddress || keyWalletId !== String(args.walletId) || rawKeySubjectId && rawKeySubjectId !== expectedKeySubjectId || keyRpId !== args.rpId || thresholdOwnerAddress !== ownerAddress) return null;
-	try {
-		const publicCapability = parseProfilePublicCapability({
-			raw: raw.publicCapability,
-			walletId: args.walletId,
-			thresholdEcdsaPublicKeyB64u
-		});
-		if (!publicCapability) return null;
-		const canonicalKeyHandle = toEvmFamilyEcdsaKeyHandle(keyHandle.keyHandle);
-		const ecdsaThresholdKeyId = resolveThresholdEcdsaKeyIdFromRecord({ record: { ecdsaThresholdKeyId: raw.ecdsaThresholdKeyId } });
-		const signingRootBinding = parseThresholdSigningRootBinding({
-			signingRootId: raw.signingRootId || rawKey.signingRootId,
-			signingRootVersion: raw.signingRootVersion || rawKey.signingRootVersion
-		});
-		return {
-			accountAddress,
-			ownerAddress,
-			publicCapability,
-			walletKey: buildEvmFamilyEcdsaWalletKey({
-				walletId: args.walletId,
-				keyHandle: canonicalKeyHandle,
-				chainTarget,
-				ecdsaThresholdKeyId,
-				signingRootId: signingRootBinding.signingRootId,
-				signingRootVersion: signingRootBinding.signingRootVersion,
-				participantIds: rawKey.participantIds || raw.participantIds,
-				thresholdOwnerAddress,
-				thresholdEcdsaPublicKeyB64u
-			})
-		};
-	} catch {
-		return null;
-	}
-}
-function parseThresholdEcdsaKeyIdentityTargets(args) {
-	const entries = [];
-	for (const raw of args.records) {
-		const parsed = parseThresholdEcdsaKeyIdentityRecord({
-			walletId: args.walletId,
-			rpId: args.rpId,
-			raw
-		});
-		if (!parsed) continue;
-		entries.push(parsed);
-	}
-	return entries;
-}
-//#endregion
-export { parseProfileContinuityEcdsaWarmKey, parseThresholdEcdsaKeyIdentityTargets };
-
-//# sourceMappingURL=ecdsaKeyFactsInventory.js.map

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

@@ -1,87 +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",
-		resolution
-	};
-	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