@seams/wallet-server 0.5.0

package/dist/esm/shared-ts/src/utils/routerAbEcdsaDerivation.js

@@ -0,0 +1,1655 @@
+import { parseEcdsaActiveStateId, parseRootShareEpoch, parseThresholdEcdsaSessionId } from "./domainIds.js";
+import { EVM_ECDSA_MPC_OPERATION_KINDS, parseEcdsaAuthorizationSessionId, parseMpcWalletSigningQuotaId, parseWalletSessionAuthorizationId, parseWalletSessionId, parseWalletSessionMintId } from "../authorization/capabilityKinds.js";
+import { base64UrlDecode, base64UrlEncode } from "./base64.js";
+import { parseCorrelationId } from "./canonicalPrimitives.js";
+import { alphabetizeStringify, sha256BytesUtf8 } from "./digests.js";
+import "./encoders.js";
+import { requireRouterAbX25519PublicKey } from "./routerAbPublicKeyset.js";
+import { canonicalRouterAbMpcMaterialActivationRefBytes, canonicalRouterAbNormalSigningAuthorizationBytes, parseRouterAbMpcMaterialActivationRef, parseRouterAbNormalSigningAuthorization, routerAbMpcMaterialActivationRefToWire, sameRouterAbMpcMaterialActivationRef } from "./routerAbNormalSigningIdentity.js";
+import "../threshold/ecdsaDerivationRoleLocalBootstrap.js";
+import { normalizeRuntimePolicyScope } from "../threshold/signingRootScope.js";
+import { parseEcdsaServerGeneration } from "./ecdsaCapabilityActivation.js";
+import { isEmailOtpWalletAuthAuthority, isPasskeyWalletAuthAuthority, parseWalletAuthAuthority } from "./walletAuthAuthority.js";
+import { parseActiveWalletSessionV1, parseWalletSessionOperationCredentialV1 } from "../device-linking/parsers.js";
+//#region ../shared-ts/src/utils/routerAbEcdsaDerivation.ts
+const ROUTER_AB_ECDSA_DERIVATION_NORMAL_SIGNING_STATE_KIND_V1 = "router_ab_ecdsa_derivation_normal_signing_v1";
+const ROUTER_AB_ECDSA_DERIVATION_HEALTH_PATH = "/router-ab/ecdsa-derivation/healthz";
+const ROUTER_AB_ECDSA_DERIVATION_EXPORT_PATH = "/router-ab/ecdsa-derivation/export";
+const ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_FILL_INIT_PATH = "/router-ab/ecdsa-derivation/presignature-pool/fill/init";
+const ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_FILL_STEP_PATH = "/router-ab/ecdsa-derivation/presignature-pool/fill/step";
+const ROUTER_AB_ECDSA_DERIVATION_NORMAL_SIGNING_PREPARE_PATH = "/router-ab/ecdsa-derivation/sign/prepare";
+const ROUTER_AB_ECDSA_DERIVATION_NORMAL_SIGNING_PATH = "/router-ab/ecdsa-derivation/sign";
+const ROUTER_AB_ECDSA_DERIVATION_REFRESH_PATH = "/router-ab/ecdsa-derivation/refresh";
+const ROUTER_AB_ECDSA_DERIVATION_SESSION_ACTIVATION_PATH = "/router-ab/ecdsa-derivation/session/activate";
+const ROUTER_AB_ECDSA_DERIVATION_OPERATION_STEP_UP_PATH = "/router-ab/ecdsa-derivation/operation-step-up";
+const ROUTER_AB_ECDSA_OPERATION_STEP_UP_CHALLENGE_DOMAIN_V1 = "router-ab-ecdsa-operation-step-up/challenge/v1";
+const ECDSA_DERIVATION_CONTEXT_DOMAIN_TAG_V1 = "router-ab-ecdsa-derivation/context/v1";
+const ECDSA_DERIVATION_CONTEXT_BINDING_DOMAIN_V1 = "router-ab-ecdsa-derivation/role-local/context-binding/v1";
+const ECDSA_DERIVATION_SCHEME_ID_V1 = "router-ab-ecdsa-derivation-v1";
+const ECDSA_DERIVATION_CURVE_V1 = "secp256k1";
+const ECDSA_DERIVATION_CONTEXT_FIELD_BYTES_V1 = 1;
+const ECDSA_DERIVATION_PARTICIPANT_IDS_V1 = [1, 2];
+const ROUTER_AB_ECDSA_DERIVATION_PUBLIC_IDENTITY_VERSION_V1 = "router-ab-ecdsa-derivation/public-identity/v1";
+const ROUTER_AB_ECDSA_DERIVATION_NORMAL_SIGNING_SCOPE_VERSION_V1 = "router-ab-ecdsa-derivation/normal-signing-scope/v1";
+const ROUTER_AB_ECDSA_DERIVATION_NORMAL_SIGNING_REQUEST_VERSION_V1 = "router-ab-ecdsa-derivation/normal-signing-request/v1";
+const ROUTER_AB_ECDSA_DERIVATION_NORMAL_SIGNING_FINALIZE_REQUEST_VERSION_V1 = "router-ab-ecdsa-derivation/normal-signing-finalize-request/v1";
+function requireExportShareAuthorizationKind(value, label) {
+	if (value === "reusable_wallet_session" || value === "verified_step_up") return value;
+	throw new Error(`${label} must be reusable_wallet_session or verified_step_up`);
+}
+function projectRouterAbEcdsaDerivationExplicitExportRequestToProtocolV1(request) {
+	switch (request.authorization.kind) {
+		case "reusable_wallet_session": {
+			const { operation: _operation, ...protocolRequest } = request;
+			return protocolRequest;
+		}
+		case "operation_step_up": {
+			const { operation: _operation, ...protocolRequest } = request;
+			return protocolRequest;
+		}
+	}
+}
+async function computeRouterAbEcdsaOperationStepUpChallengeB64u(value) {
+	return base64UrlEncode(await sha256BytesUtf8(alphabetizeStringify({
+		domain: ROUTER_AB_ECDSA_OPERATION_STEP_UP_CHALLENGE_DOMAIN_V1,
+		operation: parseRouterAbEcdsaOperationStepUpPreparationV1(value)
+	})));
+}
+function requireRecord(value, label) {
+	if (value && typeof value === "object" && !Array.isArray(value)) return value;
+	throw new Error(`${label} must be an object`);
+}
+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 a supported field`);
+}
+function requireAsciiNonEmptyString(value, label) {
+	if (typeof value !== "string") throw new Error(`${label} must be a string`);
+	const parsed = value.trim();
+	if (!parsed) throw new Error(`${label} is required`);
+	if (!/^[\x20-\x7e]+$/.test(parsed)) throw new Error(`${label} must be printable ASCII`);
+	return parsed;
+}
+function requireRootShareEpoch(value, label) {
+	const parsed = parseRootShareEpoch(requireAsciiNonEmptyString(value, label));
+	if (!parsed.ok) throw new Error(`${label} is invalid`);
+	return parsed.value;
+}
+function requireThresholdEcdsaSessionId(value, label) {
+	const parsed = parseThresholdEcdsaSessionId(requireAsciiNonEmptyString(value, label));
+	if (!parsed.ok) throw new Error(`${label} is invalid`);
+	return parsed.value;
+}
+function requireEcdsaAuthorizationSessionId(value, label) {
+	const parsed = parseEcdsaAuthorizationSessionId(value);
+	if (!parsed.ok) throw new Error(`${label} is invalid`);
+	return parsed.value;
+}
+function requireWalletSessionAuthorizationId(value, label) {
+	const parsed = parseWalletSessionAuthorizationId(value);
+	if (!parsed.ok) throw new Error(`${label} is invalid`);
+	return parsed.value;
+}
+function requireWalletSessionId(value, label) {
+	const parsed = parseWalletSessionId(value);
+	if (!parsed.ok) throw new Error(`${label} is invalid`);
+	return parsed.value;
+}
+function requireMpcWalletSigningQuotaId(value, label) {
+	const parsed = parseMpcWalletSigningQuotaId(value);
+	if (!parsed.ok) throw new Error(`${label} is invalid`);
+	return parsed.value;
+}
+function requirePositiveUnixMs(value, label) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) throw new Error(`${label} must be a positive safe integer`);
+	return value;
+}
+function requirePositiveCounter(value, label) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) throw new Error(`${label} must be a positive safe-integer counter`);
+	return value;
+}
+function requireNonNegativeInteger(value, label) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${label} must be a finite number`);
+	const parsed = Math.floor(value);
+	if (parsed !== value || parsed < 0) throw new Error(`${label} must be a non-negative integer`);
+	return parsed;
+}
+function requireU32(value, label) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${label} must be a finite number`);
+	const parsed = Math.floor(value);
+	if (parsed !== value || parsed < 0 || parsed > 4294967295) throw new Error(`${label} must be a u32 integer`);
+	return parsed;
+}
+function requireBoolean(value, label) {
+	if (typeof value !== "boolean") throw new Error(`${label} must be a boolean`);
+	return value;
+}
+function requireByte(value, label) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${label} must be a finite number`);
+	const parsed = Math.floor(value);
+	if (parsed !== value || parsed < 0 || parsed > 255) throw new Error(`${label} must be a byte`);
+	return parsed;
+}
+function requireBase64UrlFixed(value, label, byteLength) {
+	const parsed = requireAsciiNonEmptyString(value, label);
+	if (!/^[A-Za-z0-9_-]+$/.test(parsed)) throw new Error(`${label} must be unpadded base64url`);
+	let decoded;
+	try {
+		decoded = base64UrlDecode(parsed);
+	} catch {
+		throw new Error(`${label} must be valid base64url`);
+	}
+	if (decoded.length !== byteLength) throw new Error(`${label} must decode to ${byteLength} bytes`);
+	return parsed;
+}
+function requireCompressedSecp256k1PublicKey(value, label) {
+	const parsed = requireBase64UrlFixed(value, label, 33);
+	const decoded = base64UrlDecode(parsed);
+	if (decoded[0] !== 2 && decoded[0] !== 3) throw new Error(`${label} must be a compressed secp256k1 public key`);
+	return parsed;
+}
+function requireBase64UrlNonEmpty(value, label) {
+	const parsed = requireAsciiNonEmptyString(value, label);
+	if (!/^[A-Za-z0-9_-]+$/.test(parsed)) throw new Error(`${label} must be unpadded base64url`);
+	let decoded;
+	try {
+		decoded = base64UrlDecode(parsed);
+	} catch {
+		throw new Error(`${label} must be valid base64url`);
+	}
+	if (decoded.length === 0) throw new Error(`${label} must decode to non-empty bytes`);
+	return parsed;
+}
+function requireX25519PublicKey(value, label) {
+	const parsed = requireAsciiNonEmptyString(value, label);
+	if (!/^x25519:[0-9a-f]{64}$/.test(parsed)) throw new Error(`${label} must use x25519:<64 lowercase hex chars> encoding`);
+	return parsed;
+}
+function parsePublicDigest32(value, label) {
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, ["bytes"]);
+	if (!Array.isArray(record.bytes)) throw new Error(`${label}.bytes must be an array`);
+	if (record.bytes.length !== 32) throw new Error(`${label}.bytes must contain 32 bytes`);
+	return { bytes: record.bytes.map((entry, index) => requireByte(entry, `${label}.bytes[${index}]`)) };
+}
+function parseStableKeyContext(value) {
+	const record = requireRecord(value, "scope.context");
+	requireExactKeys(record, "scope.context", ["application_binding_digest_b64u"]);
+	const digest = base64UrlDecode(requireAsciiNonEmptyString(record.application_binding_digest_b64u, "scope.context.application_binding_digest_b64u"));
+	if (digest.length !== 32) throw new Error("scope.context.application_binding_digest_b64u must decode to 32 bytes");
+	return { application_binding_digest_b64u: base64UrlEncode(digest) };
+}
+function parsePublicIdentity(value) {
+	const record = requireRecord(value, "scope.public_identity");
+	requireExactKeys(record, "scope.public_identity", [
+		"context_binding_b64u",
+		"derivation_client_share_public_key33_b64u",
+		"server_public_key33_b64u",
+		"threshold_public_key33_b64u",
+		"ethereum_address20_b64u",
+		"client_share_retry_counter",
+		"server_share_retry_counter"
+	]);
+	return {
+		context_binding_b64u: requireBase64UrlFixed(record.context_binding_b64u, "scope.public_identity.context_binding_b64u", 32),
+		derivation_client_share_public_key33_b64u: requireCompressedSecp256k1PublicKey(record.derivation_client_share_public_key33_b64u, "scope.public_identity.derivation_client_share_public_key33_b64u"),
+		server_public_key33_b64u: requireCompressedSecp256k1PublicKey(record.server_public_key33_b64u, "scope.public_identity.server_public_key33_b64u"),
+		threshold_public_key33_b64u: requireCompressedSecp256k1PublicKey(record.threshold_public_key33_b64u, "scope.public_identity.threshold_public_key33_b64u"),
+		ethereum_address20_b64u: requireBase64UrlFixed(record.ethereum_address20_b64u, "scope.public_identity.ethereum_address20_b64u", 20),
+		client_share_retry_counter: requireU32(record.client_share_retry_counter, "scope.public_identity.client_share_retry_counter"),
+		server_share_retry_counter: requireU32(record.server_share_retry_counter, "scope.public_identity.server_share_retry_counter")
+	};
+}
+function parseServerIdentity(value) {
+	return parseServerIdentityWithLabel(value, "scope.signing_worker");
+}
+function parseServerIdentityWithLabel(value, label) {
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"server_id",
+		"key_epoch",
+		"recipient_encryption_key"
+	]);
+	return {
+		server_id: requireAsciiNonEmptyString(record.server_id, `${label}.server_id`),
+		key_epoch: requireAsciiNonEmptyString(record.key_epoch, `${label}.key_epoch`),
+		recipient_encryption_key: requireRouterAbX25519PublicKey(record.recipient_encryption_key, `${label}.recipient_encryption_key`)
+	};
+}
+function parsePostRegistrationLifecycleScope(value, label, expectedWorkKind, expectedPrimitiveRequestKind) {
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"lifecycle_id",
+		"work_kind",
+		"primitive_request_kind",
+		"root_share_epoch",
+		"account_id",
+		"session_id",
+		"signer_set_id",
+		"selected_server_id"
+	]);
+	if (requireAsciiNonEmptyString(record.work_kind, `${label}.work_kind`) !== expectedWorkKind) throw new Error(`${label}.work_kind must be ${expectedWorkKind}`);
+	if (requireAsciiNonEmptyString(record.primitive_request_kind, `${label}.primitive_request_kind`) !== expectedPrimitiveRequestKind) throw new Error(`${label}.primitive_request_kind must be ${expectedPrimitiveRequestKind}`);
+	return {
+		lifecycle_id: requireAsciiNonEmptyString(record.lifecycle_id, `${label}.lifecycle_id`),
+		work_kind: expectedWorkKind,
+		primitive_request_kind: expectedPrimitiveRequestKind,
+		root_share_epoch: requireRootShareEpoch(record.root_share_epoch, `${label}.root_share_epoch`),
+		account_id: requireAsciiNonEmptyString(record.account_id, `${label}.account_id`),
+		session_id: requireThresholdEcdsaSessionId(record.session_id, `${label}.session_id`),
+		signer_set_id: requireAsciiNonEmptyString(record.signer_set_id, `${label}.signer_set_id`),
+		selected_server_id: requireAsciiNonEmptyString(record.selected_server_id, `${label}.selected_server_id`)
+	};
+}
+function parsePostRegistrationSignerIdentity(value, label, expectedRole) {
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"role",
+		"signer_id",
+		"key_epoch"
+	]);
+	if (requireAsciiNonEmptyString(record.role, `${label}.role`) !== expectedRole) throw new Error(`${label}.role must be ${expectedRole}`);
+	return {
+		role: expectedRole,
+		signer_id: requireAsciiNonEmptyString(record.signer_id, `${label}.signer_id`),
+		key_epoch: requireAsciiNonEmptyString(record.key_epoch, `${label}.key_epoch`)
+	};
+}
+function parsePostRegistrationSignerSet(value, label) {
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"signer_set_id",
+		"policy",
+		"signer_a",
+		"signer_b",
+		"selected_server"
+	]);
+	const policy = requireAsciiNonEmptyString(record.policy, `${label}.policy`);
+	if (policy !== "all_2") throw new Error(`${label}.policy must be all_2`);
+	const signerA = parsePostRegistrationSignerIdentity(record.signer_a, `${label}.signer_a`, "signer_a");
+	const signerB = parsePostRegistrationSignerIdentity(record.signer_b, `${label}.signer_b`, "signer_b");
+	if (signerA.signer_id === signerB.signer_id) throw new Error(`${label} requires distinct signer ids`);
+	return {
+		signer_set_id: requireAsciiNonEmptyString(record.signer_set_id, `${label}.signer_set_id`),
+		policy,
+		signer_a: signerA,
+		signer_b: signerB,
+		selected_server: parseServerIdentityWithLabel(record.selected_server, `${label}.selected_server`)
+	};
+}
+function parsePostRegistrationRoleEnvelope(value, label, expectedRole) {
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"recipient_role",
+		"header_digest",
+		"aad_digest",
+		"ciphertext"
+	]);
+	if (requireAsciiNonEmptyString(record.recipient_role, `${label}.recipient_role`) !== expectedRole) throw new Error(`${label}.recipient_role must be ${expectedRole}`);
+	const ciphertextRecord = requireRecord(record.ciphertext, `${label}.ciphertext`);
+	requireExactKeys(ciphertextRecord, `${label}.ciphertext`, ["bytes"]);
+	if (!Array.isArray(ciphertextRecord.bytes) || ciphertextRecord.bytes.length === 0) throw new Error(`${label}.ciphertext.bytes must be a non-empty byte array`);
+	return {
+		recipient_role: expectedRole,
+		header_digest: parsePublicDigest32(record.header_digest, `${label}.header_digest`),
+		aad_digest: parsePublicDigest32(record.aad_digest, `${label}.aad_digest`),
+		ciphertext: { bytes: ciphertextRecord.bytes.map((entry, index) => requireByte(entry, `${label}.ciphertext.bytes[${index}]`)) }
+	};
+}
+function parseRegistrationLifecycle(value) {
+	const label = "registration.lifecycle";
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"lifecycle_id",
+		"work_kind",
+		"primitive_request_kind",
+		"root_share_epoch",
+		"account_id",
+		"session_id",
+		"signer_set_id",
+		"selected_server_id"
+	]);
+	if (record.work_kind !== "registration_prepare") throw new Error(`${label}.work_kind must be registration_prepare`);
+	if (record.primitive_request_kind !== "registration") throw new Error(`${label}.primitive_request_kind must be registration`);
+	return {
+		lifecycle_id: requireAsciiNonEmptyString(record.lifecycle_id, `${label}.lifecycle_id`),
+		work_kind: "registration_prepare",
+		primitive_request_kind: "registration",
+		root_share_epoch: requireRootShareEpoch(record.root_share_epoch, `${label}.root_share_epoch`),
+		account_id: requireAsciiNonEmptyString(record.account_id, `${label}.account_id`),
+		session_id: requireAsciiNonEmptyString(record.session_id, `${label}.session_id`),
+		signer_set_id: requireAsciiNonEmptyString(record.signer_set_id, `${label}.signer_set_id`),
+		selected_server_id: requireAsciiNonEmptyString(record.selected_server_id, `${label}.selected_server_id`)
+	};
+}
+function parseRegistrationRecipientKey(value, label, role) {
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"role",
+		"key_epoch",
+		"public_key"
+	]);
+	if (record.role !== role) throw new Error(`${label}.role must be ${role}`);
+	return {
+		role,
+		key_epoch: requireAsciiNonEmptyString(record.key_epoch, `${label}.key_epoch`),
+		public_key: requireRouterAbX25519PublicKey(record.public_key, `${label}.public_key`)
+	};
+}
+function parseRegistrationRecipientKeys(value, label = "registration.deriver_recipient_keys") {
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, ["deriver_a", "deriver_b"]);
+	return {
+		deriver_a: parseRegistrationRecipientKey(record.deriver_a, `${label}.deriver_a`, "signer_a"),
+		deriver_b: parseRegistrationRecipientKey(record.deriver_b, `${label}.deriver_b`, "signer_b")
+	};
+}
+function parseRouterAbEcdsaRegistrationRequestFactsV1(value) {
+	const label = "registration";
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"registration_purpose",
+		"context",
+		"lifecycle",
+		"signer_set",
+		"router_id",
+		"client_id",
+		"replay_nonce",
+		"expires_at_ms",
+		"deriver_recipient_keys"
+	]);
+	if (record.registration_purpose !== "wallet_registration" && record.registration_purpose !== "wallet_add_signer") throw new Error(`${label}.registration_purpose is invalid`);
+	const lifecycle = parseRegistrationLifecycle(record.lifecycle);
+	const signerSet = parsePostRegistrationSignerSet(record.signer_set, `${label}.signer_set`);
+	if (lifecycle.signer_set_id !== signerSet.signer_set_id) throw new Error(`${label}.lifecycle signer set does not match signer_set`);
+	if (lifecycle.selected_server_id !== signerSet.selected_server.server_id) throw new Error(`${label}.lifecycle selected server does not match signer_set`);
+	const recipientKeys = parseRegistrationRecipientKeys(record.deriver_recipient_keys);
+	if (recipientKeys.deriver_a.key_epoch !== signerSet.signer_a.key_epoch) throw new Error(`${label}.deriver_a recipient key epoch does not match signer_set`);
+	if (recipientKeys.deriver_b.key_epoch !== signerSet.signer_b.key_epoch) throw new Error(`${label}.deriver_b recipient key epoch does not match signer_set`);
+	return {
+		registration_purpose: record.registration_purpose,
+		context: parseStableKeyContext(record.context),
+		lifecycle,
+		signer_set: signerSet,
+		router_id: requireAsciiNonEmptyString(record.router_id, `${label}.router_id`),
+		client_id: requireAsciiNonEmptyString(record.client_id, `${label}.client_id`),
+		replay_nonce: requireAsciiNonEmptyString(record.replay_nonce, `${label}.replay_nonce`),
+		expires_at_ms: requirePositiveUnixMs(record.expires_at_ms, `${label}.expires_at_ms`),
+		deriver_recipient_keys: recipientKeys
+	};
+}
+function parseRouterAbEcdsaRegistrationRequestV1(value) {
+	const label = "registration";
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"registration_purpose",
+		"context",
+		"lifecycle",
+		"signer_set",
+		"router_id",
+		"client_id",
+		"client_ephemeral_public_key",
+		"replay_nonce",
+		"expires_at_ms",
+		"deriver_a_envelope",
+		"deriver_b_envelope"
+	]);
+	if (record.registration_purpose !== "wallet_registration" && record.registration_purpose !== "wallet_add_signer") throw new Error(`${label}.registration_purpose is invalid`);
+	const lifecycle = parseRegistrationLifecycle(record.lifecycle);
+	const signerSet = parsePostRegistrationSignerSet(record.signer_set, `${label}.signer_set`);
+	if (lifecycle.signer_set_id !== signerSet.signer_set_id) throw new Error(`${label}.lifecycle signer set does not match signer_set`);
+	if (lifecycle.selected_server_id !== signerSet.selected_server.server_id) throw new Error(`${label}.lifecycle selected server does not match signer_set`);
+	return {
+		registration_purpose: record.registration_purpose,
+		context: parseStableKeyContext(record.context),
+		lifecycle,
+		signer_set: signerSet,
+		router_id: requireAsciiNonEmptyString(record.router_id, `${label}.router_id`),
+		client_id: requireAsciiNonEmptyString(record.client_id, `${label}.client_id`),
+		client_ephemeral_public_key: requireX25519PublicKey(record.client_ephemeral_public_key, `${label}.client_ephemeral_public_key`),
+		replay_nonce: requireAsciiNonEmptyString(record.replay_nonce, `${label}.replay_nonce`),
+		expires_at_ms: requirePositiveUnixMs(record.expires_at_ms, `${label}.expires_at_ms`),
+		deriver_a_envelope: parsePostRegistrationRoleEnvelope(record.deriver_a_envelope, `${label}.deriver_a_envelope`, "signer_a"),
+		deriver_b_envelope: parsePostRegistrationRoleEnvelope(record.deriver_b_envelope, `${label}.deriver_b_envelope`, "signer_b")
+	};
+}
+function parseRouterAbEcdsaClientProofBundleV1(value, label) {
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"kind",
+		"transcriptDigestB64u",
+		"payloadB64u"
+	]);
+	if (record.kind !== "recipient_proof_bundle") throw new Error(`${label}.kind must be recipient_proof_bundle`);
+	return {
+		kind: "recipient_proof_bundle",
+		transcriptDigestB64u: requireBase64UrlFixed(record.transcriptDigestB64u, `${label}.transcriptDigestB64u`, 32),
+		payloadB64u: requireBase64UrlNonEmpty(record.payloadB64u, `${label}.payloadB64u`)
+	};
+}
+function parseRouterAbEcdsaStrictForwardedRegistrationResponseV1(value) {
+	const label = "registrationForwarded";
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, ["result", "response"]);
+	if (record.result !== "forwarded") throw new Error(`${label}.result must be forwarded`);
+	return {
+		result: "forwarded",
+		response: parseRouterAbEcdsaStrictProofResponseV1(record.response, `${label}.response`)
+	};
+}
+function parseRouterAbEcdsaExplicitExportProtocolForwardedResponseV1(value) {
+	return parseRouterAbEcdsaExplicitExportForwardedResponseWithV1(value, parseRouterAbEcdsaSigningWorkerProtocolExportShareEnvelopeV1);
+}
+function parseRouterAbEcdsaExplicitExportForwardedResponseWithV1(value, parseEnvelope) {
+	const label = "explicitExportForwarded";
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"result",
+		"response",
+		"signing_worker_export"
+	]);
+	if (record.result !== "forwarded") throw new Error(`${label}.result must be forwarded`);
+	return {
+		result: "forwarded",
+		response: parseRouterAbEcdsaStrictProofResponseV1(record.response, `${label}.response`),
+		signing_worker_export: parseEnvelope(record.signing_worker_export)
+	};
+}
+function parseRouterAbEcdsaSigningWorkerProtocolExportShareEnvelopeV1(value) {
+	return parseRouterAbEcdsaSigningWorkerExportShareEnvelopeWithV1(value, parseRouterAbEcdsaClientProtocolMaterialActivationRef);
+}
+function parseRouterAbEcdsaSigningWorkerExportShareBindingWithV1(value, parseMaterialActivation, label) {
+	const binding = requireRecord(value, label);
+	requireExactKeys(binding, label, [
+		"wallet_id",
+		"key_handle",
+		"ecdsa_threshold_key_id",
+		"signing_root_id",
+		"signing_root_version",
+		"activation_epoch",
+		"signing_worker_id",
+		"context_binding_b64u",
+		"threshold_public_key33_b64u",
+		"export_request_digest_b64u",
+		"export_authorization_digest_b64u",
+		"export_nonce",
+		"authorization_kind",
+		"authorization_id",
+		"material_activation",
+		"lifecycle_id",
+		"recipient_identity",
+		"recipient_public_key",
+		"expires_at_ms"
+	]);
+	const materialActivation = parseMaterialActivation(binding.material_activation);
+	if (materialActivation.material_owner !== binding.wallet_id || materialActivation.signing_worker !== binding.signing_worker_id) throw new Error(`${label}.material_activation is not bound to wallet and worker`);
+	return {
+		wallet_id: requireAsciiNonEmptyString(binding.wallet_id, `${label}.wallet_id`),
+		key_handle: requireAsciiNonEmptyString(binding.key_handle, `${label}.key_handle`),
+		ecdsa_threshold_key_id: requireAsciiNonEmptyString(binding.ecdsa_threshold_key_id, `${label}.ecdsa_threshold_key_id`),
+		signing_root_id: requireAsciiNonEmptyString(binding.signing_root_id, `${label}.signing_root_id`),
+		signing_root_version: requireAsciiNonEmptyString(binding.signing_root_version, `${label}.signing_root_version`),
+		activation_epoch: requireRootShareEpoch(binding.activation_epoch, `${label}.activation_epoch`),
+		signing_worker_id: requireAsciiNonEmptyString(binding.signing_worker_id, `${label}.signing_worker_id`),
+		context_binding_b64u: requireBase64UrlFixed(binding.context_binding_b64u, `${label}.context_binding_b64u`, 32),
+		threshold_public_key33_b64u: requireCompressedSecp256k1PublicKey(binding.threshold_public_key33_b64u, `${label}.threshold_public_key33_b64u`),
+		export_request_digest_b64u: requireBase64UrlFixed(binding.export_request_digest_b64u, `${label}.export_request_digest_b64u`, 32),
+		export_authorization_digest_b64u: requireBase64UrlFixed(binding.export_authorization_digest_b64u, `${label}.export_authorization_digest_b64u`, 32),
+		export_nonce: requireAsciiNonEmptyString(binding.export_nonce, `${label}.export_nonce`),
+		authorization_kind: requireExportShareAuthorizationKind(binding.authorization_kind, `${label}.authorization_kind`),
+		authorization_id: requireAsciiNonEmptyString(binding.authorization_id, `${label}.authorization_id`),
+		material_activation: materialActivation,
+		lifecycle_id: requireAsciiNonEmptyString(binding.lifecycle_id, `${label}.lifecycle_id`),
+		recipient_identity: requireAsciiNonEmptyString(binding.recipient_identity, `${label}.recipient_identity`),
+		recipient_public_key: requireX25519PublicKey(binding.recipient_public_key, `${label}.recipient_public_key`),
+		expires_at_ms: requirePositiveUnixMs(binding.expires_at_ms, `${label}.expires_at_ms`)
+	};
+}
+function parseRouterAbEcdsaSigningWorkerExportShareEnvelopeWithV1(value, parseMaterialActivation) {
+	const label = "signingWorkerExportShare";
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"version",
+		"algorithm",
+		"binding",
+		"ciphertext_and_tag"
+	]);
+	if (record.version !== "router-ab-ecdsa-derivation/signing-worker-export-share-envelope/v1") throw new Error(`${label}.version is invalid`);
+	if (record.algorithm !== "hpke_x25519_hkdf_sha256_aes256gcm_v1") throw new Error(`${label}.algorithm is invalid`);
+	if (!Array.isArray(record.ciphertext_and_tag) || record.ciphertext_and_tag.length <= 48) throw new Error(`${label}.ciphertext_and_tag is invalid`);
+	return {
+		version: "router-ab-ecdsa-derivation/signing-worker-export-share-envelope/v1",
+		algorithm: "hpke_x25519_hkdf_sha256_aes256gcm_v1",
+		binding: parseRouterAbEcdsaSigningWorkerExportShareBindingWithV1(record.binding, parseMaterialActivation, `${label}.binding`),
+		ciphertext_and_tag: record.ciphertext_and_tag.map((entry, index) => requireByte(entry, `${label}.ciphertext_and_tag[${index}]`))
+	};
+}
+function parseRouterAbEcdsaClientProtocolMaterialActivationRef(value) {
+	const record = requireRecord(value, "material_activation");
+	requireExactKeys(record, "material_activation", [
+		"kind",
+		"activationId",
+		"capability",
+		"materialOwner",
+		"keyBinding",
+		"lifecycleBinding",
+		"signingWorker"
+	]);
+	return parseRouterAbMpcMaterialActivationRef({
+		kind: record.kind,
+		activation_id: record.activationId,
+		capability: record.capability,
+		material_owner: record.materialOwner,
+		key_binding: record.keyBinding,
+		lifecycle_binding: record.lifecycleBinding,
+		signing_worker: record.signingWorker
+	});
+}
+function parseRouterAbEcdsaStrictProofResponseV1(value, label) {
+	const response = requireRecord(value, label);
+	requireExactKeys(response, label, ["bundles"]);
+	const bundlesLabel = `${label}.bundles`;
+	const bundles = requireRecord(response.bundles, bundlesLabel);
+	requireExactKeys(bundles, bundlesLabel, ["signerA", "signerB"]);
+	return { bundles: {
+		signerA: parseRouterAbEcdsaClientProofBundleV1(bundles.signerA, `${bundlesLabel}.signerA`),
+		signerB: parseRouterAbEcdsaClientProofBundleV1(bundles.signerB, `${bundlesLabel}.signerB`)
+	} };
+}
+function parseRouterAbEcdsaDerivationActivationRefreshResponseV1(value) {
+	const label = "activationRefreshResponse";
+	const record = requireRecord(value, label);
+	switch (record.result) {
+		case "forwarded":
+			requireExactKeys(record, label, [
+				"result",
+				"response",
+				"signing_worker_activation"
+			]);
+			return {
+				result: "forwarded",
+				response: parseRouterAbEcdsaStrictProofResponseV1(record.response, `${label}.response`),
+				signing_worker_activation: parseRouterAbEcdsaRegistrationActivationReceiptV1(record.signing_worker_activation)
+			};
+		case "activation_committed":
+			requireExactKeys(record, label, ["result", "signing_worker_activation"]);
+			return {
+				result: "activation_committed",
+				signing_worker_activation: parseRouterAbEcdsaRegistrationActivationReceiptV1(record.signing_worker_activation)
+			};
+		case "stopped":
+			requireExactKeys(record, label, [
+				"result",
+				"replay",
+				"lifecycle",
+				"decision"
+			]);
+			return {
+				result: "stopped",
+				replay: parseRouterAbReplayReservation(record.replay, `${label}.replay`),
+				lifecycle: parseRouterAbLifecycleReceipt(record.lifecycle, `${label}.lifecycle`),
+				decision: parseRouterAbExpensiveWorkGateDecision(record.decision, `${label}.decision`)
+			};
+		default: throw new Error(`${label}.result must be forwarded, activation_committed, or stopped`);
+	}
+}
+function parseRouterAbReplayReservation(value, label) {
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, ["request_id", "reserved"]);
+	if (typeof record.reserved !== "boolean") throw new Error(`${label}.reserved must be boolean`);
+	return {
+		request_id: requireAsciiNonEmptyString(record.request_id, `${label}.request_id`),
+		reserved: record.reserved
+	};
+}
+function parseRouterAbLifecycleReceipt(value, label) {
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, ["lifecycle_id", "stored"]);
+	if (typeof record.stored !== "boolean") throw new Error(`${label}.stored must be boolean`);
+	return {
+		lifecycle_id: requireAsciiNonEmptyString(record.lifecycle_id, `${label}.lifecycle_id`),
+		stored: record.stored
+	};
+}
+function parseRouterAbExpensiveWorkGateDecision(value, label) {
+	const record = requireRecord(value, label);
+	switch (record.kind) {
+		case "accepted":
+			requireExactKeys(record, label, ["kind", "request_id"]);
+			return {
+				kind: "accepted",
+				request_id: requireAsciiNonEmptyString(record.request_id, `${label}.request_id`)
+			};
+		case "reuse_existing":
+			requireExactKeys(record, label, [
+				"kind",
+				"request_id",
+				"existing_lifecycle_id"
+			]);
+			return {
+				kind: "reuse_existing",
+				request_id: requireAsciiNonEmptyString(record.request_id, `${label}.request_id`),
+				existing_lifecycle_id: requireAsciiNonEmptyString(record.existing_lifecycle_id, `${label}.existing_lifecycle_id`)
+			};
+		case "defer":
+			requireExactKeys(record, label, ["kind", "reason"]);
+			if (record.reason !== "short_window_saturated" && record.reason !== "signer_queue_saturated") throw new Error(`${label}.reason is invalid`);
+			return {
+				kind: "defer",
+				reason: record.reason
+			};
+		case "rejected":
+			requireExactKeys(record, label, [
+				"kind",
+				"reason",
+				"retry_after_ms"
+			]);
+			if (record.reason !== "rate_limited" && record.reason !== "abuse_policy") throw new Error(`${label}.reason is invalid`);
+			return {
+				kind: "rejected",
+				reason: record.reason,
+				retry_after_ms: requireNonNegativeInteger(record.retry_after_ms, `${label}.retry_after_ms`)
+			};
+		default: throw new Error(`${label}.kind is invalid`);
+	}
+}
+function parseRouterAbEcdsaVerifiedClientActivationFactsV1(value) {
+	const label = "registrationActivation.publicFacts";
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"registrationRequestDigestB64u",
+		"proofTranscriptDigestB64u",
+		"contextBinding32B64u",
+		"derivationClientSharePublicKey33B64u",
+		"clientShareRetryCounter",
+		"participantId"
+	]);
+	if (record.participantId !== 1) throw new Error(`${label}.participantId must be 1`);
+	return {
+		registrationRequestDigestB64u: requireBase64UrlFixed(record.registrationRequestDigestB64u, `${label}.registrationRequestDigestB64u`, 32),
+		proofTranscriptDigestB64u: requireBase64UrlFixed(record.proofTranscriptDigestB64u, `${label}.proofTranscriptDigestB64u`, 32),
+		contextBinding32B64u: requireBase64UrlFixed(record.contextBinding32B64u, `${label}.contextBinding32B64u`, 32),
+		derivationClientSharePublicKey33B64u: requireCompressedSecp256k1PublicKey(record.derivationClientSharePublicKey33B64u, `${label}.derivationClientSharePublicKey33B64u`),
+		clientShareRetryCounter: requireU32(record.clientShareRetryCounter, `${label}.clientShareRetryCounter`),
+		participantId: 1
+	};
+}
+function parseRouterAbEcdsaRegistrationActivationRequestV1(value) {
+	const label = "registrationActivation";
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, ["registrationCeremonyId", "ecdsa"]);
+	const ecdsa = requireRecord(record.ecdsa, `${label}.ecdsa`);
+	requireExactKeys(ecdsa, `${label}.ecdsa`, [
+		"kind",
+		"activationCorrelationId",
+		"publicFacts"
+	]);
+	if (ecdsa.kind !== "router_ab_ecdsa_registration_activation_v1") throw new Error(`${label}.ecdsa.kind is invalid`);
+	return {
+		registrationCeremonyId: requireAsciiNonEmptyString(record.registrationCeremonyId, `${label}.registrationCeremonyId`),
+		ecdsa: {
+			kind: "router_ab_ecdsa_registration_activation_v1",
+			activationCorrelationId: parseCorrelationId(ecdsa.activationCorrelationId),
+			publicFacts: parseRouterAbEcdsaVerifiedClientActivationFactsV1(ecdsa.publicFacts)
+		}
+	};
+}
+function parseRouterAbEcdsaRegistrationActivationReceiptV1(value) {
+	const label = "registrationActivationReceipt";
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"activation_correlation_id",
+		"activation_request_digest",
+		"server_generation",
+		"ecdsa_activation",
+		"lifecycle_id",
+		"transcript_digest"
+	]);
+	const activationLabel = `${label}.ecdsa_activation`;
+	const activation = requireRecord(record.ecdsa_activation, activationLabel);
+	requireExactKeys(activation, activationLabel, [
+		"context",
+		"public_identity",
+		"signing_worker",
+		"material_activation",
+		"activation_epoch",
+		"activation_digest_b64u",
+		"activated_at_ms"
+	]);
+	const signingWorker = parseServerIdentityWithLabel(activation.signing_worker, `${activationLabel}.signing_worker`);
+	const materialActivation = parseRouterAbMpcMaterialActivationRef(activation.material_activation);
+	if (materialActivation.signing_worker !== signingWorker.server_id) throw new Error(`${activationLabel}.material_activation.signing_worker does not match signing_worker`);
+	const activationDigestB64u = requireBase64UrlFixed(activation.activation_digest_b64u, `${activationLabel}.activation_digest_b64u`, 32);
+	const transcriptDigest = parsePublicDigest32(record.transcript_digest, `${label}.transcript_digest`);
+	return {
+		activation_correlation_id: parseCorrelationId(record.activation_correlation_id),
+		activation_request_digest: parsePublicDigest32(record.activation_request_digest, `${label}.activation_request_digest`),
+		server_generation: parseEcdsaServerGeneration(record.server_generation),
+		ecdsa_activation: {
+			context: parseStableKeyContext(activation.context),
+			public_identity: parsePublicIdentity(activation.public_identity),
+			signing_worker: signingWorker,
+			material_activation: materialActivation,
+			activation_epoch: requireRootShareEpoch(activation.activation_epoch, `${activationLabel}.activation_epoch`),
+			activation_digest_b64u: activationDigestB64u,
+			activated_at_ms: requirePositiveUnixMs(activation.activated_at_ms, `${activationLabel}.activated_at_ms`)
+		},
+		lifecycle_id: requireAsciiNonEmptyString(record.lifecycle_id, `${label}.lifecycle_id`),
+		transcript_digest: transcriptDigest
+	};
+}
+function sameRouterAbServerIdentityV1(left, right) {
+	return left.server_id === right.server_id && left.key_epoch === right.key_epoch && left.recipient_encryption_key === right.recipient_encryption_key;
+}
+function sameRouterAbEcdsaVerifiedClientActivationFactsV1(left, right) {
+	return left.registrationRequestDigestB64u === right.registrationRequestDigestB64u && left.proofTranscriptDigestB64u === right.proofTranscriptDigestB64u && left.contextBinding32B64u === right.contextBinding32B64u && left.derivationClientSharePublicKey33B64u === right.derivationClientSharePublicKey33B64u && left.clientShareRetryCounter === right.clientShareRetryCounter && left.participantId === right.participantId;
+}
+function sameRegistrationSignerSet(left, right) {
+	return left.signer_set_id === right.signer_set_id && left.policy === right.policy && left.signer_a.role === right.signer_a.role && left.signer_a.signer_id === right.signer_a.signer_id && left.signer_a.key_epoch === right.signer_a.key_epoch && left.signer_b.role === right.signer_b.role && left.signer_b.signer_id === right.signer_b.signer_id && left.signer_b.key_epoch === right.signer_b.key_epoch && sameRouterAbServerIdentityV1(left.selected_server, right.selected_server);
+}
+function sameRegistrationLifecycle(left, right) {
+	return left.lifecycle_id === right.lifecycle_id && left.work_kind === right.work_kind && left.primitive_request_kind === right.primitive_request_kind && left.root_share_epoch === right.root_share_epoch && left.account_id === right.account_id && left.session_id === right.session_id && left.signer_set_id === right.signer_set_id && left.selected_server_id === right.selected_server_id;
+}
+function sameRouterAbEcdsaRegistrationRequestFactsV1(left, right) {
+	return left.registration_purpose === right.registration_purpose && left.context.application_binding_digest_b64u === right.context.application_binding_digest_b64u && sameRegistrationLifecycle(left.lifecycle, right.lifecycle) && sameRegistrationSignerSet(left.signer_set, right.signer_set) && sameRegistrationRecipientKeys(left.deriver_recipient_keys, right.deriver_recipient_keys) && left.router_id === right.router_id && left.client_id === right.client_id && left.replay_nonce === right.replay_nonce && left.expires_at_ms === right.expires_at_ms;
+}
+function assertRouterAbEcdsaRegistrationFactsMatchRequestV1(input) {
+	const facts = input.facts;
+	const request = input.request;
+	if (facts.registration_purpose !== request.registration_purpose || facts.context.application_binding_digest_b64u !== request.context.application_binding_digest_b64u || !sameRegistrationLifecycle(facts.lifecycle, request.lifecycle) || !sameRegistrationSignerSet(facts.signer_set, request.signer_set) || facts.router_id !== request.router_id || facts.client_id !== request.client_id || facts.replay_nonce !== request.replay_nonce || facts.expires_at_ms !== request.expires_at_ms) throw new Error("ECDSA registration facts do not match the sealed registration request");
+}
+function parseRouterAbEcdsaDerivationPublicCapabilityV1(value) {
+	const label = "ecdsaPublicCapability";
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"kind",
+		"context",
+		"public_identity",
+		"material_activation",
+		"signer_set",
+		"deriver_recipient_keys",
+		"router_id",
+		"client_id",
+		"activation_epoch",
+		"registration_request_digest_b64u",
+		"proof_transcript_digest_b64u"
+	]);
+	if (record.kind !== "router_ab_ecdsa_derivation_public_capability_v1") throw new Error(`${label}.kind is invalid`);
+	const signerSet = parsePostRegistrationSignerSet(record.signer_set, `${label}.signer_set`);
+	const recipientKeys = parseRegistrationRecipientKeys(record.deriver_recipient_keys, `${label}.deriver_recipient_keys`);
+	if (recipientKeys.deriver_a.key_epoch !== signerSet.signer_a.key_epoch || recipientKeys.deriver_b.key_epoch !== signerSet.signer_b.key_epoch) throw new Error(`${label} Deriver recipient key epochs do not match signer_set`);
+	return {
+		kind: "router_ab_ecdsa_derivation_public_capability_v1",
+		context: parseStableKeyContext(record.context),
+		public_identity: parsePublicIdentity(record.public_identity),
+		material_activation: parseRouterAbMpcMaterialActivationRef(record.material_activation),
+		signer_set: signerSet,
+		deriver_recipient_keys: recipientKeys,
+		router_id: requireAsciiNonEmptyString(record.router_id, `${label}.router_id`),
+		client_id: requireAsciiNonEmptyString(record.client_id, `${label}.client_id`),
+		activation_epoch: requireRootShareEpoch(record.activation_epoch, `${label}.activation_epoch`),
+		registration_request_digest_b64u: requireBase64UrlFixed(record.registration_request_digest_b64u, `${label}.registration_request_digest_b64u`, 32),
+		proof_transcript_digest_b64u: requireBase64UrlFixed(record.proof_transcript_digest_b64u, `${label}.proof_transcript_digest_b64u`, 32)
+	};
+}
+function parsePostRegistrationSessionPolicy(value) {
+	const label = "postRegistrationSessionActivation.session_policy";
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"threshold_session_id",
+		"wallet_session_mint_id",
+		"ttl_ms",
+		"remaining_uses",
+		"runtime_policy_scope"
+	]);
+	return {
+		threshold_session_id: requireThresholdEcdsaSessionId(record.threshold_session_id, `${label}.threshold_session_id`),
+		wallet_session_mint_id: requireWalletSessionMintId(record.wallet_session_mint_id, `${label}.wallet_session_mint_id`),
+		ttl_ms: requirePositiveCounter(record.ttl_ms, `${label}.ttl_ms`),
+		remaining_uses: requirePositiveCounter(record.remaining_uses, `${label}.remaining_uses`),
+		runtime_policy_scope: normalizeRuntimePolicyScope(record.runtime_policy_scope)
+	};
+}
+function parseRouterAbEcdsaPostRegistrationSessionActivationPolicyV1(value) {
+	const label = "postRegistrationSessionActivationPolicy";
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"kind",
+		"key_handle",
+		"session_policy"
+	]);
+	if (record.kind !== "router_ab_ecdsa_post_registration_session_activation_policy_v1") throw new Error(`${label}.kind is invalid`);
+	return {
+		kind: "router_ab_ecdsa_post_registration_session_activation_policy_v1",
+		key_handle: requireAsciiNonEmptyString(record.key_handle, `${label}.key_handle`),
+		session_policy: parsePostRegistrationSessionPolicy(record.session_policy)
+	};
+}
+function requireWalletSessionMintId(value, label) {
+	const parsed = parseWalletSessionMintId(value);
+	if (!parsed.ok) throw new Error(`${label} is invalid`);
+	return parsed.value;
+}
+function sameRouterAbEcdsaDerivationPublicIdentityV1(left, right) {
+	return left.context_binding_b64u === right.context_binding_b64u && left.derivation_client_share_public_key33_b64u === right.derivation_client_share_public_key33_b64u && left.server_public_key33_b64u === right.server_public_key33_b64u && left.threshold_public_key33_b64u === right.threshold_public_key33_b64u && left.ethereum_address20_b64u === right.ethereum_address20_b64u && left.client_share_retry_counter === right.client_share_retry_counter && left.server_share_retry_counter === right.server_share_retry_counter;
+}
+function activeWalletSessionMatchesEcdsaCapability(session, capability) {
+	for (const subject of session.capabilitySubjects) {
+		if (subject.kind !== "sign" || subject.keyFamily !== "ecdsa_secp256k1") continue;
+		return sameRouterAbMpcMaterialActivationRef(capability.material_activation, routerAbMpcMaterialActivationRefToWire(subject.materialActivation));
+	}
+	return false;
+}
+function parseRouterAbEcdsaPostRegistrationSessionActivationRequestV1(value) {
+	const label = "postRegistrationSessionActivation";
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"kind",
+		"public_capability",
+		"session_policy"
+	]);
+	if (record.kind !== "router_ab_ecdsa_post_registration_session_activation_v1") throw new Error(`${label}.kind is invalid`);
+	return {
+		kind: "router_ab_ecdsa_post_registration_session_activation_v1",
+		public_capability: parseRouterAbEcdsaDerivationPublicCapabilityV1(record.public_capability),
+		session_policy: parsePostRegistrationSessionPolicy(record.session_policy)
+	};
+}
+function parseRouterAbEcdsaPostRegistrationSessionActivationResponseV1(value) {
+	const label = "postRegistrationSessionActivated";
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"kind",
+		"public_capability",
+		"session",
+		"normal_signing"
+	]);
+	if (record.kind !== "router_ab_ecdsa_post_registration_session_activated_v1") throw new Error(`${label}.kind is invalid`);
+	const publicCapability = parseRouterAbEcdsaDerivationPublicCapabilityV1(record.public_capability);
+	const sessionRecord = requireRecord(record.session, `${label}.session`);
+	requireExactKeys(sessionRecord, `${label}.session`, [
+		"authorization_session_id",
+		"authorization_id",
+		"threshold_session_id",
+		"wallet_session_id",
+		"quota_id",
+		"expires_at_ms",
+		"remaining_uses",
+		"wallet_session",
+		"operation_credential"
+	]);
+	const normalSigning = requireRouterAbEcdsaDerivationNormalSigningStateV1(record.normal_signing);
+	const authorizationId = requireWalletSessionAuthorizationId(sessionRecord.authorization_id, `${label}.session.authorization_id`);
+	const walletSessionId = requireWalletSessionId(sessionRecord.wallet_session_id, `${label}.session.wallet_session_id`);
+	const expiresAtMs = requirePositiveUnixMs(sessionRecord.expires_at_ms, `${label}.session.expires_at_ms`);
+	const walletSession = parseActiveWalletSessionV1(sessionRecord.wallet_session);
+	const operationCredential = parseWalletSessionOperationCredentialV1(sessionRecord.operation_credential);
+	if (!sameRouterAbEcdsaDerivationPublicIdentityV1(publicCapability.public_identity, normalSigning.scope.public_identity) || publicCapability.context.application_binding_digest_b64u !== normalSigning.scope.context.application_binding_digest_b64u || normalSigning.scope.activation_epoch !== publicCapability.activation_epoch || !sameRouterAbServerIdentityV1(normalSigning.scope.signing_worker, publicCapability.signer_set.selected_server) || walletSession.authorizationId !== authorizationId || walletSession.walletId !== publicCapability.client_id || walletSession.expiresAtMs !== expiresAtMs || !activeWalletSessionMatchesEcdsaCapability(walletSession, publicCapability) || operationCredential.walletSessionId !== walletSessionId) throw new Error(`${label} exact Wallet Session does not match the activated capability`);
+	return {
+		kind: "router_ab_ecdsa_post_registration_session_activated_v1",
+		public_capability: publicCapability,
+		session: {
+			authorization_session_id: requireEcdsaAuthorizationSessionId(sessionRecord.authorization_session_id, `${label}.session.authorization_session_id`),
+			authorization_id: authorizationId,
+			threshold_session_id: requireThresholdEcdsaSessionId(sessionRecord.threshold_session_id, `${label}.session.threshold_session_id`),
+			wallet_session_id: walletSessionId,
+			quota_id: requireMpcWalletSigningQuotaId(sessionRecord.quota_id, `${label}.session.quota_id`),
+			expires_at_ms: expiresAtMs,
+			remaining_uses: requirePositiveCounter(sessionRecord.remaining_uses, `${label}.session.remaining_uses`),
+			wallet_session: walletSession,
+			operation_credential: operationCredential
+		},
+		normal_signing: normalSigning
+	};
+}
+function parseRouterAbEcdsaCredentialFreeSessionActivationResponseV1(value) {
+	const label = "credentialFreeSessionActivated";
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"kind",
+		"public_capability",
+		"session",
+		"normal_signing"
+	]);
+	if (record.kind !== "router_ab_ecdsa_credential_free_session_activated_v1") throw new Error(`${label}.kind is invalid`);
+	const publicCapability = parseRouterAbEcdsaDerivationPublicCapabilityV1(record.public_capability);
+	const sessionRecord = requireRecord(record.session, `${label}.session`);
+	requireExactKeys(sessionRecord, `${label}.session`, [
+		"authorization_session_id",
+		"authorization_id",
+		"threshold_session_id",
+		"wallet_session_id",
+		"quota_id",
+		"expires_at_ms",
+		"remaining_uses"
+	]);
+	const normalSigning = requireRouterAbEcdsaDerivationNormalSigningStateV1(record.normal_signing);
+	if (!sameRouterAbEcdsaDerivationPublicIdentityV1(publicCapability.public_identity, normalSigning.scope.public_identity) || publicCapability.context.application_binding_digest_b64u !== normalSigning.scope.context.application_binding_digest_b64u || normalSigning.scope.activation_epoch !== publicCapability.activation_epoch || !sameRouterAbServerIdentityV1(normalSigning.scope.signing_worker, publicCapability.signer_set.selected_server)) throw new Error(`${label} normal-signing state does not match public capability`);
+	return {
+		kind: "router_ab_ecdsa_credential_free_session_activated_v1",
+		public_capability: publicCapability,
+		session: {
+			authorization_session_id: requireEcdsaAuthorizationSessionId(sessionRecord.authorization_session_id, `${label}.session.authorization_session_id`),
+			authorization_id: requireWalletSessionAuthorizationId(sessionRecord.authorization_id, `${label}.session.authorization_id`),
+			threshold_session_id: requireThresholdEcdsaSessionId(sessionRecord.threshold_session_id, `${label}.session.threshold_session_id`),
+			wallet_session_id: requireWalletSessionId(sessionRecord.wallet_session_id, `${label}.session.wallet_session_id`),
+			quota_id: requireMpcWalletSigningQuotaId(sessionRecord.quota_id, `${label}.session.quota_id`),
+			expires_at_ms: requirePositiveUnixMs(sessionRecord.expires_at_ms, `${label}.session.expires_at_ms`),
+			remaining_uses: requirePositiveCounter(sessionRecord.remaining_uses, `${label}.session.remaining_uses`)
+		},
+		normal_signing: normalSigning
+	};
+}
+function buildRouterAbEcdsaDerivationPublicCapabilityV1(input) {
+	const facts = parseRouterAbEcdsaRegistrationRequestFactsV1(input.registrationFacts);
+	const request = parseRouterAbEcdsaRegistrationRequestV1(input.registrationRequest);
+	const clientActivation = parseRouterAbEcdsaVerifiedClientActivationFactsV1(input.clientActivation);
+	const receipt = parseRouterAbEcdsaRegistrationActivationReceiptV1(input.activationReceipt);
+	assertRouterAbEcdsaRegistrationFactsMatchRequestV1({
+		facts,
+		request
+	});
+	const activated = receipt.ecdsa_activation;
+	if (receipt.lifecycle_id !== request.lifecycle.lifecycle_id || activated.activation_epoch !== request.lifecycle.root_share_epoch || activated.context.application_binding_digest_b64u !== request.context.application_binding_digest_b64u || !sameRouterAbServerIdentityV1(activated.signing_worker, request.signer_set.selected_server) || activated.public_identity.context_binding_b64u !== clientActivation.contextBinding32B64u || activated.public_identity.derivation_client_share_public_key33_b64u !== clientActivation.derivationClientSharePublicKey33B64u || activated.public_identity.client_share_retry_counter !== clientActivation.clientShareRetryCounter || base64UrlEncode(new Uint8Array(receipt.transcript_digest.bytes)) !== clientActivation.proofTranscriptDigestB64u) throw new Error("ECDSA activation receipt does not match verified registration facts");
+	return parseRouterAbEcdsaDerivationPublicCapabilityV1({
+		kind: "router_ab_ecdsa_derivation_public_capability_v1",
+		context: activated.context,
+		public_identity: activated.public_identity,
+		material_activation: activated.material_activation,
+		signer_set: request.signer_set,
+		deriver_recipient_keys: facts.deriver_recipient_keys,
+		router_id: request.router_id,
+		client_id: request.client_id,
+		activation_epoch: activated.activation_epoch,
+		registration_request_digest_b64u: clientActivation.registrationRequestDigestB64u,
+		proof_transcript_digest_b64u: clientActivation.proofTranscriptDigestB64u
+	});
+}
+function requirePostRegistrationBindings(label, lifecycle, signerSet) {
+	if (lifecycle.signer_set_id !== signerSet.signer_set_id) throw new Error(`${label}.lifecycle.signer_set_id must match signer_set.signer_set_id`);
+	if (lifecycle.selected_server_id !== signerSet.selected_server.server_id) throw new Error(`${label}.lifecycle.selected_server_id must match signer_set.selected_server.server_id`);
+}
+function parseRouterAbEcdsaDerivationExplicitExportRequestV1(value) {
+	const label = "export";
+	const record = requireRecord(value, label);
+	const authorization = parseRouterAbNormalSigningAuthorization(record.authorization);
+	const commonKeys = explicitExportRequestCommonKeys();
+	switch (authorization.kind) {
+		case "reusable_wallet_session":
+			requireExactKeys(record, label, commonKeys);
+			break;
+		case "operation_step_up":
+			requireExactKeys(record, label, [...commonKeys, "operation"]);
+			break;
+	}
+	const parsed = parseExplicitExportRequestProtocolFields(record, label, authorization);
+	switch (authorization.kind) {
+		case "reusable_wallet_session": return {
+			...parsed,
+			authorization
+		};
+		case "operation_step_up": return {
+			...parsed,
+			authorization,
+			operation: parseRouterAbEcdsaOperationStepUpPreparationV1(record.operation)
+		};
+	}
+}
+function explicitExportRequestCommonKeys() {
+	return [
+		"context",
+		"lifecycle",
+		"public_identity",
+		"signer_set",
+		"router_id",
+		"client_id",
+		"client_ephemeral_public_key",
+		"authorization",
+		"material_activation",
+		"export_authorization_digest_b64u",
+		"export_nonce",
+		"expires_at_ms",
+		"deriver_a_export_envelope",
+		"deriver_b_export_envelope"
+	];
+}
+function parseExplicitExportRequestProtocolFields(record, label, authorization) {
+	const lifecycle = parsePostRegistrationLifecycleScope(record.lifecycle, `${label}.lifecycle`, "key_export", "export");
+	const signerSet = parsePostRegistrationSignerSet(record.signer_set, `${label}.signer_set`);
+	requirePostRegistrationBindings(label, lifecycle, signerSet);
+	const materialActivation = parseRouterAbMpcMaterialActivationRef(record.material_activation);
+	if (materialActivation.material_owner !== lifecycle.account_id || materialActivation.signing_worker !== lifecycle.selected_server_id) throw new Error(`${label}.material_activation is not bound to lifecycle owner and selected server`);
+	return {
+		context: parseStableKeyContext(record.context),
+		lifecycle,
+		public_identity: parsePublicIdentity(record.public_identity),
+		signer_set: signerSet,
+		router_id: requireAsciiNonEmptyString(record.router_id, `${label}.router_id`),
+		client_id: requireAsciiNonEmptyString(record.client_id, `${label}.client_id`),
+		client_ephemeral_public_key: requireX25519PublicKey(record.client_ephemeral_public_key, `${label}.client_ephemeral_public_key`),
+		material_activation: materialActivation,
+		export_authorization_digest_b64u: requireBase64UrlFixed(record.export_authorization_digest_b64u, `${label}.export_authorization_digest_b64u`, 32),
+		export_nonce: requireAsciiNonEmptyString(record.export_nonce, `${label}.export_nonce`),
+		expires_at_ms: requirePositiveUnixMs(record.expires_at_ms, `${label}.expires_at_ms`),
+		deriver_a_export_envelope: parsePostRegistrationRoleEnvelope(record.deriver_a_export_envelope, `${label}.deriver_a_export_envelope`, "signer_a"),
+		deriver_b_export_envelope: parsePostRegistrationRoleEnvelope(record.deriver_b_export_envelope, `${label}.deriver_b_export_envelope`, "signer_b"),
+		authorization
+	};
+}
+function parseRouterAbEcdsaDerivationActivationRefreshRequestV1(value) {
+	const label = "refresh";
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"context",
+		"lifecycle",
+		"public_identity",
+		"signer_set",
+		"router_id",
+		"client_id",
+		"signing_worker_ephemeral_public_key",
+		"refresh_authorization_digest_b64u",
+		"refresh_nonce",
+		"previous_activation_epoch",
+		"next_activation_epoch",
+		"material_activation",
+		"expires_at_ms",
+		"deriver_a_refresh_envelope",
+		"deriver_b_refresh_envelope"
+	]);
+	const lifecycle = parsePostRegistrationLifecycleScope(record.lifecycle, `${label}.lifecycle`, "server_share_refresh", "refresh");
+	const signerSet = parsePostRegistrationSignerSet(record.signer_set, `${label}.signer_set`);
+	const previousActivationEpoch = requireRootShareEpoch(record.previous_activation_epoch, `${label}.previous_activation_epoch`);
+	const nextActivationEpoch = requireRootShareEpoch(record.next_activation_epoch, `${label}.next_activation_epoch`);
+	if (previousActivationEpoch === nextActivationEpoch) throw new Error("refresh must advance activation epoch");
+	if (lifecycle.root_share_epoch !== nextActivationEpoch) throw new Error("refresh.lifecycle.root_share_epoch must equal next_activation_epoch");
+	requirePostRegistrationBindings(label, lifecycle, signerSet);
+	const materialActivation = parseRouterAbMpcMaterialActivationRef(record.material_activation);
+	if (materialActivation.material_owner !== lifecycle.account_id || materialActivation.signing_worker !== signerSet.selected_server.server_id) throw new Error("refresh.material_activation is not bound to lifecycle owner and selected server");
+	return {
+		context: parseStableKeyContext(record.context),
+		lifecycle,
+		public_identity: parsePublicIdentity(record.public_identity),
+		signer_set: signerSet,
+		router_id: requireAsciiNonEmptyString(record.router_id, `${label}.router_id`),
+		client_id: requireAsciiNonEmptyString(record.client_id, `${label}.client_id`),
+		signing_worker_ephemeral_public_key: requireX25519PublicKey(record.signing_worker_ephemeral_public_key, `${label}.signing_worker_ephemeral_public_key`),
+		refresh_authorization_digest_b64u: requireBase64UrlFixed(record.refresh_authorization_digest_b64u, `${label}.refresh_authorization_digest_b64u`, 32),
+		refresh_nonce: requireAsciiNonEmptyString(record.refresh_nonce, `${label}.refresh_nonce`),
+		previous_activation_epoch: previousActivationEpoch,
+		next_activation_epoch: nextActivationEpoch,
+		material_activation: materialActivation,
+		expires_at_ms: requirePositiveUnixMs(record.expires_at_ms, `${label}.expires_at_ms`),
+		deriver_a_refresh_envelope: parsePostRegistrationRoleEnvelope(record.deriver_a_refresh_envelope, `${label}.deriver_a_refresh_envelope`, "signer_a"),
+		deriver_b_refresh_envelope: parsePostRegistrationRoleEnvelope(record.deriver_b_refresh_envelope, `${label}.deriver_b_refresh_envelope`, "signer_b")
+	};
+}
+function parseRouterAbEcdsaDerivationActivationRefreshCommitRequestV1(value) {
+	const label = "refreshCommit";
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"activation_correlation_id",
+		"expected_server_generation",
+		"refresh_request"
+	]);
+	return {
+		activation_correlation_id: parseCorrelationId(record.activation_correlation_id),
+		expected_server_generation: parseEcdsaServerGeneration(record.expected_server_generation),
+		refresh_request: parseRouterAbEcdsaDerivationActivationRefreshRequestV1(record.refresh_request)
+	};
+}
+function publicDigest32FromBase64Url(value, label = "signing_digest_b64u") {
+	return { bytes: Array.from(base64UrlDecode(requireBase64UrlFixed(value, label, 32))) };
+}
+function samePublicDigest32(left, right) {
+	return left.bytes.length === 32 && right.bytes.length === 32 && left.bytes.every((b, i) => b === right.bytes[i]);
+}
+function sameRouterAbPublicDigest32V1Wire(left, right) {
+	return left.bytes.length === right.bytes.length && left.bytes.every((b, i) => b === right.bytes[i]);
+}
+function sameRegistrationRecipientKeys(left, right) {
+	return left.deriver_a.role === right.deriver_a.role && left.deriver_a.key_epoch === right.deriver_a.key_epoch && left.deriver_a.public_key === right.deriver_a.public_key && left.deriver_b.role === right.deriver_b.role && left.deriver_b.key_epoch === right.deriver_b.key_epoch && left.deriver_b.public_key === right.deriver_b.public_key;
+}
+function sameRouterAbEcdsaRegistrationActivationReceiptV1(left, right) {
+	const leftActivation = left.ecdsa_activation;
+	const rightActivation = right.ecdsa_activation;
+	return left.activation_correlation_id === right.activation_correlation_id && sameRouterAbPublicDigest32V1Wire(left.activation_request_digest, right.activation_request_digest) && left.server_generation === right.server_generation && left.lifecycle_id === right.lifecycle_id && sameRouterAbPublicDigest32V1Wire(left.transcript_digest, right.transcript_digest) && leftActivation.context.application_binding_digest_b64u === rightActivation.context.application_binding_digest_b64u && sameRouterAbEcdsaDerivationPublicIdentityV1(leftActivation.public_identity, rightActivation.public_identity) && sameRouterAbServerIdentityV1(leftActivation.signing_worker, rightActivation.signing_worker) && sameRouterAbMpcMaterialActivationRef(leftActivation.material_activation, rightActivation.material_activation) && leftActivation.activation_epoch === rightActivation.activation_epoch && leftActivation.activation_digest_b64u === rightActivation.activation_digest_b64u && leftActivation.activated_at_ms === rightActivation.activated_at_ms;
+}
+function sameRouterAbEcdsaDerivationNormalSigningStateV1(left, right) {
+	const leftScope = left.scope;
+	const rightScope = right.scope;
+	return left.kind === right.kind && leftScope.wallet_id === rightScope.wallet_id && leftScope.ecdsa_threshold_key_id === rightScope.ecdsa_threshold_key_id && leftScope.signing_root_id === rightScope.signing_root_id && leftScope.signing_root_version === rightScope.signing_root_version && leftScope.context.application_binding_digest_b64u === rightScope.context.application_binding_digest_b64u && sameRouterAbEcdsaDerivationPublicIdentityV1(leftScope.public_identity, rightScope.public_identity) && sameRouterAbMpcMaterialActivationRef(leftScope.material_activation, rightScope.material_activation) && sameRouterAbServerIdentityV1(leftScope.signing_worker, rightScope.signing_worker) && leftScope.activation_epoch === rightScope.activation_epoch;
+}
+function sameRouterAbEcdsaDerivationPublicCapabilityV1(left, right) {
+	return left.kind === right.kind && left.context.application_binding_digest_b64u === right.context.application_binding_digest_b64u && sameRouterAbEcdsaDerivationPublicIdentityV1(left.public_identity, right.public_identity) && sameRouterAbMpcMaterialActivationRef(left.material_activation, right.material_activation) && sameRegistrationSignerSet(left.signer_set, right.signer_set) && sameRegistrationRecipientKeys(left.deriver_recipient_keys, right.deriver_recipient_keys) && left.router_id === right.router_id && left.client_id === right.client_id && left.activation_epoch === right.activation_epoch && left.registration_request_digest_b64u === right.registration_request_digest_b64u && left.proof_transcript_digest_b64u === right.proof_transcript_digest_b64u;
+}
+function asciiBytes(value) {
+	return new TextEncoder().encode(requireAsciiNonEmptyString(value, "canonical string"));
+}
+function pushBytes(out, bytes) {
+	for (const byte of bytes) out.push(byte);
+}
+function pushOperationDigests(out, digests) {
+	pushBytes(out, base64UrlDecode(digests.lane_digest_b64u));
+	pushBytes(out, base64UrlDecode(digests.intent_digest_b64u));
+	pushBytes(out, base64UrlDecode(digests.display_digest_b64u));
+}
+function pushU16(out, value) {
+	if (!Number.isInteger(value) || value < 0 || value > 65535) throw new Error("canonical u16 must be an integer between 0 and 65535");
+	out.push(value >>> 8 & 255, value & 255);
+}
+function pushU32(out, value) {
+	if (!Number.isInteger(value) || value < 0 || value > 4294967295) throw new Error("canonical u32 must be an integer between 0 and 4294967295");
+	out.push(value >>> 24 & 255, value >>> 16 & 255, value >>> 8 & 255, value & 255);
+}
+function pushU64(out, value) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new Error("canonical u64 must be a non-negative safe integer");
+	const remaining = BigInt(value);
+	for (let shift = 56; shift >= 0; shift -= 8) out.push(Number(remaining >> BigInt(shift) & 255n));
+}
+function pushLen32(out, bytes) {
+	pushU32(out, bytes.length);
+	pushBytes(out, bytes);
+}
+function pushAsciiU16(out, value) {
+	const bytes = asciiBytes(value);
+	pushU16(out, bytes.length);
+	pushBytes(out, bytes);
+}
+function pushServerIdentity(out, server) {
+	pushLen32(out, asciiBytes(server.server_id));
+	pushLen32(out, asciiBytes(server.key_epoch));
+	pushLen32(out, asciiBytes(server.recipient_encryption_key));
+}
+async function sha256Bytes(input) {
+	const subtle = globalThis.crypto?.subtle;
+	if (!subtle) throw new Error("crypto.subtle is required for Router A/B ECDSA derivation request digest binding");
+	const buffer = new ArrayBuffer(input.byteLength);
+	new Uint8Array(buffer).set(input);
+	return new Uint8Array(await subtle.digest("SHA-256", buffer));
+}
+function canonicalStableKeyContextBytes(context) {
+	const parsed = parseStableKeyContext(context);
+	const out = [];
+	pushBytes(out, asciiBytes(ECDSA_DERIVATION_CONTEXT_DOMAIN_TAG_V1));
+	pushAsciiU16(out, ECDSA_DERIVATION_SCHEME_ID_V1);
+	pushAsciiU16(out, ECDSA_DERIVATION_CURVE_V1);
+	pushBytes(out, base64UrlDecode(parsed.application_binding_digest_b64u));
+	out.push(ECDSA_DERIVATION_PARTICIPANT_IDS_V1.length);
+	for (const participantId of ECDSA_DERIVATION_PARTICIPANT_IDS_V1) pushU16(out, participantId);
+	return new Uint8Array(out);
+}
+function contextBindingFrame(contextBytes) {
+	const out = [];
+	pushBytes(out, asciiBytes(ECDSA_DERIVATION_CONTEXT_BINDING_DOMAIN_V1));
+	out.push(1);
+	out.push(ECDSA_DERIVATION_CONTEXT_FIELD_BYTES_V1);
+	pushU16(out, contextBytes.length);
+	pushBytes(out, contextBytes);
+	return new Uint8Array(out);
+}
+async function routerAbEcdsaDerivationContextBindingDigestV1(context) {
+	return publicDigest32FromCanonicalBytes(contextBindingFrame(canonicalStableKeyContextBytes(context)));
+}
+function canonicalPublicIdentityBytes(publicIdentity) {
+	const parsed = parsePublicIdentity(publicIdentity);
+	const out = [];
+	pushLen32(out, asciiBytes(ROUTER_AB_ECDSA_DERIVATION_PUBLIC_IDENTITY_VERSION_V1));
+	pushLen32(out, asciiBytes(parsed.context_binding_b64u));
+	pushLen32(out, asciiBytes(parsed.derivation_client_share_public_key33_b64u));
+	pushLen32(out, asciiBytes(parsed.server_public_key33_b64u));
+	pushLen32(out, asciiBytes(parsed.threshold_public_key33_b64u));
+	pushLen32(out, asciiBytes(parsed.ethereum_address20_b64u));
+	pushU32(out, parsed.client_share_retry_counter);
+	pushU32(out, parsed.server_share_retry_counter);
+	return new Uint8Array(out);
+}
+function canonicalNormalSigningScopeBytes(scope) {
+	const parsed = parseRouterAbEcdsaDerivationNormalSigningScopeV1(scope);
+	const out = [];
+	pushLen32(out, asciiBytes(ROUTER_AB_ECDSA_DERIVATION_NORMAL_SIGNING_SCOPE_VERSION_V1));
+	pushLen32(out, asciiBytes(parsed.wallet_id));
+	pushLen32(out, asciiBytes(parsed.ecdsa_threshold_key_id));
+	pushLen32(out, asciiBytes(parsed.signing_root_id));
+	pushLen32(out, asciiBytes(parsed.signing_root_version));
+	pushLen32(out, canonicalStableKeyContextBytes(parsed.context));
+	pushLen32(out, canonicalPublicIdentityBytes(parsed.public_identity));
+	out.push(...canonicalRouterAbMpcMaterialActivationRefBytes(parsed.material_activation));
+	pushServerIdentity(out, parsed.signing_worker);
+	pushLen32(out, asciiBytes(parsed.activation_epoch));
+	return new Uint8Array(out);
+}
+function routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1(scope) {
+	return canonicalNormalSigningScopeBytes(scope);
+}
+function sameCanonicalBytes(left, right) {
+	return left.length === right.length && left.every((byte, index) => byte === right[index]);
+}
+function sameRouterAbEcdsaDerivationNormalSigningScopeV1(left, right) {
+	try {
+		return sameCanonicalBytes(routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1(left), routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1(right));
+	} catch {
+		return false;
+	}
+}
+async function publicDigest32FromCanonicalBytes(bytes) {
+	return { bytes: Array.from(await sha256Bytes(bytes)) };
+}
+async function verifyRouterAbEcdsaDerivationNormalSigningScopeContextBindingV1(scope) {
+	const parsed = parseRouterAbEcdsaDerivationNormalSigningScopeV1(scope);
+	const expected = await routerAbEcdsaDerivationContextBindingDigestV1(parsed.context);
+	if (!samePublicDigest32(publicDigest32FromBase64Url(parsed.public_identity.context_binding_b64u, "scope.public_identity.context_binding_b64u"), expected)) throw new Error("scope.public_identity.context_binding_b64u does not match scope.context");
+	return parsed;
+}
+function routerAbEcdsaDerivationEvmDigestSigningRequestCanonicalBytesV1(request) {
+	const parsed = parseRouterAbEcdsaDerivationEvmDigestSigningRequestV1(request);
+	const out = [];
+	pushLen32(out, asciiBytes(ROUTER_AB_ECDSA_DERIVATION_NORMAL_SIGNING_REQUEST_VERSION_V1));
+	pushLen32(out, canonicalNormalSigningScopeBytes(parsed.scope));
+	pushLen32(out, asciiBytes(parsed.request_id));
+	pushLen32(out, asciiBytes(parsed.operation_id));
+	pushOperationDigests(out, parsed.operation_digests);
+	out.push(...canonicalRouterAbNormalSigningAuthorizationBytes(parsed.authorization));
+	out.push(...canonicalRouterAbMpcMaterialActivationRefBytes(parsed.material_activation));
+	pushLen32(out, asciiBytes(parsed.client_presignature_id));
+	pushU64(out, parsed.expires_at_ms);
+	pushBytes(out, base64UrlDecode(parsed.signing_digest_b64u));
+	pushLen32(out, base64UrlDecode(parsed.client_rerandomization_commitment32_b64u));
+	return new Uint8Array(out);
+}
+async function routerAbEcdsaDerivationEvmDigestSigningRequestDigestV1(request) {
+	const parsed = parseRouterAbEcdsaDerivationEvmDigestSigningRequestV1(request);
+	await verifyRouterAbEcdsaDerivationNormalSigningScopeContextBindingV1(parsed.scope);
+	return publicDigest32FromCanonicalBytes(routerAbEcdsaDerivationEvmDigestSigningRequestCanonicalBytesV1(parsed));
+}
+function routerAbEcdsaDerivationEvmDigestSigningFinalizeCoreRequestCanonicalBytesV1(request) {
+	const parsed = parseRouterAbEcdsaDerivationEvmDigestSigningFinalizeCoreRequestV1(request);
+	const out = [];
+	pushLen32(out, asciiBytes(ROUTER_AB_ECDSA_DERIVATION_NORMAL_SIGNING_FINALIZE_REQUEST_VERSION_V1));
+	pushLen32(out, canonicalNormalSigningScopeBytes(parsed.scope));
+	pushLen32(out, asciiBytes(parsed.request_id));
+	pushLen32(out, asciiBytes(parsed.operation_id));
+	pushOperationDigests(out, parsed.operation_digests);
+	out.push(...canonicalRouterAbNormalSigningAuthorizationBytes(parsed.authorization));
+	out.push(...canonicalRouterAbMpcMaterialActivationRefBytes(parsed.material_activation));
+	pushU64(out, parsed.expires_at_ms);
+	pushBytes(out, base64UrlDecode(parsed.signing_digest_b64u));
+	pushLen32(out, asciiBytes(parsed.server_presignature_id));
+	pushLen32(out, base64UrlDecode(parsed.client_signature_share32_b64u));
+	pushLen32(out, base64UrlDecode(parsed.client_rerandomization_contribution32_b64u));
+	return new Uint8Array(out);
+}
+async function routerAbEcdsaDerivationEvmDigestSigningFinalizeCoreRequestDigestV1(request) {
+	const parsed = parseRouterAbEcdsaDerivationEvmDigestSigningFinalizeCoreRequestV1(request);
+	await verifyRouterAbEcdsaDerivationNormalSigningScopeContextBindingV1(parsed.scope);
+	return publicDigest32FromCanonicalBytes(routerAbEcdsaDerivationEvmDigestSigningFinalizeCoreRequestCanonicalBytesV1(parsed));
+}
+function parseRouterAbEcdsaDerivationNormalSigningScopeV1(value) {
+	const record = requireRecord(value, "scope");
+	requireExactKeys(record, "scope", [
+		"wallet_id",
+		"ecdsa_threshold_key_id",
+		"signing_root_id",
+		"signing_root_version",
+		"context",
+		"public_identity",
+		"material_activation",
+		"signing_worker",
+		"activation_epoch"
+	]);
+	return {
+		wallet_id: requireAsciiNonEmptyString(record.wallet_id, "scope.wallet_id"),
+		ecdsa_threshold_key_id: requireAsciiNonEmptyString(record.ecdsa_threshold_key_id, "scope.ecdsa_threshold_key_id"),
+		signing_root_id: requireAsciiNonEmptyString(record.signing_root_id, "scope.signing_root_id"),
+		signing_root_version: requireAsciiNonEmptyString(record.signing_root_version, "scope.signing_root_version"),
+		context: parseStableKeyContext(record.context),
+		public_identity: parsePublicIdentity(record.public_identity),
+		material_activation: parseRouterAbMpcMaterialActivationRef(record.material_activation),
+		signing_worker: parseServerIdentity(record.signing_worker),
+		activation_epoch: requireRootShareEpoch(record.activation_epoch, "scope.activation_epoch")
+	};
+}
+function parseRouterAbEcdsaDerivationNormalSigningStateV1(value) {
+	if (value === void 0 || value === null) return null;
+	const record = requireRecord(value, "routerAbEcdsaDerivationNormalSigning");
+	requireExactKeys(record, "routerAbEcdsaDerivationNormalSigning", ["kind", "scope"]);
+	if (requireAsciiNonEmptyString(record.kind, "routerAbEcdsaDerivationNormalSigning.kind") !== "router_ab_ecdsa_derivation_normal_signing_v1") throw new Error("routerAbEcdsaDerivationNormalSigning.kind is not supported");
+	return {
+		kind: ROUTER_AB_ECDSA_DERIVATION_NORMAL_SIGNING_STATE_KIND_V1,
+		scope: parseRouterAbEcdsaDerivationNormalSigningScopeV1(record.scope)
+	};
+}
+function requireRouterAbEcdsaDerivationNormalSigningStateV1(value) {
+	const parsed = parseRouterAbEcdsaDerivationNormalSigningStateV1(value);
+	if (!parsed) throw new Error("Router A/B ECDSA derivation normal-signing state is required");
+	return parsed;
+}
+function buildRouterAbEcdsaDerivationActiveStateIdV1(input) {
+	const parsed = parseEcdsaActiveStateId([
+		requireAsciiNonEmptyString(input.ecdsaThresholdKeyId, "ecdsaThresholdKeyId"),
+		requireAsciiNonEmptyString(input.signingRootId, "signingRootId"),
+		requireAsciiNonEmptyString(input.signingRootVersion, "signingRootVersion"),
+		requireRootShareEpoch(input.activationEpoch, "activationEpoch")
+	].join(":"));
+	if (!parsed.ok) throw new Error(`activeStateId ${parsed.error.message}`);
+	return parsed.value;
+}
+function routerAbEcdsaDerivationActiveStateId(state) {
+	return buildRouterAbEcdsaDerivationActiveStateIdV1({
+		ecdsaThresholdKeyId: state.scope.ecdsa_threshold_key_id,
+		signingRootId: state.scope.signing_root_id,
+		signingRootVersion: state.scope.signing_root_version,
+		activationEpoch: state.scope.activation_epoch
+	});
+}
+function parseRouterAbEcdsaDerivationOperationDigestsV1(value, label) {
+	const record = requireRecord(value, label);
+	requireExactKeys(record, label, [
+		"lane_digest_b64u",
+		"intent_digest_b64u",
+		"display_digest_b64u"
+	]);
+	return {
+		lane_digest_b64u: requireBase64UrlFixed(record.lane_digest_b64u, `${label}.lane_digest_b64u`, 32),
+		intent_digest_b64u: requireBase64UrlFixed(record.intent_digest_b64u, `${label}.intent_digest_b64u`, 32),
+		display_digest_b64u: requireBase64UrlFixed(record.display_digest_b64u, `${label}.display_digest_b64u`, 32)
+	};
+}
+function parseRouterAbEcdsaDerivationEvmDigestSigningRequestV1(value) {
+	const record = requireRecord(value, "ecdsaSigningRequest");
+	requireExactKeys(record, "ecdsaSigningRequest", [
+		"scope",
+		"request_id",
+		"operation_id",
+		"operation_digests",
+		"authorization",
+		"material_activation",
+		"client_presignature_id",
+		"expires_at_ms",
+		"signing_digest_b64u",
+		"client_rerandomization_commitment32_b64u"
+	]);
+	const parsed = {
+		scope: parseRouterAbEcdsaDerivationNormalSigningScopeV1(record.scope),
+		request_id: requireAsciiNonEmptyString(record.request_id, "ecdsaSigningRequest.request_id"),
+		operation_id: requireAsciiNonEmptyString(record.operation_id, "ecdsaSigningRequest.operation_id"),
+		operation_digests: parseRouterAbEcdsaDerivationOperationDigestsV1(record.operation_digests, "ecdsaSigningRequest.operation_digests"),
+		authorization: parseRouterAbNormalSigningAuthorization(record.authorization),
+		material_activation: parseRouterAbMpcMaterialActivationRef(record.material_activation),
+		client_presignature_id: requireAsciiNonEmptyString(record.client_presignature_id, "ecdsaSigningRequest.client_presignature_id"),
+		expires_at_ms: requirePositiveUnixMs(record.expires_at_ms, "ecdsaSigningRequest.expires_at_ms"),
+		signing_digest_b64u: requireBase64UrlFixed(record.signing_digest_b64u, "ecdsaSigningRequest.signing_digest_b64u", 32),
+		client_rerandomization_commitment32_b64u: requireBase64UrlFixed(record.client_rerandomization_commitment32_b64u, "ecdsaSigningRequest.client_rerandomization_commitment32_b64u", 32)
+	};
+	if (parsed.operation_digests.intent_digest_b64u !== parsed.signing_digest_b64u) throw new Error("ecdsaSigningRequest intent digest must equal the admitted signing digest");
+	return parsed;
+}
+function parseRouterAbEcdsaOperationStepUpWebAuthnCredentialV1(value) {
+	const credential = requireRecord(value, "webauthn_authentication");
+	requireExactKeys(credential, "webauthn_authentication", [
+		"id",
+		"rawId",
+		"type",
+		"authenticatorAttachment",
+		"response",
+		"clientExtensionResults"
+	]);
+	const response = requireRecord(credential.response, "webauthn_authentication.response");
+	requireExactKeys(response, "webauthn_authentication.response", [
+		"clientDataJSON",
+		"authenticatorData",
+		"signature",
+		"userHandle"
+	]);
+	const authenticatorAttachment = credential.authenticatorAttachment === null ? null : requireAsciiNonEmptyString(credential.authenticatorAttachment, "webauthn_authentication.authenticatorAttachment");
+	const userHandle = response.userHandle === null ? null : requireAsciiNonEmptyString(response.userHandle, "webauthn_authentication.response.userHandle");
+	return {
+		id: requireAsciiNonEmptyString(credential.id, "webauthn_authentication.id"),
+		rawId: requireAsciiNonEmptyString(credential.rawId, "webauthn_authentication.rawId"),
+		type: requireAsciiNonEmptyString(credential.type, "webauthn_authentication.type"),
+		authenticatorAttachment,
+		response: {
+			clientDataJSON: requireAsciiNonEmptyString(response.clientDataJSON, "webauthn_authentication.response.clientDataJSON"),
+			authenticatorData: requireAsciiNonEmptyString(response.authenticatorData, "webauthn_authentication.response.authenticatorData"),
+			signature: requireAsciiNonEmptyString(response.signature, "webauthn_authentication.response.signature"),
+			userHandle
+		},
+		clientExtensionResults: credential.clientExtensionResults
+	};
+}
+function parseRouterAbEcdsaOperationStepUpAuthorizationRequestV1(value) {
+	const request = requireRecord(value, "operationStepUpAuthorizationRequest");
+	requireExactKeys(request, "operationStepUpAuthorizationRequest", [
+		"kind",
+		"operation",
+		"proof"
+	]);
+	if (request.kind !== "router_ab_ecdsa_operation_step_up_v1") throw new Error("operationStepUpAuthorizationRequest.kind must be router_ab_ecdsa_operation_step_up_v1");
+	const operation = parseRouterAbEcdsaOperationStepUpPreparationV1(request.operation);
+	const proof = requireRecord(request.proof, "operationStepUpAuthorizationRequest.proof");
+	const authority = parseWalletAuthAuthority(proof.authority);
+	let parsedProof;
+	switch (proof.kind) {
+		case "passkey":
+			requireExactKeys(proof, "operationStepUpAuthorizationRequest.proof", [
+				"kind",
+				"authority",
+				"webauthn_authentication"
+			]);
+			if (!authority || !isPasskeyWalletAuthAuthority(authority)) throw new Error("operationStepUpAuthorizationRequest.proof requires an exact passkey authority");
+			parsedProof = {
+				kind: "passkey",
+				authority,
+				webauthn_authentication: parseRouterAbEcdsaOperationStepUpWebAuthnCredentialV1(proof.webauthn_authentication)
+			};
+			break;
+		case "email_otp":
+			requireExactKeys(proof, "operationStepUpAuthorizationRequest.proof", [
+				"kind",
+				"authority",
+				"challenge_id",
+				"otp_code"
+			]);
+			if (!authority || !isEmailOtpWalletAuthAuthority(authority)) throw new Error("operationStepUpAuthorizationRequest.proof requires an exact Email OTP authority");
+			parsedProof = {
+				kind: "email_otp",
+				authority,
+				challenge_id: requireAsciiNonEmptyString(proof.challenge_id, "operationStepUpAuthorizationRequest.proof.challenge_id"),
+				otp_code: requireAsciiNonEmptyString(proof.otp_code, "operationStepUpAuthorizationRequest.proof.otp_code")
+			};
+			break;
+		default: throw new Error("operationStepUpAuthorizationRequest.proof.kind is invalid");
+	}
+	return {
+		kind: "router_ab_ecdsa_operation_step_up_v1",
+		operation,
+		proof: parsedProof
+	};
+}
+function parseRouterAbEcdsaOperationStepUpPreparationV1(value) {
+	const operation = requireRecord(value, "ecdsaOperationStepUpPreparation");
+	requireExactKeys(operation, "operationStepUpGrantRequest.operation", [
+		"wallet_id",
+		"operation_kind",
+		"operation_id",
+		"operation_digests",
+		"material_activation",
+		"normal_signing_scope",
+		"signing_worker_id",
+		"key_handle",
+		"relayer_key_id",
+		"participant_ids",
+		"expires_at_ms"
+	]);
+	if (!Array.isArray(operation.participant_ids) || operation.participant_ids.length !== 2 || !operation.participant_ids.every((participantId) => Number.isSafeInteger(participantId) && participantId > 0)) throw new Error("operationStepUpGrantRequest.operation.participant_ids must contain two positive integers");
+	return {
+		wallet_id: requireAsciiNonEmptyString(operation.wallet_id, "operationStepUpGrantRequest.operation.wallet_id"),
+		operation_kind: requireEcdsaOperationStepUpKind(operation.operation_kind),
+		operation_id: requireAsciiNonEmptyString(operation.operation_id, "operationStepUpGrantRequest.operation.operation_id"),
+		operation_digests: parseRouterAbEcdsaDerivationOperationDigestsV1(operation.operation_digests, "operationStepUpGrantRequest.operation.operation_digests"),
+		material_activation: parseRouterAbMpcMaterialActivationRef(operation.material_activation),
+		normal_signing_scope: parseRouterAbEcdsaDerivationNormalSigningScopeV1(operation.normal_signing_scope),
+		signing_worker_id: requireAsciiNonEmptyString(operation.signing_worker_id, "operationStepUpGrantRequest.operation.signing_worker_id"),
+		key_handle: requireAsciiNonEmptyString(operation.key_handle, "operationStepUpGrantRequest.operation.key_handle"),
+		relayer_key_id: requireAsciiNonEmptyString(operation.relayer_key_id, "operationStepUpGrantRequest.operation.relayer_key_id"),
+		participant_ids: [Number(operation.participant_ids[0]), Number(operation.participant_ids[1])],
+		expires_at_ms: requirePositiveUnixMs(operation.expires_at_ms, "operationStepUpGrantRequest.operation.expires_at_ms")
+	};
+}
+function requireEcdsaOperationStepUpKind(value) {
+	switch (value) {
+		case EVM_ECDSA_MPC_OPERATION_KINDS.signTransaction:
+		case EVM_ECDSA_MPC_OPERATION_KINDS.exportKey: return value;
+		default: throw new Error("operationStepUpGrantRequest.operation.operation_kind must be evm.sign_transaction or evm.export_key");
+	}
+}
+function parseRouterAbEcdsaDerivationEvmDigestSigningFinalizeCoreRequestV1(value) {
+	const record = requireRecord(value, "ecdsaFinalizeCoreRequest");
+	requireExactKeys(record, "ecdsaFinalizeCoreRequest", [
+		"scope",
+		"request_id",
+		"operation_id",
+		"operation_digests",
+		"authorization",
+		"material_activation",
+		"expires_at_ms",
+		"signing_digest_b64u",
+		"server_presignature_id",
+		"client_signature_share32_b64u",
+		"client_rerandomization_contribution32_b64u"
+	]);
+	return parseRouterAbEcdsaDerivationEvmDigestSigningFinalizeCoreRequestFields(record);
+}
+function parseRouterAbEcdsaDerivationEvmDigestSigningFinalizeCoreRequestFields(record) {
+	const parsed = {
+		scope: parseRouterAbEcdsaDerivationNormalSigningScopeV1(record.scope),
+		request_id: requireAsciiNonEmptyString(record.request_id, "ecdsaFinalizeRequest.request_id"),
+		operation_id: requireAsciiNonEmptyString(record.operation_id, "ecdsaFinalizeRequest.operation_id"),
+		operation_digests: parseRouterAbEcdsaDerivationOperationDigestsV1(record.operation_digests, "ecdsaFinalizeRequest.operation_digests"),
+		authorization: parseRouterAbNormalSigningAuthorization(record.authorization),
+		material_activation: parseRouterAbMpcMaterialActivationRef(record.material_activation),
+		expires_at_ms: requirePositiveUnixMs(record.expires_at_ms, "ecdsaFinalizeRequest.expires_at_ms"),
+		signing_digest_b64u: requireBase64UrlFixed(record.signing_digest_b64u, "ecdsaFinalizeRequest.signing_digest_b64u", 32),
+		server_presignature_id: requireAsciiNonEmptyString(record.server_presignature_id, "ecdsaFinalizeRequest.server_presignature_id"),
+		client_signature_share32_b64u: requireBase64UrlFixed(record.client_signature_share32_b64u, "ecdsaFinalizeRequest.client_signature_share32_b64u", 32),
+		client_rerandomization_contribution32_b64u: requireBase64UrlFixed(record.client_rerandomization_contribution32_b64u, "ecdsaFinalizeRequest.client_rerandomization_contribution32_b64u", 32)
+	};
+	if (parsed.operation_digests.intent_digest_b64u !== parsed.signing_digest_b64u) throw new Error("ecdsaFinalizeRequest intent digest must equal the admitted signing digest");
+	return parsed;
+}
+function parseRouterAbEcdsaDerivationEvmDigestSigningFinalizeRequestV1(value) {
+	const record = requireRecord(value, "ecdsaFinalizeRequest");
+	requireExactKeys(record, "ecdsaFinalizeRequest", [
+		"scope",
+		"request_id",
+		"operation_id",
+		"operation_digests",
+		"authorization",
+		"material_activation",
+		"expires_at_ms",
+		"signing_digest_b64u",
+		"server_presignature_id",
+		"client_signature_share32_b64u",
+		"client_rerandomization_contribution32_b64u"
+	]);
+	return parseRouterAbEcdsaDerivationEvmDigestSigningFinalizeCoreRequestFields(record);
+}
+function parseServerPresignatureShare(value) {
+	const record = requireRecord(value, "presignature");
+	requireExactKeys(record, "presignature", [
+		"serverKeyId",
+		"presignatureId",
+		"bigRB64u",
+		"kShareB64u",
+		"sigmaShareB64u",
+		"createdAtMs"
+	]);
+	return {
+		serverKeyId: requireAsciiNonEmptyString(record.serverKeyId, "presignature.serverKeyId"),
+		presignatureId: requireAsciiNonEmptyString(record.presignatureId, "presignature.presignatureId"),
+		bigRB64u: requireBase64UrlFixed(record.bigRB64u, "presignature.bigRB64u", 33),
+		kShareB64u: requireBase64UrlFixed(record.kShareB64u, "presignature.kShareB64u", 32),
+		sigmaShareB64u: requireBase64UrlFixed(record.sigmaShareB64u, "presignature.sigmaShareB64u", 32),
+		createdAtMs: requirePositiveUnixMs(record.createdAtMs, "presignature.createdAtMs")
+	};
+}
+function parseActiveSigningWorkerState(value) {
+	const record = requireRecord(value, "receipt.active_signing_worker_state");
+	requireExactKeys(record, "receipt.active_signing_worker_state", [
+		"account_id",
+		"material_activation",
+		"account_public_key",
+		"signing_worker",
+		"activation_transcript_digest",
+		"activation_digest",
+		"signing_worker_material_handle",
+		"activated_at_ms"
+	]);
+	return {
+		account_id: requireAsciiNonEmptyString(record.account_id, "receipt.active_signing_worker_state.account_id"),
+		material_activation: parseRouterAbMpcMaterialActivationRef(record.material_activation),
+		account_public_key: requireAsciiNonEmptyString(record.account_public_key, "receipt.active_signing_worker_state.account_public_key"),
+		signing_worker: parseServerIdentityWithLabel(record.signing_worker, "receipt.active_signing_worker_state.signing_worker"),
+		activation_transcript_digest: parsePublicDigest32(record.activation_transcript_digest, "receipt.active_signing_worker_state.activation_transcript_digest"),
+		activation_digest: parsePublicDigest32(record.activation_digest, "receipt.active_signing_worker_state.activation_digest"),
+		signing_worker_material_handle: requireAsciiNonEmptyString(record.signing_worker_material_handle, "receipt.active_signing_worker_state.signing_worker_material_handle"),
+		activated_at_ms: requirePositiveUnixMs(record.activated_at_ms, "receipt.active_signing_worker_state.activated_at_ms")
+	};
+}
+function buildCloudflareSigningWorkerEcdsaDerivationPresignaturePoolPutRequestV1(input) {
+	const scope = parseRouterAbEcdsaDerivationNormalSigningScopeV1(input.scope);
+	const presignature = parseServerPresignatureShare(input.presignature);
+	const expiresAtMs = requirePositiveUnixMs(input.expiresAtMs, "expiresAtMs");
+	return {
+		scope,
+		server_presignature_id: presignature.presignatureId,
+		server_big_r33_b64u: presignature.bigRB64u,
+		server_k_share32_b64u: presignature.kShareB64u,
+		server_sigma_share32_b64u: presignature.sigmaShareB64u,
+		expires_at_ms: expiresAtMs
+	};
+}
+function parseCloudflareSigningWorkerEcdsaDerivationPresignaturePoolPutRequestV1(value) {
+	const record = requireRecord(value, "poolFillRequest");
+	requireExactKeys(record, "poolFillRequest", [
+		"scope",
+		"server_presignature_id",
+		"server_big_r33_b64u",
+		"server_k_share32_b64u",
+		"server_sigma_share32_b64u",
+		"expires_at_ms"
+	]);
+	return {
+		scope: parseRouterAbEcdsaDerivationNormalSigningScopeV1(record.scope),
+		server_presignature_id: requireAsciiNonEmptyString(record.server_presignature_id, "poolFillRequest.server_presignature_id"),
+		server_big_r33_b64u: requireBase64UrlFixed(record.server_big_r33_b64u, "poolFillRequest.server_big_r33_b64u", 33),
+		server_k_share32_b64u: requireBase64UrlFixed(record.server_k_share32_b64u, "poolFillRequest.server_k_share32_b64u", 32),
+		server_sigma_share32_b64u: requireBase64UrlFixed(record.server_sigma_share32_b64u, "poolFillRequest.server_sigma_share32_b64u", 32),
+		expires_at_ms: requirePositiveUnixMs(record.expires_at_ms, "poolFillRequest.expires_at_ms")
+	};
+}
+function parseCloudflareSigningWorkerEcdsaDerivationPresignaturePoolPutReceiptV1(value) {
+	const record = requireRecord(value, "receipt");
+	requireExactKeys(record, "receipt", [
+		"active_signing_worker_state",
+		"server_presignature_id",
+		"server_big_r33_b64u",
+		"stored"
+	]);
+	return {
+		active_signing_worker_state: parseActiveSigningWorkerState(record.active_signing_worker_state),
+		server_presignature_id: requireAsciiNonEmptyString(record.server_presignature_id, "receipt.server_presignature_id"),
+		server_big_r33_b64u: requireBase64UrlFixed(record.server_big_r33_b64u, "receipt.server_big_r33_b64u", 33),
+		stored: requireBoolean(record.stored, "receipt.stored")
+	};
+}
+function parseCloudflareSigningWorkerEcdsaDerivationPresignaturePoolPutReceiptForRequestV1(request, value) {
+	const parsedRequest = parseCloudflareSigningWorkerEcdsaDerivationPresignaturePoolPutRequestV1(request);
+	const receipt = parseCloudflareSigningWorkerEcdsaDerivationPresignaturePoolPutReceiptV1(value);
+	if (receipt.server_presignature_id !== parsedRequest.server_presignature_id) throw new Error("receipt.server_presignature_id does not match pool-fill request");
+	if (receipt.server_big_r33_b64u !== parsedRequest.server_big_r33_b64u) throw new Error("receipt.server_big_r33_b64u does not match pool-fill request");
+	return receipt;
+}
+//#endregion
+export { ROUTER_AB_ECDSA_DERIVATION_EXPORT_PATH, ROUTER_AB_ECDSA_DERIVATION_HEALTH_PATH, ROUTER_AB_ECDSA_DERIVATION_NORMAL_SIGNING_PATH, ROUTER_AB_ECDSA_DERIVATION_NORMAL_SIGNING_PREPARE_PATH, ROUTER_AB_ECDSA_DERIVATION_NORMAL_SIGNING_STATE_KIND_V1, ROUTER_AB_ECDSA_DERIVATION_OPERATION_STEP_UP_PATH, ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_FILL_INIT_PATH, ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_FILL_STEP_PATH, ROUTER_AB_ECDSA_DERIVATION_REFRESH_PATH, ROUTER_AB_ECDSA_DERIVATION_SESSION_ACTIVATION_PATH, buildCloudflareSigningWorkerEcdsaDerivationPresignaturePoolPutRequestV1, buildRouterAbEcdsaDerivationActiveStateIdV1, buildRouterAbEcdsaDerivationPublicCapabilityV1, computeRouterAbEcdsaOperationStepUpChallengeB64u, parseCloudflareSigningWorkerEcdsaDerivationPresignaturePoolPutReceiptForRequestV1, parseCloudflareSigningWorkerEcdsaDerivationPresignaturePoolPutRequestV1, parseRouterAbEcdsaCredentialFreeSessionActivationResponseV1, parseRouterAbEcdsaDerivationActivationRefreshCommitRequestV1, parseRouterAbEcdsaDerivationActivationRefreshRequestV1, parseRouterAbEcdsaDerivationActivationRefreshResponseV1, parseRouterAbEcdsaDerivationEvmDigestSigningFinalizeRequestV1, parseRouterAbEcdsaDerivationEvmDigestSigningRequestV1, parseRouterAbEcdsaDerivationExplicitExportRequestV1, parseRouterAbEcdsaDerivationNormalSigningScopeV1, parseRouterAbEcdsaDerivationNormalSigningStateV1, parseRouterAbEcdsaDerivationPublicCapabilityV1, parseRouterAbEcdsaExplicitExportProtocolForwardedResponseV1, parseRouterAbEcdsaOperationStepUpAuthorizationRequestV1, parseRouterAbEcdsaOperationStepUpPreparationV1, parseRouterAbEcdsaPostRegistrationSessionActivationPolicyV1, parseRouterAbEcdsaPostRegistrationSessionActivationRequestV1, parseRouterAbEcdsaPostRegistrationSessionActivationResponseV1, parseRouterAbEcdsaRegistrationActivationReceiptV1, parseRouterAbEcdsaRegistrationActivationRequestV1, parseRouterAbEcdsaRegistrationRequestFactsV1, parseRouterAbEcdsaRegistrationRequestV1, parseRouterAbEcdsaSigningWorkerProtocolExportShareEnvelopeV1, parseRouterAbEcdsaStrictForwardedRegistrationResponseV1, parseRouterAbEcdsaVerifiedClientActivationFactsV1, projectRouterAbEcdsaDerivationExplicitExportRequestToProtocolV1, requireRouterAbEcdsaDerivationNormalSigningStateV1, routerAbEcdsaDerivationActiveStateId, routerAbEcdsaDerivationEvmDigestSigningFinalizeCoreRequestDigestV1, routerAbEcdsaDerivationEvmDigestSigningRequestDigestV1, sameRouterAbEcdsaDerivationNormalSigningScopeV1, sameRouterAbEcdsaDerivationNormalSigningStateV1, sameRouterAbEcdsaDerivationPublicCapabilityV1, sameRouterAbEcdsaDerivationPublicIdentityV1, sameRouterAbEcdsaRegistrationActivationReceiptV1, sameRouterAbEcdsaRegistrationRequestFactsV1, sameRouterAbEcdsaVerifiedClientActivationFactsV1, sameRouterAbPublicDigest32V1Wire, sameRouterAbServerIdentityV1 };
+
+//# sourceMappingURL=routerAbEcdsaDerivation.js.map