@seams/wallet-server 0.5.0

package/dist/esm/router/domains/passkeyCustody/walletRecoveryKeyManifest.js

@@ -0,0 +1,396 @@
+import { base64UrlDecode, base64UrlEncode } from "../../../shared-ts/src/utils/base64.js";
+import { parseDigestB64u } from "../../../shared-ts/src/utils/canonicalPrimitives.js";
+import { alphabetizeStringify, sha256BytesUtf8 } from "../../../shared-ts/src/utils/digests.js";
+import "../../../shared-ts/src/utils/encoders.js";
+import { sameRouterAbMpcMaterialActivationRef } from "../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
+import { deriveEvmFamilySigningKeySlotId } from "../../../shared-ts/src/signing-lanes/evmFamilySigningKeySlotId.js";
+import { sameRouterAbEcdsaDerivationPublicCapabilityV1, sameRouterAbEcdsaDerivationPublicIdentityV1, sameRouterAbEcdsaRegistrationActivationReceiptV1, sameRouterAbServerIdentityV1 } from "../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
+import { verifySecp256k1Bip340SignatureAgainstPublicKey33 } from "../../../core/ThresholdService/evmCryptoWasm.js";
+import "../../../shared-ts/src/signing-lanes/index.js";
+import { deriveWalletRecoveryKeyLifecycleId, parseRecoveryCodeReservationId } from "../../../shared-ts/src/wallet-recovery/recoveryCodeReservation.js";
+import { parseWalletRecoveryEcdsaPossessionChallengeV1, walletRecoveryEcdsaPossessionChallengeDigestB64uV1 } from "../../../shared-ts/src/wallet-recovery/walletRecoveryEcdsaPossession.js";
+//#region src/router/domains/passkeyCustody/walletRecoveryKeyManifest.ts
+/**
+* Builds the ECDSA possession challenges from server-owned recovery state.
+* The nonce is derived from the stored WebAuthn challenge, so finalization can
+* reconstruct the exact challenge without accepting another client field.
+*/
+async function buildWalletRecoveryEcdsaPossessionChallengesV1(input) {
+	const challenges = /* @__PURE__ */ new Map();
+	for (const entry of input.manifest.entries) {
+		if (entry.kind !== "evm_family_ecdsa") continue;
+		const publicCapabilityDigestB64u = parseDigestB64u(base64UrlEncode(await sha256BytesUtf8(alphabetizeStringify(entry.publicCapability))));
+		const serverNonceB64u = parseDigestB64u(base64UrlEncode(await sha256BytesUtf8(`seams:wallet-recovery-ecdsa-server-nonce:v1|${input.challengeB64u}|${entry.keySetId}`)));
+		challenges.set(entry.keySetId, {
+			kind: "wallet_recovery_ecdsa_possession_challenge_v1",
+			walletId: String(input.walletId),
+			reservationId: String(input.reservationId),
+			replacementId: input.replacementId,
+			keySetId: entry.keySetId,
+			keyHandle: entry.keyHandle,
+			recordedKeyManifestDigestB64u: parseDigestB64u(entry.recordedKeyManifestDigestB64u),
+			publicCapabilityDigestB64u,
+			authorityRefDigestB64u: parseDigestB64u(input.sourceAuthorityDigestB64u),
+			derivationClientSharePublicKey33B64u: entry.publicCapability.public_identity.derivation_client_share_public_key33_b64u,
+			expectedServerGeneration: entry.activationReceipt.server_generation,
+			expiresAtMs: input.expiresAtMs,
+			serverNonceB64u
+		});
+	}
+	return challenges;
+}
+async function resolveWalletRecoveryKeyManifestV1(input) {
+	const [ed25519Signers, ecdsaSigners] = await Promise.all([input.registry.listEd25519SignersForWallet({ walletId: input.walletId }), input.registry.listEcdsaSignersForWallet({ walletId: input.walletId })]);
+	const entries = [...ed25519ManifestEntries(ed25519Signers), ...ecdsaManifestEntries(ecdsaSigners)];
+	if (entries.length === 0) throw new Error("wallet recovery has no registered key capabilities");
+	return {
+		version: "wallet_recovery_key_manifest_v1",
+		walletId: input.walletId,
+		entries
+	};
+}
+function projectWalletRecoveryPreparationKeyManifestV1(manifest, possessionChallenges) {
+	return {
+		version: "wallet_recovery_preparation_key_manifest_v1",
+		walletId: manifest.walletId,
+		entries: manifest.entries.map((entry) => projectWalletRecoveryPreparationEntryV1(entry, possessionChallenges))
+	};
+}
+function projectWalletUnlockKeyManifestV1(manifest) {
+	return {
+		version: "wallet_custody_unlock_key_manifest_v1",
+		walletId: manifest.walletId,
+		entries: manifest.entries.map(projectWalletUnlockEntryV1)
+	};
+}
+function projectWalletUnlockEntryV1(entry) {
+	switch (entry.kind) {
+		case "near_ed25519": return {
+			kind: entry.kind,
+			keySetId: entry.keySetId,
+			signerId: entry.signerId,
+			nearAccountId: entry.nearAccountId,
+			nearEd25519SigningKeyId: entry.nearEd25519SigningKeyId,
+			signerSlot: entry.recoveryBasis.applicationBinding.key_creation_signer_slot,
+			registeredPublicKeyB64u: entry.registeredPublicKeyB64u,
+			recordedKeyManifestDigestB64u: entry.recordedKeyManifestDigestB64u,
+			activeCapabilityBinding: [...entry.recoveryBasis.activeCapabilityBinding]
+		};
+		case "evm_family_ecdsa": return {
+			kind: entry.kind,
+			keySetId: entry.keySetId,
+			keyHandle: entry.keyHandle,
+			evmFamilySigningKeySlotId: entry.evmFamilySigningKeySlotId,
+			recordedKeyManifestDigestB64u: entry.recordedKeyManifestDigestB64u,
+			clientRootPublicKey33B64u: entry.clientRootPublicKey33B64u,
+			applicationBindingDigestB64u: entry.publicCapability.context.application_binding_digest_b64u,
+			chainTargetKeys: [...entry.chainTargetKeys]
+		};
+	}
+}
+function projectWalletRecoveryPreparationEntryV1(entry, possessionChallenges) {
+	switch (entry.kind) {
+		case "near_ed25519": return {
+			kind: entry.kind,
+			keySetId: entry.keySetId,
+			signerId: entry.signerId,
+			nearAccountId: entry.nearAccountId,
+			recordedKeyManifestDigestB64u: entry.recordedKeyManifestDigestB64u,
+			recoveryBasis: {
+				capabilityKind: entry.recoveryBasis.capabilityKind,
+				activeCapabilityBinding: [...entry.recoveryBasis.activeCapabilityBinding],
+				scope: projectEd25519LifecycleScope(entry.recoveryBasis.scope),
+				applicationBinding: projectEd25519ApplicationBinding(entry.recoveryBasis.applicationBinding),
+				participantIds: [entry.recoveryBasis.participantIds[0], entry.recoveryBasis.participantIds[1]],
+				registeredPublicKey: [...entry.recoveryBasis.registeredPublicKey],
+				runtimePolicyScope: projectRuntimePolicyScope(entry.recoveryBasis.runtimePolicyScope),
+				activationTranscript: [...entry.recoveryBasis.activationTranscript],
+				activationStateEpoch: entry.recoveryBasis.activationStateEpoch,
+				signingWorkerVerifyingShare: [...entry.recoveryBasis.signingWorkerVerifyingShare]
+			}
+		};
+		case "evm_family_ecdsa": {
+			const possessionChallenge = possessionChallenges.get(entry.keySetId);
+			if (!possessionChallenge) throw new Error(`wallet recovery ECDSA possession challenge is missing for ${entry.keySetId}`);
+			return {
+				kind: entry.kind,
+				keySetId: entry.keySetId,
+				keyHandle: entry.keyHandle,
+				evmFamilySigningKeySlotId: entry.evmFamilySigningKeySlotId,
+				recordedKeyManifestDigestB64u: entry.recordedKeyManifestDigestB64u,
+				recoveryBasis: {
+					publicCapability: entry.publicCapability,
+					activationReceipt: entry.activationReceipt,
+					serverGeneration: entry.activationReceipt.server_generation,
+					clientRootPublicKey33B64u: entry.clientRootPublicKey33B64u,
+					chainTargets: entry.chainTargets.map(projectThresholdEcdsaChainTarget),
+					ecdsaThresholdKeyId: entry.ecdsaThresholdKeyId,
+					signingRootId: entry.signingRootId,
+					signingRootVersion: entry.signingRootVersion,
+					runtimePolicyScope: projectRuntimePolicyScope(entry.runtimePolicyScope),
+					participantIds: [entry.participantIds[0], entry.participantIds[1]],
+					possessionChallenge
+				}
+			};
+		}
+	}
+}
+function projectEd25519LifecycleScope(scope) {
+	return {
+		lifecycle_id: scope.lifecycle_id,
+		root_share_epoch: scope.root_share_epoch,
+		account_id: scope.account_id,
+		threshold_session_id: scope.threshold_session_id,
+		signer_set_id: scope.signer_set_id,
+		signing_worker_id: scope.signing_worker_id,
+		material_activation: projectMaterialActivation(scope.material_activation)
+	};
+}
+function projectMaterialActivation(materialActivation) {
+	return {
+		kind: materialActivation.kind,
+		activation_id: materialActivation.activation_id,
+		capability: materialActivation.capability,
+		material_owner: materialActivation.material_owner,
+		key_binding: materialActivation.key_binding,
+		lifecycle_binding: materialActivation.lifecycle_binding,
+		signing_worker: materialActivation.signing_worker
+	};
+}
+function projectEd25519ApplicationBinding(applicationBinding) {
+	return {
+		wallet_id: applicationBinding.wallet_id,
+		near_ed25519_signing_key_id: applicationBinding.near_ed25519_signing_key_id,
+		signing_root_id: applicationBinding.signing_root_id,
+		key_creation_signer_slot: applicationBinding.key_creation_signer_slot
+	};
+}
+function projectRuntimePolicyScope(scope) {
+	return {
+		orgId: scope.orgId,
+		projectId: scope.projectId,
+		envId: scope.envId,
+		signingRootVersion: scope.signingRootVersion
+	};
+}
+function projectThresholdEcdsaChainTarget(target) {
+	return { ...target };
+}
+async function verifyWalletRecoveryKeyActivationsV1(input) {
+	let recoveryReservationId;
+	try {
+		recoveryReservationId = parseRecoveryCodeReservationId(input.recoveryCorrelationId);
+	} catch {
+		return refused("wallet recovery activation correlation is missing");
+	}
+	let manifest;
+	try {
+		manifest = await resolveWalletRecoveryKeyManifestV1({
+			registry: input.registry,
+			walletId: input.walletId
+		});
+	} catch (error) {
+		return refused(errorMessage(error, "wallet recovery key manifest is unavailable"));
+	}
+	let ecdsaSigners;
+	try {
+		ecdsaSigners = await input.registry.listEcdsaSignersForWallet({ walletId: input.walletId });
+	} catch (error) {
+		return refused(errorMessage(error, "wallet recovery ECDSA signer state is unavailable"));
+	}
+	const ecdsaEntryCount = manifest.entries.filter((entry) => entry.kind === "evm_family_ecdsa").length;
+	if (input.ecdsaPossessionChallenges.length !== ecdsaEntryCount || input.ecdsaActivationReceipts.length !== ecdsaEntryCount || input.ecdsaMaterialPossessionProofs.length !== ecdsaEntryCount) return refused("wallet recovery ECDSA possession set does not match the key manifest");
+	for (const entry of manifest.entries) {
+		const keyLifecycleId = await deriveWalletRecoveryKeyLifecycleId({
+			reservationId: recoveryReservationId,
+			keySetId: entry.keySetId
+		});
+		switch (entry.kind) {
+			case "near_ed25519": {
+				const failure = verifyEd25519RecoveryActivation(entry, keyLifecycleId);
+				if (failure) return refused(failure);
+				break;
+			}
+			case "evm_family_ecdsa": {
+				const pending = await input.registry.listEcdsaPendingSessionActivationsForLifecycle({
+					walletId: input.walletId,
+					lifecycleId: keyLifecycleId
+				});
+				const currentSigners = ecdsaSigners.filter((signer) => signer.walletKey.keyHandle === entry.keyHandle);
+				if (currentSigners.length === 0) return refused(`wallet recovery has no ECDSA signer rows for ${entry.keySetId}`);
+				if (currentSigners.some((signer) => !sameRouterAbEcdsaDerivationPublicCapabilityV1(signer.walletKey.publicCapability, entry.publicCapability) || !sameRouterAbEcdsaRegistrationActivationReceiptV1(signer.activationReceipt, entry.activationReceipt) || !ecdsaActivationReceiptMatchesCapability({
+					walletId: input.walletId,
+					activationReceipt: signer.activationReceipt,
+					publicCapability: signer.walletKey.publicCapability
+				}))) return refused(`wallet recovery ECDSA signer rows changed for ${entry.keySetId}`);
+				if (pending.length > 0) return refused(`wallet recovery has stale ECDSA activation receipts for ${entry.keySetId}`);
+				const failure = await verifyEcdsaMaterialPossessionActivation({
+					entry,
+					walletId: input.walletId,
+					reservationId: recoveryReservationId,
+					replacementId: input.replacementId,
+					authorityRef: input.authorityRef,
+					challenges: input.ecdsaPossessionChallenges,
+					activationReceipts: input.ecdsaActivationReceipts,
+					proofs: input.ecdsaMaterialPossessionProofs,
+					nowMs: input.nowMs
+				});
+				if (failure) return refused(failure);
+				break;
+			}
+		}
+	}
+	return {
+		kind: "verified",
+		keySetIds: manifest.entries.map(manifestEntryKeySetId)
+	};
+}
+function ed25519ManifestEntries(signers) {
+	const seen = /* @__PURE__ */ new Set();
+	const entries = [];
+	for (const signer of signers) {
+		if (seen.has(signer.signerId)) throw new Error(`wallet has duplicate Ed25519 signer ${signer.signerId}`);
+		seen.add(signer.signerId);
+		entries.push({
+			kind: "near_ed25519",
+			keySetId: `near_ed25519:${signer.signerId}`,
+			signerId: signer.signerId,
+			nearAccountId: signer.nearAccountId,
+			nearEd25519SigningKeyId: signer.nearEd25519SigningKeyId,
+			publicKey: signer.publicKey,
+			registeredPublicKeyB64u: base64UrlEncode(Uint8Array.from(signer.activeYaoCapability.activationResult.public_receipt.registered_public_key)),
+			recordedKeyManifestDigestB64u: signer.custodyKeyManifestDigestB64u,
+			recoveryBasis: recoveryBasisFromEd25519Signer(signer)
+		});
+	}
+	return entries.sort(compareManifestEntries);
+}
+function ecdsaManifestEntries(signers) {
+	const byKeyHandle = /* @__PURE__ */ new Map();
+	for (const signer of signers) {
+		const keyHandle = signer.walletKey.keyHandle;
+		if (!ecdsaActivationReceiptMatchesCapability({
+			walletId: signer.walletId,
+			activationReceipt: signer.activationReceipt,
+			publicCapability: signer.walletKey.publicCapability
+		})) throw new Error(`wallet has invalid ECDSA activation receipt ${keyHandle}`);
+		const current = byKeyHandle.get(keyHandle);
+		if (!current) {
+			byKeyHandle.set(keyHandle, {
+				signer,
+				chainTargets: [signer.chainTarget],
+				chainTargetKeys: [signer.chainTargetKey]
+			});
+			continue;
+		}
+		if (!sameRouterAbEcdsaDerivationPublicCapabilityV1(current.signer.walletKey.publicCapability, signer.walletKey.publicCapability) || !sameRouterAbEcdsaRegistrationActivationReceiptV1(current.signer.activationReceipt, signer.activationReceipt)) throw new Error(`wallet has conflicting ECDSA activation state ${keyHandle}`);
+		if (!current.chainTargetKeys.includes(signer.chainTargetKey)) {
+			current.chainTargetKeys.push(signer.chainTargetKey);
+			current.chainTargets.push(signer.chainTarget);
+		}
+	}
+	const entries = [];
+	for (const [keyHandle, current] of byKeyHandle) entries.push({
+		kind: "evm_family_ecdsa",
+		keySetId: `evm_family_ecdsa:${keyHandle}`,
+		keyHandle,
+		evmFamilySigningKeySlotId: deriveEvmFamilySigningKeySlotId({
+			walletId: current.signer.walletId,
+			signingRootId: current.signer.walletKey.signingRootId,
+			signingRootVersion: current.signer.walletKey.signingRootVersion
+		}),
+		recordedKeyManifestDigestB64u: current.signer.custodyKeyManifestDigestB64u,
+		clientRootPublicKey33B64u: current.signer.custodyClientRootPublicKey33B64u,
+		publicCapability: current.signer.walletKey.publicCapability,
+		activationReceipt: current.signer.activationReceipt,
+		chainTargets: current.chainTargets.map(projectThresholdEcdsaChainTarget),
+		chainTargetKeys: current.chainTargetKeys.sort(),
+		ecdsaThresholdKeyId: current.signer.walletKey.ecdsaThresholdKeyId,
+		signingRootId: current.signer.walletKey.signingRootId,
+		signingRootVersion: current.signer.walletKey.signingRootVersion,
+		runtimePolicyScope: current.signer.runtimePolicyScope,
+		participantIds: [current.signer.walletKey.participantIds[0], current.signer.walletKey.participantIds[1]]
+	});
+	return entries.sort(compareManifestEntries);
+}
+function compareManifestEntries(left, right) {
+	return left.keySetId.localeCompare(right.keySetId);
+}
+function manifestEntryKeySetId(entry) {
+	return entry.keySetId;
+}
+function recoveryBasisFromEd25519Signer(signer) {
+	const capability = signer.activeYaoCapability;
+	const receipt = capability.activationResult.public_receipt;
+	return {
+		capabilityKind: capability.version === "wallet_ed25519_yao_registration_capability_v1" ? "registration" : "recovery",
+		activeCapabilityBinding: [...capability.activeCapabilityBinding],
+		activeMaterialActivation: receipt.material_activation,
+		scope: capability.admissionRequest.scope,
+		applicationBinding: capability.admissionRequest.application_binding,
+		participantIds: [capability.admissionRequest.participant_ids[0], capability.admissionRequest.participant_ids[1]],
+		registeredPublicKey: [...receipt.registered_public_key],
+		runtimePolicyScope: capability.runtimePolicyScope,
+		activationTranscript: [...receipt.transcript],
+		activationStateEpoch: receipt.state_epoch,
+		signingWorkerVerifyingShare: [...receipt.signing_worker_verifying_share]
+	};
+}
+function verifyEd25519RecoveryActivation(entry, keyLifecycleId) {
+	const recoveryBasis = entry.recoveryBasis;
+	if (recoveryBasis.capabilityKind !== "recovery") return `wallet recovery has no fresh Ed25519 activation for ${entry.keySetId}`;
+	if (recoveryBasis.scope.lifecycle_id !== keyLifecycleId) return `wallet recovery Ed25519 activation correlation does not match ${entry.keySetId}`;
+	if (recoveryBasis.applicationBinding.near_ed25519_signing_key_id !== entry.nearEd25519SigningKeyId) return `wallet recovery Ed25519 identity changed for ${entry.keySetId}`;
+	return null;
+}
+async function verifyEcdsaMaterialPossessionActivation(input) {
+	const challenge = input.challenges.find((candidate) => candidate.keySetId === input.entry.keySetId);
+	if (!challenge || input.challenges.filter((candidate) => candidate.keySetId === input.entry.keySetId).length !== 1) return `wallet recovery ECDSA possession challenge is missing for ${input.entry.keySetId}`;
+	if (challenge.expiresAtMs <= input.nowMs) return `wallet recovery ECDSA possession challenge expired for ${input.entry.keySetId}`;
+	const proof = input.proofs.find((candidate) => candidate.keySetId === input.entry.keySetId);
+	if (!proof || input.proofs.filter((candidate) => candidate.keySetId === input.entry.keySetId).length !== 1) return `wallet recovery ECDSA possession proof is missing for ${input.entry.keySetId}`;
+	const activationReceipt = input.activationReceipts.find((candidate) => candidate.keySetId === input.entry.keySetId)?.activationReceipt;
+	if (!activationReceipt || input.activationReceipts.filter((candidate) => candidate.keySetId === input.entry.keySetId).length !== 1 || !sameRouterAbEcdsaRegistrationActivationReceiptV1(activationReceipt, input.entry.activationReceipt)) return `wallet recovery ECDSA activation receipt changed for ${input.entry.keySetId}`;
+	const expectedPublicCapabilityDigestB64u = parseDigestB64u(base64UrlEncode(await sha256BytesUtf8(alphabetizeStringify(input.entry.publicCapability))));
+	if (!sameWalletRecoveryEcdsaPossessionChallengeV1(parseWalletRecoveryEcdsaPossessionChallengeV1({
+		...challenge,
+		walletId: String(input.walletId),
+		reservationId: String(input.reservationId),
+		replacementId: input.replacementId,
+		keySetId: input.entry.keySetId,
+		keyHandle: input.entry.keyHandle,
+		recordedKeyManifestDigestB64u: input.entry.recordedKeyManifestDigestB64u,
+		publicCapabilityDigestB64u: expectedPublicCapabilityDigestB64u,
+		authorityRefDigestB64u: String(input.authorityRef.authorityDigest),
+		derivationClientSharePublicKey33B64u: input.entry.publicCapability.public_identity.derivation_client_share_public_key33_b64u,
+		expectedServerGeneration: input.entry.activationReceipt.server_generation
+	}), challenge)) return `wallet recovery ECDSA possession challenge changed for ${input.entry.keySetId}`;
+	const challengeDigest = await walletRecoveryEcdsaPossessionChallengeDigestB64uV1(challenge);
+	try {
+		await verifySecp256k1Bip340SignatureAgainstPublicKey33(base64UrlDecode(challengeDigest), base64UrlDecode(proof.proof.signature64B64u), base64UrlDecode(challenge.derivationClientSharePublicKey33B64u));
+	} catch {
+		return `wallet recovery ECDSA possession proof is invalid for ${input.entry.keySetId}`;
+	}
+	if (input.proofs.length !== input.challenges.length) return "wallet recovery ECDSA possession proof set is incomplete";
+	return null;
+}
+function ecdsaActivationReceiptMatchesCapability(input) {
+	const activation = input.activationReceipt.ecdsa_activation;
+	return input.publicCapability.client_id === String(input.walletId) && input.publicCapability.material_activation.material_owner === String(input.walletId) && activation.activation_epoch === input.publicCapability.activation_epoch && activation.context.application_binding_digest_b64u === input.publicCapability.context.application_binding_digest_b64u && sameRouterAbEcdsaDerivationPublicIdentityV1(activation.public_identity, input.publicCapability.public_identity) && sameRouterAbServerIdentityV1(activation.signing_worker, input.publicCapability.signer_set.selected_server) && sameRouterAbMpcMaterialActivationRef(activation.material_activation, input.publicCapability.material_activation);
+}
+function sameWalletRecoveryEcdsaPossessionChallengeV1(left, right) {
+	return left.kind === right.kind && left.walletId === right.walletId && left.reservationId === right.reservationId && left.replacementId === right.replacementId && left.keySetId === right.keySetId && left.keyHandle === right.keyHandle && left.recordedKeyManifestDigestB64u === right.recordedKeyManifestDigestB64u && left.publicCapabilityDigestB64u === right.publicCapabilityDigestB64u && left.authorityRefDigestB64u === right.authorityRefDigestB64u && left.derivationClientSharePublicKey33B64u === right.derivationClientSharePublicKey33B64u && left.expectedServerGeneration === right.expectedServerGeneration && left.expiresAtMs === right.expiresAtMs && left.serverNonceB64u === right.serverNonceB64u;
+}
+function refused(reason) {
+	return {
+		kind: "refused",
+		reason
+	};
+}
+function errorMessage(error, fallback) {
+	return error instanceof Error && error.message ? error.message : fallback;
+}
+//#endregion
+export { buildWalletRecoveryEcdsaPossessionChallengesV1, projectWalletRecoveryPreparationKeyManifestV1, projectWalletUnlockKeyManifestV1, resolveWalletRecoveryKeyManifestV1, verifyWalletRecoveryKeyActivationsV1 };
+
+//# sourceMappingURL=walletRecoveryKeyManifest.js.map

package/dist/esm/router/domains/passkeyCustody/walletRecoveryRotation.js

@@ -0,0 +1,87 @@
+import { buildWalletCustodySeedRecoveryEntry, buildWalletRecoveryEnvelopeSetRecord, buildWalletRecoveryManifestKekWrap, parseWalletRecoveryEnvelopeSetRecord } from "../../../shared-ts/src/wallet-recovery/walletRecoveryEnvelopeSet.js";
+//#region src/router/domains/passkeyCustody/walletRecoveryRotation.ts
+function buildReplacementRecord(input) {
+	const manifestKekWraps = input.replacement.manifestKekWraps.map((wrap) => buildWalletRecoveryManifestKekWrap({
+		recoveryKeyId: wrap.recoveryKeyId,
+		nonceB64u: wrap.nonceB64u,
+		wrappedManifestKekB64u: wrap.ciphertextB64u,
+		aadHashB64u: wrap.aadHashB64u,
+		lifecycle: {
+			state: "active",
+			issuedAtMs: input.nowMs
+		}
+	}));
+	return buildWalletRecoveryEnvelopeSetRecord({
+		walletId: input.walletId,
+		manifestKekWraps,
+		entries: [buildWalletCustodySeedRecoveryEntry({
+			nonceB64u: input.replacement.entry.nonceB64u,
+			wrappedCustodySecretB64u: input.replacement.entry.wrappedCustodySecretB64u,
+			aadHashB64u: input.replacement.entry.aadHashB64u
+		})],
+		issuedAtMs: input.nowMs,
+		updatedAtMs: input.nowMs
+	});
+}
+async function rotateWalletRecoveryCodesV1(input) {
+	const stored = await input.store.readRecoveryEnvelopeSet(input.walletId);
+	if (!stored) return { kind: "no_recovery_set" };
+	if (stored.storeVersion !== input.expectedStoreVersion) return { kind: "conflict" };
+	if (input.nowMs <= Number(stored.record.issuedAtMs)) return {
+		kind: "rejected",
+		reason: "a rotation must be newer than the issuance it replaces"
+	};
+	if (String(input.replacement.walletId) !== String(input.walletId)) return {
+		kind: "rejected",
+		reason: "replacement recovery set names a different wallet"
+	};
+	if (input.recoveryCodeLocators.length !== input.replacement.manifestKekWraps.length) return {
+		kind: "rejected",
+		reason: "recovery code locators do not match the recovery wraps"
+	};
+	const locatorValues = /* @__PURE__ */ new Set();
+	for (const [index, locator] of input.recoveryCodeLocators.entries()) {
+		const wrap = input.replacement.manifestKekWraps[index];
+		if (!wrap || String(locator.walletId) !== String(input.walletId) || String(locator.recoveryKeyId) !== String(wrap.recoveryKeyId) || locatorValues.has(String(locator.locatorB64u))) return {
+			kind: "rejected",
+			reason: "recovery code locators do not match the recovery wraps"
+		};
+		locatorValues.add(String(locator.locatorB64u));
+	}
+	let next;
+	try {
+		next = buildReplacementRecord({
+			walletId: input.walletId,
+			replacement: input.replacement,
+			nowMs: input.nowMs
+		});
+		parseWalletRecoveryEnvelopeSetRecord(next, {
+			expectedWalletId: input.walletId,
+			label: "walletRecoveryEnvelopeSetRotation"
+		});
+	} catch (error) {
+		return {
+			kind: "rejected",
+			reason: error instanceof Error ? error.message : "the replacement recovery set is invalid"
+		};
+	}
+	const written = await input.store.replaceRecoveryEnvelopeSetAndPreserveBackupAcknowledgement({
+		record: next,
+		expectedRecoverySetVersion: stored.storeVersion,
+		recoveryCodeLocators: input.recoveryCodeLocators
+	});
+	if (written.kind === "conflict") return { kind: "conflict" };
+	if (written.kind === "collision") return {
+		kind: "rejected",
+		reason: "recovery code locator already exists"
+	};
+	return {
+		kind: "rotated",
+		issuedAtMs: input.nowMs,
+		storeVersion: written.storeVersion
+	};
+}
+//#endregion
+export { rotateWalletRecoveryCodesV1 };
+
+//# sourceMappingURL=walletRecoveryRotation.js.map

package/dist/esm/router/domains/signingOperations/ed25519AuthorizedOperationReceipt.js

@@ -0,0 +1,89 @@
+import { parseDigestB64u } from "../../../shared-ts/src/utils/canonicalPrimitives.js";
+import { parseCapabilityOperationFingerprintDigest } from "../../../shared-ts/src/authorization/operationFingerprint.js";
+import { isPlainObject } from "../../../shared-ts/src/utils/validation.js";
+//#region src/router/domains/signingOperations/ed25519AuthorizedOperationReceipt.ts
+function requireEd25519OperationKind(value) {
+	if (value !== "near.sign_transaction" && value !== "near.sign_delegate_action" && value !== "near.sign_nep413_message") throw new Error("authorized_operation.operation_kind is invalid");
+	return value;
+}
+function requireAuthorizedOperationReceiptString(record, name) {
+	const field = typeof record[name] === "string" ? record[name].trim() : "";
+	if (!field) throw new Error(`authorized_operation.${name} is required`);
+	return field;
+}
+function requireExactAuthorizedOperationReceiptFields(record, branchFields = []) {
+	const expected = [
+		"capability_kind",
+		"display_digest_b64u",
+		"intent_digest_b64u",
+		"kind",
+		"lane_digest_b64u",
+		"operation_fingerprint_digest",
+		"operation_id",
+		"operation_kind",
+		"authorized_operation_id",
+		...branchFields
+	].sort();
+	const actual = Object.keys(record).sort();
+	if (actual.length !== expected.length || actual.some((field, index) => field !== expected[index])) throw new Error("authorized_operation has invalid fields");
+}
+function parseEd25519ReusableAuthorizedOperationReceipt(value) {
+	const record = isPlainObject(value) ? value : null;
+	if (!record || record.kind !== "reusable_wallet_session_authorized_operation_v1") throw new Error("Ed25519 reusable Wallet Session authorized operation is required");
+	requireExactAuthorizedOperationReceiptFields(record);
+	if (requireAuthorizedOperationReceiptString(record, "capability_kind") !== "near_ed25519_mpc_signing") throw new Error("authorized_operation.capability_kind is invalid");
+	const operationKind = requireEd25519OperationKind(requireAuthorizedOperationReceiptString(record, "operation_kind"));
+	const laneDigest = requireAuthorizedOperationReceiptString(record, "lane_digest_b64u");
+	const intentDigest = requireAuthorizedOperationReceiptString(record, "intent_digest_b64u");
+	const displayDigest = requireAuthorizedOperationReceiptString(record, "display_digest_b64u");
+	parseDigestB64u(laneDigest);
+	parseDigestB64u(intentDigest);
+	parseDigestB64u(displayDigest);
+	const fingerprint = requireAuthorizedOperationReceiptString(record, "operation_fingerprint_digest");
+	parseCapabilityOperationFingerprintDigest(fingerprint);
+	return {
+		kind: "reusable_wallet_session_authorized_operation_v1",
+		authorized_operation_id: requireAuthorizedOperationReceiptString(record, "authorized_operation_id"),
+		operation_id: requireAuthorizedOperationReceiptString(record, "operation_id"),
+		capability_kind: "near_ed25519_mpc_signing",
+		operation_kind: operationKind,
+		lane_digest_b64u: laneDigest,
+		intent_digest_b64u: intentDigest,
+		display_digest_b64u: displayDigest,
+		operation_fingerprint_digest: fingerprint
+	};
+}
+function parseEd25519VerifiedStepUpAuthorizedOperationReceipt(value) {
+	const record = isPlainObject(value) ? value : null;
+	if (!record || record.kind !== "verified_step_up_authorized_operation_v1") throw new Error("Ed25519 verified step-up authorized operation is required");
+	requireExactAuthorizedOperationReceiptFields(record, ["authorization_session_id", "evidence_set_digest"]);
+	if (requireAuthorizedOperationReceiptString(record, "capability_kind") !== "near_ed25519_mpc_signing") throw new Error("authorized_operation.capability_kind is invalid");
+	const operationKind = requireEd25519OperationKind(requireAuthorizedOperationReceiptString(record, "operation_kind"));
+	const evidenceSetDigest = requireAuthorizedOperationReceiptString(record, "evidence_set_digest");
+	parseDigestB64u(evidenceSetDigest);
+	const laneDigest = requireAuthorizedOperationReceiptString(record, "lane_digest_b64u");
+	const intentDigest = requireAuthorizedOperationReceiptString(record, "intent_digest_b64u");
+	const displayDigest = requireAuthorizedOperationReceiptString(record, "display_digest_b64u");
+	parseDigestB64u(laneDigest);
+	parseDigestB64u(intentDigest);
+	parseDigestB64u(displayDigest);
+	const fingerprint = requireAuthorizedOperationReceiptString(record, "operation_fingerprint_digest");
+	parseCapabilityOperationFingerprintDigest(fingerprint);
+	return {
+		kind: "verified_step_up_authorized_operation_v1",
+		authorization_session_id: requireAuthorizedOperationReceiptString(record, "authorization_session_id"),
+		evidence_set_digest: evidenceSetDigest,
+		authorized_operation_id: requireAuthorizedOperationReceiptString(record, "authorized_operation_id"),
+		operation_id: requireAuthorizedOperationReceiptString(record, "operation_id"),
+		capability_kind: "near_ed25519_mpc_signing",
+		operation_kind: operationKind,
+		lane_digest_b64u: laneDigest,
+		intent_digest_b64u: intentDigest,
+		display_digest_b64u: displayDigest,
+		operation_fingerprint_digest: fingerprint
+	};
+}
+//#endregion
+export { parseEd25519ReusableAuthorizedOperationReceipt, parseEd25519VerifiedStepUpAuthorizedOperationReceipt, requireAuthorizedOperationReceiptString, requireEd25519OperationKind, requireExactAuthorizedOperationReceiptFields };
+
+//# sourceMappingURL=ed25519AuthorizedOperationReceipt.js.map