@seams/wallet-server 0.6.1 → 0.7.1

package/dist/esm/router/domains/ed25519Yao/registration/routerAbEd25519YaoHttpRegistrationBackend.js

@@ -1,15 +1,19 @@
-import { deriveRouterAbEd25519YaoStableContextBindingV1, parseRouterAbEd25519YaoActivationKeysetV1, parseRouterAbEd25519YaoActivationResultV1, parseRouterAbEd25519YaoExportResultV1 } from "../../../../shared-ts/src/utils/routerAbEd25519Yao.js";
+import { requireRecord } from "../../../../shared-ts/src/utils/validation.js";
+import { deriveRouterAbEd25519YaoStableContextBindingV1 } from "../../../../shared-ts/src/utils/routerAbEd25519YaoDigests.js";
+import { parseRouterAbEd25519YaoActivationKeysetV1, parseRouterAbEd25519YaoActivationResultV1, parseRouterAbEd25519YaoExportResultV1 } from "../../../../shared-ts/src/utils/routerAbEd25519Yao.js";
 import { createRouterAbTraceContextV1 } from "../../../../shared-ts/src/utils/routerAbTraceContext.js";
+import { routerAbEd25519YaoTenantRootWireV1 } from "../routerAbEd25519YaoGatewayEnvelope.js";
 //#region src/router/domains/ed25519Yao/registration/routerAbEd25519YaoHttpRegistrationBackend.ts
 const INTERNAL_AUTH_HEADER = "x-router-ab-internal-service-auth";
 const TRACE_ID_HEADER = "x-seams-trace-id";
 const ROUTER_REPLAY_HEADER = "x-seams-yao-replay";
 const ROUTER_EXECUTE_PATH = "/router-ab/router/ed25519-yao/execute";
+const ROUTER_REGISTRATION_CONSUME_PATH = "/router-ab/router/ed25519-yao/registration/consume";
 const ROUTER_RECOVERY_PROMOTE_PATH = "/router-ab/router/ed25519-yao/recovery/promote";
 const ROUTER_AB_ENV_KEYS = {
 	routerUrl: "MPC_ROUTER_URL",
 	signingWorkerId: "SIGNING_WORKER_ID",
-	internalServiceAuth: "ROUTER_AB_INTERNAL_SERVICE_AUTH_SECRET",
+	internalServiceAuth: "ROUTER_AB_GATEWAY_TO_ROUTER_AUTH_SECRET",
 	deriverAInputPublicKey: "DERIVER_A_ED25519_YAO_INPUT_PUBLIC_KEY",
 	deriverBInputPublicKey: "DERIVER_B_ED25519_YAO_INPUT_PUBLIC_KEY",
 	signingWorkerRecipientPublicKey: "SIGNING_WORKER_SERVER_OUTPUT_HPKE_PUBLIC_KEY"
@@ -21,10 +25,6 @@ function parseRouterAbEd25519YaoActivationKeysetFromEnvV1(env) {
 		signing_worker_recipient_public_key: x25519PublicKeyFromEnv(envValue(env, ROUTER_AB_ENV_KEYS.signingWorkerRecipientPublicKey), ROUTER_AB_ENV_KEYS.signingWorkerRecipientPublicKey)
 	});
 }
-function requireRecord(value, label) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
-	return value;
-}
 function requireExactKeys(record, label, allowedKeys) {
 	const allowed = new Set(allowedKeys);
 	for (const key of Object.keys(record)) if (!allowed.has(key)) throw new Error(`${label}.${key} is not supported`);
@@ -140,6 +140,31 @@ function unavailableFailure(error) {
 		message: error instanceof Error ? error.message : String(error)
 	};
 }
+function executionInProgressFailure() {
+	return {
+		ok: false,
+		status: 409,
+		code: "execution_in_progress",
+		message: "registration execution is already in progress"
+	};
+}
+function executionMismatchFailure() {
+	return {
+		ok: false,
+		status: 409,
+		code: "execution_mismatch",
+		message: "registration execution rejects a different execution payload"
+	};
+}
+/** A later attempt of the same recovery took this one's place: final. */
+function attemptSupersededFailure() {
+	return {
+		ok: false,
+		status: 409,
+		code: "recovery_superseded",
+		message: "a later attempt of this recovery took its place at the SigningWorker"
+	};
+}
 function ceremonyExpiredFailure() {
 	return {
 		ok: false,
@@ -184,44 +209,42 @@ function activeReceiptMatchesRecoveryActivation(receipt, activation) {
 	const publicReceipt = activation.public_receipt;
 	return equalBytes(receipt.session, activation.binding.session_id) && equalBytes(receipt.transcript, publicReceipt.transcript) && equalBytes(receipt.registeredPublicKey, publicReceipt.registered_public_key) && equalBytes(receipt.joinedClientCommitment, publicReceipt.joined_client_commitment) && equalBytes(receipt.joinedSigningWorkerCommitment, publicReceipt.joined_signing_worker_commitment) && equalBytes(receipt.signingWorkerVerifyingShare, publicReceipt.signing_worker_verifying_share) && receipt.stateEpoch === publicReceipt.state_epoch;
 }
-function tenantRootBoundary(root) {
+function registrationRouterExecuteRequest(input, tenantRoot) {
 	return {
-		identity_digest_b64u: root.identityDigestB64u,
-		custody_lineage_b64u: root.custodyLineageB64u
+		tenant_root: tenantRoot,
+		application: input.admissionRequest.application_binding,
+		participant_ids: input.admissionRequest.participant_ids,
+		target: {
+			operation: "registration",
+			binding: input.request.binding,
+			deriver_a_input: input.request.deriver_a_input,
+			deriver_b_input: input.request.deriver_b_input
+		}
 	};
 }
+function recoveryRouterExecuteRequest(input, tenantRoot, attempt) {
+	return {
+		tenant_root: tenantRoot,
+		application: input.admissionRequest.application_binding,
+		participant_ids: input.admissionRequest.participant_ids,
+		target: {
+			operation: "recovery",
+			binding: input.request.binding,
+			attempt,
+			deriver_a_input: input.request.deriver_a_input,
+			deriver_b_input: input.request.deriver_b_input
+		}
+	};
+}
+/** A recovery runs under the root pinned at its admission, never resolved here. */
 async function routerExecuteRequest(input, resolveTenantRoot) {
 	switch (input.operation) {
-		case "registration": return {
-			tenant_root: tenantRootBoundary(await resolveTenantRoot({
-				operation: "registration",
-				admissionRequest: input.admissionRequest
-			})),
-			application: input.admissionRequest.application_binding,
-			participant_ids: input.admissionRequest.participant_ids,
-			target: {
-				operation: "registration",
-				binding: input.request.binding,
-				deriver_a_input: input.request.deriver_a_input,
-				deriver_b_input: input.request.deriver_b_input
-			}
-		};
-		case "recovery": return {
-			tenant_root: tenantRootBoundary(await resolveTenantRoot({
-				operation: "recovery",
-				admissionRequest: input.admissionRequest
-			})),
-			application: input.admissionRequest.application_binding,
-			participant_ids: input.admissionRequest.participant_ids,
-			target: {
-				operation: "recovery",
-				binding: input.request.binding,
-				deriver_a_input: input.request.deriver_a_input,
-				deriver_b_input: input.request.deriver_b_input
-			}
-		};
+		case "registration": return registrationRouterExecuteRequest(input, await routerAbEd25519YaoTenantRootWireV1(await resolveTenantRoot({
+			operation: "registration",
+			admissionRequest: input.admissionRequest
+		})));
 		case "export": return {
-			tenant_root: tenantRootBoundary(await resolveTenantRoot({
+			tenant_root: await routerAbEd25519YaoTenantRootWireV1(await resolveTenantRoot({
 				operation: "export",
 				admissionRequest: input.admissionRequest
 			})),
@@ -256,15 +279,19 @@ function parseRouterExecuteResult(value, request) {
 					"ceremony_expired",
 					"signing_worker_uncertain",
 					"terminal_role_failure",
-					"authorization_rejected"
+					"authorization_rejected",
+					"execution_in_progress"
 				].includes(envelope.code)) throw new Error("Router Yao recoverable failure code is invalid");
 				requirePositiveSafeInteger(envelope.retry_after_ms, "Router Yao retry_after_ms");
 				if (envelope.code === "ceremony_expired") return ceremonyExpiredFailure();
+				if (envelope.code === "execution_in_progress") return executionInProgressFailure();
 				return internalFailure("router_execution_retryable", "Router Yao execution is retryable");
 			case "rejected":
 				requireExactKeys(envelope, "Router Yao rejected result", ["status", "code"]);
 				if (typeof envelope.code !== "string" || envelope.code.length === 0) throw new Error("Router Yao rejection code is invalid");
 				if (envelope.code === "ceremony_expired") return ceremonyExpiredFailure();
+				if (envelope.code === "execution_mismatch") return executionMismatchFailure();
+				if (envelope.code === "attempt_superseded") return attemptSupersededFailure();
 				return internalFailure("router_execution_rejected", "Router Yao execution was rejected");
 			case "burned":
 				requireExactKeys(envelope, "Router Yao burned result", [
@@ -317,6 +344,55 @@ function parseRouterExecuteResult(value, request) {
 		return internalFailure("invalid_router_result", error instanceof Error ? error.message : String(error));
 	}
 }
+/** The registration result a Router answer, exactly as recorded, carries. */
+function parseRouterAbEd25519YaoRegistrationRouterAnswerV1(responseJson, request) {
+	let answer;
+	try {
+		answer = JSON.parse(responseJson);
+	} catch {
+		return internalFailure("invalid_router_result", "Router registration answer is not JSON");
+	}
+	return parseRouterExecuteResult(answer, request);
+}
+function parseRouterRegistrationConsumeOutcome(value) {
+	try {
+		const envelope = requireRecord(value, "Router registration consume answer");
+		switch (envelope.kind) {
+			case "consumed":
+				requireExactKeys(envelope, "Router registration consumption", [
+					"kind",
+					"request_json",
+					"response_json"
+				]);
+				if (typeof envelope.request_json !== "string" || typeof envelope.response_json !== "string") throw new Error("Router registration consumption is invalid");
+				return {
+					kind: "consumed",
+					requestJson: envelope.request_json,
+					responseJson: envelope.response_json
+				};
+			case "refused": {
+				requireExactKeys(envelope, "Router registration consume refusal", [
+					"kind",
+					"code",
+					"message"
+				]);
+				const code = envelope.code;
+				if (code !== "unknown_registration" && code !== "registration_not_activated" && code !== "activation_reference_mismatch" && code !== "activation_consumed" || typeof envelope.message !== "string") throw new Error("Router registration consume refusal is invalid");
+				return {
+					kind: "refused",
+					code,
+					message: envelope.message
+				};
+			}
+			default: throw new Error("Router registration consume answer kind is invalid");
+		}
+	} catch (error) {
+		return {
+			kind: "unavailable",
+			message: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
 function requestInitWithReplayHeader(init) {
 	const headers = new Headers(init.headers);
 	headers.set(ROUTER_REPLAY_HEADER, "1");
@@ -387,7 +463,7 @@ var RouterAbEd25519YaoHttpRegistrationBackend = class {
 			operation: "export",
 			request,
 			admissionRequest
-		}, traceContext);
+		}, false, traceContext);
 	}
 	keyset() {
 		return {
@@ -458,16 +534,59 @@ var RouterAbEd25519YaoHttpRegistrationBackend = class {
 			operation: "registration",
 			request,
 			admissionRequest
-		}, traceContext);
+		}, false, traceContext);
 	}
-	async executeRecovery(request, admissionRequest, traceContext) {
-		return await this.executeRouterRequest({
+	async resolveRegistrationDispatchRoot(admissionRequest) {
+		return await routerAbEd25519YaoTenantRootWireV1(await this.config.resolveTenantRoot({
+			operation: "registration",
+			admissionRequest
+		}));
+	}
+	async executePinnedRegistration(request, admissionRequest, dispatchRoot, traceContext) {
+		const routerInput = {
+			operation: "registration",
+			request,
+			admissionRequest
+		};
+		return await this.sendRouterRequest(routerInput, registrationRouterExecuteRequest(routerInput, dispatchRoot), traceContext.value, "exact", false);
+	}
+	async consumeRegistration(input) {
+		let response;
+		try {
+			response = await this.post(ROUTER_REGISTRATION_CONSUME_PATH, {
+				tenant_root: input.tenantRoot,
+				wallet_id: input.walletId,
+				lifecycle_id: input.lifecycleId,
+				session_id: Array.from(input.sessionId),
+				consumer_binding: input.consumerBinding
+			}, createRouterAbTraceContextV1().value, "exact");
+		} catch (error) {
+			return {
+				kind: "unavailable",
+				message: error instanceof Error ? error.message : String(error)
+			};
+		}
+		if (!response.ok) return {
+			kind: "unavailable",
+			message: response.message
+		};
+		return parseRouterRegistrationConsumeOutcome(response.body);
+	}
+	async resolveRecoveryDispatchRoot(admissionRequest) {
+		return await routerAbEd25519YaoTenantRootWireV1(await this.config.resolveTenantRoot({
+			operation: "recovery",
+			admissionRequest
+		}));
+	}
+	async executeRecovery(request, admissionRequest, dispatchRoot, attempt, replay, traceContext) {
+		const routerInput = {
 			operation: "recovery",
 			request,
 			admissionRequest
-		}, traceContext);
+		};
+		return await this.sendRouterRequest(routerInput, recoveryRouterExecuteRequest(routerInput, dispatchRoot, attempt), (traceContext ?? createRouterAbTraceContextV1()).value, "replay", replay);
 	}
-	async executeRouterRequest(request, traceContext) {
+	async executeRouterRequest(request, replay, traceContext) {
 		const traceId = (traceContext ?? createRouterAbTraceContextV1()).value;
 		const operation = request.operation;
 		const preYaoStartedAt = performance.now();
@@ -479,9 +598,13 @@ var RouterAbEd25519YaoHttpRegistrationBackend = class {
 			return unavailableFailure(error);
 		}
 		emitGatewaySpan(this.config.onSpan, "gateway.pre_yao", operation, traceId, preYaoStartedAt, "success");
+		return await this.sendRouterRequest(request, routerRequest, traceId, "replay", replay);
+	}
+	async sendRouterRequest(request, routerRequest, traceId, retryAfterTransportFailure, replay) {
+		const operation = request.operation;
 		const executeStartedAt = performance.now();
 		try {
-			const response = await this.post(ROUTER_EXECUTE_PATH, routerRequest, traceId, true);
+			const response = await this.post(ROUTER_EXECUTE_PATH, routerRequest, traceId, retryAfterTransportFailure, replay);
 			this.lastRouterServerTiming = response.ok ? response.serverTiming : null;
 			const result = response.ok ? parseRouterExecuteResult(response.body, request.request) : response;
 			emitGatewaySpan(this.config.onSpan, "gateway.yao_execute", operation, traceId, executeStartedAt, result.ok ? "success" : "failure");
@@ -491,8 +614,11 @@ var RouterAbEd25519YaoHttpRegistrationBackend = class {
 			return unavailableFailure(error);
 		}
 	}
-	async activateRecovery(request, traceContext) {
-		const promoted = await this.post(ROUTER_RECOVERY_PROMOTE_PATH, request, (traceContext ?? createRouterAbTraceContextV1()).value);
+	async activateRecovery(request, dispatchRoot, traceContext) {
+		const promoted = await this.post(ROUTER_RECOVERY_PROMOTE_PATH, {
+			...request,
+			tenant_root: dispatchRoot
+		}, (traceContext ?? createRouterAbTraceContextV1()).value);
 		if (!promoted.ok) return promoted;
 		if (!activeReceiptMatchesRecoveryActivation(parseActiveSigningWorkerReceipt(promoted.body, request.binding.session_id, request.public_receipt.transcript), request)) return internalFailure("recovery_promotion_mismatch", "Router promotion receipt does not match the verified recovery result");
 		return {
@@ -500,12 +626,13 @@ var RouterAbEd25519YaoHttpRegistrationBackend = class {
 			body: request
 		};
 	}
-	async post(path, body, traceId, replayOnTransportFailure = false) {
-		return await this.request(this.config.routerUrl, path, {
+	async post(path, body, traceId, retryAfterTransportFailure = "none", replay = false) {
+		const init = {
 			method: "POST",
 			headers: this.headers(traceId),
 			body: JSON.stringify(body)
-		}, replayOnTransportFailure);
+		};
+		return await this.request(this.config.routerUrl, path, replay ? requestInitWithReplayHeader(init) : init, retryAfterTransportFailure);
 	}
 	headers(traceId) {
 		return {
@@ -514,13 +641,13 @@ var RouterAbEd25519YaoHttpRegistrationBackend = class {
 			[TRACE_ID_HEADER]: traceId
 		};
 	}
-	async request(baseUrl, path, init, replayOnTransportFailure) {
+	async request(baseUrl, path, init, retryAfterTransportFailure) {
 		let response;
 		try {
 			response = await this.config.fetch.call(globalThis, `${baseUrl}${path}`, init);
 		} catch (error) {
-			if (!replayOnTransportFailure) throw error;
-			response = await this.config.fetch.call(globalThis, `${baseUrl}${path}`, requestInitWithReplayHeader(init));
+			if (retryAfterTransportFailure === "none") throw error;
+			response = await this.config.fetch.call(globalThis, `${baseUrl}${path}`, retryAfterTransportFailure === "replay" ? requestInitWithReplayHeader(init) : init);
 		}
 		const text = await response.text();
 		if (!response.ok) return internalFailure("worker_rejected", `worker ${path} returned HTTP ${response.status}`);
@@ -567,6 +694,6 @@ function createRouterAbEd25519YaoHttpRegistrationBackendFromEnv(input) {
 	});
 }
 //#endregion
-export { RouterAbEd25519YaoHttpRegistrationBackend, createRouterAbEd25519YaoHttpRegistrationBackendFromEnv, parseRouterAbEd25519YaoActivationKeysetFromEnvV1 };
+export { RouterAbEd25519YaoHttpRegistrationBackend, createRouterAbEd25519YaoHttpRegistrationBackendFromEnv, parseRouterAbEd25519YaoActivationKeysetFromEnvV1, parseRouterAbEd25519YaoRegistrationRouterAnswerV1 };
 
 //# sourceMappingURL=routerAbEd25519YaoHttpRegistrationBackend.js.map

package/dist/esm/router/domains/ed25519Yao/registration/routerAbEd25519YaoRegistration.js

@@ -22,6 +22,7 @@ var InMemoryRouterAbEd25519YaoRegistrationStateV1 = class {
 		this.states = /* @__PURE__ */ new Map();
 		this.lifecycleSessions = /* @__PURE__ */ new Map();
 		this.admissionClaims = /* @__PURE__ */ new Map();
+		this.dispatchRoots = /* @__PURE__ */ new Map();
 	}
 };
 function registrationSessionKey(receipt) {
@@ -550,6 +551,6 @@ var InMemoryRouterAbEd25519YaoRegistrationService = class {
 	}
 };
 //#endregion
-export { InMemoryRouterAbEd25519YaoRegistrationService, InMemoryRouterAbEd25519YaoRegistrationStateV1, createRouterAbEd25519YaoRegistrationModule, encodeRouterAbEd25519YaoRegistrationAdmissionFingerprintV1, routerAbEd25519YaoExecutionMatchesAdmissionV1, routerAbEd25519YaoResultMatchesExecutionV1 };
+export { InMemoryRouterAbEd25519YaoRegistrationService, InMemoryRouterAbEd25519YaoRegistrationStateV1, createRouterAbEd25519YaoRegistrationModule, encodeRouterAbEd25519YaoRegistrationAdmissionFingerprintV1, routerAbEd25519YaoExecutionMatchesAdmissionV1 };
 
 //# sourceMappingURL=routerAbEd25519YaoRegistration.js.map