@seams/wallet-server 0.5.0

package/dist/esm/core/signingLanes/LaneLifecycleApplicationService.js

@@ -0,0 +1,200 @@
+import { base64UrlEncode } from "../../shared-ts/src/utils/base64.js";
+import { parseCorrelationId, parseDigestB64u } from "../../shared-ts/src/utils/canonicalPrimitives.js";
+import { sha256Bytes } from "../../shared-ts/src/utils/digests.js";
+import { buildRevokeSigningLaneV1, parseLaneProtocolCommitReceiptV1, parseLaneRefreshPredecessorRetirementV1, parseLaneServerActivationReceiptV1, parseRevokeSigningLaneV1 } from "../../shared-ts/src/signing-lanes/rotationParsers.js";
+import { encodeLaneProtocolCommitReceiptV1 } from "../../shared-ts/src/signing-lanes/rotationDigests.js";
+//#region src/core/signingLanes/LaneLifecycleApplicationService.ts
+var LaneLifecycleApplicationService = class {
+	constructor(input) {
+		this.input = input;
+	}
+	async recordLaneProtocolCommitV1(request) {
+		await authorizeProtocolCommit(this.input.authorization, request);
+		const parsedReceipt = parseLaneProtocolCommitReceiptV1(request.curve === "ed25519_yao" ? await this.input.execution.ed25519.executeProtocolCommitV1({
+			job: request.job,
+			requestJson: requireJson(request.requestJson, "requestJson")
+		}) : await this.input.execution.ecdsa.executeProtocolCommitV1({
+			job: request.job,
+			holderRound: request.holderRound,
+			holderPackage: request.holderPackage,
+			encryptedDeltaPackageJson: requireJson(request.encryptedDeltaPackageJson, "encryptedDeltaPackageJson")
+		}));
+		assertProtocolReceiptMatchesJob(parsedReceipt, request.job);
+		return await this.input.gateway.recordLaneProtocolCommitV1({
+			receipt: parsedReceipt,
+			expectedVersion: request.expectedVersion
+		});
+	}
+	async activateLaneServerMaterialV1(request) {
+		assertProtocolReceiptMatchesJob(request.protocolCommitReceipt, request.job);
+		assertHolderDeliveryReceiptMatchesJob(request.holderDeliveryReceipt, request.protocolCommitReceipt, request.job);
+		await authorizeServerActivation(this.input.authorization, request);
+		const parsedReceipt = parseLaneServerActivationReceiptV1(request.curve === "ed25519_yao" ? await this.input.execution.ed25519.executeServerActivationV1({
+			job: request.job,
+			protocolCommitReceipt: request.protocolCommitReceipt,
+			holderDeliveryReceipt: request.holderDeliveryReceipt
+		}) : await this.input.execution.ecdsa.executeServerActivationV1({
+			job: request.job,
+			protocolCommitReceipt: request.protocolCommitReceipt,
+			holderDeliveryReceipt: request.holderDeliveryReceipt
+		}));
+		assertServerActivationReceiptMatchesJob(parsedReceipt, request.protocolCommitReceipt, request.holderDeliveryReceipt, request.job);
+		return await this.input.gateway.activateLaneServerMaterialV1({
+			receipt: parsedReceipt,
+			expectedVersion: request.expectedVersion
+		});
+	}
+	async revokeSigningLaneV1(request) {
+		const command = parseRevokeSigningLaneV1(request.command);
+		await this.input.authorization.authorizeLaneLifecycleV1({
+			kind: "revoke_signing_lane_v1",
+			curve: request.curve,
+			command
+		});
+		const fenced = await this.input.gateway.fenceSigningLaneRevocationV1(command);
+		if (fenced.outcome === "conflict") return revocationConflict(command, fenced);
+		if (fenced.outcome === "already_completed") return completedRevocation(command, fenced);
+		assertRevocationFenceMatchesCommand(fenced.productEpoch, command);
+		const execution = request.curve === "ed25519_yao" ? await this.input.execution.ed25519.executeServerRetirementV1({ command }) : await this.input.execution.ecdsa.executeServerRetirementV1({ command });
+		assertRetirementExecutionMatchesCommand(execution, command);
+		return await this.input.gateway.completeSigningLaneRevocationV1({
+			kind: "complete_signing_lane_revocation_v1",
+			command,
+			expectedVersion: fenced.version,
+			commandDigestB64u: fenced.commandDigestB64u,
+			retirementReceipt: execution.retirementReceipt,
+			revokedAtMs: command.requestedAtMs
+		});
+	}
+	async retireLaneRefreshPredecessorV1(request) {
+		const protocolCommitReceipt = parseLaneProtocolCommitReceiptV1(request.protocolCommitReceipt);
+		assertProtocolReceiptMatchesJob(protocolCommitReceipt, request.job);
+		const retirementRequestDigestB64u = parseDigestB64u(base64UrlEncode(await sha256Bytes(encodeLaneProtocolCommitReceiptV1(protocolCommitReceipt))));
+		const command = buildRevokeSigningLaneV1({
+			walletId: request.job.walletId,
+			walletKeyId: request.job.walletKeyId,
+			laneId: request.job.source.laneId,
+			laneShareEpoch: request.job.source.laneShareEpoch,
+			expectedRevocationEpoch: request.job.source.revocationEpoch,
+			reason: "rotation",
+			retirementCorrelationId: parseCorrelationId(request.job.operationId),
+			retirementRequestDigestB64u,
+			retirementEffectBindingDigestB64u: request.job.authorization.ownerLaneRefreshDigestB64u,
+			requestedAtMs: request.requestedAtMs
+		});
+		await this.input.authorization.authorizeLaneLifecycleV1({
+			kind: "revoke_signing_lane_v1",
+			curve: request.curve,
+			command
+		});
+		const fenced = await this.input.gateway.fenceSigningLaneRevocationV1(command);
+		if (fenced.outcome === "conflict") throw new Error("lane refresh predecessor revocation fence conflicted");
+		if (fenced.outcome === "already_completed") return parseLaneRefreshPredecessorRetirementV1({
+			refreshOperationId: request.job.operationId,
+			sourceLaneId: request.job.source.laneId,
+			sourceLaneShareEpoch: request.job.source.laneShareEpoch,
+			sourceMaterialActivation: request.job.source.materialActivation,
+			retirementEffectBindingDigestB64u: request.job.authorization.ownerLaneRefreshDigestB64u,
+			retirementReceipt: fenced.retirementReceipt
+		});
+		assertRevocationFenceMatchesCommand(fenced.productEpoch, command);
+		const execution = request.curve === "ed25519_yao" ? await this.input.execution.ed25519.executeServerRetirementV1({ command }) : await this.input.execution.ecdsa.executeServerRetirementV1({ command });
+		assertRetirementExecutionMatchesCommand(execution, command);
+		return parseLaneRefreshPredecessorRetirementV1({
+			refreshOperationId: request.job.operationId,
+			sourceLaneId: request.job.source.laneId,
+			sourceLaneShareEpoch: request.job.source.laneShareEpoch,
+			sourceMaterialActivation: request.job.source.materialActivation,
+			retirementEffectBindingDigestB64u: execution.retirementEffectBindingDigestB64u,
+			retirementReceipt: execution.retirementReceipt
+		});
+	}
+};
+function assertRetirementExecutionMatchesCommand(execution, command) {
+	if (execution.kind !== "lane_lifecycle_retirement_execution_v1") throw new Error("lane retirement execution result kind is invalid");
+	if (execution.retirementEffectBindingDigestB64u !== command.retirementEffectBindingDigestB64u) throw new Error("lane retirement effect binding digest does not match the authorized effect binding");
+	assertRevokeSigningLaneCommandEqual(command, parseRevokeSigningLaneV1(execution.command));
+}
+function revocationConflict(command, result) {
+	return {
+		kind: "lane_signing_lane_revocation_result_v1",
+		outcome: "conflict",
+		walletKeyId: command.walletKeyId,
+		laneId: command.laneId,
+		laneShareEpoch: command.laneShareEpoch,
+		expectedVersion: result.expectedVersion,
+		actualVersion: result.actualVersion,
+		requestedCommandDigestB64u: result.requestedCommandDigestB64u,
+		storedCommandDigestB64u: result.storedCommandDigestB64u
+	};
+}
+function completedRevocation(command, result) {
+	return {
+		kind: "lane_signing_lane_revocation_result_v1",
+		outcome: "replayed",
+		walletKeyId: command.walletKeyId,
+		laneId: command.laneId,
+		laneShareEpoch: command.laneShareEpoch,
+		version: result.version,
+		commandDigestB64u: result.commandDigestB64u,
+		productEpoch: result.productEpoch,
+		retirementReceipt: result.retirementReceipt
+	};
+}
+function assertRevocationFenceMatchesCommand(product, command) {
+	if (String(product.walletId) !== String(command.walletId) || String(product.walletKeyId) !== String(command.walletKeyId) || String(product.laneId) !== String(command.laneId) || String(product.laneShareEpoch) !== String(command.laneShareEpoch) || product.revocationEpoch !== command.expectedRevocationEpoch + 1 || product.revocationReason !== command.reason || product.retirementEffectBindingDigestB64u !== command.retirementEffectBindingDigestB64u) throw new Error("lane revocation fence does not match the authorized command");
+}
+async function authorizeProtocolCommit(authorization, request) {
+	if (request.curve === "ed25519_yao") {
+		await authorization.authorizeLaneLifecycleV1({
+			kind: "record_lane_protocol_commit_v1",
+			curve: request.curve,
+			job: request.job,
+			expectedVersion: request.expectedVersion
+		});
+		return;
+	}
+	await authorization.authorizeLaneLifecycleV1({
+		kind: "record_lane_protocol_commit_v1",
+		curve: request.curve,
+		job: request.job,
+		expectedVersion: request.expectedVersion
+	});
+}
+async function authorizeServerActivation(authorization, request) {
+	if (request.curve === "ed25519_yao") {
+		await authorization.authorizeLaneLifecycleV1({
+			kind: "activate_lane_server_material_v1",
+			curve: request.curve,
+			job: request.job,
+			expectedVersion: request.expectedVersion
+		});
+		return;
+	}
+	await authorization.authorizeLaneLifecycleV1({
+		kind: "activate_lane_server_material_v1",
+		curve: request.curve,
+		job: request.job,
+		expectedVersion: request.expectedVersion
+	});
+}
+function requireJson(value, label) {
+	if (typeof value !== "string" || value.trim().length === 0) throw new Error(`${label} is required`);
+	return value;
+}
+function assertProtocolReceiptMatchesJob(receipt, job) {
+	if (receipt.operationId !== job.operationId || receipt.enrollmentId !== job.enrollmentId || receipt.walletId !== job.walletId || receipt.walletKeyId !== job.walletKeyId || receipt.targetLaneId !== job.target.laneId || receipt.targetLaneShareEpoch !== job.target.laneShareEpoch || receipt.targetMaterialActivationId !== job.targetMaterialActivationId || receipt.keyFamily !== job.keyFamily || receipt.holderRecipientKeyDigestB64u !== job.targetHolder.hpkePublicKeyDigestB64u || receipt.serverRecipientKeyDigestB64u !== job.targetSigningWorker.hpkePublicKeyDigestB64u) throw new Error("lane protocol commit receipt does not match the admitted job");
+}
+function assertHolderDeliveryReceiptMatchesJob(receipt, protocolReceipt, job) {
+	if (receipt.operationId !== job.operationId || receipt.enrollmentId !== job.enrollmentId || receipt.targetLaneId !== job.target.laneId || receipt.targetLaneShareEpoch !== job.target.laneShareEpoch || receipt.targetMaterialActivationId !== job.targetMaterialActivationId || receipt.holderCiphertextDigestSetB64u !== protocolReceipt.targetHolderCiphertextDigestSetB64u || receipt.acknowledgedAtMs < protocolReceipt.committedAtMs) throw new Error("lane holder delivery receipt does not match the admitted job");
+}
+function assertServerActivationReceiptMatchesJob(receipt, protocolReceipt, holderReceipt, job) {
+	if (receipt.operationId !== job.operationId || receipt.enrollmentId !== job.enrollmentId || receipt.targetLaneId !== job.target.laneId || receipt.targetLaneShareEpoch !== job.target.laneShareEpoch || receipt.targetMaterialActivation.activationId !== job.targetMaterialActivationId || receipt.targetMaterialActivation.capability !== job.source.materialActivation.capability || receipt.targetMaterialActivation.materialOwner !== job.source.materialActivation.materialOwner || receipt.targetMaterialActivation.keyBinding !== job.source.materialActivation.keyBinding || receipt.targetMaterialActivation.lifecycleBinding !== job.source.materialActivation.lifecycleBinding || String(receipt.targetMaterialActivation.signingWorker) !== String(job.targetSigningWorker.participantId) || receipt.serverCiphertextDigestSetB64u !== protocolReceipt.targetServerCiphertextDigestSetB64u || receipt.activatedAtMs < holderReceipt.acknowledgedAtMs) throw new Error("lane server activation receipt does not match the admitted job");
+}
+function assertRevokeSigningLaneCommandEqual(expected, actual) {
+	if (expected.kind !== actual.kind || expected.walletId !== actual.walletId || expected.walletKeyId !== actual.walletKeyId || expected.laneId !== actual.laneId || expected.laneShareEpoch !== actual.laneShareEpoch || expected.expectedRevocationEpoch !== actual.expectedRevocationEpoch || expected.reason !== actual.reason || expected.retirementCorrelationId !== actual.retirementCorrelationId || expected.retirementRequestDigestB64u !== actual.retirementRequestDigestB64u || expected.retirementEffectBindingDigestB64u !== actual.retirementEffectBindingDigestB64u || expected.requestedAtMs !== actual.requestedAtMs) throw new Error("lane retirement execution changed the authorized command");
+}
+//#endregion
+export { LaneLifecycleApplicationService };
+
+//# sourceMappingURL=LaneLifecycleApplicationService.js.map

package/dist/esm/core/signingLanes/LaneLifecycleStore.js

@@ -0,0 +1,24 @@
+//#region src/core/signingLanes/LaneLifecycleStore.ts
+function protocolCasResultToAdmissionResult(result) {
+	if (result.outcome === "conflict") return {
+		outcome: "conflict",
+		expectedVersion: result.expectedVersion,
+		actualVersion: result.actualVersion,
+		requestedCommandDigestB64u: result.requestedCommandDigestB64u,
+		storedCommandDigestB64u: result.storedCommandDigestB64u
+	};
+	return {
+		outcome: result.outcome,
+		version: result.version,
+		commandDigestB64u: result.commandDigestB64u,
+		value: result.record
+	};
+}
+function assertNonEmptyVersion(value, label) {
+	if (!Number.isSafeInteger(value) || value < 1) throw new Error(`${label} must be a positive safe integer`);
+	return value;
+}
+//#endregion
+export { assertNonEmptyVersion, protocolCasResultToAdmissionResult };
+
+//# sourceMappingURL=LaneLifecycleStore.js.map

package/dist/esm/core/signingLanes/WalletExecutionLaneProjection.js

@@ -0,0 +1,296 @@
+import { parseEmailOtpProviderUserId, parseLaneShareEpoch, parseMpcSigningWorkerRef, parseSigningLaneId, parseWalletKeyId, parseWebAuthnCredentialIdB64u } from "../../shared-ts/src/utils/domainIds.js";
+import { 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 { base58Encode } from "../../shared-ts/src/utils/base58.js";
+import { parseEd25519PublicKeyB64u, parseKeyCreationSignerSlot, parseSecp256k1CompressedPublicKeyB64u } from "../../shared-ts/src/passkey-custody/primitives.js";
+import { parseNearEd25519SigningKeyId } from "../../shared-ts/src/utils/registrationIntent.js";
+import { routerAbMpcMaterialActivationRefFromWire, sameRouterAbMpcMaterialActivationRef } from "../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
+import { deriveEvmFamilySigningKeySlotId } from "../../shared-ts/src/signing-lanes/evmFamilySigningKeySlotId.js";
+import { walletAuthAuthorityRef } from "../../shared-ts/src/utils/walletAuthAuthority.js";
+import { sameRouterAbEcdsaDerivationPublicCapabilityV1, sameRouterAbEcdsaDerivationPublicIdentityV1, sameRouterAbEcdsaRegistrationActivationReceiptV1, sameRouterAbServerIdentityV1 } from "../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
+import { buildOwnerLaneParticipantContinuityV1, computeOwnerLaneParticipantBindingDigestV1, parseWalletSignerId } from "../../shared-ts/src/signing-lanes/ownerContinuity.js";
+import "../../shared-ts/src/signing-lanes/index.js";
+import { buildActiveSigningLaneLifecycle, buildActiveWalletKeyLifecycle, buildEd25519WalletKeyRecord, buildEvmFamilyWalletKeyRecord, buildOwnerEmailOtpSigningLaneRecord, buildOwnerPasskeySigningLaneRecord, parseWalletKeyVersion } from "../../shared-ts/src/signing-lanes/recordParsers.js";
+//#region src/core/signingLanes/WalletExecutionLaneProjection.ts
+const SOURCE_IDENTITY_DOMAIN = "seams/wallet-execution-lane/source-identity/v1";
+const ED25519_RECEIPT_DOMAIN = "seams/wallet-execution-lane/ed25519-receipt/v1";
+async function resolveWalletAuthMethodIdForAuthority(input) {
+	const matches = [];
+	for (const authMethod of input.authMethods) {
+		if (authMethod.walletId !== input.walletId || authMethod.status !== "active") continue;
+		if (authMethod.walletAuthMethodId !== input.authorityRef.walletAuthMethodId) continue;
+		const authority = walletAuthorityForAuthMethod(authMethod, input.authSource);
+		if (!authority) continue;
+		const candidateRef = await walletAuthAuthorityRef({ authority });
+		if (candidateRef.walletId === input.authorityRef.walletId && candidateRef.authorityDigest === input.authorityRef.authorityDigest && candidateRef.walletAuthMethodId === input.authorityRef.walletAuthMethodId) matches.push(authMethod.walletAuthMethodId);
+	}
+	return matches.length === 1 ? matches[0] ?? null : null;
+}
+async function resolveActiveOwnerWalletExecutionLane(input) {
+	const [authMethods, signers] = await Promise.all([input.source.listWalletAuthMethods({ walletId: input.walletId }), input.source.listWalletSigners({ walletId: input.walletId })]);
+	const matchingAuthMethods = authMethods.filter((record) => String(record.walletAuthMethodId) === String(input.walletAuthMethodId));
+	if (matchingAuthMethods.length === 0) return refused("auth_method_missing");
+	if (matchingAuthMethods.length !== 1) return refused("auth_method_ambiguous");
+	const authMethod = matchingAuthMethods[0];
+	if (!authMethod) return refused("auth_method_missing");
+	if (authMethod.walletId !== input.walletId) return refused("auth_method_mismatch");
+	if (authMethod.status !== "active") return refused("auth_method_inactive");
+	const matchingSigners = signers.filter((signer) => signerMatchesMaterialActivation(signer, input.expectedMaterialActivation));
+	if (matchingSigners.length === 0) return refused("signer_missing");
+	try {
+		return {
+			kind: "projected",
+			projection: await projectActiveOwnerWalletExecutionLane({
+				walletId: input.walletId,
+				walletAuthMethodId: input.walletAuthMethodId,
+				authMethod,
+				signers: matchingSigners,
+				expectedMaterialActivation: input.expectedMaterialActivation
+			})
+		};
+	} catch (error) {
+		return refused(error instanceof SignerProjectionConflictError ? "signer_conflict" : "signer_invalid");
+	}
+}
+async function projectActiveOwnerWalletExecutionLane(input) {
+	if (input.authMethod.walletId !== input.walletId || String(input.authMethod.walletAuthMethodId) !== String(input.walletAuthMethodId) || input.authMethod.status !== "active") throw new Error("wallet auth method does not authorize the requested owner lane");
+	if (input.signers.length === 0) throw new Error("wallet signer is required");
+	const first = input.signers[0];
+	if (!first) throw new Error("wallet signer is required");
+	if (first.walletId !== input.walletId) throw new Error("wallet signer changed wallet");
+	return first.version === "wallet_signer_ed25519_v1" ? await projectEd25519OwnerLane({
+		...input,
+		signers: requireOnlyEd25519Signer(input.signers)
+	}) : await projectEcdsaOwnerLane({
+		...input,
+		signers: requireOnlyEcdsaSigners(input.signers)
+	});
+}
+async function projectEd25519OwnerLane(input) {
+	const signer = input.signers[0];
+	const capability = signer.activeYaoCapability;
+	const receipt = capability.activationResult.public_receipt;
+	const scope = capability.admissionRequest.scope;
+	const application = capability.admissionRequest.application_binding;
+	const receiptActivation = receipt.material_activation;
+	if (application.wallet_id !== input.walletId || scope.account_id !== input.walletId || signer.signingWorkerId !== scope.signing_worker_id || signer.publicKey !== `ed25519:${base58Encode(Uint8Array.from(receipt.registered_public_key))}` || signer.participantIds[0] !== capability.admissionRequest.participant_ids[0] || signer.participantIds[1] !== capability.admissionRequest.participant_ids[1] || !sameRouterAbMpcMaterialActivationRef(receiptActivation, capability.admissionRequest.scope.material_activation)) throw new Error("Ed25519 signer continuity is invalid");
+	assertExpectedActivation(receiptActivation, input.expectedMaterialActivation);
+	const materialActivation = routerAbMpcMaterialActivationRefFromWire(receiptActivation);
+	const sourceIdentityDigestB64u = await digestPublicIdentity({
+		keyFamily: "ed25519",
+		walletId: input.walletId,
+		signerId: signer.signerId,
+		capability,
+		receipt
+	});
+	const activationReceiptDigestB64u = await digestValue(ED25519_RECEIPT_DOMAIN, receipt);
+	const ownerParticipantContinuity = await ownerContinuity({
+		signerId: signer.signerId,
+		participantIds: signer.participantIds,
+		signingWorkerId: signer.signingWorkerId,
+		custodyKeyManifestDigestB64u: signer.custodyKeyManifestDigestB64u,
+		sourceIdentityDigestB64u
+	});
+	const walletKeyId = requireParsed(parseWalletKeyId(`wallet-key:ed25519:${input.walletId}:${signer.nearEd25519SigningKeyId}`));
+	return {
+		kind: "active_owner_wallet_execution_lane_projection_v1",
+		walletKey: buildEd25519WalletKeyRecord({
+			walletId: input.walletId,
+			walletKeyId,
+			walletKeyVersion: parseWalletKeyVersion(`wallet-key-version:${signer.keyVersion}`),
+			nearEd25519SigningKeyId: parseNearEd25519SigningKeyId(signer.nearEd25519SigningKeyId),
+			keyCreationSignerSlot: parseKeyCreationSignerSlot(signer.signerSlot),
+			registeredPublicKeyB64u: parseEd25519PublicKeyB64u(base64UrlEncode(Uint8Array.from(receipt.registered_public_key))),
+			lifecycle: buildActiveWalletKeyLifecycle({ activatedAtMs: signer.updatedAtMs })
+		}),
+		lane: await buildOwnerLane({
+			walletId: input.walletId,
+			walletKeyId,
+			walletAuthMethodId: input.walletAuthMethodId,
+			authMethod: input.authMethod,
+			laneShareEpoch: scope.root_share_epoch,
+			activatedAtMs: signer.updatedAtMs,
+			activationReceiptDigestB64u,
+			ownerParticipantContinuity
+		}),
+		materialActivation,
+		verifiedActivationReceiptDigestB64u: activationReceiptDigestB64u
+	};
+}
+async function projectEcdsaOwnerLane(input) {
+	const signer = input.signers[0];
+	if (!signer) throw new Error("ECDSA signer is required");
+	assertEcdsaReceiptContinuity(signer);
+	assertExpectedActivation(signer.walletKey.publicCapability.material_activation, input.expectedMaterialActivation);
+	for (const candidate of input.signers.slice(1)) assertSameEcdsaWalletKey(signer, candidate);
+	const materialActivation = routerAbMpcMaterialActivationRefFromWire(signer.walletKey.publicCapability.material_activation);
+	const sourceIdentityDigestB64u = await digestPublicIdentity({
+		keyFamily: "ecdsa_secp256k1",
+		walletId: input.walletId,
+		keyHandle: signer.walletKey.keyHandle,
+		publicCapability: signer.walletKey.publicCapability,
+		activationReceipt: signer.activationReceipt
+	});
+	const activationReceiptDigestB64u = parseDigestB64u(signer.activationReceipt.ecdsa_activation.activation_digest_b64u);
+	const ownerParticipantContinuity = await ownerContinuity({
+		signerId: `ecdsa-key:${signer.walletKey.keyHandle}`,
+		participantIds: signer.walletKey.participantIds,
+		signingWorkerId: signer.activationReceipt.ecdsa_activation.signing_worker.server_id,
+		custodyKeyManifestDigestB64u: signer.custodyKeyManifestDigestB64u,
+		sourceIdentityDigestB64u
+	});
+	const evmFamilySigningKeySlotId = deriveEvmFamilySigningKeySlotId({
+		walletId: input.walletId,
+		signingRootId: signer.walletKey.signingRootId,
+		signingRootVersion: signer.walletKey.signingRootVersion
+	});
+	const walletKeyId = requireParsed(parseWalletKeyId(`wallet-key:ecdsa:${input.walletId}:${evmFamilySigningKeySlotId}`));
+	return {
+		kind: "active_owner_wallet_execution_lane_projection_v1",
+		walletKey: buildEvmFamilyWalletKeyRecord({
+			walletId: input.walletId,
+			walletKeyId,
+			walletKeyVersion: parseWalletKeyVersion(`wallet-key-version:${signer.walletKey.signingRootVersion}`),
+			evmFamilySigningKeySlotId,
+			thresholdPublicKey33B64u: parseSecp256k1CompressedPublicKeyB64u(signer.walletKey.thresholdEcdsaPublicKeyB64u),
+			evmAddress: signer.walletKey.thresholdOwnerAddress,
+			lifecycle: buildActiveWalletKeyLifecycle({ activatedAtMs: signer.activationReceipt.ecdsa_activation.activated_at_ms })
+		}),
+		lane: await buildOwnerLane({
+			walletId: input.walletId,
+			walletKeyId,
+			walletAuthMethodId: input.walletAuthMethodId,
+			authMethod: input.authMethod,
+			laneShareEpoch: signer.walletKey.publicCapability.activation_epoch,
+			activatedAtMs: signer.activationReceipt.ecdsa_activation.activated_at_ms,
+			activationReceiptDigestB64u,
+			ownerParticipantContinuity
+		}),
+		materialActivation,
+		verifiedActivationReceiptDigestB64u: activationReceiptDigestB64u
+	};
+}
+async function buildOwnerLane(input) {
+	const participantBindingDigestB64u = await computeOwnerLaneParticipantBindingDigestV1(input.ownerParticipantContinuity);
+	const laneId = requireParsed(parseSigningLaneId(`signing-lane:${input.authMethod.kind}:${input.walletKeyId}:${input.walletAuthMethodId}`));
+	const base = {
+		walletId: input.walletId,
+		walletKeyId: input.walletKeyId,
+		laneId,
+		laneShareEpoch: requireParsed(parseLaneShareEpoch(input.laneShareEpoch)),
+		participantBindingDigestB64u,
+		walletAuthMethodId: input.walletAuthMethodId,
+		ownerParticipantContinuity: input.ownerParticipantContinuity,
+		lifecycle: buildActiveSigningLaneLifecycle({
+			revocationEpoch: 0,
+			activatedAtMs: input.activatedAtMs,
+			activationReceiptDigestB64u: input.activationReceiptDigestB64u
+		})
+	};
+	switch (input.authMethod.kind) {
+		case "passkey": return buildOwnerPasskeySigningLaneRecord(base);
+		case "email_otp": return buildOwnerEmailOtpSigningLaneRecord(base);
+	}
+}
+async function ownerContinuity(input) {
+	const signingWorkerId = requireParsed(parseMpcSigningWorkerRef(input.signingWorkerId));
+	return buildOwnerLaneParticipantContinuityV1({
+		signerId: parseWalletSignerId(input.signerId),
+		participantIds: input.participantIds,
+		signingWorkerId,
+		custodyKeyManifestDigestB64u: parseDigestB64u(input.custodyKeyManifestDigestB64u),
+		sourceIdentityDigestB64u: input.sourceIdentityDigestB64u
+	});
+}
+function requireOnlyEd25519Signer(signers) {
+	if (signers.length !== 1 || signers[0]?.version !== "wallet_signer_ed25519_v1") throw new SignerProjectionConflictError();
+	return [signers[0]];
+}
+function requireOnlyEcdsaSigners(signers) {
+	const ecdsaSigners = [];
+	for (const signer of signers) {
+		if (signer.version !== "wallet_signer_ecdsa_v1") throw new SignerProjectionConflictError();
+		ecdsaSigners.push(signer);
+	}
+	return ecdsaSigners;
+}
+function signerMatchesMaterialActivation(signer, expected) {
+	const wire = signer.version === "wallet_signer_ed25519_v1" ? signer.activeYaoCapability.activationResult.public_receipt.material_activation : signer.walletKey.publicCapability.material_activation;
+	try {
+		return sameMaterialActivation(routerAbMpcMaterialActivationRefFromWire(wire), expected);
+	} catch {
+		return false;
+	}
+}
+function assertExpectedActivation(wire, expected) {
+	if (!sameMaterialActivation(routerAbMpcMaterialActivationRefFromWire(wire), expected)) throw new Error("wallet signer material activation changed");
+}
+function assertEcdsaReceiptContinuity(signer) {
+	const capability = signer.walletKey.publicCapability;
+	const activation = signer.activationReceipt.ecdsa_activation;
+	if (capability.client_id !== String(signer.walletId) || capability.material_activation.material_owner !== String(signer.walletId) || activation.activation_epoch !== capability.activation_epoch || activation.context.application_binding_digest_b64u !== capability.context.application_binding_digest_b64u || !sameRouterAbEcdsaDerivationPublicIdentityV1(activation.public_identity, capability.public_identity) || !sameRouterAbServerIdentityV1(activation.signing_worker, capability.signer_set.selected_server) || !sameRouterAbMpcMaterialActivationRef(activation.material_activation, capability.material_activation)) throw new Error("ECDSA activation receipt does not match the public capability");
+}
+function assertSameEcdsaWalletKey(expected, candidate) {
+	assertEcdsaReceiptContinuity(candidate);
+	if (expected.walletId !== candidate.walletId || expected.walletKey.keyHandle !== candidate.walletKey.keyHandle || expected.walletKey.signingRootId !== candidate.walletKey.signingRootId || expected.walletKey.signingRootVersion !== candidate.walletKey.signingRootVersion || expected.custodyKeyManifestDigestB64u !== candidate.custodyKeyManifestDigestB64u || !sameRouterAbEcdsaDerivationPublicCapabilityV1(expected.walletKey.publicCapability, candidate.walletKey.publicCapability) || !sameRouterAbEcdsaRegistrationActivationReceiptV1(expected.activationReceipt, candidate.activationReceipt) || expected.walletKey.participantIds[0] !== candidate.walletKey.participantIds[0] || expected.walletKey.participantIds[1] !== candidate.walletKey.participantIds[1]) throw new SignerProjectionConflictError();
+}
+async function digestPublicIdentity(value) {
+	return await digestValue(SOURCE_IDENTITY_DOMAIN, value);
+}
+async function digestValue(domain, value) {
+	return parseDigestB64u(base64UrlEncode(await sha256BytesUtf8(`${domain}\u0000${alphabetizeStringify(value)}`)));
+}
+function sameMaterialActivation(left, right) {
+	return left.activationId === right.activationId && left.capability === right.capability && left.materialOwner === right.materialOwner && left.keyBinding === right.keyBinding && left.lifecycleBinding === right.lifecycleBinding && left.signingWorker === right.signingWorker;
+}
+function requireParsed(result) {
+	if (result.ok) return result.value;
+	throw new Error("wallet execution lane identity is invalid");
+}
+function refused(reason) {
+	return {
+		kind: "refused",
+		reason
+	};
+}
+var SignerProjectionConflictError = class extends Error {};
+function walletAuthorityForAuthMethod(authMethod, authSource) {
+	if (authMethod.kind === "passkey") {
+		if (authSource.kind !== "passkey" || authSource.credentialIdB64u !== authMethod.credentialIdB64u) return null;
+		const credentialId = parseWebAuthnCredentialIdB64u(authMethod.credentialIdB64u);
+		if (!credentialId.ok) return null;
+		return {
+			walletId: authMethod.walletId,
+			factor: {
+				kind: "passkey",
+				credentialIdB64u: credentialId.value
+			},
+			verifier: {
+				kind: "webauthn",
+				rpId: authMethod.rpId
+			},
+			bindingId: authMethod.walletAuthMethodId
+		};
+	}
+	if (authSource.kind !== "oidc_provider") return null;
+	const providerUserId = parseEmailOtpProviderUserId(authSource.providerSubject);
+	if (!providerUserId.ok) return null;
+	return {
+		walletId: authMethod.walletId,
+		factor: {
+			kind: "email_otp",
+			provider: authSource.providerId === "google_oidc" ? "google" : "email",
+			providerUserId: providerUserId.value
+		},
+		verifier: {
+			kind: "email_otp_wallet_auth_method",
+			emailHashHex: authMethod.emailHashHex
+		},
+		bindingId: authMethod.walletAuthMethodId
+	};
+}
+//#endregion
+export { projectActiveOwnerWalletExecutionLane, resolveActiveOwnerWalletExecutionLane, resolveWalletAuthMethodIdForAuthority };
+
+//# sourceMappingURL=WalletExecutionLaneProjection.js.map

package/dist/esm/core/signingLanes/ecdsaServerRetirement.js

@@ -0,0 +1,78 @@
+import { mpcMaterialActivationRefsEqual } from "../../shared-ts/src/utils/domainIds.js";
+import { parseDigestB64u } from "../../shared-ts/src/utils/canonicalPrimitives.js";
+import { parseEcdsaServerRetirementReceiptV1 } from "../../shared-ts/src/signing-lanes/rotationParsers.js";
+import { computeEcdsaServerRetirementReceiptDigestV1 } from "../../shared-ts/src/signing-lanes/rotationDigests.js";
+import "../../shared-ts/src/signing-lanes/index.js";
+//#region src/core/signingLanes/ecdsaServerRetirement.ts
+function buildEcdsaServerRetirementRequestV1(input) {
+	assertIdentityMatchesCommand(input.binding, input.command);
+	const retirementReason = retirementReasonForCommand(input.command.reason);
+	return {
+		identity: input.binding.identity,
+		manifest: input.binding.manifest,
+		materialActivation: input.binding.materialActivation,
+		revocationEpoch: input.command.expectedRevocationEpoch,
+		retirementReason,
+		retirementCorrelationId: input.command.retirementCorrelationId,
+		retirementRequestDigestB64u: parseDigestB64u(input.command.retirementRequestDigestB64u),
+		retirementEffectBindingDigestB64u: parseDigestB64u(input.command.retirementEffectBindingDigestB64u),
+		serverGeneration: input.binding.serverGeneration,
+		lifecycleId: input.binding.lifecycleId
+	};
+}
+function assertIdentityMatchesCommand(binding, command) {
+	const identity = binding.identity;
+	if (identity.keyFamily !== "ecdsa_secp256k1" || identity.walletId !== command.walletId || identity.walletKeyId !== command.walletKeyId || identity.targetLaneId !== command.laneId || identity.targetLaneShareEpoch !== command.laneShareEpoch || identity.targetMaterialActivationId !== binding.materialActivation.activationId) throw new Error("ECDSA retirement binding identity does not match the authorized command");
+}
+async function parseAndVerifyEcdsaServerRetirementEffectV1(input) {
+	const label = input.label ?? "ecdsaLaneRetireEffect";
+	const effect = exactEffectEnvelope(input.raw, label);
+	const outcome = parseOutcome(effect.outcome, `${label}.outcome`);
+	const receipt = parseEcdsaServerRetirementReceiptV1(effect.receipt, `${label}.receipt`);
+	assertReceiptMatchesExpectation(receipt, input.expectation);
+	const canonicalDigest = await computeEcdsaServerRetirementReceiptDigestV1(receipt);
+	if (receipt.receiptDigestB64u !== canonicalDigest) throw new Error(`${label}.receipt.receiptDigestB64u does not match its canonical digest`);
+	return {
+		outcome,
+		receipt,
+		retirementEffectBindingDigestB64u: input.expectation.retirementEffectBindingDigestB64u,
+		retirementReceiptDigestB64u: parseDigestB64u(receipt.receiptDigestB64u)
+	};
+}
+function assertEcdsaServerRetirementReceiptMatchesExpectationV1(receipt, expectation) {
+	assertReceiptMatchesExpectation(receipt, expectation);
+}
+function assertReceiptMatchesExpectation(receipt, expectation) {
+	if (receipt.manifest.manifestId !== expectation.manifest.manifestId || receipt.manifest.manifestRevision !== expectation.manifest.manifestRevision || !mpcMaterialActivationRefsEqual(receipt.materialActivation, expectation.materialActivation) || receipt.walletKeyId !== expectation.walletKeyId || receipt.laneId !== expectation.laneId || receipt.laneShareEpoch !== expectation.laneShareEpoch || receipt.revocationEpoch !== expectation.revocationEpoch || receipt.retirementReason !== expectation.retirementReason || receipt.retirementCorrelationId !== expectation.retirementCorrelationId || receipt.retirementRequestDigestB64u !== expectation.retirementRequestDigestB64u || receipt.serverGeneration !== expectation.serverGeneration || receipt.lifecycleId !== expectation.lifecycleId) throw new Error("ECDSA retirement receipt does not match the admitted lane binding");
+}
+function retirementReasonForCommand(reason) {
+	switch (reason) {
+		case "user_revoked":
+		case "policy_revoked": return "lane_revoked";
+		case "device_compromise": return "device_compromise";
+		case "agent_compromise": return "agent_compromise";
+		case "rotation": return "rotation";
+	}
+}
+function exactEffectEnvelope(value, label) {
+	if (!isObject(value)) throw new Error(`${label} must be an object`);
+	const fields = ["outcome", "receipt"];
+	const allowed = new Set(fields);
+	for (const key of Object.keys(value)) if (!allowed.has(key)) throw new Error(`${label}.${key} is unsupported`);
+	for (const field of fields) if (!Object.hasOwn(value, field)) throw new Error(`${label}.${field} is required`);
+	return {
+		outcome: Reflect.get(value, "outcome"),
+		receipt: Reflect.get(value, "receipt")
+	};
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseOutcome(value, label) {
+	if (value === "applied" || value === "replayed") return value;
+	throw new Error(`${label} is invalid`);
+}
+//#endregion
+export { assertEcdsaServerRetirementReceiptMatchesExpectationV1, buildEcdsaServerRetirementRequestV1, parseAndVerifyEcdsaServerRetirementEffectV1 };
+
+//# sourceMappingURL=ecdsaServerRetirement.js.map