@seams/wallet-server 0.5.0

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

@@ -0,0 +1,324 @@
+import { base64UrlEncode } from "../../shared-ts/src/utils/base64.js";
+import { parseDigestB64u } from "../../shared-ts/src/utils/canonicalPrimitives.js";
+import { sha256Bytes, sha256BytesUtf8 } from "../../shared-ts/src/utils/digests.js";
+import { buildLaneProtocolRecordV1, parseLaneHolderDeliveryReceiptV1, parseLaneProtocolCommitReceiptV1, parseLaneServerActivationReceiptV1 } from "../../shared-ts/src/signing-lanes/rotationParsers.js";
+import { computeLaneEnrollmentManifestDigestV1, encodeLaneHolderDeliveryReceiptV1, encodeLaneProtocolCommitReceiptV1, encodeLaneServerActivationReceiptV1 } from "../../shared-ts/src/signing-lanes/rotationDigests.js";
+import { transitionLaneProtocolLifecycleV1 } from "../../shared-ts/src/signing-lanes/rotationLifecycle.js";
+//#region src/core/signingLanes/LaneEnrollmentActivation.ts
+var LaneEnrollmentActivation = class {
+	constructor(lifecycleStore) {
+		this.lifecycleStore = lifecycleStore;
+	}
+	async prepareLaneEnrollmentV1(input) {
+		const commandDigestB64u = await computeLaneEnrollmentManifestDigestV1(input.manifest);
+		const lifecycle = {
+			state: "preparing",
+			manifestDigestB64u: commandDigestB64u,
+			startedAtMs: input.manifest.createdAtMs
+		};
+		const admissionInput = {
+			manifest: input.manifest,
+			children: input.children.map((job) => buildLaneProtocolRecordV1({
+				job,
+				lifecycle: {
+					state: "awaiting_protocol_commitment",
+					startedAtMs: input.manifest.createdAtMs
+				}
+			})),
+			commandDigestB64u,
+			lifecycle
+		};
+		const admitted = await this.lifecycleStore.putEnrollmentAdmission(admissionInput);
+		if (admitted.outcome === "conflict") return {
+			kind: "lane_enrollment_preparation_result_v1",
+			outcome: "conflict",
+			enrollmentId: input.manifest.enrollmentId,
+			expectedVersion: admitted.expectedVersion ?? 0,
+			actualVersion: admitted.actualVersion,
+			requestedCommandDigestB64u: parseDigestB64u(admitted.requestedCommandDigestB64u),
+			storedCommandDigestB64u: parseDigestB64u(admitted.storedCommandDigestB64u)
+		};
+		const orderedProtocols = await readOrderedProtocols(this.lifecycleStore, input.children);
+		return {
+			kind: "lane_enrollment_preparation_result_v1",
+			outcome: admitted.outcome,
+			enrollmentId: input.manifest.enrollmentId,
+			version: admitted.version,
+			commandDigestB64u: parseDigestB64u(admitted.commandDigestB64u),
+			lifecycle: admitted.value.lifecycle,
+			orderedProtocols
+		};
+	}
+	async recordLaneProtocolCommitV1(input) {
+		const receipt = parseLaneProtocolCommitReceiptV1(input.receipt);
+		const current = await this.lifecycleStore.getProtocol(receipt.operationId);
+		if (!current || String(current.value.job.enrollmentId) !== String(receipt.enrollmentId)) return {
+			outcome: "conflict",
+			expectedVersion: input.expectedVersion,
+			actualVersion: current?.version ?? 0,
+			requestedCommandDigestB64u: await digestReceipt(receipt),
+			storedCommandDigestB64u: current?.commandDigestB64u ?? ""
+		};
+		const receiptDigestB64u = await digestReceipt(receipt);
+		if (current.value.lifecycle.state !== "awaiting_protocol_commitment") {
+			if ((current.value.lifecycle.state === "committed_awaiting_holder_delivery" || current.value.lifecycle.state === "awaiting_server_activation" || current.value.lifecycle.state === "ready_for_parent_visibility" || current.value.lifecycle.state === "active") && current.value.lifecycle.protocolCommitReceiptDigestB64u === receiptDigestB64u) return {
+				outcome: "replayed",
+				version: current.version,
+				commandDigestB64u: current.commandDigestB64u,
+				record: current.value
+			};
+			return {
+				outcome: "conflict",
+				expectedVersion: input.expectedVersion,
+				actualVersion: current.version,
+				requestedCommandDigestB64u: receiptDigestB64u,
+				storedCommandDigestB64u: current.commandDigestB64u
+			};
+		}
+		const persistedReceipt = await this.lifecycleStore.putProtocolCommitReceipt(receipt, receiptDigestB64u);
+		if (persistedReceipt.outcome === "conflict") return {
+			outcome: "conflict",
+			expectedVersion: input.expectedVersion,
+			actualVersion: persistedReceipt.actualVersion,
+			requestedCommandDigestB64u: persistedReceipt.requestedCommandDigestB64u,
+			storedCommandDigestB64u: persistedReceipt.storedCommandDigestB64u
+		};
+		const lifecycle = transitionLaneProtocolLifecycleV1(current.value.lifecycle, {
+			action: "record_commit",
+			committedAtMs: receipt.committedAtMs,
+			transcriptHashB64u: receipt.transcriptHashB64u,
+			protocolCommitReceiptDigestB64u: receiptDigestB64u
+		});
+		if (lifecycle.state !== "committed_awaiting_holder_delivery") throw new Error("protocol commit transition did not produce holder-delivery state");
+		const cas = await this.lifecycleStore.compareAndSetProtocolLifecycle({
+			operationId: receipt.operationId,
+			expectedVersion: input.expectedVersion,
+			commandDigestB64u: receiptDigestB64u,
+			lifecycle
+		});
+		return cas.outcome === "conflict" ? await reconcileProtocolCas(this.lifecycleStore, receipt.operationId, cas, receiptDigestB64u, "protocol") : cas;
+	}
+	async resumeLaneProtocolOperationV1(input) {
+		const current = await this.lifecycleStore.getProtocol(input.operationId);
+		if (!current || String(current.value.job.enrollmentId) !== String(input.enrollmentId) || String(current.value.job.idempotencyKey) !== String(input.idempotencyKey)) return {
+			outcome: "conflict",
+			expectedVersion: input.expectedVersion,
+			actualVersion: current?.version ?? 0,
+			requestedCommandDigestB64u: await digestResumeCommand(input),
+			storedCommandDigestB64u: current?.commandDigestB64u ?? ""
+		};
+		if (current.value.lifecycle.state !== "preparing" && current.value.lifecycle.state !== "committed_completion_required") return {
+			outcome: "replayed",
+			version: current.version,
+			commandDigestB64u: current.commandDigestB64u,
+			record: current.value
+		};
+		const lifecycle = nextResumeLifecycle(current.value.lifecycle);
+		return await this.lifecycleStore.compareAndSetProtocolLifecycle({
+			operationId: input.operationId,
+			expectedVersion: input.expectedVersion,
+			commandDigestB64u: await digestResumeCommand(input),
+			lifecycle
+		});
+	}
+	async recordLaneHolderDeliveryV1(input) {
+		const receipt = parseLaneHolderDeliveryReceiptV1(input.receipt);
+		const current = await this.lifecycleStore.getProtocol(receipt.operationId);
+		if (!current || String(current.value.job.enrollmentId) !== String(receipt.enrollmentId)) return {
+			outcome: "conflict",
+			expectedVersion: input.expectedVersion,
+			actualVersion: current?.version ?? 0,
+			requestedCommandDigestB64u: await digestHolderReceipt(receipt),
+			storedCommandDigestB64u: current?.commandDigestB64u ?? ""
+		};
+		const receiptDigestB64u = await digestHolderReceipt(receipt);
+		if (current.value.lifecycle.state !== "committed_awaiting_holder_delivery") {
+			if ((current.value.lifecycle.state === "awaiting_server_activation" || current.value.lifecycle.state === "ready_for_parent_visibility" || current.value.lifecycle.state === "active") && current.value.lifecycle.holderDeliveryReceiptDigestB64u === receiptDigestB64u) return {
+				outcome: "replayed",
+				version: current.version,
+				commandDigestB64u: current.commandDigestB64u,
+				record: current.value
+			};
+			return {
+				outcome: "conflict",
+				expectedVersion: input.expectedVersion,
+				actualVersion: current.version,
+				requestedCommandDigestB64u: receiptDigestB64u,
+				storedCommandDigestB64u: current.commandDigestB64u
+			};
+		}
+		const persistedReceipt = await this.lifecycleStore.putHolderDeliveryReceipt(receipt, receiptDigestB64u);
+		if (persistedReceipt.outcome === "conflict") return {
+			outcome: "conflict",
+			expectedVersion: input.expectedVersion,
+			actualVersion: persistedReceipt.actualVersion,
+			requestedCommandDigestB64u: persistedReceipt.requestedCommandDigestB64u,
+			storedCommandDigestB64u: persistedReceipt.storedCommandDigestB64u
+		};
+		const lifecycle = transitionLaneProtocolLifecycleV1(current.value.lifecycle, {
+			action: "record_holder_delivery",
+			holderReceiptAtMs: receipt.acknowledgedAtMs,
+			holderDeliveryReceiptDigestB64u: receiptDigestB64u
+		});
+		if (lifecycle.state !== "awaiting_server_activation") throw new Error("holder delivery transition did not produce awaiting server activation");
+		const cas = await this.lifecycleStore.compareAndSetProtocolLifecycle({
+			operationId: receipt.operationId,
+			expectedVersion: input.expectedVersion,
+			commandDigestB64u: receiptDigestB64u,
+			lifecycle
+		});
+		return cas.outcome === "conflict" ? await reconcileProtocolCas(this.lifecycleStore, receipt.operationId, cas, receiptDigestB64u, "holder") : cas;
+	}
+	async activateLaneServerMaterialV1(input) {
+		const receipt = parseLaneServerActivationReceiptV1(input.receipt);
+		const current = await this.lifecycleStore.getProtocol(receipt.operationId);
+		if (!current || String(current.value.job.enrollmentId) !== String(receipt.enrollmentId)) return {
+			outcome: "conflict",
+			expectedVersion: input.expectedVersion,
+			actualVersion: current?.version ?? 0,
+			requestedCommandDigestB64u: await digestServerReceipt(receipt),
+			storedCommandDigestB64u: current?.commandDigestB64u ?? ""
+		};
+		const receiptDigestB64u = await digestServerReceipt(receipt);
+		if (current.value.lifecycle.state === "ready_for_parent_visibility" || current.value.lifecycle.state === "active") {
+			if (current.value.lifecycle.serverActivationReceiptDigestB64u !== receiptDigestB64u) return {
+				outcome: "conflict",
+				expectedVersion: input.expectedVersion,
+				actualVersion: current.version,
+				requestedCommandDigestB64u: receiptDigestB64u,
+				storedCommandDigestB64u: current.commandDigestB64u
+			};
+			return {
+				outcome: "replayed",
+				version: current.version,
+				commandDigestB64u: current.commandDigestB64u,
+				record: current.value
+			};
+		}
+		if (current.value.lifecycle.state !== "awaiting_server_activation") return {
+			outcome: "conflict",
+			expectedVersion: input.expectedVersion,
+			actualVersion: current.version,
+			requestedCommandDigestB64u: receiptDigestB64u,
+			storedCommandDigestB64u: current.commandDigestB64u
+		};
+		const persistedReceipt = await this.lifecycleStore.putServerActivationReceipt(receipt, receiptDigestB64u);
+		if (persistedReceipt.outcome === "conflict") return {
+			outcome: "conflict",
+			expectedVersion: input.expectedVersion,
+			actualVersion: persistedReceipt.actualVersion,
+			requestedCommandDigestB64u: persistedReceipt.requestedCommandDigestB64u,
+			storedCommandDigestB64u: persistedReceipt.storedCommandDigestB64u
+		};
+		const lifecycle = transitionLaneProtocolLifecycleV1(current.value.lifecycle, {
+			action: "record_server_activation",
+			serverActivatedAtMs: receipt.activatedAtMs,
+			serverActivationReceiptDigestB64u: receiptDigestB64u
+		});
+		if (lifecycle.state !== "ready_for_parent_visibility") throw new Error("server activation transition did not produce ready-for-parent-visibility");
+		const cas = await this.lifecycleStore.compareAndSetProtocolLifecycle({
+			operationId: receipt.operationId,
+			expectedVersion: input.expectedVersion,
+			commandDigestB64u: receiptDigestB64u,
+			lifecycle
+		});
+		return cas.outcome === "conflict" ? await reconcileProtocolCas(this.lifecycleStore, receipt.operationId, cas, receiptDigestB64u, "server") : cas;
+	}
+	async commitLaneEnrollmentActivationV1(input) {
+		const result = await this.lifecycleStore.commitEnrollmentVisibility(input);
+		if (result.outcome === "conflict") return {
+			kind: "lane_enrollment_activation_result_v1",
+			...result
+		};
+		const productEpochs = requireActiveProductEpochs(result.productEpochs);
+		return {
+			kind: "lane_enrollment_activation_result_v1",
+			outcome: result.outcome,
+			enrollmentId: input.enrollmentId,
+			version: result.version,
+			commandDigestB64u: result.commandDigestB64u,
+			receipt: result.receipt,
+			lifecycle: result.lifecycle,
+			productEpochs
+		};
+	}
+};
+function nextResumeLifecycle(lifecycle) {
+	switch (lifecycle.state) {
+		case "preparing": return transitionLaneProtocolLifecycleV1(lifecycle, {
+			action: "await_protocol_commitment",
+			atMs: lifecycle.startedAtMs
+		});
+		case "awaiting_protocol_commitment":
+		case "committed_awaiting_holder_delivery":
+		case "awaiting_server_activation":
+		case "ready_for_parent_visibility":
+		case "active":
+		case "aborted_precommit": return lifecycle;
+		case "committed_completion_required": return transitionLaneProtocolLifecycleV1(lifecycle, {
+			action: "resume_completion",
+			atMs: lifecycle.committedAtMs
+		});
+		default: return assertNeverLifecycle(lifecycle);
+	}
+}
+function assertNeverLifecycle(value) {
+	throw new Error(`Unhandled lane protocol lifecycle ${JSON.stringify(value)}`);
+}
+async function digestResumeCommand(input) {
+	return base64UrlEncode(await sha256BytesUtf8([
+		"seams/rotatable-signing-lanes/resume-protocol-operation/v1",
+		String(input.operationId),
+		String(input.enrollmentId),
+		String(input.idempotencyKey),
+		String(input.expectedVersion)
+	].join("\0")));
+}
+async function encodedDigest(value, encode) {
+	return base64UrlEncode(await sha256Bytes(encode(value)));
+}
+async function digestReceipt(receipt) {
+	return encodedDigest(receipt, (value) => encodeLaneProtocolCommitReceiptV1(value));
+}
+async function digestHolderReceipt(receipt) {
+	return encodedDigest(receipt, (value) => encodeLaneHolderDeliveryReceiptV1(value));
+}
+async function digestServerReceipt(receipt) {
+	return encodedDigest(receipt, (value) => encodeLaneServerActivationReceiptV1(value));
+}
+async function readOrderedProtocols(store, children) {
+	const protocols = [];
+	for (const child of children) {
+		const protocol = await store.getProtocol(child.operationId);
+		if (!protocol) throw new Error(`lane protocol admission did not persist ${String(child.operationId)}`);
+		protocols.push({
+			version: protocol.version,
+			commandDigestB64u: parseDigestB64u(protocol.commandDigestB64u),
+			record: protocol.value
+		});
+	}
+	const first = protocols[0];
+	if (!first) throw new Error("lane enrollment requires at least one child");
+	return [first, ...protocols.slice(1)];
+}
+async function reconcileProtocolCas(store, operationId, conflict, digestB64u, stage) {
+	const raced = await store.getProtocol(operationId);
+	if (!raced) return conflict;
+	const lifecycle = raced.value.lifecycle;
+	return stage === "protocol" && (lifecycle.state === "committed_awaiting_holder_delivery" || lifecycle.state === "awaiting_server_activation" || lifecycle.state === "ready_for_parent_visibility" || lifecycle.state === "active") && lifecycle.protocolCommitReceiptDigestB64u === digestB64u || stage === "holder" && (lifecycle.state === "awaiting_server_activation" || lifecycle.state === "ready_for_parent_visibility" || lifecycle.state === "active") && lifecycle.holderDeliveryReceiptDigestB64u === digestB64u || stage === "server" && (lifecycle.state === "ready_for_parent_visibility" || lifecycle.state === "active") && lifecycle.serverActivationReceiptDigestB64u === digestB64u ? {
+		outcome: "replayed",
+		version: raced.version,
+		commandDigestB64u: raced.commandDigestB64u,
+		record: raced.value
+	} : conflict;
+}
+function requireActiveProductEpochs(values) {
+	const active = values.filter((value) => value.state === "active");
+	const first = active[0];
+	if (!first) throw new Error("lane activation returned no active product epochs");
+	return [first, ...active.slice(1)];
+}
+//#endregion
+export { LaneEnrollmentActivation };
+
+//# sourceMappingURL=LaneEnrollmentActivation.js.map

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

@@ -0,0 +1,173 @@
+import { base64UrlEncode } from "../../shared-ts/src/utils/base64.js";
+import { sha256BytesUtf8 } from "../../shared-ts/src/utils/digests.js";
+import { buildAggregateLaneRevocationReceiptV1, buildCommitLaneEnrollmentRevocationV1, parseRevokeLaneEnrollmentV1 } from "../../shared-ts/src/signing-lanes/rotationParsers.js";
+import { computeLaneEnrollmentManifestDigestV1, computeRevokeSigningLaneDigestV1 } from "../../shared-ts/src/signing-lanes/rotationDigests.js";
+//#region src/core/signingLanes/LaneEnrollmentRevocation.ts
+/**
+* Revocation is intentionally separate from activation. The fence write must
+* land before any caller asks a participant to retire material; this class
+* only owns the Gateway-side lifecycle boundary.
+*/
+var LaneEnrollmentRevocation = class {
+	constructor(lifecycleStore) {
+		this.lifecycleStore = lifecycleStore;
+	}
+	async fenceEnrollment(input) {
+		const result = await this.lifecycleStore.fenceEnrollmentRevocation(input);
+		if (result.outcome === "conflict") throw new Error(`lane enrollment revocation fence conflicted at version ${result.actualVersion}`);
+	}
+	async commitEnrollment(input) {
+		const result = await this.lifecycleStore.commitEnrollmentRevocation(input);
+		if (result.outcome === "conflict") return {
+			kind: "lane_enrollment_revocation_result_v1",
+			...result
+		};
+		const productEpochs = result.productEpochs.filter((epoch) => epoch.state === "revoked");
+		const first = productEpochs[0];
+		if (!first) throw new Error("lane revocation returned no revoked product epochs");
+		return {
+			kind: "lane_enrollment_revocation_result_v1",
+			outcome: result.outcome,
+			enrollmentId: input.command.enrollmentId,
+			version: result.version,
+			commandDigestB64u: result.commandDigestB64u,
+			receipt: result.receipt,
+			lifecycle: result.lifecycle,
+			productEpochs: [first, ...productEpochs.slice(1)]
+		};
+	}
+	async completeLaneEnrollmentRevocationV1(input) {
+		const command = parseRevokeLaneEnrollmentV1(input.command);
+		const admission = await this.lifecycleStore.getEnrollment(command.enrollmentId);
+		if (!admission) throw new Error("lane enrollment is not admitted");
+		if (String(admission.value.manifest.walletId) !== String(command.walletId)) throw new Error("lane enrollment revocation wallet differs from its manifest");
+		if (await computeLaneEnrollmentManifestDigestV1(admission.value.manifest) !== command.manifestDigestB64u) throw new Error("lane enrollment revocation manifest differs from its admission");
+		const productEpochs = await this.lifecycleStore.listEnrollmentProductEpochs(command.enrollmentId);
+		if (productEpochs.length !== admission.value.manifest.orderedChildren.length) throw new Error("lane enrollment revocation product count differs from its manifest");
+		const productsByOperation = new Map(productEpochs.map((product) => [String(product.operationId), product]));
+		const orderedProducts = admission.value.manifest.orderedChildren.map((child) => {
+			const product = productsByOperation.get(String(child.operationId));
+			if (!product) throw new Error(`lane enrollment product is missing ${String(child.operationId)}`);
+			return product;
+		});
+		if (productsByOperation.size !== productEpochs.length) throw new Error("lane enrollment revocation product operation ids are duplicated");
+		const first = orderedProducts[0];
+		if (!first) throw new Error("lane enrollment revocation requires product epochs");
+		const revokedAtMs = first.state === "revoked" ? first.revokedAtMs : void 0;
+		if (revokedAtMs === void 0 || revokedAtMs !== command.requestedAtMs) throw new Error("lane enrollment revocation timestamp differs from its product epochs");
+		const orderedChildReceipts = orderedProducts.map((product, index) => {
+			const child = admission.value.manifest.orderedChildren[index];
+			if (product.state !== "revoked") throw new Error(`lane enrollment product ${String(child.operationId)} is not durably revoked`);
+			assertRevokedProductMatchesManifest(product, child, command.walletId, command.enrollmentId);
+			if (product.revokedAtMs !== revokedAtMs) throw new Error("lane enrollment product revocation timestamps differ");
+			return {
+				operationId: product.operationId,
+				walletKeyId: product.walletKeyId,
+				targetLaneId: product.laneId,
+				targetLaneShareEpoch: product.laneShareEpoch,
+				targetMaterialActivation: product.materialActivation,
+				revocationEpoch: product.revocationEpoch,
+				retirementReceiptDigestB64u: product.revocationReceiptDigestB64u
+			};
+		});
+		const firstChildReceipt = orderedChildReceipts[0];
+		if (!firstChildReceipt) throw new Error("lane enrollment revocation requires child receipts");
+		const receipt = buildAggregateLaneRevocationReceiptV1({
+			enrollmentId: command.enrollmentId,
+			walletId: command.walletId,
+			manifestDigestB64u: command.manifestDigestB64u,
+			orderedChildReceipts: [firstChildReceipt, ...orderedChildReceipts.slice(1)],
+			revokedAtMs
+		});
+		const commit = buildCommitLaneEnrollmentRevocationV1({
+			enrollmentId: command.enrollmentId,
+			walletId: command.walletId,
+			manifestDigestB64u: command.manifestDigestB64u,
+			receipt,
+			revokedAtMs
+		});
+		return await this.commitEnrollment({
+			command: commit,
+			expectedVersion: input.expectedVersion,
+			commandDigestB64u: await digestLaneEnrollmentRevocationCommand(command)
+		});
+	}
+	async fenceSigningLaneRevocationV1(input) {
+		const commandDigestB64u = await computeRevokeSigningLaneDigestV1(input);
+		const result = await this.lifecycleStore.fenceLaneRevocation(input);
+		if (result.outcome === "conflict") return {
+			kind: "lane_signing_lane_revocation_fence_result_v1",
+			outcome: "conflict",
+			walletKeyId: input.walletKeyId,
+			laneId: input.laneId,
+			laneShareEpoch: input.laneShareEpoch,
+			expectedVersion: result.expectedVersion,
+			actualVersion: result.actualVersion,
+			requestedCommandDigestB64u: result.requestedCommandDigestB64u,
+			storedCommandDigestB64u: result.storedCommandDigestB64u
+		};
+		if (result.outcome === "already_completed") return {
+			kind: "lane_signing_lane_revocation_fence_result_v1",
+			outcome: "already_completed",
+			walletKeyId: input.walletKeyId,
+			laneId: input.laneId,
+			laneShareEpoch: input.laneShareEpoch,
+			version: result.version,
+			commandDigestB64u,
+			productEpoch: result.productEpoch,
+			retirementReceipt: result.retirementReceipt
+		};
+		return {
+			kind: "lane_signing_lane_revocation_fence_result_v1",
+			outcome: result.outcome,
+			walletKeyId: input.walletKeyId,
+			laneId: input.laneId,
+			laneShareEpoch: input.laneShareEpoch,
+			version: result.version,
+			commandDigestB64u,
+			productEpoch: result.productEpoch
+		};
+	}
+	async completeSigningLaneRevocationV1(input) {
+		const result = await this.lifecycleStore.commitLaneRevocation({ completion: input });
+		if (result.outcome === "conflict") return {
+			kind: "lane_signing_lane_revocation_result_v1",
+			outcome: "conflict",
+			walletKeyId: input.command.walletKeyId,
+			laneId: input.command.laneId,
+			laneShareEpoch: input.command.laneShareEpoch,
+			expectedVersion: result.expectedVersion,
+			actualVersion: result.actualVersion,
+			requestedCommandDigestB64u: result.requestedCommandDigestB64u,
+			storedCommandDigestB64u: result.storedCommandDigestB64u
+		};
+		return {
+			kind: "lane_signing_lane_revocation_result_v1",
+			outcome: result.outcome,
+			walletKeyId: input.command.walletKeyId,
+			laneId: input.command.laneId,
+			laneShareEpoch: input.command.laneShareEpoch,
+			version: result.version,
+			commandDigestB64u: result.commandDigestB64u,
+			productEpoch: result.productEpoch,
+			retirementReceipt: result.retirementReceipt
+		};
+	}
+};
+function assertRevokedProductMatchesManifest(product, child, walletId, enrollmentId) {
+	if (String(product.walletId) !== String(walletId) || String(product.enrollmentId) !== String(enrollmentId) || String(product.operationId) !== String(child.operationId) || String(product.walletKeyId) !== String(child.walletKeyId) || product.keyFamily !== child.keyFamily || String(product.laneId) !== String(child.targetLaneId) || String(product.laneShareEpoch) !== String(child.targetLaneShareEpoch) || String(product.targetMaterialActivationId) !== String(child.targetMaterialActivationId) || String(product.materialActivation.activationId) !== String(child.targetMaterialActivationId) || product.holderParticipant.participantBindingDigestB64u !== child.holderParticipantBindingDigestB64u || product.signingWorkerParticipant.participantBindingDigestB64u !== child.signingWorkerParticipantBindingDigestB64u) throw new Error("lane enrollment product differs from its admitted manifest child");
+}
+async function digestLaneEnrollmentRevocationCommand(input) {
+	return base64UrlEncode(await sha256BytesUtf8([
+		"seams/rotatable-signing-lanes/revoke-enrollment/v1",
+		String(input.enrollmentId),
+		String(input.walletId),
+		input.manifestDigestB64u,
+		input.reason,
+		String(input.requestedAtMs)
+	].join("\0")));
+}
+//#endregion
+export { LaneEnrollmentRevocation };
+
+//# sourceMappingURL=LaneEnrollmentRevocation.js.map