@seams/wallet 0.8.0 → 0.9.1

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

@@ -2,16 +2,6 @@ import { requireRecord } from "./validation.js";
 import { parseRouterAbMpcMaterialActivationRef, sameRouterAbMpcMaterialActivationRef } from "./routerAbNormalSigningIdentity.js";
 import { equalBytes, requireBytes, requireBytes32, requireVisibleIdentifier } from "./routerAbEd25519YaoDigests.js";
 //#region ../shared-ts/src/utils/routerAbEd25519Yao.ts
-const ROUTER_AB_ED25519_YAO_REGISTRATION_ADMISSION_PATH_V1 = "/router-ab/ed25519/yao/registration/admit";
-const ROUTER_AB_ED25519_YAO_REGISTRATION_EXECUTE_PATH_V1 = "/router-ab/ed25519/yao/registration/execute";
-const ROUTER_AB_ED25519_YAO_RECOVERY_ADMISSION_PATH_V1 = "/router-ab/ed25519/yao/recovery/admit";
-const ROUTER_AB_ED25519_YAO_RECOVERY_EXECUTE_PATH_V1 = "/router-ab/ed25519/yao/recovery/execute";
-const ROUTER_AB_ED25519_YAO_RECOVERY_ACTIVATE_PATH_V1 = "/router-ab/ed25519/yao/recovery/activate";
-const ROUTER_AB_ED25519_YAO_RECOVERY_CHALLENGE_ID_HEADER_V1 = "x-seams-wallet-recovery-challenge-id";
-const ROUTER_AB_ED25519_YAO_WARM_RECOVERY_BOOTSTRAP_PATH_V1 = "/router-ab/ed25519/yao/recovery/bootstrap";
-const ROUTER_AB_ED25519_YAO_EMAIL_OTP_RECOVERY_BOOTSTRAP_KIND_V1 = "router_ab_ed25519_yao_email_otp_recovery_v1";
-const ROUTER_AB_ED25519_YAO_EXPORT_ADMISSION_PATH_V1 = "/router-ab/ed25519/yao/export/admit";
-const ROUTER_AB_ED25519_YAO_EXPORT_EXECUTE_PATH_V1 = "/router-ab/ed25519/yao/export/execute";
 const ED25519_YAO_CONTROL_CIPHERTEXT_MAX_BYTES_V1 = 64 * 1024;
 function sameRouterAbEd25519YaoActivationBindingV1(left, right) {
 	return left.operation === right.operation && sameRouterAbEd25519YaoByteSequence(left.session_id, right.session_id) && sameRouterAbEd25519YaoByteSequence(left.stable_key_context_binding, right.stable_key_context_binding) && sameRouterAbMpcMaterialActivationRef(left.material_activation, right.material_activation) && left.lifecycle.lifecycle_id === right.lifecycle.lifecycle_id && left.lifecycle.work_kind === right.lifecycle.work_kind && left.lifecycle.primitive_request_kind === right.lifecycle.primitive_request_kind && left.lifecycle.root_share_epoch === right.lifecycle.root_share_epoch && left.lifecycle.account_id === right.lifecycle.account_id && left.lifecycle.session_id === right.lifecycle.session_id && left.lifecycle.signer_set_id === right.lifecycle.signer_set_id && left.lifecycle.selected_server_id === right.lifecycle.selected_server_id;
@@ -19,18 +9,6 @@ function sameRouterAbEd25519YaoActivationBindingV1(left, right) {
 function sameRouterAbEd25519YaoByteSequence(left, right) {
 	return left.length === right.length && left.every((value, index) => value === right[index]);
 }
-function sameRouterAbEd25519YaoParticipantPairV1(left, right) {
-	return left[0] === right[0] && left[1] === right[1];
-}
-function sameRouterAbEd25519YaoLifecycleScopeV1(left, right) {
-	return left.lifecycle_id === right.lifecycle_id && left.root_share_epoch === right.root_share_epoch && left.account_id === right.account_id && left.threshold_session_id === right.threshold_session_id && left.signer_set_id === right.signer_set_id && left.signing_worker_id === right.signing_worker_id && sameRouterAbMpcMaterialActivationRef(left.material_activation, right.material_activation);
-}
-function sameRouterAbEd25519YaoApplicationBindingFactsV1(left, right) {
-	return left.wallet_id === right.wallet_id && left.near_ed25519_signing_key_id === right.near_ed25519_signing_key_id && left.signing_root_id === right.signing_root_id && left.key_creation_signer_slot === right.key_creation_signer_slot;
-}
-function sameRouterAbEd25519YaoRegistrationAdmissionRequestV1(left, right) {
-	return sameRouterAbEd25519YaoLifecycleScopeV1(left.scope, right.scope) && sameRouterAbEd25519YaoApplicationBindingFactsV1(left.application_binding, right.application_binding) && sameRouterAbEd25519YaoParticipantPairV1(left.participant_ids, right.participant_ids);
-}
 const REGISTRATION_WORK_KIND = "registration_prepare";
 const REGISTRATION_PRIMITIVE_REQUEST_KIND = "registration";
 const RECOVERY_WORK_KIND = "recovery";
@@ -75,14 +53,6 @@ function parseInputKind(value, label) {
 		default: throw new Error(`${label} is invalid`);
 	}
 }
-function parsePackageKind(value, label) {
-	switch (value) {
-		case "activation_client":
-		case "activation_signing_worker":
-		case "export_client": return value;
-		default: throw new Error(`${label} is invalid`);
-	}
-}
 function parseWorkKind(value, label) {
 	switch (value) {
 		case "registration_prepare":
@@ -203,43 +173,6 @@ function parseCeremonyBinding(value) {
 function parseRouterAbEd25519YaoCeremonyBindingV1(value) {
 	return parseCeremonyBinding(value);
 }
-function requireExportCeremonyBinding(value) {
-	const binding = parseCeremonyBinding(value);
-	if (binding.operation !== "export" || binding.lifecycle.work_kind !== EXPORT_WORK_KIND || binding.lifecycle.primitive_request_kind !== EXPORT_PRIMITIVE_REQUEST_KIND) throw new Error("export binding requires the exact export lifecycle");
-	return {
-		lifecycle: {
-			lifecycle_id: binding.lifecycle.lifecycle_id,
-			work_kind: EXPORT_WORK_KIND,
-			primitive_request_kind: EXPORT_PRIMITIVE_REQUEST_KIND,
-			root_share_epoch: binding.lifecycle.root_share_epoch,
-			account_id: binding.lifecycle.account_id,
-			session_id: binding.lifecycle.session_id,
-			signer_set_id: binding.lifecycle.signer_set_id,
-			selected_server_id: binding.lifecycle.selected_server_id
-		},
-		operation: "export",
-		session_id: binding.session_id,
-		stable_key_context_binding: binding.stable_key_context_binding,
-		material_activation: binding.material_activation
-	};
-}
-function parseExportBinding(value) {
-	const record = requireRecord(value, "export binding");
-	requireExactKeys(record, "export binding", [
-		"ceremony",
-		"registered_public_key",
-		"state_epoch",
-		"runtime_policy_binding",
-		"authorization_digest"
-	]);
-	return {
-		ceremony: requireExportCeremonyBinding(record.ceremony),
-		registered_public_key: requireBytes32(record.registered_public_key, "export binding.registered_public_key", true),
-		state_epoch: requirePositiveSafeInteger(record.state_epoch, "export binding.state_epoch"),
-		runtime_policy_binding: requireBytes32(record.runtime_policy_binding, "export binding.runtime_policy_binding", true),
-		authorization_digest: requireBytes32(record.authorization_digest, "export binding.authorization_digest", true)
-	};
-}
 function requireActivationBinding(binding) {
 	switch (binding.operation) {
 		case "registration":
@@ -346,37 +279,6 @@ function requireActivationInput(binding, input, expectedDeriver, label) {
 		};
 	}
 }
-function requireExportInput(binding, input, expectedDeriver, label) {
-	if (input.kind !== "export" || input.deriver !== expectedDeriver || input.operation !== "export" || !equalBytes(input.session, binding.ceremony.session_id) || !equalBytes(input.stable_context_binding, binding.ceremony.stable_key_context_binding)) throw new Error(`${label} does not match the admitted export binding`);
-	return {
-		kind: "export",
-		deriver: expectedDeriver,
-		operation: "export",
-		session: input.session,
-		stable_context_binding: input.stable_context_binding,
-		encapsulated_key: input.encapsulated_key,
-		ciphertext: input.ciphertext
-	};
-}
-function parseEncryptedPackage(value, label) {
-	const record = requireRecord(value, label);
-	requireExactKeys(record, label, [
-		"kind",
-		"deriver",
-		"session",
-		"transcript",
-		"encapsulated_key",
-		"ciphertext"
-	]);
-	return {
-		kind: parsePackageKind(record.kind, `${label}.kind`),
-		deriver: parseDeriverRole(record.deriver, `${label}.deriver`),
-		session: requireBytes32(record.session, `${label}.session`, true),
-		transcript: requireBytes32(record.transcript, `${label}.transcript`, true),
-		encapsulated_key: requireBytes32(record.encapsulated_key, `${label}.encapsulated_key`, true),
-		ciphertext: requireBytes(record.ciphertext, `${label}.ciphertext`, 16, ED25519_YAO_CONTROL_CIPHERTEXT_MAX_BYTES_V1)
-	};
-}
 function parseRouterAbEd25519YaoActivationPublicReceiptV1(value) {
 	const record = requireRecord(value, "public_receipt");
 	requireExactKeys(record, "public_receipt", [
@@ -398,28 +300,6 @@ function parseRouterAbEd25519YaoActivationPublicReceiptV1(value) {
 		material_activation: parseRouterAbMpcMaterialActivationRef(record.material_activation)
 	};
 }
-function requireActivationClientPackage(binding, receipt, packageValue, expectedDeriver, label) {
-	if (packageValue.kind !== "activation_client" || packageValue.deriver !== expectedDeriver || !equalBytes(packageValue.session, binding.session_id) || !equalBytes(packageValue.transcript, receipt.transcript)) throw new Error(`${label} does not match the terminal activation receipt`);
-	return {
-		kind: "activation_client",
-		deriver: expectedDeriver,
-		session: packageValue.session,
-		transcript: packageValue.transcript,
-		encapsulated_key: packageValue.encapsulated_key,
-		ciphertext: packageValue.ciphertext
-	};
-}
-function requireExportClientPackage(binding, transcript, packageValue, expectedDeriver, label) {
-	if (packageValue.kind !== "export_client" || packageValue.deriver !== expectedDeriver || !equalBytes(packageValue.session, binding.ceremony.session_id) || !equalBytes(packageValue.transcript, transcript)) throw new Error(`${label} does not match the terminal export result`);
-	return {
-		kind: "export_client",
-		deriver: expectedDeriver,
-		session: packageValue.session,
-		transcript: packageValue.transcript,
-		encapsulated_key: packageValue.encapsulated_key,
-		ciphertext: packageValue.ciphertext
-	};
-}
 function parseBoundary(parser, value) {
 	try {
 		return {
@@ -447,98 +327,6 @@ function parseRegistrationAdmissionRequestValue(value) {
 		participant_ids: parseParticipantIds(record.participant_ids)
 	};
 }
-function parseRecoveryAdmissionRequestValue(value) {
-	const record = requireRecord(value, "recovery admission request");
-	requireExactKeys(record, "recovery admission request", [
-		"scope",
-		"active_material_activation",
-		"application_binding",
-		"participant_ids",
-		"active_capability_binding",
-		"replacement_capability_binding",
-		"registered_public_key"
-	]);
-	const activeCapabilityBinding = requireBytes32(record.active_capability_binding, "recovery admission request.active_capability_binding", true);
-	const replacementCapabilityBinding = requireBytes32(record.replacement_capability_binding, "recovery admission request.replacement_capability_binding", true);
-	if (equalBytes(activeCapabilityBinding, replacementCapabilityBinding)) throw new Error("recovery replacement capability binding must be fresh");
-	const scope = parsePublicLifecycleScope(record.scope);
-	const activeMaterialActivation = parseRouterAbMpcMaterialActivationRef(record.active_material_activation);
-	const replacementMaterialActivation = scope.material_activation;
-	if (activeMaterialActivation.activation_id === replacementMaterialActivation.activation_id || activeMaterialActivation.lifecycle_binding === replacementMaterialActivation.lifecycle_binding) throw new Error("recovery replacement material activation identity must be fresh");
-	if (activeMaterialActivation.capability !== replacementMaterialActivation.capability || activeMaterialActivation.material_owner !== replacementMaterialActivation.material_owner || activeMaterialActivation.key_binding !== replacementMaterialActivation.key_binding || activeMaterialActivation.signing_worker !== replacementMaterialActivation.signing_worker) throw new Error("recovery replacement material activation changed stable identity facts");
-	return {
-		scope,
-		active_material_activation: activeMaterialActivation,
-		application_binding: parseRouterAbEd25519YaoApplicationBindingFactsV1(record.application_binding),
-		participant_ids: parseParticipantIds(record.participant_ids),
-		active_capability_binding: activeCapabilityBinding,
-		replacement_capability_binding: replacementCapabilityBinding,
-		registered_public_key: requireBytes32(record.registered_public_key, "recovery admission request.registered_public_key", true)
-	};
-}
-function parseWarmRecoveryBootstrapRequestValue(value) {
-	const record = requireRecord(value, "warm recovery bootstrap request");
-	requireExactKeys(record, "warm recovery bootstrap request", [
-		"kind",
-		"walletId",
-		"nearAccountId",
-		"nearEd25519SigningKeyId",
-		"signerSlot",
-		"thresholdSessionId",
-		"signingWorkerId",
-		"participantIds"
-	]);
-	if (record.kind !== "router_ab_ed25519_yao_warm_recovery_bootstrap_request_v1") throw new Error("warm recovery bootstrap request.kind is invalid");
-	return {
-		kind: "router_ab_ed25519_yao_warm_recovery_bootstrap_request_v1",
-		walletId: requireVisibleIdentifier(record.walletId, "warm recovery bootstrap request.walletId"),
-		nearAccountId: requireVisibleIdentifier(record.nearAccountId, "warm recovery bootstrap request.nearAccountId"),
-		nearEd25519SigningKeyId: requireVisibleIdentifier(record.nearEd25519SigningKeyId, "warm recovery bootstrap request.nearEd25519SigningKeyId"),
-		signerSlot: requirePositiveSafeInteger(record.signerSlot, "warm recovery bootstrap request.signerSlot"),
-		thresholdSessionId: requireVisibleIdentifier(record.thresholdSessionId, "warm recovery bootstrap request.thresholdSessionId"),
-		signingWorkerId: requireVisibleIdentifier(record.signingWorkerId, "warm recovery bootstrap request.signingWorkerId"),
-		participantIds: parseParticipantIds(record.participantIds)
-	};
-}
-function parseExportAdmissionReceiptValue(value) {
-	const record = requireRecord(value, "export admission receipt");
-	requireExactKeys(record, "export admission receipt", ["binding", "keyset"]);
-	return {
-		binding: parseExportBinding(record.binding),
-		keyset: parseKeyset(record.keyset)
-	};
-}
-function parseExportExecuteRequestValue(value) {
-	const record = requireRecord(value, "export execute request");
-	requireExactKeys(record, "export execute request", [
-		"binding",
-		"deriver_a_input",
-		"deriver_b_input"
-	]);
-	const binding = parseExportBinding(record.binding);
-	return {
-		binding,
-		deriver_a_input: requireExportInput(binding, parseEncryptedInput(record.deriver_a_input, "deriver_a_input"), "deriver_a", "deriver_a_input"),
-		deriver_b_input: requireExportInput(binding, parseEncryptedInput(record.deriver_b_input, "deriver_b_input"), "deriver_b", "deriver_b_input")
-	};
-}
-function parseExportResultValue(value) {
-	const record = requireRecord(value, "export result");
-	requireExactKeys(record, "export result", [
-		"binding",
-		"transcript",
-		"deriver_a_client_package",
-		"deriver_b_client_package"
-	]);
-	const binding = parseExportBinding(record.binding);
-	const transcript = requireBytes32(record.transcript, "export result.transcript", true);
-	return {
-		binding,
-		transcript,
-		deriver_a_client_package: requireExportClientPackage(binding, transcript, parseEncryptedPackage(record.deriver_a_client_package, "deriver_a_client_package"), "deriver_a", "deriver_a_client_package"),
-		deriver_b_client_package: requireExportClientPackage(binding, transcript, parseEncryptedPackage(record.deriver_b_client_package, "deriver_b_client_package"), "deriver_b", "deriver_b_client_package")
-	};
-}
 function parseActivationAdmissionReceiptValue(value) {
 	const record = requireRecord(value, "activation admission receipt");
 	requireExactKeys(record, "activation admission receipt", ["binding", "keyset"]);
@@ -580,70 +368,12 @@ function parseActivationExecuteRequestValue(value) {
 		deriver_b_input: deriverBInput
 	};
 }
-function parseActivationResultValue(value) {
-	const record = requireRecord(value, "activation result");
-	requireExactKeys(record, "activation result", [
-		"binding",
-		"deriver_a_client_package",
-		"deriver_b_client_package",
-		"public_receipt"
-	]);
-	const binding = requireActivationBinding(parseCeremonyBinding(record.binding));
-	const receipt = parseRouterAbEd25519YaoActivationPublicReceiptV1(record.public_receipt);
-	if (!sameRouterAbMpcMaterialActivationRef(binding.material_activation, receipt.material_activation)) throw new Error("activation result receipt material does not match the admitted binding");
-	const packageA = parseEncryptedPackage(record.deriver_a_client_package, "deriver_a_client_package");
-	const packageB = parseEncryptedPackage(record.deriver_b_client_package, "deriver_b_client_package");
-	const deriverAPackage = requireActivationClientPackage(binding, receipt, packageA, "deriver_a", "deriver_a_client_package");
-	const deriverBPackage = requireActivationClientPackage(binding, receipt, packageB, "deriver_b", "deriver_b_client_package");
-	switch (binding.operation) {
-		case "registration": return {
-			binding,
-			deriver_a_client_package: deriverAPackage,
-			deriver_b_client_package: deriverBPackage,
-			public_receipt: receipt
-		};
-		case "recovery": return {
-			binding,
-			deriver_a_client_package: deriverAPackage,
-			deriver_b_client_package: deriverBPackage,
-			public_receipt: receipt
-		};
-	}
-}
-function requireRecoveryBinding(value) {
-	const binding = requireActivationBinding(parseCeremonyBinding(value));
-	switch (binding.operation) {
-		case "registration": throw new Error("recovery activation requires a recovery binding");
-		case "recovery": return binding;
-	}
-}
-function parseRecoveryActivationReceiptValue(value) {
-	const record = requireRecord(value, "recovery activation receipt");
-	requireExactKeys(record, "recovery activation receipt", [
-		"binding",
-		"public_receipt",
-		"active_capability_binding",
-		"retired_capability_binding"
-	]);
-	const activeCapabilityBinding = requireBytes32(record.active_capability_binding, "recovery activation receipt.active_capability_binding", true);
-	const retiredCapabilityBinding = requireBytes32(record.retired_capability_binding, "recovery activation receipt.retired_capability_binding", true);
-	if (equalBytes(activeCapabilityBinding, retiredCapabilityBinding)) throw new Error("recovery activation receipt capability bindings must be distinct");
-	return {
-		binding: requireRecoveryBinding(record.binding),
-		public_receipt: parseRouterAbEd25519YaoActivationPublicReceiptV1(record.public_receipt),
-		active_capability_binding: activeCapabilityBinding,
-		retired_capability_binding: retiredCapabilityBinding
-	};
-}
 function isActivationAdmissionReceiptFor(value, operation) {
 	return value.binding.operation === operation;
 }
 function isActivationExecuteRequestFor(value, operation) {
 	return value.binding.operation === operation;
 }
-function isActivationResultFor(value, operation) {
-	return value.binding.operation === operation;
-}
 function operationMismatch(operation) {
 	return {
 		ok: false,
@@ -654,21 +384,6 @@ function operationMismatch(operation) {
 function parseRouterAbEd25519YaoRegistrationAdmissionRequestV1(value) {
 	return parseBoundary(parseRegistrationAdmissionRequestValue, value);
 }
-function parseRouterAbEd25519YaoRecoveryAdmissionRequestV1(value) {
-	return parseBoundary(parseRecoveryAdmissionRequestValue, value);
-}
-function parseRouterAbEd25519YaoWarmRecoveryBootstrapRequestV1(value) {
-	return parseBoundary(parseWarmRecoveryBootstrapRequestValue, value);
-}
-function parseRouterAbEd25519YaoExportAdmissionReceiptV1(value) {
-	return parseBoundary(parseExportAdmissionReceiptValue, value);
-}
-function parseRouterAbEd25519YaoExportExecuteRequestV1(value) {
-	return parseBoundary(parseExportExecuteRequestValue, value);
-}
-function parseRouterAbEd25519YaoExportResultV1(value) {
-	return parseBoundary(parseExportResultValue, value);
-}
 function parseRouterAbEd25519YaoActivationAdmissionReceiptV1(value) {
 	return parseBoundary(parseActivationAdmissionReceiptValue, value);
 }
@@ -681,15 +396,6 @@ function parseRouterAbEd25519YaoRegistrationActivationAdmissionReceiptV1(value)
 		value: parsed.value
 	};
 }
-function parseRouterAbEd25519YaoRecoveryActivationAdmissionReceiptV1(value) {
-	const parsed = parseRouterAbEd25519YaoActivationAdmissionReceiptV1(value);
-	if (!parsed.ok) return parsed;
-	if (!isActivationAdmissionReceiptFor(parsed.value, "recovery")) return operationMismatch("recovery");
-	return {
-		ok: true,
-		value: parsed.value
-	};
-}
 function parseRouterAbEd25519YaoActivationExecuteRequestV1(value) {
 	return parseBoundary(parseActivationExecuteRequestValue, value);
 }
@@ -702,46 +408,7 @@ function parseRouterAbEd25519YaoRegistrationActivationExecuteRequestV1(value) {
 		value: parsed.value
 	};
 }
-function parseRouterAbEd25519YaoRecoveryActivationExecuteRequestV1(value) {
-	const parsed = parseRouterAbEd25519YaoActivationExecuteRequestV1(value);
-	if (!parsed.ok) return parsed;
-	if (!isActivationExecuteRequestFor(parsed.value, "recovery")) return operationMismatch("recovery");
-	return {
-		ok: true,
-		value: parsed.value
-	};
-}
-function parseRouterAbEd25519YaoActivationResultV1(value) {
-	return parseBoundary(parseActivationResultValue, value);
-}
-function parseRouterAbEd25519YaoRegistrationActivationResultV1(value) {
-	const parsed = parseRouterAbEd25519YaoActivationResultV1(value);
-	if (!parsed.ok) return parsed;
-	if (!isActivationResultFor(parsed.value, "registration")) return operationMismatch("registration");
-	return {
-		ok: true,
-		value: parsed.value
-	};
-}
-function parseRouterAbEd25519YaoRecoveryActivationResultV1(value) {
-	const parsed = parseRouterAbEd25519YaoActivationResultV1(value);
-	if (!parsed.ok) return parsed;
-	if (!isActivationResultFor(parsed.value, "recovery")) return operationMismatch("recovery");
-	return {
-		ok: true,
-		value: parsed.value
-	};
-}
-function parseRouterAbEd25519YaoRecoveryActivationReceiptV1(value) {
-	return parseBoundary(parseRecoveryActivationReceiptValue, value);
-}
-function parseRouterAbEd25519YaoEncryptedPackageV1(value) {
-	return parseBoundary(parseEncryptedPackageValue, value);
-}
-function parseEncryptedPackageValue(value) {
-	return parseEncryptedPackage(value, "encrypted_package");
-}
 //#endregion
-export { ROUTER_AB_ED25519_YAO_EMAIL_OTP_RECOVERY_BOOTSTRAP_KIND_V1, ROUTER_AB_ED25519_YAO_EXPORT_ADMISSION_PATH_V1, ROUTER_AB_ED25519_YAO_EXPORT_EXECUTE_PATH_V1, ROUTER_AB_ED25519_YAO_RECOVERY_ACTIVATE_PATH_V1, ROUTER_AB_ED25519_YAO_RECOVERY_ADMISSION_PATH_V1, ROUTER_AB_ED25519_YAO_RECOVERY_CHALLENGE_ID_HEADER_V1, ROUTER_AB_ED25519_YAO_RECOVERY_EXECUTE_PATH_V1, ROUTER_AB_ED25519_YAO_REGISTRATION_ADMISSION_PATH_V1, ROUTER_AB_ED25519_YAO_REGISTRATION_EXECUTE_PATH_V1, ROUTER_AB_ED25519_YAO_WARM_RECOVERY_BOOTSTRAP_PATH_V1, parseRouterAbEd25519YaoActivationPublicReceiptV1, parseRouterAbEd25519YaoActivationResultV1, parseRouterAbEd25519YaoApplicationBindingFactsV1, parseRouterAbEd25519YaoCeremonyBindingV1, parseRouterAbEd25519YaoEncryptedPackageV1, parseRouterAbEd25519YaoExportAdmissionReceiptV1, parseRouterAbEd25519YaoExportExecuteRequestV1, parseRouterAbEd25519YaoExportResultV1, parseRouterAbEd25519YaoParticipantIdsV1, parseRouterAbEd25519YaoRecoveryActivationAdmissionReceiptV1, parseRouterAbEd25519YaoRecoveryActivationExecuteRequestV1, parseRouterAbEd25519YaoRecoveryActivationReceiptV1, parseRouterAbEd25519YaoRecoveryActivationResultV1, parseRouterAbEd25519YaoRecoveryAdmissionRequestV1, parseRouterAbEd25519YaoRegistrationActivationAdmissionReceiptV1, parseRouterAbEd25519YaoRegistrationActivationExecuteRequestV1, parseRouterAbEd25519YaoRegistrationActivationResultV1, parseRouterAbEd25519YaoRegistrationAdmissionRequestV1, parseRouterAbEd25519YaoWarmRecoveryBootstrapRequestV1, sameRouterAbEd25519YaoActivationBindingV1, sameRouterAbEd25519YaoByteSequence, sameRouterAbEd25519YaoRegistrationAdmissionRequestV1 };
+export { parseRouterAbEd25519YaoActivationPublicReceiptV1, parseRouterAbEd25519YaoApplicationBindingFactsV1, parseRouterAbEd25519YaoCeremonyBindingV1, parseRouterAbEd25519YaoParticipantIdsV1, parseRouterAbEd25519YaoRegistrationActivationAdmissionReceiptV1, parseRouterAbEd25519YaoRegistrationActivationExecuteRequestV1, parseRouterAbEd25519YaoRegistrationAdmissionRequestV1, sameRouterAbEd25519YaoActivationBindingV1, sameRouterAbEd25519YaoByteSequence };
 
 //# sourceMappingURL=routerAbEd25519Yao.js.map

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

@@ -1,6 +1,4 @@
-//#region ../shared-ts/src/utils/routerAbEd25519YaoDigests.ts
-const APPLICATION_BINDING_DOMAIN = "seams/router-ab/ed25519-yao/application-binding/v1";
-const UTF8 = new TextEncoder();
+new TextEncoder();
 function requireVisibleIdentifier(value, label) {
 	if (typeof value !== "string" || value.length === 0) throw new Error(`${label} must be a non-empty visible ASCII string`);
 	for (let index = 0; index < value.length; index += 1) {
@@ -34,43 +32,7 @@ function equalBytes(left, right) {
 	for (let index = 0; index < left.length; index += 1) if (left[index] !== right[index]) return false;
 	return true;
 }
-function u32BigEndian(value) {
-	const bytes = new Uint8Array(4);
-	new DataView(bytes.buffer).setUint32(0, value, false);
-	return bytes;
-}
-function concatenateBytes(chunks) {
-	let length = 0;
-	for (const chunk of chunks) length += chunk.length;
-	const output = new Uint8Array(length);
-	let offset = 0;
-	for (const chunk of chunks) {
-		output.set(chunk, offset);
-		offset += chunk.length;
-	}
-	return output;
-}
-function lengthDelimited(value) {
-	return concatenateBytes([u32BigEndian(value.length), value]);
-}
-function labeledField(label, value) {
-	return concatenateBytes([lengthDelimited(UTF8.encode(label)), lengthDelimited(value)]);
-}
-async function sha256(value) {
-	const digest = await globalThis.crypto.subtle.digest("SHA-256", value);
-	return new Uint8Array(digest);
-}
-async function deriveRouterAbEd25519YaoApplicationBindingDigestV1(facts) {
-	const encoded = concatenateBytes([
-		lengthDelimited(UTF8.encode(APPLICATION_BINDING_DOMAIN)),
-		labeledField("walletId", UTF8.encode(facts.wallet_id)),
-		labeledField("nearEd25519SigningKeyId", UTF8.encode(facts.near_ed25519_signing_key_id)),
-		labeledField("signingRootId", UTF8.encode(facts.signing_root_id)),
-		labeledField("keyCreationSignerSlot", u32BigEndian(facts.key_creation_signer_slot))
-	]);
-	return Array.from(await sha256(encoded));
-}
 //#endregion
-export { deriveRouterAbEd25519YaoApplicationBindingDigestV1, equalBytes, requireBytes, requireBytes32, requireVisibleIdentifier };
+export { equalBytes, requireBytes, requireBytes32, requireVisibleIdentifier };
 
 //# sourceMappingURL=routerAbEd25519YaoDigests.js.map

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

@@ -1,5 +1,5 @@
-import { parseMpcMaterialActivationRef } from "./domainIds.js";
 import { requireRecord } from "./validation.js";
+import { parseMpcMaterialActivationRef } from "./domainIds.js";
 //#region ../shared-ts/src/utils/routerAbNormalSigningIdentity.ts
 function requireExactFields(record, expectedFields, label) {
 	const actualFields = Object.keys(record).sort();

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

@@ -87,12 +87,7 @@ function parseRouterAbEd25519NormalSigningState(value) {
 		signingWorkerId
 	};
 }
-function requireRouterAbEd25519NormalSigningState(value) {
-	const parsed = parseRouterAbEd25519NormalSigningState(value);
-	if (!parsed) throw new Error("Router A/B Ed25519 normal-signing state is required");
-	return parsed;
-}
 //#endregion
-export { PASSKEY_PRF_FIRST_SALT_V1, PASSKEY_PRF_SECOND_SALT_V1, ROUTER_AB_ED25519_NORMAL_SIGNING_STATE_KIND, ROUTER_AB_ED25519_WALLET_SESSION_PATH, SIGNING_SESSION_SEAL_ALG, SIGNING_SESSION_SEAL_GROUP_ID, SIGNING_SESSION_SEAL_STORAGE_SCOPE, SIGNING_SESSION_SECRET_KIND, parseRouterAbEd25519NormalSigningState, requireRouterAbEd25519NormalSigningState };
+export { PASSKEY_PRF_FIRST_SALT_V1, PASSKEY_PRF_SECOND_SALT_V1, ROUTER_AB_ED25519_NORMAL_SIGNING_STATE_KIND, ROUTER_AB_ED25519_WALLET_SESSION_PATH, SIGNING_SESSION_SEAL_ALG, SIGNING_SESSION_SEAL_GROUP_ID, SIGNING_SESSION_SEAL_STORAGE_SCOPE, SIGNING_SESSION_SECRET_KIND, parseRouterAbEd25519NormalSigningState };
 
 //# sourceMappingURL=signingSessionSeal.js.map

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

@@ -1,11 +1,6 @@
 import { base64UrlEncode } from "./base64.js";
 import { alphabetizeStringify, sha256BytesUtf8 } from "./digests.js";
 //#region ../shared-ts/src/utils/thresholdEcdsaKeyHandle.ts
-function parseThresholdEcdsaKeyHandle(value) {
-	const normalized = typeof value === "string" ? value.trim() : "";
-	if (!normalized.startsWith("ederivation-key-")) throw new Error("Threshold ECDSA key handle is invalid");
-	return normalized;
-}
 function requiredString(value, field) {
 	const normalized = String(value ?? "").trim();
 	if (!normalized) throw new Error(`[threshold-ecdsa-key-handle] ${field} is required`);
@@ -23,6 +18,6 @@ async function deriveThresholdEcdsaKeyHandle(input) {
 	})))}`;
 }
 //#endregion
-export { deriveThresholdEcdsaKeyHandle, parseThresholdEcdsaKeyHandle };
+export { deriveThresholdEcdsaKeyHandle };
 
 //# sourceMappingURL=thresholdEcdsaKeyHandle.js.map

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

@@ -1,13 +1,10 @@
-import { normalizeOptionalTrimmedString, normalizeTrimmedString } from "./normalize.js";
+import { normalizeOptionalTrimmedString } from "./normalize.js";
 //#region ../shared-ts/src/utils/validation.ts
 function requireTrimmedString(value, label, message = "is required") {
 	const parsed = normalizeOptionalTrimmedString(value);
 	if (!parsed) throw new Error(`${label} ${message}`);
 	return parsed;
 }
-function toOptionalTrimmedNonEmptyString(value) {
-	return normalizeOptionalTrimmedString(value) || void 0;
-}
 function requireNonEmptyString(value, label) {
 	return requireTrimmedString(value, label, "must be a non-empty string");
 }
@@ -20,11 +17,6 @@ function coerceNonEmptyString(value, label) {
 	if (!normalized) throw new Error(`${label} is required`);
 	return normalized;
 }
-function coerceNonNullishString(value, label) {
-	const normalized = normalizeTrimmedString(value);
-	if (!normalized) throw new Error(`${label} is required`);
-	return normalized;
-}
 function isObject(x) {
 	return x !== null && typeof x === "object";
 }
@@ -46,9 +38,6 @@ function isArray(x) {
 function asRecord(value) {
 	return isPlainObject(value) ? value : null;
 }
-function asRecordOrArray(value) {
-	return isObject(value) ? value : null;
-}
 function requireRecord(value, label) {
 	if (!isPlainObject(value)) throw new Error(`${label} must be an object`);
 	return value;
@@ -60,10 +49,6 @@ function requireArray(value, label) {
 	if (!Array.isArray(value)) throw new Error(`${label} must be an array`);
 	return value;
 }
-function assertString(val, name = "value") {
-	if (typeof val !== "string") throw new Error(`Invalid ${name}: expected string`);
-	return val;
-}
 function stripFunctionsShallow(obj) {
 	if (!obj || !isObject(obj)) return void 0;
 	const out = {};
@@ -86,6 +71,6 @@ function extractBorshBytesFromPlainSignedTx(x) {
 	return Array.from(asU8 || new Uint8Array());
 }
 //#endregion
-export { asRecord, asRecordOrArray, assertString, coerceNonEmptyString, coerceNonNullishString, extractBorshBytesFromPlainSignedTx, isArray, isBoolean, isFunction, isObject, isPlainObject, isPlainSignedTransactionLike, isString, requireArray, requireCanonicalString, requireNonEmptyString, requireRecord, requireRecordCopy, requireTrimmedString, stripFunctionsShallow, toOptionalTrimmedNonEmptyString };
+export { asRecord, coerceNonEmptyString, extractBorshBytesFromPlainSignedTx, isArray, isBoolean, isFunction, isObject, isPlainObject, isPlainSignedTransactionLike, isString, requireArray, requireCanonicalString, requireNonEmptyString, requireRecord, requireRecordCopy, requireTrimmedString, stripFunctionsShallow };
 
 //# sourceMappingURL=validation.js.map

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

@@ -58,24 +58,6 @@ function hasAnyOwnField(obj, fields) {
 	for (const field of fields) if (hasOwnField(obj, field)) return true;
 	return false;
 }
-function buildPasskeyWalletAuthAuthority(args) {
-	const walletId = requireParsed(parseWalletId(args.walletId), "Passkey wallet auth authority requires walletId");
-	const rpId = requireParsed(parseWebAuthnRpId(args.rpId), "Passkey wallet auth authority requires rpId");
-	const credentialIdB64u = requireParsed(parseWebAuthnCredentialIdB64u(args.credentialIdB64u), "Passkey wallet auth authority requires credentialIdB64u");
-	const bindingId = requireParsed(parseWalletAuthMethodId(`passkey:${rpId}:${credentialIdB64u}`), "Passkey wallet auth authority requires bindingId");
-	return {
-		walletId,
-		factor: {
-			kind: "passkey",
-			credentialIdB64u
-		},
-		verifier: {
-			kind: "webauthn",
-			rpId
-		},
-		bindingId
-	};
-}
 function buildEmailOtpFactorIdentity(args) {
 	const provider = parseEmailOtpProvider(args.provider);
 	if (!provider) throw new Error("Email OTP factor identity requires provider");
@@ -101,15 +83,6 @@ function buildEmailOtpWalletAuthAuthority(args) {
 		bindingId
 	};
 }
-function emailOtpWalletAuthAuthorityProvider(authority) {
-	return authority.factor.provider;
-}
-function emailOtpWalletAuthAuthorityProviderUserId(authority) {
-	return authority.factor.providerUserId;
-}
-function emailOtpWalletAuthAuthorityEmailHashHex(authority) {
-	return authority.verifier.emailHashHex;
-}
 function parsePasskeyWalletAuthAuthorityObject(obj) {
 	const factor = obj.factor;
 	if (!factor || typeof factor !== "object" || Array.isArray(factor)) return null;
@@ -218,6 +191,6 @@ async function walletAuthAuthorityRef(args) {
 	};
 }
 //#endregion
-export { buildEmailOtpWalletAuthAuthority, buildPasskeyWalletAuthAuthority, canonicalWalletAuthorityBindingDigestInput, emailOtpWalletAuthAuthorityEmailHashHex, emailOtpWalletAuthAuthorityProvider, emailOtpWalletAuthAuthorityProviderUserId, isEmailOtpWalletAuthAuthority, isPasskeyWalletAuthAuthority, parseEmailOtpWalletAuthAuthority, parsePasskeyWalletAuthAuthority, parseWalletAuthAuthority, parseWalletAuthAuthorityRef, walletAuthAuthoritiesMatch, walletAuthAuthorityRef, walletAuthorityBindingDigest };
+export { buildEmailOtpWalletAuthAuthority, canonicalWalletAuthorityBindingDigestInput, isEmailOtpWalletAuthAuthority, isPasskeyWalletAuthAuthority, parseEmailOtpWalletAuthAuthority, parsePasskeyWalletAuthAuthority, parseWalletAuthAuthority, parseWalletAuthAuthorityRef, walletAuthAuthoritiesMatch, walletAuthAuthorityRef, walletAuthorityBindingDigest };
 
 //# sourceMappingURL=walletAuthAuthority.js.map

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

@@ -1,16 +1,6 @@
 import { parseWalletAuthMethodId, parseWalletAuthorityId, parseWalletId, parseWebAuthnCredentialIdB64u, parseWebAuthnRpId } from "./domainIds.js";
-import { alphabetizeStringify } from "./digests.js";
-import { sha256Utf8DigestB64u } from "./canonicalPrimitives.js";
 import { inspectRawObject, trimString } from "./registrationAuthMethodInput.js";
 //#region ../shared-ts/src/utils/walletAuthMethodRecord.ts
-async function computeWalletAuthMethodRevokeOperationFingerprintV1(input) {
-	return sha256Utf8DigestB64u(alphabetizeStringify({
-		version: "wallet_auth_method_revoke_operation_v1",
-		walletId: String(input.walletId),
-		targetWalletAuthMethodId: String(input.targetWalletAuthMethodId),
-		requestedAtMs: input.requestedAtMs
-	}));
-}
 function sameWalletAuthMethodRecordV2(left, right) {
 	if (left.version !== right.version || left.walletAuthMethodId !== right.walletAuthMethodId || left.walletId !== right.walletId || left.walletAuthorityId !== right.walletAuthorityId || left.status !== right.status || left.createdAtMs !== right.createdAtMs || left.updatedAtMs !== right.updatedAtMs) return false;
 	switch (left.kind) {
@@ -352,6 +342,6 @@ function validateNonNegativeInteger(raw, label) {
 	if (!Number.isSafeInteger(raw) || raw < 0) throw new Error(`${label} must be a non-negative safe integer`);
 }
 //#endregion
-export { buildWalletAuthMethodRecordV2, computeWalletAuthMethodRevokeOperationFingerprintV1, parseWalletAuthMethodRecordV2, sameWalletAuthMethodRecordV2 };
+export { buildWalletAuthMethodRecordV2, parseWalletAuthMethodRecordV2, sameWalletAuthMethodRecordV2 };
 
 //# sourceMappingURL=walletAuthMethodRecord.js.map

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

@@ -88,12 +88,6 @@ function passkeyAuthScopeFromRaw(raw) {
 		}
 	};
 }
-function buildPasskeyAuthScope(args) {
-	return {
-		wallet: args.wallet,
-		rpId: args.rpId
-	};
-}
 function buildPasskeyWalletAuthMethodBinding(args) {
 	const credentialIdB64u = trimString(args.credentialIdB64u);
 	if (!credentialIdB64u) throw new Error("credentialIdB64u is required");
@@ -272,6 +266,6 @@ function nearEd25519SignerBindingFromRaw(raw) {
 	};
 }
 //#endregion
-export { buildEmailOtpWalletAuthMethodBinding, buildImplicitNearAccountBinding, buildNamedNearAccountBinding, buildNearEd25519SignerBinding, buildNoCurrentWalletAuthMethod, buildPasskeyAuthScope, buildPasskeyWalletAuthMethodBinding, buildSelectedCurrentWalletAuthMethod, buildWalletIdentity, nearAccountBindingFromRaw, nearEd25519SignerBindingFromRaw, parseRpId, walletAuthMethodBindingFromRaw };
+export { buildEmailOtpWalletAuthMethodBinding, buildImplicitNearAccountBinding, buildNamedNearAccountBinding, buildNearEd25519SignerBinding, buildNoCurrentWalletAuthMethod, buildPasskeyWalletAuthMethodBinding, buildSelectedCurrentWalletAuthMethod, buildWalletIdentity, nearAccountBindingFromRaw, nearEd25519SignerBindingFromRaw, parseRpId, walletAuthMethodBindingFromRaw };
 
 //# sourceMappingURL=walletCapabilityBindings.js.map