@seams/wallet 0.7.1 → 0.8.0

package/dist/esm/react/core/rpcClients/relayer/walletRecoveryGoogleEmailOtp.js

@@ -1,161 +0,0 @@
-import { parseEmailOtpProviderUserId } from "../../../shared-ts/src/utils/domainIds.js";
-import { parsePasskeyCustodyEnvelopeRecord } from "../../../shared-ts/src/passkey-custody/custodyEnvelope.js";
-import "../../../shared-ts/src/passkey-custody/index.js";
-import { buildRelayerJsonPostRequestInit, normalizeRelayerBaseUrl } from "./relayerHttp.js";
-import { parseWalletRecoveryEcdsaPossessionProofV1 } from "../../../shared-ts/src/wallet-recovery/walletRecoveryEcdsaPossession.js";
-import { parseWalletRecoveryCommittedProjectionV1 } from "../../../shared-ts/src/wallet-recovery/walletRecoveryCommittedProjection.js";
-//#region src/core/rpcClients/relayer/walletRecoveryGoogleEmailOtp.ts
-const GOOGLE_EMAIL_OTP_FINALIZE_PATH = "/wallets/recovery/google-email-otp/finalize";
-async function finalizeWalletRecoveryGoogleEmailOtp(args) {
-	let replacementEnvelope;
-	let ecdsaMaterialPossessionProofs;
-	try {
-		replacementEnvelope = parsePasskeyCustodyEnvelopeRecord(args.replacementEnvelope, "walletRecoveryGoogleEmailOtpFinalize.replacementEnvelope");
-		if (replacementEnvelope.factor.kind !== "email_otp") throw new Error("wrong factor");
-		ecdsaMaterialPossessionProofs = args.ecdsaMaterialPossessionProofs.map((entry) => ({
-			keySetId: entry.keySetId,
-			proof: parseWalletRecoveryEcdsaPossessionProofV1(entry.proof)
-		}));
-	} catch {
-		return { kind: "refused" };
-	}
-	const response = await postRecoveryJson(args, GOOGLE_EMAIL_OTP_FINALIZE_PATH, {
-		kind: "finalize",
-		recoveryOperationId: args.recoveryOperationId,
-		reservationId: args.reservationId,
-		replacementEnvelope,
-		ecdsaMaterialPossessionProofs,
-		...args.emailOtpEnrollment ? { emailOtpEnrollment: args.emailOtpEnrollment } : {}
-	});
-	if (!response.ok) return response.failure;
-	try {
-		const projection = await parseWalletRecoveryCommittedProjectionV1(decodeWalletRecoveryProjectionResponse(response.body, "walletRecoveryGoogleEmailOtpFinalize").projection, buildGoogleEmailOtpProjectionExpectation(args, replacementEnvelope));
-		if (projection.kind !== "google_email_otp") throw new Error("recovery projection branch changed");
-		return {
-			kind: "promoted",
-			storeVersion: projection.storeVersion,
-			authority: projection.authority,
-			authMethod: projection.authMethod
-		};
-	} catch {
-		return { kind: "transport_uncertain" };
-	}
-}
-/** Replays an already-committed Email OTP recovery without an OTP or factor. */
-async function replayWalletRecoveryGoogleEmailOtp(args) {
-	let replacementEnvelope;
-	try {
-		replacementEnvelope = parsePasskeyCustodyEnvelopeRecord(args.replacementEnvelope, "walletRecoveryGoogleEmailOtpReplay.replacementEnvelope");
-		if (replacementEnvelope.factor.kind !== "email_otp" || String(replacementEnvelope.walletId) !== String(args.walletId)) throw new Error("recovery replay envelope identity is invalid");
-	} catch {
-		return { kind: "refused" };
-	}
-	const response = await postRecoveryJson(args, GOOGLE_EMAIL_OTP_FINALIZE_PATH, {
-		kind: "replay",
-		recoveryOperationId: args.recoveryOperationId,
-		reservationId: args.reservationId,
-		replacementEnvelope
-	});
-	if (!response.ok) return response.failure;
-	try {
-		const projection = await parseWalletRecoveryCommittedProjectionV1(decodeWalletRecoveryProjectionResponse(response.body, "walletRecoveryGoogleEmailOtpReplay").projection, buildGoogleEmailOtpProjectionExpectation(args, replacementEnvelope));
-		if (projection.kind !== "google_email_otp") throw new Error("recovery projection branch changed");
-		return {
-			kind: "promoted",
-			storeVersion: projection.storeVersion,
-			authority: projection.authority,
-			authMethod: projection.authMethod
-		};
-	} catch {
-		return { kind: "transport_uncertain" };
-	}
-}
-async function postRecoveryJson(args, path, body) {
-	let response;
-	try {
-		response = await (args.fetchImpl ?? fetch)(`${normalizeRelayerBaseUrl(args.relayUrl)}${path}`, buildRelayerJsonPostRequestInit({ body }));
-	} catch {
-		return {
-			ok: false,
-			failure: { kind: "transport_uncertain" }
-		};
-	}
-	const responseBody = await response.json().catch(() => void 0);
-	if (response.status === 200) return {
-		ok: true,
-		body: responseBody
-	};
-	if (response.status === 409 || response.status === 429) return {
-		ok: false,
-		failure: { kind: "retryable_conflict" }
-	};
-	if (response.status === 400 || response.status === 401) return {
-		ok: false,
-		failure: { kind: "refused" }
-	};
-	return {
-		ok: false,
-		failure: { kind: "transport_uncertain" }
-	};
-}
-function decodeWalletRecoveryProjectionResponse(value, label) {
-	const response = requireExactJsonResponse(value, ["ok", "projection"], label);
-	requireSuccessfulResponse(response, label);
-	return { projection: readResponseField(response, "projection") };
-}
-function requireExactJsonResponse(value, fields, label) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${label} must be a JSON object`);
-	const prototype = Object.getPrototypeOf(value);
-	if (prototype !== Object.prototype && prototype !== null) throw new Error(`${label} must be a plain JSON object`);
-	const keys = Object.keys(value);
-	if (keys.length !== fields.length || !hasExactResponseFields(keys, fields)) throw new Error(`${label} has an unexpected response shape`);
-	return value;
-}
-function hasExactResponseFields(keys, fields) {
-	for (const field of fields) if (!keys.includes(field)) return false;
-	return true;
-}
-function requireSuccessfulResponse(value, label) {
-	if (readResponseField(value, "ok") !== true) throw new Error(`${label} did not succeed`);
-}
-function readResponseField(value, field) {
-	const descriptor = Object.getOwnPropertyDescriptor(value, field);
-	if (!descriptor || !("value" in descriptor)) throw new Error(`response field ${field} is missing`);
-	return descriptor.value;
-}
-function requireParsed(result) {
-	if (!result.ok) throw new Error("invalid domain identity");
-	return result.value;
-}
-function requireString(value) {
-	if (typeof value !== "string" || !value.trim()) throw new Error("value must be a string");
-	return value.trim();
-}
-function buildGoogleEmailOtpProjectionExpectation(args, replacementEnvelope) {
-	if (replacementEnvelope.factor.kind !== "email_otp") throw new Error("replacement envelope is not an Email OTP envelope");
-	return {
-		kind: "google_email_otp",
-		walletId: args.walletId,
-		recoveryOperationId: args.recoveryOperationId,
-		targetDeviceId: args.targetDeviceId,
-		targetAuthorityId: args.targetAuthorityId,
-		targetWalletAuthMethodId: args.targetWalletAuthMethodId,
-		providerSubject: requireParsed(parseEmailOtpProviderUserId(args.expectedProviderSubject)),
-		emailHashHex: requireEmailHash(args.expectedEmailHashHex),
-		registrationAuthorityId: requireString(args.expectedRegistrationAuthorityId),
-		enrollment: {
-			kind: "email_otp_enrollment_reference_v1",
-			enrollmentId: requireString(replacementEnvelope.factor.enrollmentId),
-			enrollmentSealKeyVersion: requireString(replacementEnvelope.factor.enrollmentSealKeyVersion)
-		}
-	};
-}
-function requireEmailHash(value) {
-	const hash = requireString(value);
-	if (!/^[0-9a-f]{64}$/.test(hash)) throw new Error("email hash is invalid");
-	return hash;
-}
-//#endregion
-export { finalizeWalletRecoveryGoogleEmailOtp, replayWalletRecoveryGoogleEmailOtp };
-
-//# sourceMappingURL=walletRecoveryGoogleEmailOtp.js.map

package/dist/esm/react/core/rpcClients/relayer/walletRecoveryPrepare.js

@@ -1,295 +0,0 @@
-import "../../../shared-ts/src/utils/encoders.js";
-import { normalizeRuntimePolicyScope } from "../../../shared-ts/src/threshold/signingRootScope.js";
-import "../../../shared-ts/src/utils/signingSessionSeal.js";
-import { parseEcdsaServerGeneration } from "../../../shared-ts/src/utils/ecdsaCapabilityActivation.js";
-import { parseRouterAbMpcMaterialActivationRef } from "../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
-import "../../../shared-ts/src/authorization/capabilityKinds.js";
-import { parseDigestField } from "../../../shared-ts/src/passkey-custody/primitives.js";
-import { parseRouterAbEcdsaDerivationPublicCapabilityV1, parseRouterAbEcdsaRegistrationActivationReceiptV1 } from "../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
-import { requireEvmFamilySigningKeySlotId } from "../../../shared-ts/src/signing-lanes/evmFamilySigningKeySlotId.js";
-import { ecdsaClientRootPublicKey33B64uFromString, parseSdkEcdsaDerivationSigningRootId, parseSdkEcdsaDerivationSigningRootVersion, parseSdkEcdsaDerivationThresholdKeyId } from "../../../shared-ts/src/threshold/ecdsaDerivationRoleLocalBootstrap.js";
-import "../../../shared-ts/src/signing-lanes/index.js";
-import "../../../shared-ts/src/passkey-custody/index.js";
-import { parseWalletRecoveryEcdsaPossessionChallengeV1 } from "../../../shared-ts/src/wallet-recovery/walletRecoveryEcdsaPossession.js";
-import "../../../shared-ts/src/wallet-recovery/index.js";
-function decodeJsonObject(raw, label) {
-	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) throw new Error(`${label} must be an object`);
-	return raw;
-}
-function assertExactJsonObjectKeys(value, fields, label) {
-	const expected = new Set(fields);
-	const actual = Object.keys(value);
-	if (actual.length !== expected.size || actual.some((field) => !expected.has(field))) throw new Error(`${label} contains unexpected fields`);
-}
-function decodeExactJsonObject(raw, fields, label) {
-	const value = decodeJsonObject(raw, label);
-	assertExactJsonObjectKeys(value, fields, label);
-	return value;
-}
-function readJsonField(value, field) {
-	return Object.prototype.hasOwnProperty.call(value, field) ? Reflect.get(value, field) : void 0;
-}
-function requireResponseString(raw, field) {
-	if (typeof raw !== "string" || !raw.trim()) throw new Error(`walletRecoveryPrepare.${field} must be a non-empty string`);
-	return raw.trim();
-}
-function parseWalletRecoveryPreparationKeyManifest(raw, expectedWalletId) {
-	const manifest = decodeExactJsonObject(raw, [
-		"version",
-		"walletId",
-		"entries"
-	], "walletRecoveryPrepare.keyManifest");
-	if (readJsonField(manifest, "version") !== "wallet_recovery_preparation_key_manifest_v1") throw new Error("walletRecoveryPrepare.keyManifest version is invalid");
-	const walletId = requireResponseString(readJsonField(manifest, "walletId"), "keyManifest.walletId");
-	if (walletId !== expectedWalletId) throw new Error("walletRecoveryPrepare.keyManifest changed the wallet identity");
-	const rawEntries = readJsonField(manifest, "entries");
-	if (!Array.isArray(rawEntries) || rawEntries.length === 0) throw new Error("walletRecoveryPrepare.keyManifest must contain a key set");
-	const entries = rawEntries.map((entry) => parseWalletRecoveryPreparationKeyManifestEntry(entry, walletId));
-	if (new Set(entries.map((entry) => entry.keySetId)).size !== entries.length) throw new Error("walletRecoveryPrepare.keyManifest contains duplicate key sets");
-	return {
-		version: "wallet_recovery_preparation_key_manifest_v1",
-		walletId,
-		entries
-	};
-}
-function parseWalletRecoveryPreparationKeyManifestEntry(raw, expectedWalletId) {
-	switch (readJsonField(decodeJsonObject(raw, "walletRecoveryPrepare.keyManifest.entries[]"), "kind")) {
-		case "near_ed25519": {
-			const exactEntry = decodeExactJsonObject(raw, [
-				"kind",
-				"keySetId",
-				"signerId",
-				"nearAccountId",
-				"recordedKeyManifestDigestB64u",
-				"recoveryBasis"
-			], "walletRecoveryPrepare.keyManifest.entries[].near_ed25519");
-			const signerId = requireResponseString(readJsonField(exactEntry, "signerId"), "keyManifest.entries[].signerId");
-			const suppliedKeySetId = requireResponseString(readJsonField(exactEntry, "keySetId"), "keyManifest.entries[].keySetId");
-			const keySetId = `near_ed25519:${signerId}`;
-			if (suppliedKeySetId !== keySetId) throw new Error("walletRecoveryPrepare NEAR key-set identity is inconsistent");
-			const nearAccountId = requireResponseString(readJsonField(exactEntry, "nearAccountId"), "keyManifest.entries[].nearAccountId");
-			const recoveryBasis = parseWalletRecoveryPreparationNearRecoveryBasis(readJsonField(exactEntry, "recoveryBasis"), expectedWalletId);
-			return {
-				kind: "near_ed25519",
-				keySetId,
-				signerId,
-				nearAccountId,
-				recordedKeyManifestDigestB64u: parseDigestField(readJsonField(exactEntry, "recordedKeyManifestDigestB64u"), "walletRecoveryPrepare.keyManifest.entries[].recordedKeyManifestDigestB64u"),
-				recoveryBasis
-			};
-		}
-		case "evm_family_ecdsa": {
-			const exactEntry = decodeExactJsonObject(raw, [
-				"kind",
-				"keySetId",
-				"keyHandle",
-				"evmFamilySigningKeySlotId",
-				"recordedKeyManifestDigestB64u",
-				"recoveryBasis"
-			], "walletRecoveryPrepare.keyManifest.entries[].evm_family_ecdsa");
-			const keyHandle = requireResponseString(readJsonField(exactEntry, "keyHandle"), "keyManifest.entries[].keyHandle");
-			const suppliedKeySetId = requireResponseString(readJsonField(exactEntry, "keySetId"), "keyManifest.entries[].keySetId");
-			const keySetId = `evm_family_ecdsa:${keyHandle}`;
-			if (suppliedKeySetId !== keySetId) throw new Error("walletRecoveryPrepare ECDSA key-set identity is inconsistent");
-			const recoveryBasis = parseWalletRecoveryPreparationEcdsaRecoveryBasis(readJsonField(exactEntry, "recoveryBasis"), expectedWalletId);
-			return {
-				kind: "evm_family_ecdsa",
-				keySetId,
-				keyHandle,
-				evmFamilySigningKeySlotId: requireEvmFamilySigningKeySlotId(readJsonField(exactEntry, "evmFamilySigningKeySlotId")),
-				recordedKeyManifestDigestB64u: parseDigestField(readJsonField(exactEntry, "recordedKeyManifestDigestB64u"), "walletRecoveryPrepare.keyManifest.entries[].recordedKeyManifestDigestB64u"),
-				recoveryBasis
-			};
-		}
-		default: throw new Error("walletRecoveryPrepare key-manifest entry kind is invalid");
-	}
-}
-function parseWalletRecoveryPreparationNearRecoveryBasis(raw, expectedWalletId) {
-	const basis = decodeExactJsonObject(raw, [
-		"capabilityKind",
-		"activeCapabilityBinding",
-		"scope",
-		"applicationBinding",
-		"participantIds",
-		"registeredPublicKey",
-		"runtimePolicyScope",
-		"activationTranscript",
-		"activationStateEpoch",
-		"signingWorkerVerifyingShare"
-	], "walletRecoveryPrepare.keyManifest.entries[].recoveryBasis");
-	const capabilityKind = readJsonField(basis, "capabilityKind");
-	if (capabilityKind !== "registration" && capabilityKind !== "recovery") throw new Error("walletRecoveryPrepare NEAR recovery capability kind is invalid");
-	const activeCapabilityBinding = requireByteArray(readJsonField(basis, "activeCapabilityBinding"), 32, "NEAR recovery active capability binding");
-	const scope = parseWalletRecoveryNearLifecycleScope(readJsonField(basis, "scope"));
-	const applicationBinding = parseWalletRecoveryNearApplicationBinding(readJsonField(basis, "applicationBinding"));
-	const participantIds = requireParticipantPair(readJsonField(basis, "participantIds"), "NEAR recovery participant IDs");
-	const registeredPublicKey = requireByteArray(readJsonField(basis, "registeredPublicKey"), 32, "NEAR recovery registered public key");
-	const runtimePolicyScope = parseWalletRecoveryRuntimePolicyScope(readJsonField(basis, "runtimePolicyScope"));
-	const activationTranscript = requireByteArray(readJsonField(basis, "activationTranscript"), 32, "NEAR recovery activation transcript");
-	const activationStateEpoch = Number(readJsonField(basis, "activationStateEpoch"));
-	if (!Number.isSafeInteger(activationStateEpoch) || activationStateEpoch <= 0) throw new Error("walletRecoveryPrepare NEAR recovery activation state epoch is invalid");
-	const signingWorkerVerifyingShare = requireByteArray(readJsonField(basis, "signingWorkerVerifyingShare"), 32, "NEAR recovery signing-worker verifying share");
-	if (applicationBinding.wallet_id !== expectedWalletId || scope.account_id !== expectedWalletId || scope.root_share_epoch !== runtimePolicyScope.signingRootVersion) throw new Error("walletRecoveryPrepare NEAR recovery basis changed its wallet scope");
-	return {
-		capabilityKind,
-		activeCapabilityBinding,
-		scope,
-		applicationBinding,
-		participantIds,
-		registeredPublicKey,
-		runtimePolicyScope,
-		activationTranscript,
-		activationStateEpoch,
-		signingWorkerVerifyingShare
-	};
-}
-function parseWalletRecoveryPreparationEcdsaRecoveryBasis(raw, expectedWalletId) {
-	const basis = decodeExactJsonObject(raw, [
-		"publicCapability",
-		"activationReceipt",
-		"serverGeneration",
-		"clientRootPublicKey33B64u",
-		"chainTargets",
-		"ecdsaThresholdKeyId",
-		"signingRootId",
-		"signingRootVersion",
-		"runtimePolicyScope",
-		"participantIds",
-		"possessionChallenge"
-	], "walletRecoveryPrepare.keyManifest.entries[].recoveryBasis");
-	const publicCapability = parseRouterAbEcdsaDerivationPublicCapabilityV1(readJsonField(basis, "publicCapability"));
-	const activationReceipt = parseRouterAbEcdsaRegistrationActivationReceiptV1(readJsonField(basis, "activationReceipt"));
-	if (publicCapability.client_id !== expectedWalletId) throw new Error("walletRecoveryPrepare ECDSA recovery capability changed the wallet scope");
-	const signingRootId = parseSdkEcdsaDerivationSigningRootId(readJsonField(basis, "signingRootId"));
-	const signingRootVersion = parseSdkEcdsaDerivationSigningRootVersion(readJsonField(basis, "signingRootVersion"));
-	const runtimePolicyScope = parseWalletRecoveryRuntimePolicyScope(readJsonField(basis, "runtimePolicyScope"));
-	if (runtimePolicyScope.signingRootVersion !== signingRootVersion) throw new Error("walletRecoveryPrepare ECDSA recovery scope changed the signing root");
-	const serverGeneration = parseEcdsaServerGeneration(readJsonField(basis, "serverGeneration"));
-	if (String(activationReceipt.server_generation) !== String(serverGeneration)) throw new Error("walletRecoveryPrepare ECDSA activation receipt changed server generation");
-	const possessionChallenge = parseWalletRecoveryEcdsaPossessionChallengeV1(readJsonField(basis, "possessionChallenge"));
-	if (possessionChallenge.walletId !== expectedWalletId || possessionChallenge.expectedServerGeneration !== String(serverGeneration) || possessionChallenge.derivationClientSharePublicKey33B64u !== publicCapability.public_identity.derivation_client_share_public_key33_b64u) throw new Error("walletRecoveryPrepare ECDSA possession challenge changed its capability");
-	return {
-		publicCapability,
-		activationReceipt,
-		serverGeneration,
-		clientRootPublicKey33B64u: ecdsaClientRootPublicKey33B64uFromString(requireResponseString(readJsonField(basis, "clientRootPublicKey33B64u"), "keyManifest.entries[].recoveryBasis.clientRootPublicKey33B64u")),
-		chainTargets: parseWalletRecoveryEcdsaChainTargets(readJsonField(basis, "chainTargets")),
-		ecdsaThresholdKeyId: parseSdkEcdsaDerivationThresholdKeyId(readJsonField(basis, "ecdsaThresholdKeyId")),
-		signingRootId,
-		signingRootVersion,
-		runtimePolicyScope,
-		participantIds: parseWalletRecoveryEcdsaParticipantIds(readJsonField(basis, "participantIds")),
-		possessionChallenge
-	};
-}
-function parseWalletRecoveryEcdsaChainTargets(raw) {
-	if (!Array.isArray(raw) || raw.length === 0) throw new Error("walletRecoveryPrepare ECDSA recovery chain targets are invalid");
-	const targets = raw.map((value, index) => parseWalletRecoveryEcdsaChainTarget(value, index));
-	if (new Set(targets.map(walletRecoveryEcdsaChainTargetKey)).size !== targets.length) throw new Error("walletRecoveryPrepare ECDSA recovery chain targets are duplicated");
-	const first = targets[0];
-	if (!first) throw new Error("walletRecoveryPrepare ECDSA recovery chain targets are invalid");
-	return [first, ...targets.slice(1)];
-}
-function parseWalletRecoveryEcdsaChainTarget(raw, index) {
-	const label = `walletRecoveryPrepare.keyManifest.entries[].recoveryBasis.chainTargets[${index}]`;
-	const target = decodeJsonObject(raw, label);
-	const kind = readJsonField(target, "kind");
-	assertExactJsonObjectKeys(target, kind === "evm" ? [
-		"kind",
-		"namespace",
-		"chainId",
-		"networkSlug"
-	] : [
-		"kind",
-		"chainId",
-		"networkSlug"
-	], label);
-	const namespace = readJsonField(target, "namespace");
-	const chainId = Number(readJsonField(target, "chainId"));
-	if (!Number.isSafeInteger(chainId) || chainId <= 0) throw new Error("walletRecoveryPrepare ECDSA recovery chain id is invalid");
-	const networkSlugValue = readJsonField(target, "networkSlug");
-	const networkSlug = typeof networkSlugValue === "string" && networkSlugValue.trim() ? networkSlugValue.trim() : null;
-	if (kind === "evm") {
-		if (namespace !== "eip155") throw new Error("walletRecoveryPrepare ECDSA recovery EVM namespace is invalid");
-		return {
-			kind: "evm",
-			namespace: "eip155",
-			chainId,
-			networkSlug: networkSlug ?? `evm-${chainId}`
-		};
-	}
-	if (kind === "tempo") return {
-		kind: "tempo",
-		chainId,
-		networkSlug: networkSlug ?? `tempo-${chainId}`
-	};
-	throw new Error("walletRecoveryPrepare ECDSA recovery chain family is invalid");
-}
-function walletRecoveryEcdsaChainTargetKey(target) {
-	return target.kind === "evm" ? `evm:eip155:${target.chainId}` : `tempo:${target.chainId}`;
-}
-function parseWalletRecoveryEcdsaParticipantIds(raw) {
-	if (!Array.isArray(raw) || raw.length !== 2 || raw[0] !== 1 || raw[1] !== 2) throw new Error("walletRecoveryPrepare ECDSA recovery participant IDs are invalid");
-	return [1, 2];
-}
-function parseWalletRecoveryNearLifecycleScope(raw) {
-	const scope = decodeExactJsonObject(raw, [
-		"lifecycle_id",
-		"root_share_epoch",
-		"account_id",
-		"threshold_session_id",
-		"signer_set_id",
-		"signing_worker_id",
-		"material_activation"
-	], "walletRecoveryPrepare.keyManifest.entries[].recoveryBasis.scope");
-	return {
-		lifecycle_id: requireResponseString(readJsonField(scope, "lifecycle_id"), "keyManifest.entries[].recoveryBasis.scope.lifecycle_id"),
-		root_share_epoch: requireResponseString(readJsonField(scope, "root_share_epoch"), "keyManifest.entries[].recoveryBasis.scope.root_share_epoch"),
-		account_id: requireResponseString(readJsonField(scope, "account_id"), "keyManifest.entries[].recoveryBasis.scope.account_id"),
-		threshold_session_id: requireResponseString(readJsonField(scope, "threshold_session_id"), "keyManifest.entries[].recoveryBasis.scope.threshold_session_id"),
-		signer_set_id: requireResponseString(readJsonField(scope, "signer_set_id"), "keyManifest.entries[].recoveryBasis.scope.signer_set_id"),
-		signing_worker_id: requireResponseString(readJsonField(scope, "signing_worker_id"), "keyManifest.entries[].recoveryBasis.scope.signing_worker_id"),
-		material_activation: parseRouterAbMpcMaterialActivationRef(readJsonField(scope, "material_activation"))
-	};
-}
-function parseWalletRecoveryNearApplicationBinding(raw) {
-	const applicationBinding = decodeExactJsonObject(raw, [
-		"wallet_id",
-		"near_ed25519_signing_key_id",
-		"signing_root_id",
-		"key_creation_signer_slot"
-	], "walletRecoveryPrepare.keyManifest.entries[].recoveryBasis.applicationBinding");
-	const keyCreationSignerSlot = Number(readJsonField(applicationBinding, "key_creation_signer_slot"));
-	if (!Number.isSafeInteger(keyCreationSignerSlot) || keyCreationSignerSlot <= 0) throw new Error("walletRecoveryPrepare NEAR recovery key-creation signer slot is invalid");
-	return {
-		wallet_id: requireResponseString(readJsonField(applicationBinding, "wallet_id"), "keyManifest.entries[].recoveryBasis.applicationBinding.wallet_id"),
-		near_ed25519_signing_key_id: requireResponseString(readJsonField(applicationBinding, "near_ed25519_signing_key_id"), "keyManifest.entries[].recoveryBasis.applicationBinding.near_ed25519_signing_key_id"),
-		signing_root_id: requireResponseString(readJsonField(applicationBinding, "signing_root_id"), "keyManifest.entries[].recoveryBasis.applicationBinding.signing_root_id"),
-		key_creation_signer_slot: keyCreationSignerSlot
-	};
-}
-function parseWalletRecoveryRuntimePolicyScope(raw) {
-	const scope = decodeExactJsonObject(raw, [
-		"orgId",
-		"projectId",
-		"envId",
-		"signingRootVersion"
-	], "walletRecoveryPrepare.keyManifest.entries[].recoveryBasis.runtimePolicyScope");
-	try {
-		return normalizeRuntimePolicyScope(scope);
-	} catch {
-		throw new Error("walletRecoveryPrepare NEAR recovery runtime policy scope is invalid");
-	}
-}
-function requireParticipantPair(raw, label) {
-	if (!Array.isArray(raw) || raw.length !== 2 || !Number.isSafeInteger(raw[0]) || !Number.isSafeInteger(raw[1]) || Number(raw[0]) <= 0 || Number(raw[1]) <= 0 || Number(raw[0]) === Number(raw[1])) throw new Error(`walletRecoveryPrepare ${label} is invalid`);
-	return [Number(raw[0]), Number(raw[1])];
-}
-function requireByteArray(raw, length, label) {
-	if (!Array.isArray(raw) || raw.length !== length || raw.some((value) => !Number.isInteger(value) || value < 0 || value > 255)) throw new Error(`walletRecoveryPrepare ${label} is invalid`);
-	return raw.map(Number);
-}
-//#endregion
-export { parseWalletRecoveryPreparationKeyManifest };
-
-//# sourceMappingURL=walletRecoveryPrepare.js.map