@seams/wallet 0.8.0 → 0.9.1

package/dist/esm/core/rpcClients/relayer/walletRegistrationTerminalResponse.js

@@ -1,718 +0,0 @@
-import { parseThresholdEd25519SessionId, parseWebAuthnRpId } from "../../../shared-ts/src/utils/domainIds.js";
-import { isPlainObject } from "../../../shared-ts/src/utils/validation.js";
-import { base64UrlDecode } from "../../../shared-ts/src/utils/base64.js";
-import { requireRouterAbEd25519NormalSigningState } from "../../../shared-ts/src/utils/signingSessionSeal.js";
-import { parseImplicitNearAccountId, parseNamedNearAccountId } from "../../../shared-ts/src/utils/near.js";
-import { parseNearEd25519SigningKeyId, walletIdFromString } from "../../../shared-ts/src/utils/registrationIds.js";
-import { thresholdEcdsaChainTargetFromRequest, thresholdEcdsaChainTargetKey } from "../../signingEngine/interfaces/ecdsaChainTarget.js";
-import { normalizeThresholdRuntimePolicyScope } from "../../signingEngine/threshold/sessionPolicy.js";
-import { parseWalletCustodyRegistrationOutcome } from "../../../shared-ts/src/passkey-custody/ceremonyCommitPayload.js";
-import "../../../shared-ts/src/passkey-custody/index.js";
-import { isPasskeyWalletAuthAuthority, parseWalletAuthAuthority } from "../../../shared-ts/src/utils/walletAuthAuthority.js";
-import { parseRouterAbEcdsaDerivationPublicCapabilityV1 } from "../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
-import { parseWalletAuthMethodRecordV2 } from "../../../shared-ts/src/utils/walletAuthMethodRecord.js";
-import { parseWalletAuthorityV1 } from "../../../shared-ts/src/authorization/walletAuthority.js";
-//#region src/core/rpcClients/relayer/walletRegistrationTerminalResponse.ts
-function requireResponseString(args) {
-	const value = String(args.value || "").trim();
-	if (!value) throw new Error(`${args.responseName} response missing ${args.field}`);
-	return value;
-}
-function requireResponseRecord(args) {
-	if (!isPlainObject(args.value)) throw new Error(`${args.responseName} response missing ${args.field}`);
-	return args.value;
-}
-function assertExactResponseKeys(record, allowedKeys, responseName) {
-	const allowed = new Set(allowedKeys);
-	for (const key of Object.keys(record)) if (!allowed.has(key)) throw new Error(`${responseName} response contains unexpected ${key}`);
-}
-function requireResponseSafeInteger(args) {
-	const value = Number(args.value);
-	if (!Number.isSafeInteger(value) || value < args.minimum) throw new Error(`${args.responseName} response has invalid ${args.field}`);
-	return value;
-}
-function requireResponseParticipantPair(value, responseName) {
-	if (!Array.isArray(value) || value.length !== 2) throw new Error(`${responseName} response has invalid participantIds`);
-	const first = requireResponseSafeInteger({
-		responseName,
-		field: "participantIds[0]",
-		value: value[0],
-		minimum: 1
-	});
-	const second = requireResponseSafeInteger({
-		responseName,
-		field: "participantIds[1]",
-		value: value[1],
-		minimum: 1
-	});
-	if (first === second) throw new Error(`${responseName} response has duplicate participantIds`);
-	if (first !== 1 || second !== 2) throw new Error(`${responseName} response has unsupported participantIds`);
-	return [first, second];
-}
-function requireResponseRpId(value, responseName) {
-	const parsed = parseWebAuthnRpId(value);
-	if (!parsed.ok) throw new Error(`${responseName} response has invalid rpId`);
-	return parsed.value;
-}
-function parseWalletRegistrationEd25519AuthorityScope(value, responseName) {
-	const authorityScope = requireResponseRecord({
-		responseName,
-		field: "authorityScope",
-		value
-	});
-	switch (authorityScope.kind) {
-		case "passkey_rp":
-			assertExactResponseKeys(authorityScope, ["kind", "rpId"], responseName);
-			return {
-				kind: "passkey_rp",
-				rpId: requireResponseRpId(authorityScope.rpId, responseName)
-			};
-		case "email_otp":
-			assertExactResponseKeys(authorityScope, [
-				"kind",
-				"provider",
-				"providerUserId"
-			], responseName);
-			if (authorityScope.provider !== "google" && authorityScope.provider !== "email") throw new Error(`${responseName} response has invalid authorityScope provider`);
-			return {
-				kind: "email_otp",
-				provider: authorityScope.provider,
-				providerUserId: requireResponseString({
-					responseName,
-					field: "authorityScope.providerUserId",
-					value: authorityScope.providerUserId
-				})
-			};
-		default: throw new Error(`${responseName} response has invalid authorityScope`);
-	}
-}
-function parseWalletEd25519YaoSignerPublicResult(value, responseName) {
-	const ed25519 = requireResponseRecord({
-		responseName,
-		field: "ed25519",
-		value
-	});
-	assertExactResponseKeys(ed25519, [
-		"signerSlot",
-		"nearAccountId",
-		"nearEd25519SigningKeyId",
-		"publicKey",
-		"relayerKeyId",
-		"keyVersion",
-		"recoveryExportCapable",
-		"participantIds"
-	], responseName);
-	if (ed25519.recoveryExportCapable !== true) throw new Error(`${responseName} response is not recovery/export capable`);
-	return {
-		signerSlot: requireResponseSafeInteger({
-			responseName,
-			field: "ed25519.signerSlot",
-			value: ed25519.signerSlot,
-			minimum: 1
-		}),
-		nearAccountId: requireResponseString({
-			responseName,
-			field: "ed25519.nearAccountId",
-			value: ed25519.nearAccountId
-		}),
-		nearEd25519SigningKeyId: requireResponseString({
-			responseName,
-			field: "ed25519.nearEd25519SigningKeyId",
-			value: ed25519.nearEd25519SigningKeyId
-		}),
-		publicKey: requireResponseString({
-			responseName,
-			field: "ed25519.publicKey",
-			value: ed25519.publicKey
-		}),
-		relayerKeyId: requireResponseString({
-			responseName,
-			field: "ed25519.relayerKeyId",
-			value: ed25519.relayerKeyId
-		}),
-		keyVersion: requireResponseString({
-			responseName,
-			field: "ed25519.keyVersion",
-			value: ed25519.keyVersion
-		}),
-		recoveryExportCapable: true,
-		participantIds: requireResponseParticipantPair(ed25519.participantIds, responseName)
-	};
-}
-function parseWalletRegistrationEd25519Result(value, responseName) {
-	const ed25519 = requireResponseRecord({
-		responseName,
-		field: "ed25519",
-		value
-	});
-	assertExactResponseKeys(ed25519, [
-		"signerSlot",
-		"nearAccountId",
-		"nearEd25519SigningKeyId",
-		"publicKey",
-		"relayerKeyId",
-		"keyVersion",
-		"recoveryExportCapable",
-		"participantIds",
-		"thresholdSessionId",
-		"runtimePolicyScope",
-		"routerAbNormalSigning"
-	], responseName);
-	const publicResult = parseWalletEd25519YaoSignerPublicResult({
-		signerSlot: ed25519.signerSlot,
-		nearAccountId: ed25519.nearAccountId,
-		nearEd25519SigningKeyId: ed25519.nearEd25519SigningKeyId,
-		publicKey: ed25519.publicKey,
-		relayerKeyId: ed25519.relayerKeyId,
-		keyVersion: ed25519.keyVersion,
-		recoveryExportCapable: ed25519.recoveryExportCapable,
-		participantIds: ed25519.participantIds
-	}, responseName);
-	const thresholdSessionId = parseThresholdEd25519SessionId(ed25519.thresholdSessionId);
-	if (!thresholdSessionId.ok) throw new Error(`${responseName} response has invalid ed25519.thresholdSessionId`);
-	const runtimePolicyScope = normalizeThresholdRuntimePolicyScope(ed25519.runtimePolicyScope);
-	if (!runtimePolicyScope) throw new Error(`${responseName} response has invalid ed25519.runtimePolicyScope`);
-	return {
-		...publicResult,
-		thresholdSessionId: thresholdSessionId.value,
-		runtimePolicyScope,
-		routerAbNormalSigning: requireRouterAbEd25519NormalSigningState(ed25519.routerAbNormalSigning)
-	};
-}
-function parseWalletAddSignerChainTarget(value, responseName) {
-	const target = requireResponseRecord({
-		responseName,
-		field: "chainTarget",
-		value
-	});
-	switch (target.kind) {
-		case "evm":
-			assertExactResponseKeys(target, [
-				"kind",
-				"namespace",
-				"chainId",
-				"networkSlug"
-			], responseName);
-			return thresholdEcdsaChainTargetFromRequest(target);
-		case "tempo":
-			assertExactResponseKeys(target, [
-				"kind",
-				"chainId",
-				"networkSlug"
-			], responseName);
-			return thresholdEcdsaChainTargetFromRequest(target);
-		default: throw new Error(`${responseName} response has invalid chainTarget kind`);
-	}
-}
-function parseWalletAddSignerEcdsaWalletKey(value, responseName) {
-	const key = requireResponseRecord({
-		responseName,
-		field: "ecdsa.walletKeys[]",
-		value
-	});
-	assertExactResponseKeys(key, [
-		"keyScope",
-		"chainTarget",
-		"walletId",
-		"evmFamilySigningKeySlotId",
-		"keyHandle",
-		"ecdsaThresholdKeyId",
-		"signingRootId",
-		"signingRootVersion",
-		"thresholdEcdsaPublicKeyB64u",
-		"thresholdOwnerAddress",
-		"relayerKeyId",
-		"relayerVerifyingShareB64u",
-		"contextBinding32B64u",
-		"derivationClientSharePublicKey33B64u",
-		"clientShareRetryCounter",
-		"relayerShareRetryCounter",
-		"participantIds",
-		"publicCapability"
-	], responseName);
-	if (key.keyScope !== "evm-family") throw new Error(`${responseName} response has invalid keyScope`);
-	return {
-		keyScope: "evm-family",
-		chainTarget: parseWalletAddSignerChainTarget(key.chainTarget, responseName),
-		walletId: requireResponseString({
-			responseName,
-			field: "walletId",
-			value: key.walletId
-		}),
-		evmFamilySigningKeySlotId: requireResponseString({
-			responseName,
-			field: "evmFamilySigningKeySlotId",
-			value: key.evmFamilySigningKeySlotId
-		}),
-		keyHandle: requireResponseString({
-			responseName,
-			field: "keyHandle",
-			value: key.keyHandle
-		}),
-		ecdsaThresholdKeyId: requireResponseString({
-			responseName,
-			field: "ecdsaThresholdKeyId",
-			value: key.ecdsaThresholdKeyId
-		}),
-		signingRootId: requireResponseString({
-			responseName,
-			field: "signingRootId",
-			value: key.signingRootId
-		}),
-		signingRootVersion: requireResponseString({
-			responseName,
-			field: "signingRootVersion",
-			value: key.signingRootVersion
-		}),
-		thresholdEcdsaPublicKeyB64u: requireResponseString({
-			responseName,
-			field: "thresholdEcdsaPublicKeyB64u",
-			value: key.thresholdEcdsaPublicKeyB64u
-		}),
-		thresholdOwnerAddress: requireResponseString({
-			responseName,
-			field: "thresholdOwnerAddress",
-			value: key.thresholdOwnerAddress
-		}),
-		relayerKeyId: requireResponseString({
-			responseName,
-			field: "relayerKeyId",
-			value: key.relayerKeyId
-		}),
-		relayerVerifyingShareB64u: requireResponseString({
-			responseName,
-			field: "relayerVerifyingShareB64u",
-			value: key.relayerVerifyingShareB64u
-		}),
-		contextBinding32B64u: requireResponseString({
-			responseName,
-			field: "contextBinding32B64u",
-			value: key.contextBinding32B64u
-		}),
-		derivationClientSharePublicKey33B64u: requireResponseString({
-			responseName,
-			field: "derivationClientSharePublicKey33B64u",
-			value: key.derivationClientSharePublicKey33B64u
-		}),
-		clientShareRetryCounter: requireResponseSafeInteger({
-			responseName,
-			field: "clientShareRetryCounter",
-			value: key.clientShareRetryCounter,
-			minimum: 0
-		}),
-		relayerShareRetryCounter: requireResponseSafeInteger({
-			responseName,
-			field: "relayerShareRetryCounter",
-			value: key.relayerShareRetryCounter,
-			minimum: 0
-		}),
-		participantIds: requireResponseParticipantPair(key.participantIds, responseName),
-		publicCapability: parseRouterAbEcdsaDerivationPublicCapabilityV1(key.publicCapability)
-	};
-}
-function parseWalletRegistrationRouteTimingName(value) {
-	switch (value) {
-		case "registrationIntentLoadMs":
-		case "registrationIntentDigestMs":
-		case "registrationIntentConsumeMs":
-		case "registrationAttemptGateMs":
-		case "registrationPreparationPersistMs":
-		case "registrationPreparationLoadMs":
-		case "registrationPreparationConsumeMs":
-		case "registrationPreparationScopeCheckMs":
-		case "registrationAuthorityVerifyMs":
-		case "registrationEcdsaPrepareMs":
-		case "registrationCeremonyPersistMs":
-		case "registerPrepareTotalMs":
-		case "registerStartTotalMs":
-		case "registrationEcdsaRespondMs":
-		case "registrationFinalizeReplayLoadMs":
-		case "registrationCeremonyLoadMs":
-		case "registrationEcdsaBootstrapVerifyMs":
-		case "sponsoredNearAccountCreateMs":
-		case "registrationKeygenMs":
-		case "registrationEmailOtpEnrollmentPlanMs":
-		case "relaySessionMintMs":
-		case "relayGoogleEmailOtpActivationPlanMs":
-		case "relayPersistenceMs":
-		case "registrationFinalizeReplayCacheMs":
-		case "registerFinalizeTotalMs": return value;
-		default: throw new Error("Wallet registration finalize response has invalid diagnostics timing name");
-	}
-}
-function parseWalletRegistrationFinalizeDiagnostics(value) {
-	const responseName = "Wallet registration finalize";
-	const diagnostics = requireResponseRecord({
-		responseName,
-		field: "registrationDiagnostics",
-		value
-	});
-	assertExactResponseKeys(diagnostics, [
-		"kind",
-		"route",
-		"entries"
-	], responseName);
-	if (diagnostics.kind !== "wallet_registration_route_diagnostics_v1" || diagnostics.route !== "wallets_register_finalize" || !Array.isArray(diagnostics.entries)) throw new Error(`${responseName} response has invalid registrationDiagnostics`);
-	return {
-		kind: "wallet_registration_route_diagnostics_v1",
-		route: "wallets_register_finalize",
-		entries: diagnostics.entries.map((entryValue) => {
-			const entry = requireResponseRecord({
-				responseName,
-				field: "registrationDiagnostics.entries[]",
-				value: entryValue
-			});
-			assertExactResponseKeys(entry, ["name", "durationMs"], responseName);
-			if (typeof entry.durationMs !== "number" || !Number.isFinite(entry.durationMs) || entry.durationMs < 0) throw new Error(`${responseName} response has invalid diagnostics durationMs`);
-			return {
-				name: parseWalletRegistrationRouteTimingName(entry.name),
-				durationMs: entry.durationMs
-			};
-		})
-	};
-}
-function parseWalletRegistrationFinalizeAuthority(value) {
-	const responseName = "Wallet registration finalize";
-	const authority = requireResponseRecord({
-		responseName,
-		field: "authority",
-		value
-	});
-	assertExactResponseKeys(authority, [
-		"walletId",
-		"factor",
-		"verifier",
-		"bindingId"
-	], responseName);
-	const factor = requireResponseRecord({
-		responseName,
-		field: "authority.factor",
-		value: authority.factor
-	});
-	const verifier = requireResponseRecord({
-		responseName,
-		field: "authority.verifier",
-		value: authority.verifier
-	});
-	switch (factor.kind) {
-		case "passkey":
-			assertExactResponseKeys(factor, ["kind", "credentialIdB64u"], responseName);
-			assertExactResponseKeys(verifier, ["kind", "rpId"], responseName);
-			break;
-		case "email_otp":
-			assertExactResponseKeys(factor, [
-				"kind",
-				"provider",
-				"providerUserId"
-			], responseName);
-			assertExactResponseKeys(verifier, ["kind", "emailHashHex"], responseName);
-			break;
-		default: throw new Error(`${responseName} response has invalid authority factor`);
-	}
-	const parsed = parseWalletAuthAuthority(authority);
-	if (!parsed) throw new Error(`${responseName} response has invalid authority`);
-	return parsed;
-}
-function parseWalletRegistrationFinalizeAuthorityBranch(args) {
-	const responseName = "Wallet registration finalize";
-	const authMethod = requireResponseRecord({
-		responseName,
-		field: "authMethod",
-		value: args.response.authMethod
-	});
-	if (String(args.authority.walletId) !== String(args.walletId)) throw new Error(`${responseName} response authority wallet mismatch`);
-	switch (authMethod.kind) {
-		case "passkey": {
-			assertExactResponseKeys(authMethod, [
-				"kind",
-				"credentialIdB64u",
-				"credentialPublicKeyB64u"
-			], responseName);
-			if (!isPasskeyWalletAuthAuthority(args.authority)) throw new Error(`${responseName} response has inconsistent passkey authority`);
-			const rpId = requireResponseRpId(args.response.rpId, responseName);
-			const credentialIdB64u = requireResponseString({
-				responseName,
-				field: "authMethod.credentialIdB64u",
-				value: authMethod.credentialIdB64u
-			});
-			if (String(args.authority.factor.credentialIdB64u) !== credentialIdB64u || String(args.authority.verifier.rpId) !== String(rpId)) throw new Error(`${responseName} response passkey authority binding mismatch`);
-			return {
-				kind: "passkey",
-				rpId,
-				authMethod: {
-					kind: "passkey",
-					credentialIdB64u,
-					credentialPublicKeyB64u: requireResponseString({
-						responseName,
-						field: "authMethod.credentialPublicKeyB64u",
-						value: authMethod.credentialPublicKeyB64u
-					})
-				}
-			};
-		}
-		case "email_otp":
-			assertExactResponseKeys(authMethod, ["kind", "registrationAuthorityId"], responseName);
-			if (isPasskeyWalletAuthAuthority(args.authority) || args.response.rpId !== void 0) throw new Error(`${responseName} response has inconsistent email OTP authority`);
-			return {
-				kind: "email_otp",
-				authMethod: {
-					kind: "email_otp",
-					registrationAuthorityId: requireResponseString({
-						responseName,
-						field: "authMethod.registrationAuthorityId",
-						value: authMethod.registrationAuthorityId
-					})
-				}
-			};
-		default: throw new Error(`${responseName} response has invalid authMethod`);
-	}
-}
-function parseWalletRegistrationNearAccountProvisioning(value) {
-	const responseName = "Wallet registration finalize";
-	const provisioning = requireResponseRecord({
-		responseName,
-		field: "accountProvisioning",
-		value
-	});
-	switch (provisioning.kind) {
-		case "implicit_account":
-			assertExactResponseKeys(provisioning, ["kind", "accountIdSource"], responseName);
-			if (provisioning.accountIdSource !== "ed25519_public_key") throw new Error(`${responseName} response has invalid implicit account provisioning`);
-			return {
-				kind: "implicit_account",
-				accountIdSource: "ed25519_public_key"
-			};
-		case "sponsored_named_account": {
-			assertExactResponseKeys(provisioning, [
-				"kind",
-				"requestedAccountId",
-				"sponsor"
-			], responseName);
-			const requestedAccountId = parseNamedNearAccountId(provisioning.requestedAccountId);
-			if (!requestedAccountId.ok || provisioning.sponsor !== "relayer") throw new Error(`${responseName} response has invalid named account provisioning`);
-			return {
-				kind: "sponsored_named_account",
-				requestedAccountId: requestedAccountId.value,
-				sponsor: "relayer"
-			};
-		}
-		default: throw new Error(`${responseName} response has invalid accountProvisioning kind`);
-	}
-}
-function parseWalletRegistrationResolvedNearAccount(value) {
-	const responseName = "Wallet registration finalize";
-	const resolved = requireResponseRecord({
-		responseName,
-		field: "resolvedAccount",
-		value
-	});
-	switch (resolved.kind) {
-		case "implicit_account": {
-			assertExactResponseKeys(resolved, [
-				"kind",
-				"nearAccountId",
-				"nearEd25519SigningKeyId"
-			], responseName);
-			const nearAccountId = parseImplicitNearAccountId(resolved.nearAccountId);
-			if (!nearAccountId.ok) throw new Error(`${responseName} response has invalid implicit nearAccountId`);
-			return {
-				kind: "implicit_account",
-				nearAccountId: nearAccountId.value,
-				nearEd25519SigningKeyId: parseNearEd25519SigningKeyId(resolved.nearEd25519SigningKeyId)
-			};
-		}
-		case "sponsored_named_account": {
-			assertExactResponseKeys(resolved, [
-				"kind",
-				"nearAccountId",
-				"nearEd25519SigningKeyId",
-				"transactionHash"
-			], responseName);
-			const nearAccountId = parseNamedNearAccountId(resolved.nearAccountId);
-			if (!nearAccountId.ok) throw new Error(`${responseName} response has invalid named nearAccountId`);
-			return {
-				kind: "sponsored_named_account",
-				nearAccountId: nearAccountId.value,
-				nearEd25519SigningKeyId: parseNearEd25519SigningKeyId(resolved.nearEd25519SigningKeyId),
-				transactionHash: requireResponseString({
-					responseName,
-					field: "resolvedAccount.transactionHash",
-					value: resolved.transactionHash
-				})
-			};
-		}
-		default: throw new Error(`${responseName} response has invalid resolvedAccount kind`);
-	}
-}
-function parseWalletRegistrationFinalizeEcdsaResult(args) {
-	const responseName = "Wallet registration finalize";
-	const ecdsa = requireResponseRecord({
-		responseName,
-		field: "ecdsa",
-		value: args.value
-	});
-	assertExactResponseKeys(ecdsa, ["walletKeys"], responseName);
-	if (!Array.isArray(ecdsa.walletKeys) || ecdsa.walletKeys.length === 0) throw new Error(`${responseName} response has invalid walletKeys`);
-	const targetKeys = /* @__PURE__ */ new Set();
-	return { walletKeys: ecdsa.walletKeys.map((value) => {
-		const walletKey = parseWalletAddSignerEcdsaWalletKey(value, responseName);
-		if (walletKey.walletId !== String(args.walletId)) throw new Error(`${responseName} response ECDSA walletId mismatch`);
-		if (String(walletKey.publicCapability.client_id) !== String(args.walletId) || walletKey.publicCapability.public_identity.context_binding_b64u !== walletKey.contextBinding32B64u || walletKey.publicCapability.public_identity.derivation_client_share_public_key33_b64u !== walletKey.derivationClientSharePublicKey33B64u || walletKey.publicCapability.public_identity.threshold_public_key33_b64u !== walletKey.thresholdEcdsaPublicKeyB64u || walletKey.publicCapability.public_identity.client_share_retry_counter !== walletKey.clientShareRetryCounter || walletKey.publicCapability.public_identity.server_share_retry_counter !== walletKey.relayerShareRetryCounter) throw new Error(`${responseName} response ECDSA public capability mismatch`);
-		const targetKey = thresholdEcdsaChainTargetKey(walletKey.chainTarget);
-		if (targetKeys.has(targetKey)) throw new Error(`${responseName} response has duplicate ECDSA target ${targetKey}`);
-		targetKeys.add(targetKey);
-		return walletKey;
-	}) };
-}
-function parseWalletRegistrationFinalizeNearResult(args) {
-	const responseName = "Wallet registration finalize";
-	const authorityScope = parseWalletRegistrationEd25519AuthorityScope(args.response.authorityScope, responseName);
-	const accountProvisioning = parseWalletRegistrationNearAccountProvisioning(args.response.accountProvisioning);
-	const resolvedAccount = parseWalletRegistrationResolvedNearAccount(args.response.resolvedAccount);
-	const ed25519 = parseWalletRegistrationEd25519Result(args.response.ed25519, responseName);
-	if (accountProvisioning.kind !== resolvedAccount.kind || resolvedAccount.nearAccountId !== ed25519.nearAccountId || resolvedAccount.nearEd25519SigningKeyId !== ed25519.nearEd25519SigningKeyId) throw new Error(`${responseName} response has inconsistent Ed25519 identity`);
-	if (authorityScope.kind === "passkey_rp" && (!isPasskeyWalletAuthAuthority(args.authority) || String(args.authority.verifier.rpId) !== String(authorityScope.rpId)) || authorityScope.kind === "email_otp" && (isPasskeyWalletAuthAuthority(args.authority) || args.authority.factor.provider !== authorityScope.provider || String(args.authority.factor.providerUserId) !== authorityScope.providerUserId)) throw new Error(`${responseName} response authorityScope mismatch`);
-	return {
-		authorityScope,
-		accountProvisioning,
-		resolvedAccount,
-		ed25519
-	};
-}
-function parseWalletRegistrationFinalizeResponse(args) {
-	const responseName = "Wallet registration finalize";
-	const response = requireResponseRecord({
-		responseName,
-		field: "body",
-		value: args.value
-	});
-	assertExactResponseKeys(response, [
-		"ok",
-		"walletId",
-		"authority",
-		"foundingAuthority",
-		"foundingAuthMethod",
-		"registrationDiagnostics",
-		"rpId",
-		"authMethod",
-		"walletCustody",
-		"custodyKeyManifestDigestB64u",
-		"kind",
-		"authorityScope",
-		"accountProvisioning",
-		"resolvedAccount",
-		"ed25519",
-		"ecdsa"
-	], responseName);
-	if (response.ok !== true || response.kind !== args.expectedKind) throw new Error(`${responseName} response substituted signer branch`);
-	const walletId = walletIdFromString(requireResponseString({
-		responseName,
-		field: "walletId",
-		value: response.walletId
-	}));
-	const authority = parseWalletRegistrationFinalizeAuthority(response.authority);
-	const foundingAuthority = parseWalletAuthorityV1(response.foundingAuthority);
-	const foundingAuthMethod = parseWalletAuthMethodRecordV2(response.foundingAuthMethod);
-	if (!foundingAuthority.ok) throw new Error(`${responseName} response has an invalid founding authority: ${foundingAuthority.error.message}`);
-	if (foundingAuthority.value.state !== "active") throw new Error(`${responseName} response has an inactive founding authority`);
-	if (!foundingAuthMethod) throw new Error(`${responseName} response has an invalid founding auth method`);
-	if (foundingAuthMethod.status !== "active") throw new Error(`${responseName} response has an inactive founding auth method`);
-	if (foundingAuthority.value.walletId !== walletId || foundingAuthMethod.walletId !== walletId) throw new Error(`${responseName} response changed the founding wallet identity`);
-	if (foundingAuthMethod.walletAuthorityId !== foundingAuthority.value.authorityId) throw new Error(`${responseName} response has mismatched founding authority identities`);
-	if (foundingAuthMethod.walletAuthMethodId !== authority.bindingId) throw new Error(`${responseName} response has mismatched founding auth-method identities`);
-	const authorityBranch = parseWalletRegistrationFinalizeAuthorityBranch({
-		response,
-		walletId,
-		authority
-	});
-	const registrationDiagnostics = response.registrationDiagnostics === void 0 ? void 0 : parseWalletRegistrationFinalizeDiagnostics(response.registrationDiagnostics);
-	const walletCustody = response.walletCustody === void 0 ? {} : { walletCustody: parseWalletCustodyRegistrationOutcome(response.walletCustody, responseName) };
-	const custodyKeyManifestDigestB64u = response.custodyKeyManifestDigestB64u === void 0 ? void 0 : requireResponseString({
-		responseName,
-		field: "custodyKeyManifestDigestB64u",
-		value: response.custodyKeyManifestDigestB64u
-	});
-	if (custodyKeyManifestDigestB64u !== void 0 && base64UrlDecode(custodyKeyManifestDigestB64u).byteLength !== 32) throw new Error(`${responseName} response has invalid custodyKeyManifestDigestB64u`);
-	const manifest = custodyKeyManifestDigestB64u === void 0 ? {} : { custodyKeyManifestDigestB64u };
-	switch (response.kind) {
-		case "near_ed25519": {
-			if (response.ecdsa !== void 0) throw new Error(`${responseName} response mixed signer branches`);
-			const near = parseWalletRegistrationFinalizeNearResult({
-				response,
-				authority
-			});
-			if (authorityBranch.kind === "passkey") return {
-				ok: true,
-				walletId,
-				authority,
-				foundingAuthority: foundingAuthority.value,
-				foundingAuthMethod,
-				...registrationDiagnostics ? { registrationDiagnostics } : {},
-				...walletCustody,
-				...manifest,
-				rpId: authorityBranch.rpId,
-				authMethod: authorityBranch.authMethod,
-				kind: "near_ed25519",
-				authorityScope: near.authorityScope,
-				accountProvisioning: near.accountProvisioning,
-				resolvedAccount: near.resolvedAccount,
-				ed25519: near.ed25519
-			};
-			return {
-				ok: true,
-				walletId,
-				authority,
-				foundingAuthority: foundingAuthority.value,
-				foundingAuthMethod,
-				...registrationDiagnostics ? { registrationDiagnostics } : {},
-				...walletCustody,
-				...manifest,
-				authMethod: authorityBranch.authMethod,
-				kind: "near_ed25519",
-				authorityScope: near.authorityScope,
-				accountProvisioning: near.accountProvisioning,
-				resolvedAccount: near.resolvedAccount,
-				ed25519: near.ed25519
-			};
-		}
-		case "evm_family_ecdsa": {
-			if (response.authorityScope !== void 0 || response.accountProvisioning !== void 0 || response.resolvedAccount !== void 0 || response.ed25519 !== void 0) throw new Error(`${responseName} response mixed signer branches`);
-			const ecdsa = parseWalletRegistrationFinalizeEcdsaResult({
-				value: response.ecdsa,
-				walletId
-			});
-			if (authorityBranch.kind === "passkey") return {
-				ok: true,
-				walletId,
-				authority,
-				foundingAuthority: foundingAuthority.value,
-				foundingAuthMethod,
-				...registrationDiagnostics ? { registrationDiagnostics } : {},
-				...walletCustody,
-				...manifest,
-				rpId: authorityBranch.rpId,
-				authMethod: authorityBranch.authMethod,
-				kind: "evm_family_ecdsa",
-				ecdsa
-			};
-			return {
-				ok: true,
-				walletId,
-				authority,
-				foundingAuthority: foundingAuthority.value,
-				foundingAuthMethod,
-				...registrationDiagnostics ? { registrationDiagnostics } : {},
-				...walletCustody,
-				...manifest,
-				authMethod: authorityBranch.authMethod,
-				kind: "evm_family_ecdsa",
-				ecdsa
-			};
-		}
-		default: throw new Error(`${responseName} response has invalid kind`);
-	}
-}
-//#endregion
-export { parseWalletAddSignerChainTarget, parseWalletAddSignerEcdsaWalletKey, parseWalletEd25519YaoSignerPublicResult, parseWalletRegistrationFinalizeAuthority, parseWalletRegistrationFinalizeAuthorityBranch, parseWalletRegistrationFinalizeDiagnostics, parseWalletRegistrationFinalizeResponse, requireResponseParticipantPair, requireResponseRpId, requireResponseSafeInteger, requireResponseString };
-
-//# sourceMappingURL=walletRegistrationTerminalResponse.js.map