@seams/wallet-server 0.6.1 → 0.7.1

package/dist/esm/router/domains/ed25519Yao/export/routerAbEd25519YaoExportRequestScopedCloudflare.js

@@ -8,136 +8,6 @@ import { json, readJson } from "../../../framework/http.js";
 import { InMemoryRouterAbEd25519YaoExportService, parseRouterAbEd25519YaoExportAdmissionEnvelopeV1, parseRouterAbEd25519YaoExportExecuteEnvelopeV1 } from "./routerAbEd25519YaoExport.js";
 import { runRouterAbEd25519YaoRegistrationTwoPhaseV1 } from "../registration/routerAbEd25519YaoRegistrationTwoPhaseRunner.js";
 //#region src/router/domains/ed25519Yao/export/routerAbEd25519YaoExportRequestScopedCloudflare.ts
-var ExportAuthorizationRequestRun = class {
-	constructor(context, parsed, expectedOrigin) {
-		this.context = context;
-		this.parsed = parsed;
-		this.expectedOrigin = expectedOrigin;
-		this.authorizationUncertain = false;
-		this.authorizationState = { kind: "pending" };
-	}
-	async prepare(state) {
-		const service = this.service(state);
-		if (service.authorizationIsUncertain(this.parsed.protocol)) return {
-			kind: "completed",
-			value: {
-				ok: false,
-				status: 503,
-				code: "export_authorization_uncertain",
-				message: "Export authorization outcome is uncertain and cannot be retried"
-			}
-		};
-		let identity = service.readAuthorizationIdentity(this.parsed.protocol);
-		if (identity && service.authorizationRequiresActiveIdentity(this.parsed.protocol)) {
-			const resolved = await this.context.input.authorization.resolveAuthorizationIdentity(this.context.input.request);
-			if (!resolved.ok) return {
-				kind: "completed",
-				value: resolved
-			};
-			if (!sameAuthorizationIdentity(resolved.authorizationIdentity, identity)) return {
-				kind: "completed",
-				value: {
-					ok: false,
-					status: 409,
-					code: "export_authorization_conflict",
-					message: "Export authorization owner changed for an existing request"
-				}
-			};
-		} else {
-			let authorized;
-			try {
-				authorized = await this.context.input.authorization.authorize({
-					kind: "admit",
-					request: this.context.input.request,
-					body: this.parsed.protocol,
-					authorization: this.parsed.authorization,
-					expectedOrigin: this.expectedOrigin
-				});
-			} catch (error) {
-				this.authorizationUncertain = true;
-				service.recordAuthorizationUncertain(this.parsed.protocol);
-				return {
-					kind: "completed",
-					value: {
-						ok: false,
-						status: 503,
-						code: "export_authorization_uncertain",
-						message: errorMessage(error)
-					}
-				};
-			}
-			if (!authorized.ok) return {
-				kind: "completed",
-				value: authorized
-			};
-			identity = authorized.authorizationIdentity;
-			this.authorizationState = {
-				kind: "authorized",
-				identity,
-				...authorized.factorRelease ? { factorRelease: authorized.factorRelease } : {}
-			};
-		}
-		if (!identity) return {
-			kind: "completed",
-			value: {
-				ok: false,
-				status: 503,
-				code: "export_authorization_uncertain",
-				message: "Export authorization identity is unavailable"
-			}
-		};
-		if (this.authorizationState.kind !== "authorized") this.authorizationState = {
-			kind: "authorized",
-			identity
-		};
-		const authorizationFingerprint = await authorizationFingerprintForIdentity(this.parsed, identity);
-		const preparation = service.prepareAuthorizeExport(this.parsed.protocol, authorizationFingerprint, identity);
-		switch (preparation.kind) {
-			case "claimed": return {
-				kind: "claimed",
-				state,
-				claim: preparation.claim
-			};
-			case "completed": return {
-				kind: "completed",
-				value: preparation.value
-			};
-		}
-	}
-	async backend(_claim) {
-		try {
-			if (this.authorizationState.kind !== "authorized") return {
-				kind: "uncertain",
-				message: "Export authorization was not prepared"
-			};
-			return {
-				kind: "response",
-				value: { ok: true }
-			};
-		} catch (error) {
-			return {
-				kind: "uncertain",
-				message: errorMessage(error)
-			};
-		}
-	}
-	async complete(state, claim, outcome) {
-		return {
-			state,
-			value: this.service(state).commitAuthorizeExport({
-				request: this.parsed.protocol,
-				claim,
-				outcome
-			})
-		};
-	}
-	service(state) {
-		return exportService(this.context, state);
-	}
-	didRecordAuthorizationUncertain() {
-		return this.authorizationUncertain;
-	}
-};
 var ExportAdmissionRequestRun = class {
 	constructor(context, request, authorizationIdentity) {
 		this.context = context;
@@ -177,6 +47,7 @@ var ExportAdmissionRequestRun = class {
 	}
 	async complete(state, claim, outcome) {
 		return {
+			kind: "state",
 			state,
 			value: exportService(this.context, state).commitAdmitExport({
 				request: this.request,
@@ -228,6 +99,7 @@ var ExportExecutionRequestRun = class {
 	}
 	async complete(state, claim, outcome) {
 		return {
+			kind: "state",
 			state,
 			value: exportService(this.context, state).commitExecuteExport({
 				request: this.request,
@@ -297,8 +169,7 @@ async function handleAdmissionRequest(context, raw) {
 async function handleExecutionRequest(context, raw) {
 	const parsed = parseRouterAbEd25519YaoExportExecuteEnvelopeV1(raw);
 	if (!parsed.ok) return invalidBody(parsed.message);
-	const authorized = await context.input.authorization.authorize({
-		kind: "execute",
+	const authorized = await context.input.authorization.authorizeExecution({
 		request: context.input.request,
 		body: parsed.protocol
 	});
@@ -312,26 +183,82 @@ async function handleExecutionRequest(context, raw) {
 		complete: run.complete.bind(run)
 	})));
 }
+/**
+* Authorizes one export admission in a single commit: after its proof
+* verifies, the export's `authorized` state, its nonce claim and its
+* authorized operation commit in one batch or not at all. A retry of the
+* exact request finds the export authorized, or nothing of it.
+*/
 async function runAuthorization(context, parsed, expectedOrigin) {
-	const run = new ExportAuthorizationRequestRun(context, parsed, expectedOrigin);
-	const result = await runRouterAbEd25519YaoRegistrationTwoPhaseV1({
-		lifecycleId: parsed.protocol.scope.lifecycle_id,
-		store: context.input.store,
-		prepare: run.prepare.bind(run),
-		backend: run.backend.bind(run),
-		complete: run.complete.bind(run)
-	});
-	if (run.didRecordAuthorizationUncertain()) {
-		const persisted = await persistAuthorizationUncertain(context, parsed.protocol);
-		if (persisted) return persisted;
+	const lifecycleId = parsed.protocol.scope.lifecycle_id;
+	let loaded = await context.input.store.load(lifecycleId);
+	const service = exportService(context, loaded.state);
+	if (service.authorizationIsUncertain(parsed.protocol)) return authorizationFailure(503, "export_authorization_uncertain", "Export authorization outcome is uncertain and cannot be retried");
+	const existingIdentity = service.readAuthorizationIdentity(parsed.protocol);
+	let verified;
+	if (existingIdentity) {
+		if (parsed.protocol.authorization.expires_at_ms <= Date.now()) return authorizationFailure(403, "export_authorization_expired", "Ed25519 Yao export authorization is expired");
+		const resolved = await context.input.authorization.resolveAuthorizationIdentity(parsed.protocol);
+		if (!resolved.ok) return resolved;
+		if (!sameAuthorizationIdentity(resolved.authorizationIdentity, existingIdentity)) return authorizationFailure(409, "export_authorization_conflict", "Export authorization owner changed for an existing request");
+		verified = {
+			identity: existingIdentity,
+			admission: null
+		};
+	} else {
+		let authorized;
+		try {
+			authorized = await context.input.authorization.authorizeAdmission({
+				request: context.input.request,
+				body: parsed.protocol,
+				authorization: parsed.authorization,
+				expectedOrigin
+			});
+		} catch (error) {
+			return await persistAuthorizationUncertain(context, parsed.protocol) ?? authorizationFailure(503, "export_authorization_uncertain", errorMessage(error));
+		}
+		if (!authorized.ok) return authorized;
+		verified = {
+			identity: authorized.authorizationIdentity,
+			admission: authorized.admission,
+			...authorized.factorRelease ? { factorRelease: authorized.factorRelease } : {}
+		};
 	}
-	const mapped = mapAuthorizationResult(result);
-	if (!mapped.ok) return mapped;
-	if (run.authorizationState.kind !== "authorized") return authorizationFailure(503, "export_authorization_uncertain", "Export authorization state is incomplete");
+	const authorizationFingerprint = await authorizationFingerprintForIdentity(parsed, verified.identity);
+	for (let attempt = 1;; attempt += 1) {
+		const decision = exportService(context, loaded.state).authorizeExport(parsed.protocol, authorizationFingerprint, verified.identity, verified.factorRelease ?? null);
+		if (decision.kind === "completed") return decision.value.ok ? authorizedRun({
+			identity: verified.identity,
+			admission: verified.admission,
+			...decision.value.factorRelease ? { factorRelease: decision.value.factorRelease } : {}
+		}) : decision.value;
+		if (!verified.admission) return authorizationFailure(503, "export_authorization_uncertain", "Export authorization changed while it was being replayed");
+		const prepared = await verified.admission.prepare();
+		if (prepared.kind === "rejected") return prepared.failure;
+		let committed;
+		try {
+			committed = await context.input.store.commit({
+				lifecycleId,
+				state: loaded.state,
+				baseline: loaded.baseline,
+				companionWrite: prepared.kind === "prepared" ? prepared.write : null
+			});
+		} catch (error) {
+			const rejected = verified.admission.classifyFailure(error);
+			if (rejected) return rejected;
+			throw error;
+		}
+		if (committed.kind === "stored") return authorizedRun(verified);
+		if (attempt === EXPORT_AUTHORIZATION_COMMIT_ATTEMPTS) return authorizationFailure(409, "export_authorization_conflict", `Export authorization conflicted on ${committed.key}`);
+		loaded = await context.input.store.load(lifecycleId);
+	}
+}
+const EXPORT_AUTHORIZATION_COMMIT_ATTEMPTS = 2;
+function authorizedRun(verified) {
 	return {
 		ok: true,
-		authorizationIdentity: run.authorizationState.identity,
-		...run.authorizationState.factorRelease ? { factorRelease: run.authorizationState.factorRelease } : {}
+		authorizationIdentity: verified.identity,
+		...verified.factorRelease ? { factorRelease: verified.factorRelease } : {}
 	};
 }
 async function persistAuthorizationUncertain(context, request) {
@@ -340,7 +267,8 @@ async function persistAuthorizationUncertain(context, request) {
 	if ((await context.input.store.commit({
 		lifecycleId: request.scope.lifecycle_id,
 		state: loaded.state,
-		baseline: loaded.baseline
+		baseline: loaded.baseline,
+		companionWrite: null
 	})).kind === "version_mismatch") return authorizationFailure(503, "export_authorization_uncertain", "Export authorization outcome is uncertain after persistence conflict");
 	return null;
 }
@@ -354,16 +282,6 @@ async function runAdmission(context, request, authorizationIdentity) {
 		complete: run.complete.bind(run)
 	}));
 }
-function mapAuthorizationResult(result) {
-	switch (result.kind) {
-		case "committed":
-		case "completed": return result.value;
-		case "rejected": return assertNever(result.value);
-		case "preclaim_version_mismatch": return authorizationFailure(409, "export_authorization_conflict", `Export authorization claim conflicted on ${result.key}`);
-		case "backend_uncertain": return authorizationFailure(503, "export_authorization_uncertain", result.message);
-		case "terminal_version_mismatch": return authorizationFailure(503, "export_authorization_uncertain", `Export authorization outcome is uncertain after a ${result.key} conflict`);
-	}
-}
 function mapAdmissionResult(result) {
 	switch (result.kind) {
 		case "committed":
@@ -456,9 +374,6 @@ function resolveTrace(request) {
 function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
-function assertNever(value) {
-	throw new Error(`Unhandled export request-scoped value: ${String(value)}`);
-}
 //#endregion
 export { handleRouterAbEd25519YaoExportRequestScopedCloudflareV1 };