@seams/wallet-server 0.8.0 → 0.9.1

package/dist/esm/router/cloudflare/runtime/walletRelocationDeriver.js

@@ -0,0 +1,244 @@
+import { isPlainObject } from "../../../shared-ts/src/utils/validation.js";
+import { walletObjectIdentityHeaders, walletRelocationObjectIdentity } from "./walletObjectAddresses.js";
+import { ROUTER_AB_INTERNAL_SERVICE_AUTH_HEADER_V1 } from "../../../core/ThresholdService/routerAb/internalServiceHttp.js";
+//#region src/router/cloudflare/runtime/walletRelocationDeriver.ts
+function deriverRuntimeOperation(value) {
+	let role;
+	if (value.startsWith("deriver-a-")) role = "deriver-a";
+	else if (value.startsWith("deriver-b-")) role = "deriver-b";
+	else return null;
+	const operation = value.slice(role.length + 1);
+	switch (operation) {
+		case "fence":
+		case "capture":
+		case "export":
+		case "import":
+		case "status":
+		case "verify":
+		case "activate":
+		case "cleanup": return {
+			role,
+			operation
+		};
+		default: return null;
+	}
+}
+async function forwardDeriverRelocation(input, role, operation, binding, credential, directory) {
+	const fields = operation === "export" || operation === "import" ? 3 : 2;
+	if (!isPlainObject(input) || Object.keys(input).length !== fields || !isPlainObject(input.wallet) || !isPlainObject(input.attempt)) return failure("invalid_input", 400);
+	if (operation === "export" && !count(input.segmentIndex)) return failure("invalid_input", 400);
+	const envelope = {
+		wallet: input.wallet,
+		attempt: input.attempt
+	};
+	const journalRole = role === "deriver-a" ? "deriverA" : "deriverB";
+	try {
+		const contextResponse = await postRole(binding, role, "relocation-context", { kind: "cipher" }, credential, null);
+		if (!contextResponse.ok) return failure("source_command_unavailable", 503);
+		const context = await contextResponse.json();
+		if (!isPlainObject(context) || Object.keys(context).length !== 2 || context.kind !== "deriver_cipher_context" || !digest(context.digest_hex)) return failure("source_command_unavailable", 503);
+		const freezing = operation === "fence" || operation === "capture";
+		const request = operation === "export" ? {
+			operation,
+			segmentIndex: input.segmentIndex
+		} : { operation };
+		const authorization = await postDirectory(directory, freezing ? "relocation-deriver-source" : "relocation-deriver-transfer", freezing ? {
+			wallet: envelope.wallet,
+			attempt: envelope.attempt,
+			role: journalRole,
+			cipherContextDigest: context.digest_hex
+		} : {
+			wallet: envelope.wallet,
+			attempt: envelope.attempt,
+			role: journalRole,
+			request
+		});
+		if (!authorization.ok) return failure("source_command_denied", 409);
+		const result = await authorization.json();
+		if (!isPlainObject(result) || Object.keys(result).length !== 2 || result.ok !== true || !isPlainObject(result.command)) return failure("source_command_unavailable", 503);
+		const authorized = result.command;
+		let source;
+		let body;
+		if (freezing) {
+			source = parseSource(authorized, envelope, context.digest_hex);
+			if (!source) return failure("source_command_unavailable", 503);
+			body = operation === "fence" ? source : {
+				operation: "capture",
+				source
+			};
+		} else if (operation === "cleanup") {
+			const activation = parseActivation(authorized.activation, role, envelope, context.digest_hex);
+			if (!activation || Object.keys(authorized).length !== 2 || authorized.operation !== "cleanup") return failure("source_command_unavailable", 503);
+			return await postRole(binding, role, "snapshot", {
+				operation: "cleanup",
+				activation
+			}, credential, walletRelocationObjectIdentity(envelope.wallet, activation.source.source.source_generation));
+		} else if (operation === "export") {
+			source = parseSource(authorized.source, envelope, context.digest_hex);
+			if (!source || Object.keys(authorized).length !== 3 || authorized.operation !== "export" || authorized.segment_index !== input.segmentIndex) return failure("source_command_unavailable", 503);
+			body = {
+				operation: "export",
+				source,
+				segment_index: input.segmentIndex
+			};
+		} else {
+			const receipt = parseReceipt(authorized.receipt, role, envelope, context.digest_hex);
+			if (!receipt || Object.keys(authorized).length !== 2 || authorized.operation !== operation) return failure("source_command_unavailable", 503);
+			source = receipt.source;
+			if (operation === "activate") return await confirmActivation(await postRole(binding, role, "snapshot", {
+				operation: "activate",
+				receipt
+			}, credential, walletRelocationObjectIdentity(envelope.wallet, receipt.source.destination_generation)), receipt, role, envelope, context.digest_hex, directory);
+			if (operation === "import") {
+				const segment = parseSegment(input.segment, receipt);
+				if (!segment) return failure("invalid_input", 400);
+				body = {
+					operation: "import",
+					receipt,
+					segment
+				};
+			} else body = {
+				operation,
+				receipt
+			};
+		}
+		let response = await postRole(binding, role, operation === "fence" ? "fence-relocation" : "snapshot", body, credential, walletRelocationObjectIdentity(envelope.wallet, source.source_generation + (operation === "fence" || operation === "capture" || operation === "export" ? 0 : 1)));
+		if (operation !== "capture" || !response.ok) return response;
+		let captured = await response.clone().json();
+		for (let step = 1; step < 8 && isPlainObject(captured) && Object.keys(captured).length === 2 && captured.kind === "capturing" && count(captured.segment_count); step += 1) {
+			response = await postRole(binding, role, "snapshot", body, credential, walletRelocationObjectIdentity(envelope.wallet, source.source_generation));
+			if (!response.ok) return response;
+			captured = await response.clone().json();
+		}
+		if (isPlainObject(captured) && Object.keys(captured).length === 2 && captured.kind === "capturing" && count(captured.segment_count)) return response;
+		if (!isPlainObject(captured) || Object.keys(captured).length !== 2 || captured.kind !== "frozen") return failure("source_receipt_unavailable", 503);
+		const receipt = parseReceipt(captured.receipt, role, envelope, context.digest_hex);
+		if (!receipt || JSON.stringify(receipt.source) !== JSON.stringify(source)) return failure("source_receipt_unavailable", 503);
+		const stored = await postDirectory(directory, "relocation-deriver-receipt", {
+			wallet: envelope.wallet,
+			attempt: envelope.attempt,
+			role: journalRole,
+			receipt
+		});
+		if (!stored.ok) return failure("source_receipt_unavailable", 503);
+		const acknowledgement = await stored.json();
+		if (!isPlainObject(acknowledgement) || Object.keys(acknowledgement).length !== 2 || acknowledgement.ok !== true) return failure("source_receipt_unavailable", 503);
+		const confirmed = parseReceipt(acknowledgement.receipt, role, envelope, context.digest_hex);
+		if (!confirmed || JSON.stringify(confirmed) !== JSON.stringify(receipt)) return failure("source_receipt_unavailable", 503);
+		return response;
+	} catch {
+		return failure("source_command_unavailable", 503);
+	}
+}
+function parseSource(raw, envelope, contextDigest) {
+	if (!isPlainObject(raw) || Object.keys(raw).length !== 6 || !isPlainObject(raw.owner) || Object.keys(raw.owner).length !== 4 || typeof raw.owner.org_id !== "string" || raw.owner.org_id !== envelope.wallet.organizationId || typeof raw.owner.project_id !== "string" || raw.owner.project_id !== envelope.wallet.projectId || typeof raw.owner.env_id !== "string" || raw.owner.env_id !== envelope.wallet.environmentId || typeof raw.owner.wallet_id !== "string" || raw.owner.wallet_id !== envelope.wallet.walletId || typeof raw.move_id !== "string" || raw.move_id !== envelope.attempt.moveId || raw.cipher_context_digest_hex !== contextDigest || !digest(raw.request_digest_hex) || typeof raw.source_generation !== "number" || !Number.isSafeInteger(raw.source_generation) || raw.source_generation < 1 || raw.source_generation >= Number.MAX_SAFE_INTEGER || raw.destination_generation !== raw.source_generation + 1) return null;
+	return {
+		owner: {
+			org_id: raw.owner.org_id,
+			project_id: raw.owner.project_id,
+			env_id: raw.owner.env_id,
+			wallet_id: raw.owner.wallet_id
+		},
+		move_id: raw.move_id,
+		request_digest_hex: raw.request_digest_hex,
+		cipher_context_digest_hex: contextDigest,
+		source_generation: raw.source_generation,
+		destination_generation: raw.source_generation + 1
+	};
+}
+function parseReceipt(raw, role, envelope, contextDigest) {
+	if (!isPlainObject(raw) || Object.keys(raw).length !== 5 || typeof raw.source_object !== "string" || !raw.source_object.startsWith(`${role}-wallet-`) || !digest(raw.source_object.slice(`${role}-wallet-`.length)) || !count(raw.record_count) || !count(raw.segment_count) || raw.record_count > raw.segment_count || raw.record_count === 0 !== (raw.segment_count === 0) || !digest(raw.digest_hex)) return null;
+	const source = parseSource(raw.source, envelope, contextDigest);
+	if (!source) return null;
+	return {
+		source,
+		source_object: raw.source_object,
+		record_count: raw.record_count,
+		segment_count: raw.segment_count,
+		digest_hex: raw.digest_hex
+	};
+}
+function parseSegment(raw, receipt) {
+	if (!isPlainObject(raw) || Object.keys(raw).length !== 5 || !count(raw.segment_index) || !count(raw.record_index) || !count(raw.part_index) || !count(raw.part_count) || raw.part_count === 0 || raw.part_count > 512 || raw.segment_index >= receipt.segment_count || raw.record_index >= receipt.record_count || raw.part_index >= raw.part_count || typeof raw.data_b64u !== "string" || raw.data_b64u.length === 0 || raw.data_b64u.length > 5462 || !/^[A-Za-z0-9_-]+$/u.test(raw.data_b64u)) return null;
+	return {
+		segment_index: raw.segment_index,
+		record_index: raw.record_index,
+		part_index: raw.part_index,
+		part_count: raw.part_count,
+		data_b64u: raw.data_b64u
+	};
+}
+function digest(raw) {
+	return typeof raw === "string" && /^[a-f0-9]{64}$/u.test(raw);
+}
+function count(raw) {
+	return typeof raw === "number" && Number.isInteger(raw) && raw >= 0 && raw <= 4294967295;
+}
+function postDirectory(directory, endpoint, body) {
+	const version = directory.CF_VERSION_METADATA.id;
+	if (typeof version !== "string" || !version) throw new Error("Runtime version is unavailable");
+	return directory.WALLET_CONSOLE.fetch(new Request(`https://wallet-placement.internal/internal/wallet-placement/v1/${endpoint}`, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			"x-seams-writer-role": "walletRuntime",
+			"x-seams-writer-version": version,
+			"x-seams-writer-account": directory.SEAMS_D1_HOME_ACCOUNT_ID,
+			"x-seams-writer-database": directory.SEAMS_D1_HOME_DATABASE_ID
+		},
+		body: JSON.stringify(body)
+	}));
+}
+function postRole(binding, role, operation, body, credential, identity) {
+	return binding.fetch(new Request(`https://${role}.router-ab.internal/router-ab/internal/${role}/wallet/${operation}`, {
+		method: "POST",
+		redirect: "manual",
+		headers: {
+			"content-type": "application/json",
+			[ROUTER_AB_INTERNAL_SERVICE_AUTH_HEADER_V1]: credential,
+			...identity === null ? {} : walletObjectIdentityHeaders(identity)
+		},
+		body: JSON.stringify(body)
+	}));
+}
+function failure(code, status) {
+	return Response.json({
+		ok: false,
+		code
+	}, {
+		status,
+		headers: { "Cache-Control": "no-store" }
+	});
+}
+function parseActivation(raw, role, envelope, contextDigest) {
+	if (!isPlainObject(raw) || Object.keys(raw).length !== 2) return null;
+	const source = parseReceipt(raw.source, role, envelope, contextDigest);
+	if (!source || raw.destination_object !== source.source_object) return null;
+	return {
+		source,
+		destination_object: source.source_object
+	};
+}
+async function confirmActivation(response, expected, role, envelope, contextDigest, directory) {
+	if (!response.ok) return response;
+	const raw = await response.clone().json();
+	if (!isPlainObject(raw) || Object.keys(raw).length !== 2 || raw.kind !== "activated") return failure("activation_receipt_unavailable", 503);
+	const receipt = parseActivation(raw.receipt, role, envelope, contextDigest);
+	if (!receipt || JSON.stringify(receipt.source) !== JSON.stringify(expected)) return failure("activation_receipt_unavailable", 503);
+	const stored = await postDirectory(directory, "relocation-deriver-activation", {
+		wallet: envelope.wallet,
+		attempt: envelope.attempt,
+		role: role === "deriver-a" ? "deriverA" : "deriverB",
+		receipt
+	});
+	if (!stored.ok) return failure("activation_receipt_unavailable", 503);
+	const result = await stored.json();
+	if (!isPlainObject(result) || Object.keys(result).length !== 2 || result.ok !== true) return failure("activation_receipt_unavailable", 503);
+	const confirmed = parseActivation(result.receipt, role, envelope, contextDigest);
+	if (!confirmed || JSON.stringify(confirmed) !== JSON.stringify(receipt)) return failure("activation_receipt_unavailable", 503);
+	return response;
+}
+//#endregion
+export { deriverRuntimeOperation, forwardDeriverRelocation };
+
+//# sourceMappingURL=walletRelocationDeriver.js.map

package/dist/esm/router/cloudflare/runtime/walletRelocationEcdsa.js

@@ -0,0 +1,212 @@
+import { isPlainObject } from "../../../shared-ts/src/utils/validation.js";
+import { walletObjectIdentityHeaders, walletRelocationObjectIdentity } from "./walletObjectAddresses.js";
+import { ROUTER_AB_INTERNAL_SERVICE_AUTH_HEADER_V1 } from "../../../core/ThresholdService/routerAb/internalServiceHttp.js";
+import { authorizeRuntimeSource } from "./walletRelocationSource.js";
+//#region src/router/cloudflare/runtime/walletRelocationEcdsa.ts
+const TRANSFER_BATCH_SEGMENTS = 8;
+function ecdsaRuntimeOperation(operation) {
+	switch (operation) {
+		case "ecdsa-freeze": return "freeze";
+		case "ecdsa-export": return "export";
+		case "ecdsa-import": return "import";
+		case "ecdsa-status": return "status";
+		case "ecdsa-verify": return "verify";
+		case "ecdsa-activate": return "activate";
+		case "ecdsa-cleanup": return "cleanup";
+		default: return null;
+	}
+}
+async function forwardEcdsaRelocation(input, operation, router, credential, directory) {
+	const fieldCount = operation === "export" || operation === "import" ? 3 : 2;
+	if (!isPlainObject(input) || Object.keys(input).length !== fieldCount || !isPlainObject(input.wallet) || !isPlainObject(input.attempt)) return failure("invalid_input", 400);
+	const envelope = {
+		wallet: input.wallet,
+		attempt: input.attempt
+	};
+	try {
+		if (operation === "freeze") {
+			const authorization = await authorizeRuntimeSource(input, "ecdsa-freeze", directory);
+			if (!authorization.ok) return failure(authorization.code, authorization.code === "source_command_denied" ? 409 : 503);
+			const source = JSON.parse(authorization.body);
+			if (!isPlainObject(source)) return failure("source_command_unavailable", 503);
+			let response = await postRole(router, "pool/freeze", source, credential, authorization.identity);
+			let raw = await response.clone().json();
+			for (let step = 1; step < TRANSFER_BATCH_SEGMENTS && response.ok && isPlainObject(raw) && Object.keys(raw).length === 1 && (raw.state === "invalidating" || raw.state === "sealing"); step += 1) {
+				response = await postRole(router, "pool/freeze", source, credential, authorization.identity);
+				raw = await response.clone().json();
+			}
+			if (!response.ok) return response;
+			if (isPlainObject(raw)) {
+				if (Object.keys(raw).length === 1 && (raw.state === "invalidating" || raw.state === "sealing")) return response;
+				if (Object.keys(raw).length === 3 && raw.state === "draining" && safeCount(raw.pending_effects) && safeCount(raw.pending_linked_sessions)) return response;
+			}
+			if (!isPlainObject(raw) || Object.keys(raw).length !== 2 || raw.state !== "frozen") return failure("source_receipt_unavailable", 503);
+			const receipt = parseReceipt(raw.receipt, envelope);
+			if (!receipt || !sameFields(receipt.scope, source.scope) || !sameFields(receipt.request, source.request)) return failure("source_receipt_unavailable", 503);
+			if (!await persistReceipt(directory, "relocation-ecdsa-receipt", envelope, receipt)) return failure("source_receipt_unavailable", 503);
+			return response;
+		}
+		const request = operation === "export" ? {
+			operation,
+			segmentIndex: input.segmentIndex
+		} : { operation };
+		const authorized = await postDirectory(directory, "relocation-ecdsa-transfer", {
+			...envelope,
+			request
+		});
+		if (!authorized.ok) return failure("source_command_denied", 409);
+		const result = await authorized.json();
+		const commandFields = operation === "export" ? 4 : operation === "status" || operation === "import" ? 3 : 2;
+		if (!isPlainObject(result) || Object.keys(result).length !== 2 || result.ok !== true || !isPlainObject(result.command) || result.command.kind !== operation || Object.keys(result.command).length !== commandFields) return failure("source_command_unavailable", 503);
+		const command = result.command;
+		const receipt = parseReceipt(operation === "cleanup" ? command.activation : command.receipt, envelope);
+		if (!receipt) return failure("source_command_unavailable", 503);
+		const identity = walletRelocationObjectIdentity(envelope.wallet, receipt.request.source_generation + (operation === "export" || operation === "cleanup" ? 0 : 1));
+		if ((operation === "export" || operation === "status" || operation === "import") && command.chunk_bytes !== 4096) return failure("source_command_unavailable", 503);
+		if (operation === "export") {
+			if (!safeCount(input.segmentIndex) || input.segmentIndex > 4294967295 || command.segment_index !== input.segmentIndex) return failure("source_command_unavailable", 503);
+			const chunks = [];
+			let segmentIndex = input.segmentIndex;
+			for (let step = 0; step < TRANSFER_BATCH_SEGMENTS; step += 1) {
+				const response = await postRole(router, "ecdsa/export", {
+					receipt,
+					segment_index: segmentIndex,
+					chunk_bytes: 4096
+				}, credential, identity);
+				if (!response.ok) return response;
+				const chunk = parseChunk(await response.json(), receipt);
+				if (!chunk || chunk.segment_index !== segmentIndex || chunks.length > 0 && chunk.segment_count !== chunks[0].segment_count) return failure("source_receipt_unavailable", 503);
+				chunks.push(chunk);
+				segmentIndex += 1;
+				if (segmentIndex === chunk.segment_count) break;
+			}
+			return Response.json({ chunks });
+		}
+		if (operation === "import") {
+			if (!Array.isArray(input.chunks) || input.chunks.length === 0 || input.chunks.length > TRANSFER_BATCH_SEGMENTS) return failure("invalid_input", 400);
+			const chunks = [];
+			for (const raw of input.chunks) {
+				const chunk = parseChunk(raw, receipt);
+				const previous = chunks.at(-1);
+				if (!chunk || previous && (chunk.segment_index !== previous.segment_index + 1 || chunk.segment_count !== previous.segment_count)) return failure("invalid_input", 400);
+				chunks.push(chunk);
+			}
+			let response = failure("invalid_input", 400);
+			for (const chunk of chunks) {
+				response = await postRole(router, "ecdsa/transfer", {
+					kind: "import",
+					chunk
+				}, credential, identity);
+				if (!response.ok) return response;
+				const accepted = await response.clone().json();
+				if (!isPlainObject(accepted) || accepted.kind !== "imported" || accepted.segment_index !== chunk.segment_index || typeof accepted.input_digest_hex !== "string" || !/^[a-f0-9]{64}$/u.test(accepted.input_digest_hex)) return failure("source_receipt_unavailable", 503);
+			}
+			return response;
+		}
+		if (operation === "cleanup") return await postRole(router, "ecdsa/transfer", {
+			kind: "cleanup",
+			activation: receipt
+		}, credential, identity);
+		if (operation === "status") return await postRole(router, "ecdsa/transfer", {
+			kind: "status",
+			receipt,
+			chunk_bytes: 4096
+		}, credential, identity);
+		const response = await postRole(router, "ecdsa/transfer", {
+			kind: operation,
+			receipt
+		}, credential, identity);
+		if (operation !== "activate" || !response.ok) return response;
+		const activated = await response.clone().json();
+		if (!isPlainObject(activated) || Object.keys(activated).length !== 2 || activated.kind !== "activated" || !sameFields(receipt, activated.receipt) || !await persistReceipt(directory, "relocation-ecdsa-activation", envelope, receipt)) return failure("activation_receipt_unavailable", 503);
+		return response;
+	} catch {
+		return failure("source_command_unavailable", 503);
+	}
+}
+function parseChunk(raw, receipt) {
+	if (!isPlainObject(raw) || Object.keys(raw).length !== 5 || !sameFields(raw.receipt, receipt) || raw.chunk_bytes !== 4096 || !safeCount(raw.segment_index) || !safeCount(raw.segment_count) || raw.segment_count === 0 || raw.segment_count > 4294967295 || raw.segment_index >= raw.segment_count || typeof raw.data_b64u !== "string" || raw.data_b64u.length === 0 || raw.data_b64u.length > 5462 || !/^[A-Za-z0-9_-]+$/u.test(raw.data_b64u)) return null;
+	return {
+		receipt,
+		chunk_bytes: 4096,
+		segment_index: raw.segment_index,
+		segment_count: raw.segment_count,
+		data_b64u: raw.data_b64u
+	};
+}
+function parseReceipt(raw, envelope) {
+	if (!isPlainObject(raw) || Object.keys(raw).length !== 4 || !isPlainObject(raw.scope) || Object.keys(raw.scope).length !== 4 || !isPlainObject(raw.request) || Object.keys(raw.request).length !== 3 || typeof raw.scope.org_id !== "string" || raw.scope.org_id !== envelope.wallet.organizationId || typeof raw.scope.project_id !== "string" || raw.scope.project_id !== envelope.wallet.projectId || typeof raw.scope.project_environment_id !== "string" || raw.scope.project_environment_id !== envelope.wallet.environmentId || typeof raw.scope.wallet_id !== "string" || raw.scope.wallet_id !== envelope.wallet.walletId || typeof raw.request.move_id !== "string" || raw.request.move_id !== envelope.attempt.moveId || !safeCount(raw.request.source_generation) || raw.request.source_generation === 0 || !safeCount(raw.request.invalidated_at_ms) || raw.request.invalidated_at_ms === 0 || !safeCount(raw.record_count) || typeof raw.wallet_records_digest_hex !== "string" || !/^[a-f0-9]{64}$/u.test(raw.wallet_records_digest_hex)) return null;
+	return {
+		scope: {
+			org_id: raw.scope.org_id,
+			project_id: raw.scope.project_id,
+			project_environment_id: raw.scope.project_environment_id,
+			wallet_id: raw.scope.wallet_id
+		},
+		request: {
+			move_id: raw.request.move_id,
+			source_generation: raw.request.source_generation,
+			invalidated_at_ms: raw.request.invalidated_at_ms
+		},
+		record_count: raw.record_count,
+		wallet_records_digest_hex: raw.wallet_records_digest_hex
+	};
+}
+function safeCount(raw) {
+	return typeof raw === "number" && Number.isSafeInteger(raw) && raw >= 0;
+}
+function sameFields(left, right) {
+	if (!isPlainObject(left) || !isPlainObject(right)) return left === right;
+	if (Object.keys(left).length !== Object.keys(right).length) return false;
+	for (const key of Object.keys(left)) if (!sameFields(left[key], right[key])) return false;
+	return true;
+}
+async function persistReceipt(directory, endpoint, envelope, receipt) {
+	const response = await postDirectory(directory, endpoint, {
+		...envelope,
+		receipt
+	});
+	if (!response.ok) return false;
+	const result = await response.json();
+	return isPlainObject(result) && Object.keys(result).length === 2 && result.ok === true && sameFields(receipt, result.receipt);
+}
+function postDirectory(directory, endpoint, body) {
+	const version = directory.CF_VERSION_METADATA.id;
+	if (typeof version !== "string" || !version) throw new Error("Runtime version is unavailable");
+	return directory.WALLET_CONSOLE.fetch(new Request(`https://wallet-placement.internal/internal/wallet-placement/v1/${endpoint}`, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			"x-seams-writer-role": "walletRuntime",
+			"x-seams-writer-version": version,
+			"x-seams-writer-account": directory.SEAMS_D1_HOME_ACCOUNT_ID,
+			"x-seams-writer-database": directory.SEAMS_D1_HOME_DATABASE_ID
+		},
+		body: JSON.stringify(body)
+	}));
+}
+function postRole(router, path, command, credential, identity) {
+	return router.fetch(new Request(`https://mpc-router.router-ab.internal/router-ab/signing-worker/wallet/${path}`, {
+		method: "POST",
+		redirect: "manual",
+		headers: {
+			"content-type": "application/json",
+			[ROUTER_AB_INTERNAL_SERVICE_AUTH_HEADER_V1]: credential,
+			...walletObjectIdentityHeaders(identity)
+		},
+		body: JSON.stringify(command)
+	}));
+}
+function failure(code, status) {
+	return Response.json({
+		ok: false,
+		code
+	}, {
+		status,
+		headers: { "Cache-Control": "no-store" }
+	});
+}
+//#endregion
+export { ecdsaRuntimeOperation, forwardEcdsaRelocation };
+
+//# sourceMappingURL=walletRelocationEcdsa.js.map

package/dist/esm/router/cloudflare/runtime/walletRelocationEd25519.js

@@ -0,0 +1,172 @@
+import { isPlainObject } from "../../../shared-ts/src/utils/validation.js";
+import { walletObjectIdentityHeaders, walletRelocationObjectIdentity } from "./walletObjectAddresses.js";
+import { ROUTER_AB_INTERNAL_SERVICE_AUTH_HEADER_V1 } from "../../../core/ThresholdService/routerAb/internalServiceHttp.js";
+import { authorizeRuntimeSource } from "./walletRelocationSource.js";
+//#region src/router/cloudflare/runtime/walletRelocationEd25519.ts
+function ed25519RuntimeOperation(operation) {
+	switch (operation) {
+		case "ed25519-capture": return "capture";
+		case "ed25519-export": return "export";
+		case "ed25519-import": return "import";
+		case "ed25519-status": return "status";
+		case "ed25519-verify": return "verify";
+		case "ed25519-activate": return "activate";
+		case "ed25519-cleanup": return "cleanup";
+		default: return null;
+	}
+}
+async function forwardEd25519Snapshot(input, operation, router, credential, directory) {
+	const fieldCount = operation === "export" || operation === "import" ? 3 : 2;
+	if (!isPlainObject(input) || Object.keys(input).length !== fieldCount || !isPlainObject(input.wallet) || !isPlainObject(input.attempt)) return failure("invalid_input", 400);
+	const envelope = {
+		wallet: input.wallet,
+		attempt: input.attempt
+	};
+	try {
+		if (operation === "capture") {
+			const authorization = await authorizeRuntimeSource(input, "ed25519-capture", directory);
+			if (!authorization.ok) return failure(authorization.code, authorization.code === "source_command_denied" ? 409 : 503);
+			const command = JSON.parse(authorization.body);
+			if (!isPlainObject(command)) return failure("source_command_unavailable", 503);
+			const response = await postSnapshot(router, command, credential, authorization.identity);
+			if (!response.ok) return response;
+			const raw = await response.clone().json();
+			if (isPlainObject(raw) && Object.keys(raw).length === 1 && raw.state === "capturing") return response;
+			if (!isPlainObject(raw) || Object.keys(raw).length !== 2 || raw.state !== "frozen") return failure("source_receipt_unavailable", 503);
+			const receipt = parseReceipt(raw.receipt, envelope);
+			if (!receipt || !sameFields(receipt.source, command.source)) return failure("source_receipt_unavailable", 503);
+			const recorded = await postDirectory(directory, "relocation-ed25519-receipt", {
+				...envelope,
+				receipt
+			});
+			if (!recorded.ok) return failure("source_receipt_unavailable", 503);
+			const result = await recorded.json();
+			if (!isPlainObject(result) || Object.keys(result).length !== 2 || result.ok !== true || !sameFields(receipt, result.receipt)) return failure("source_receipt_unavailable", 503);
+			return response;
+		}
+		const request = operation === "export" ? {
+			operation,
+			segmentIndex: input.segmentIndex
+		} : { operation };
+		const authorized = await postDirectory(directory, "relocation-ed25519-transfer", {
+			...envelope,
+			request
+		});
+		if (!authorized.ok) return failure("source_command_denied", 409);
+		const result = await authorized.json();
+		if (!isPlainObject(result) || Object.keys(result).length !== 2 || result.ok !== true || !isPlainObject(result.command) || result.command.command !== operation || Object.keys(result.command).length !== (operation === "export" ? 3 : 2)) return failure("source_command_unavailable", 503);
+		const receipt = parseReceipt(operation === "cleanup" ? result.command.activation : result.command.receipt, envelope);
+		if (!receipt) return failure("source_command_unavailable", 503);
+		const identity = walletRelocationObjectIdentity(envelope.wallet, receipt.source.request.source_generation + (operation === "export" || operation === "cleanup" ? 0 : 1));
+		if (operation === "cleanup") return await postSnapshot(router, {
+			command: "cleanup",
+			activation: receipt
+		}, credential, identity);
+		if (operation === "activate") {
+			const response = await postSnapshot(router, {
+				command: "activate",
+				receipt
+			}, credential, identity);
+			if (!response.ok) return response;
+			const activated = await response.clone().json();
+			if (!isPlainObject(activated) || Object.keys(activated).length !== 2 || activated.state !== "activated" || !sameFields(receipt, activated.receipt)) return failure("activation_receipt_unavailable", 503);
+			const recorded = await postDirectory(directory, "relocation-ed25519-activation", {
+				...envelope,
+				receipt
+			});
+			if (!recorded.ok) return failure("activation_receipt_unavailable", 503);
+			const confirmed = await recorded.json();
+			if (!isPlainObject(confirmed) || Object.keys(confirmed).length !== 2 || confirmed.ok !== true || !sameFields(receipt, confirmed.receipt)) return failure("activation_receipt_unavailable", 503);
+			return response;
+		}
+		if (operation === "export") {
+			if (!count(input.segmentIndex) || input.segmentIndex >= receipt.segment_count || result.command.segment_index !== input.segmentIndex) return failure("source_command_unavailable", 503);
+			return await postSnapshot(router, {
+				command: "export",
+				receipt,
+				segment_index: input.segmentIndex
+			}, credential, identity);
+		}
+		if (operation === "import") return await postSnapshot(router, {
+			command: "import",
+			receipt,
+			segment: input.segment
+		}, credential, identity);
+		return await postSnapshot(router, {
+			command: operation,
+			receipt
+		}, credential, identity);
+	} catch {
+		return failure("source_command_unavailable", 503);
+	}
+}
+function parseReceipt(raw, envelope) {
+	if (!isPlainObject(raw) || Object.keys(raw).length !== 4 || !isPlainObject(raw.source) || Object.keys(raw.source).length !== 2 || !isPlainObject(raw.source.scope) || Object.keys(raw.source.scope).length !== 4 || !isPlainObject(raw.source.request) || Object.keys(raw.source.request).length !== 3 || typeof raw.source.scope.org_id !== "string" || raw.source.scope.org_id !== envelope.wallet.organizationId || typeof raw.source.scope.project_id !== "string" || raw.source.scope.project_id !== envelope.wallet.projectId || typeof raw.source.scope.project_environment_id !== "string" || raw.source.scope.project_environment_id !== envelope.wallet.environmentId || typeof raw.source.scope.wallet_id !== "string" || raw.source.scope.wallet_id !== envelope.wallet.walletId || typeof raw.source.request.move_id !== "string" || raw.source.request.move_id !== envelope.attempt.moveId || typeof raw.source.request.source_generation !== "number" || !Number.isSafeInteger(raw.source.request.source_generation) || raw.source.request.source_generation < 1 || typeof raw.source.request.invalidated_at_ms !== "number" || !Number.isSafeInteger(raw.source.request.invalidated_at_ms) || raw.source.request.invalidated_at_ms <= 0 || !count(raw.record_count) || !count(raw.segment_count) || raw.record_count > raw.segment_count || raw.record_count === 0 !== (raw.segment_count === 0) || typeof raw.digest_hex !== "string" || !/^[a-f0-9]{64}$/u.test(raw.digest_hex)) return null;
+	return {
+		source: {
+			scope: {
+				org_id: raw.source.scope.org_id,
+				project_id: raw.source.scope.project_id,
+				project_environment_id: raw.source.scope.project_environment_id,
+				wallet_id: raw.source.scope.wallet_id
+			},
+			request: {
+				move_id: raw.source.request.move_id,
+				source_generation: raw.source.request.source_generation,
+				invalidated_at_ms: raw.source.request.invalidated_at_ms
+			}
+		},
+		record_count: raw.record_count,
+		segment_count: raw.segment_count,
+		digest_hex: raw.digest_hex
+	};
+}
+function count(raw) {
+	return typeof raw === "number" && Number.isInteger(raw) && raw >= 0 && raw <= 4294967295;
+}
+function sameFields(left, right) {
+	if (!isPlainObject(left) || !isPlainObject(right)) return left === right;
+	if (Object.keys(left).length !== Object.keys(right).length) return false;
+	for (const key of Object.keys(left)) if (!sameFields(left[key], right[key])) return false;
+	return true;
+}
+function postDirectory(directory, endpoint, body) {
+	const version = directory.CF_VERSION_METADATA.id;
+	if (typeof version !== "string" || !version) throw new Error("Runtime version is unavailable");
+	return directory.WALLET_CONSOLE.fetch(new Request(`https://wallet-placement.internal/internal/wallet-placement/v1/${endpoint}`, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			"x-seams-writer-role": "walletRuntime",
+			"x-seams-writer-version": version,
+			"x-seams-writer-account": directory.SEAMS_D1_HOME_ACCOUNT_ID,
+			"x-seams-writer-database": directory.SEAMS_D1_HOME_DATABASE_ID
+		},
+		body: JSON.stringify(body)
+	}));
+}
+function postSnapshot(router, command, credential, identity) {
+	return router.fetch(new Request("https://mpc-router.router-ab.internal/router-ab/signing-worker/wallet/ed25519/snapshot", {
+		method: "POST",
+		redirect: "manual",
+		headers: {
+			"content-type": "application/json",
+			[ROUTER_AB_INTERNAL_SERVICE_AUTH_HEADER_V1]: credential,
+			...walletObjectIdentityHeaders(identity)
+		},
+		body: JSON.stringify(command)
+	}));
+}
+function failure(code, status) {
+	return Response.json({
+		ok: false,
+		code
+	}, {
+		status,
+		headers: { "Cache-Control": "no-store" }
+	});
+}
+//#endregion
+export { ed25519RuntimeOperation, forwardEd25519Snapshot };
+
+//# sourceMappingURL=walletRelocationEd25519.js.map