@seams/wallet 0.8.0 → 0.9.0

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

@@ -1,199 +1,10 @@
 import { parseWalletId } from "./domainIds.js";
-import { base64UrlEncode } from "./base64.js";
-import { alphabetizeStringify, sha256BytesUtf8 } from "./digests.js";
 //#region ../shared-ts/src/utils/registrationIds.ts
 function walletIdFromString(value) {
 	const parsed = parseWalletId(value);
 	if (!parsed.ok) throw new Error(parsed.error.message);
 	return parsed.value;
 }
-const SERVER_ALLOCATED_WALLET_ADJECTIVES = [
-	"alpine",
-	"amber",
-	"azure",
-	"brisk",
-	"bright",
-	"calm",
-	"cedar",
-	"cobalt",
-	"copper",
-	"coral",
-	"crimson",
-	"crystal",
-	"dawn",
-	"deep",
-	"dusky",
-	"evergreen",
-	"fair",
-	"fern",
-	"frost",
-	"gentle",
-	"glacier",
-	"glowing",
-	"golden",
-	"harbor",
-	"humble",
-	"indigo",
-	"ivory",
-	"jade",
-	"keen",
-	"lunar",
-	"maple",
-	"misty",
-	"mossy",
-	"noble",
-	"ocean",
-	"opal",
-	"polar",
-	"quiet",
-	"rapid",
-	"redwood",
-	"river",
-	"royal",
-	"sage",
-	"scarlet",
-	"serene",
-	"silver",
-	"solar",
-	"steady",
-	"stone",
-	"swift",
-	"tranquil",
-	"twilight",
-	"umber",
-	"verdant",
-	"vibrant",
-	"violet",
-	"vivid",
-	"warm",
-	"wild",
-	"willow",
-	"winter",
-	"woodland",
-	"young",
-	"zephyr"
-];
-const SERVER_ALLOCATED_WALLET_NOUNS = [
-	"anchor",
-	"arbor",
-	"atlas",
-	"aurora",
-	"badger",
-	"beacon",
-	"bloom",
-	"brook",
-	"canyon",
-	"cascade",
-	"comet",
-	"cove",
-	"crane",
-	"delta",
-	"dune",
-	"eagle",
-	"ember",
-	"falcon",
-	"feather",
-	"fjord",
-	"forest",
-	"galaxy",
-	"garden",
-	"giant",
-	"grove",
-	"harvest",
-	"heron",
-	"horizon",
-	"island",
-	"lagoon",
-	"lantern",
-	"lark",
-	"meadow",
-	"meteor",
-	"monolith",
-	"nebula",
-	"oasis",
-	"orchid",
-	"otter",
-	"peak",
-	"pebble",
-	"phoenix",
-	"pine",
-	"prism",
-	"quartz",
-	"raven",
-	"reef",
-	"ridge",
-	"sable",
-	"sequoia",
-	"shore",
-	"solstice",
-	"sparrow",
-	"star",
-	"summit",
-	"tempo",
-	"thunder",
-	"tundra",
-	"valley",
-	"vermillion",
-	"voyage",
-	"wave",
-	"wren",
-	"zenith"
-];
-const SERVER_ALLOCATED_WALLET_SUFFIX_ALPHABET = "23456789abcdefghjkmnpqrstuvwxyz";
-const SERVER_ALLOCATED_WALLET_ID_PATTERN = /^([a-z]+)-([a-z]+)-([a-z0-9]{6})$/;
-const SERVER_ALLOCATED_WALLET_ADJECTIVE_SET = new Set(SERVER_ALLOCATED_WALLET_ADJECTIVES);
-const SERVER_ALLOCATED_WALLET_NOUN_SET = new Set(SERVER_ALLOCATED_WALLET_NOUNS);
-function createServerAllocatedWalletId() {
-	return requireServerAllocatedWalletId([
-		randomServerAllocatedWalletWord(SERVER_ALLOCATED_WALLET_ADJECTIVES),
-		randomServerAllocatedWalletWord(SERVER_ALLOCATED_WALLET_NOUNS),
-		randomServerAllocatedWalletSuffix(6)
-	].join("-"));
-}
-function parseServerAllocatedWalletId(raw) {
-	const parsed = parseWalletId(raw);
-	if (!parsed.ok) return parsed;
-	const value = String(parsed.value);
-	const match = SERVER_ALLOCATED_WALLET_ID_PATTERN.exec(value);
-	const adjective = match?.[1] || "";
-	const noun = match?.[2] || "";
-	const suffix = match?.[3] || "";
-	if (!match || !SERVER_ALLOCATED_WALLET_ADJECTIVE_SET.has(adjective) || !SERVER_ALLOCATED_WALLET_NOUN_SET.has(noun) || !serverAllocatedWalletSuffixIsValid(suffix)) return {
-		ok: false,
-		error: { message: "server-allocated walletId must match the approved readable word-word-suffix allocation format" }
-	};
-	return {
-		ok: true,
-		value: parsed.value
-	};
-}
-function requireServerAllocatedWalletId(value) {
-	const parsed = parseServerAllocatedWalletId(value);
-	if (!parsed.ok) throw new Error(parsed.error.message);
-	return parsed.value;
-}
-function serverAllocatedRandomIndex(maxExclusive) {
-	if (!Number.isSafeInteger(maxExclusive) || maxExclusive <= 0 || maxExclusive > 256) throw new Error("Invalid server-allocated wallet random bound");
-	const limit = 256 - 256 % maxExclusive;
-	const byte = new Uint8Array(1);
-	for (;;) {
-		crypto.getRandomValues(byte);
-		if (byte[0] < limit) return byte[0] % maxExclusive;
-	}
-}
-function randomServerAllocatedWalletWord(words) {
-	return words[serverAllocatedRandomIndex(words.length)];
-}
-function randomServerAllocatedWalletSuffix(length) {
-	let suffix = "";
-	for (let index = 0; index < length; index += 1) suffix += SERVER_ALLOCATED_WALLET_SUFFIX_ALPHABET[serverAllocatedRandomIndex(31)];
-	return suffix;
-}
-function serverAllocatedWalletSuffixIsValid(suffix) {
-	if (suffix.length !== 6) return false;
-	for (const character of suffix) if (!SERVER_ALLOCATED_WALLET_SUFFIX_ALPHABET.includes(character)) return false;
-	return true;
-}
 function nearEd25519SigningKeyIdFromString(value) {
 	const normalized = String(value || "").trim();
 	if (!normalized) throw new Error("nearEd25519SigningKeyId is required");
@@ -203,20 +14,7 @@ function parseNearEd25519SigningKeyId(value) {
 	if (typeof value !== "string") throw new Error("nearEd25519SigningKeyId must be a string");
 	return nearEd25519SigningKeyIdFromString(value);
 }
-async function computeAddSignerNearEd25519SigningKeyId(input) {
-	return nearEd25519SigningKeyIdFromString(`ed25519ks_${base64UrlEncode(await sha256BytesUtf8(alphabetizeStringify({
-		kind: input.kind,
-		walletId: String(input.walletId),
-		signingRootId: input.signingRootId,
-		signingRootVersion: input.signingRootVersion,
-		signerSlot: input.signerSlot,
-		participantIds: [...input.participantIds],
-		keyPurpose: input.keyPurpose,
-		keyVersion: input.keyVersion,
-		derivationVersion: input.derivationVersion
-	})))}`);
-}
 //#endregion
-export { computeAddSignerNearEd25519SigningKeyId, createServerAllocatedWalletId, nearEd25519SigningKeyIdFromString, parseNearEd25519SigningKeyId, walletIdFromString };
+export { nearEd25519SigningKeyIdFromString, parseNearEd25519SigningKeyId, walletIdFromString };
 
 //# sourceMappingURL=registrationIds.js.map

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

@@ -1,389 +1 @@
-import { parseWalletAuthMethodId, parseWalletAuthorityId, parseWalletId, parseWebAuthnRpId } from "./domainIds.js";
-import { base64UrlEncode } from "./base64.js";
-import { alphabetizeStringify, sha256BytesUtf8 } from "./digests.js";
-import { inspectRawObject, normalizeAddAuthMethodInput, trimString } from "./registrationAuthMethodInput.js";
-import { normalizeAddSignerSelection } from "./registrationSignerPlan.js";
-//#region ../shared-ts/src/utils/registrationIntent.ts
-function addAuthMethodIntentGrantFromString(value) {
-	return String(value || "").trim();
-}
-function addSignerIntentGrantFromString(value) {
-	return String(value || "").trim();
-}
-async function computeRegistrationIntentDigestB64u(intent) {
-	return base64UrlEncode(await sha256BytesUtf8(alphabetizeStringify(intent)));
-}
-async function computeAddAuthMethodIntentDigestB64u(intent) {
-	return base64UrlEncode(await sha256BytesUtf8(alphabetizeStringify(intent)));
-}
-function normalizeAddAuthMethodIntentCaller(raw) {
-	const record = inspectRawObject(raw);
-	if (!record || !("caller" in record)) return null;
-	const caller = trimString(record.caller);
-	if (caller === "linked_device_ceremony") {
-		if (Object.prototype.hasOwnProperty.call(record, "source")) return null;
-		return { caller: "linked_device_ceremony" };
-	}
-	if (caller !== "same_device_addition") return null;
-	const source = inspectRawObject("source" in record ? record.source : void 0);
-	if (!source) return null;
-	const walletAuthorityId = parseWalletAuthorityId("walletAuthorityId" in source ? source.walletAuthorityId : void 0);
-	const walletAuthMethodId = parseWalletAuthMethodId("walletAuthMethodId" in source ? source.walletAuthMethodId : void 0);
-	const walletSessionId = trimString("walletSessionId" in source ? source.walletSessionId : void 0);
-	const authorityDigestB64u = trimString("authorityDigestB64u" in source ? source.authorityDigestB64u : void 0);
-	const revocationEpoch = "revocationEpoch" in source ? source.revocationEpoch : void 0;
-	if (!walletAuthorityId.ok || !walletAuthMethodId.ok || !walletSessionId || !authorityDigestB64u || typeof revocationEpoch !== "number" || !Number.isSafeInteger(revocationEpoch) || revocationEpoch < 0) return null;
-	return {
-		caller: "same_device_addition",
-		source: {
-			walletAuthorityId: walletAuthorityId.value,
-			walletAuthMethodId: walletAuthMethodId.value,
-			walletSessionId,
-			authorityDigestB64u,
-			revocationEpoch
-		}
-	};
-}
-/** True when the two source claims name the same session on the same authority. */
-function sameAddAuthMethodIntentSourceV1(left, right) {
-	return left.walletAuthorityId === right.walletAuthorityId && left.walletAuthMethodId === right.walletAuthMethodId && left.walletSessionId === right.walletSessionId && left.authorityDigestB64u === right.authorityDigestB64u && left.revocationEpoch === right.revocationEpoch;
-}
-function exactRegistrationIntentObject(raw, label, requiredFields, optionalFields = []) {
-	const record = inspectRawObject(raw);
-	if (!record) throw new Error(label + " must be an object");
-	const allowedFields = new Set([...requiredFields, ...optionalFields]);
-	const actualFields = Object.keys(record);
-	if (actualFields.length < requiredFields.length || actualFields.length > allowedFields.size) throw new Error(label + " has invalid fields");
-	for (const field of requiredFields) if (!Object.prototype.hasOwnProperty.call(record, field)) throw new Error(label + "." + field + " is required");
-	for (const field of actualFields) if (!allowedFields.has(field)) throw new Error(label + " has invalid fields");
-	return record;
-}
-function readRegistrationIntentField(record, field, label) {
-	if (!Object.prototype.hasOwnProperty.call(record, field)) throw new Error(label + "." + field + " is required");
-	return Reflect.get(record, field);
-}
-function hasRegistrationIntentField(record, field) {
-	return Object.prototype.hasOwnProperty.call(record, field);
-}
-function readRegistrationIntentString(record, field, label) {
-	const value = readRegistrationIntentField(record, field, label);
-	if (typeof value !== "string" || value.length === 0 || value.trim() !== value) throw new Error(label + "." + field + " must be a non-empty canonical string");
-	return value;
-}
-function readRegistrationIntentSafeInteger(record, field, label, minimum) {
-	const value = readRegistrationIntentField(record, field, label);
-	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum) throw new Error(label + "." + field + " must be a safe integer");
-	return value;
-}
-function parseRegistrationIntentArray(value, label) {
-	if (!Array.isArray(value)) throw new Error(label + " must be an array");
-	return value;
-}
-function readRegistrationIntentParticipantIds(record, field, label) {
-	const values = parseRegistrationIntentArray(readRegistrationIntentField(record, field, label), label + "." + field);
-	if (values.length === 0) throw new Error(label + "." + field + " must not be empty");
-	const participantIds = [];
-	for (let index = 0; index < values.length; index += 1) {
-		const value = values[index];
-		if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) throw new Error(label + "." + field + "[" + index + "] must be a positive safe integer");
-		participantIds.push(value);
-	}
-	return participantIds;
-}
-function readOptionalRegistrationIntentString(record, field, label) {
-	return hasRegistrationIntentField(record, field) ? readRegistrationIntentString(record, field, label) : void 0;
-}
-function parseAddSignerIntentChainTargetV1(raw, label = "addSignerIntent.signerSelection.ecdsa.chainTarget") {
-	try {
-		const target = exactRegistrationIntentObject(raw, label, ["kind"], [
-			"namespace",
-			"chainId",
-			"networkSlug"
-		]);
-		switch (readRegistrationIntentString(target, "kind", label)) {
-			case "evm": {
-				const evm = exactRegistrationIntentObject(target, label, [
-					"kind",
-					"namespace",
-					"chainId"
-				], ["networkSlug"]);
-				if (readRegistrationIntentString(evm, "namespace", label) !== "eip155") return null;
-				const chainId = readRegistrationIntentSafeInteger(evm, "chainId", label, 1);
-				const networkSlug = readOptionalRegistrationIntentString(evm, "networkSlug", label);
-				return networkSlug === void 0 ? {
-					kind: "evm",
-					namespace: "eip155",
-					chainId
-				} : {
-					kind: "evm",
-					namespace: "eip155",
-					chainId,
-					networkSlug
-				};
-			}
-			case "tempo": {
-				const tempo = exactRegistrationIntentObject(target, label, ["kind", "chainId"], ["networkSlug"]);
-				const chainId = readRegistrationIntentSafeInteger(tempo, "chainId", label, 1);
-				const networkSlug = readOptionalRegistrationIntentString(tempo, "networkSlug", label);
-				return networkSlug === void 0 ? {
-					kind: "tempo",
-					chainId
-				} : {
-					kind: "tempo",
-					chainId,
-					networkSlug
-				};
-			}
-			default: return null;
-		}
-	} catch {
-		return null;
-	}
-}
-function parseAddSignerIntentSelectionV1(raw) {
-	const label = "addSignerIntent.signerSelection";
-	const selection = exactRegistrationIntentObject(raw, label, ["mode"], ["ed25519", "ecdsa"]);
-	switch (readRegistrationIntentString(selection, "mode", label)) {
-		case "ed25519": {
-			const ed25519 = exactRegistrationIntentObject(readRegistrationIntentField(exactRegistrationIntentObject(selection, label, ["mode", "ed25519"]), "ed25519", label), label + ".ed25519", [
-				"mode",
-				"signerSlot",
-				"participantIds",
-				"keyPurpose",
-				"keyVersion",
-				"derivationVersion"
-			]);
-			if (readRegistrationIntentString(ed25519, "mode", label + ".ed25519") !== "create_implicit_near_account") throw new Error(label + ".ed25519.mode is unsupported");
-			readRegistrationIntentSafeInteger(ed25519, "signerSlot", label + ".ed25519", 1);
-			readRegistrationIntentParticipantIds(ed25519, "participantIds", label + ".ed25519");
-			readRegistrationIntentString(ed25519, "keyPurpose", label + ".ed25519");
-			readRegistrationIntentString(ed25519, "keyVersion", label + ".ed25519");
-			readRegistrationIntentSafeInteger(ed25519, "derivationVersion", label + ".ed25519", 1);
-			break;
-		}
-		case "ecdsa": {
-			const ecdsa = exactRegistrationIntentObject(readRegistrationIntentField(exactRegistrationIntentObject(selection, label, ["mode", "ecdsa"]), "ecdsa", label), label + ".ecdsa", ["chainTargets", "participantIds"]);
-			const chainTargets = parseRegistrationIntentArray(readRegistrationIntentField(ecdsa, "chainTargets", label + ".ecdsa"), label + ".ecdsa.chainTargets");
-			if (chainTargets.length === 0) throw new Error(label + ".ecdsa.chainTargets must not be empty");
-			for (const chainTarget of chainTargets) if (!parseAddSignerIntentChainTargetV1(chainTarget)) throw new Error(label + ".ecdsa.chainTargets contains an invalid target");
-			readRegistrationIntentParticipantIds(ecdsa, "participantIds", label + ".ecdsa");
-			break;
-		}
-		default: throw new Error(label + ".mode is unsupported");
-	}
-	const normalized = normalizeAddSignerSelection(raw, { normalizeEcdsaChainTarget: parseAddSignerIntentChainTargetV1 });
-	if (!normalized.ok) throw new Error(normalized.message);
-	return normalized.value;
-}
-function parseAddAuthMethodInputV1(raw) {
-	const label = "addAuthMethodIntent.authMethod";
-	const authMethod = exactRegistrationIntentObject(raw, label, ["kind"], ["rpId", "email"]);
-	switch (readRegistrationIntentString(authMethod, "kind", label)) {
-		case "passkey": {
-			const rpId = parseWebAuthnRpId(readRegistrationIntentString(exactRegistrationIntentObject(authMethod, label, ["kind", "rpId"]), "rpId", label));
-			if (!rpId.ok) throw new Error(rpId.error.message);
-			break;
-		}
-		case "email_otp":
-			readRegistrationIntentString(exactRegistrationIntentObject(authMethod, label, ["kind", "email"]), "email", label);
-			break;
-		default: throw new Error(label + ".kind is unsupported");
-	}
-	const normalized = normalizeAddAuthMethodInput(raw);
-	if (!normalized) throw new Error(label + " is invalid");
-	return normalized;
-}
-function validateAddAuthMethodIntentSourceV1(raw) {
-	const label = "addAuthMethodIntent.source";
-	const source = exactRegistrationIntentObject(raw, label, [
-		"walletAuthorityId",
-		"walletAuthMethodId",
-		"walletSessionId",
-		"authorityDigestB64u",
-		"revocationEpoch"
-	]);
-	const walletAuthorityId = parseWalletAuthorityId(readRegistrationIntentString(source, "walletAuthorityId", label));
-	const walletAuthMethodId = parseWalletAuthMethodId(readRegistrationIntentString(source, "walletAuthMethodId", label));
-	if (!walletAuthorityId.ok || !walletAuthMethodId.ok) throw new Error(label + " has invalid identity");
-	readRegistrationIntentString(source, "walletSessionId", label);
-	readRegistrationIntentString(source, "authorityDigestB64u", label);
-	readRegistrationIntentSafeInteger(source, "revocationEpoch", label, 0);
-}
-function parseRegistrationIntentRuntimePolicyScopeV1(record, label) {
-	if (!hasRegistrationIntentField(record, "runtimePolicyScope")) return void 0;
-	const scopeLabel = label + ".runtimePolicyScope";
-	const scope = exactRegistrationIntentObject(readRegistrationIntentField(record, "runtimePolicyScope", label), scopeLabel, [
-		"orgId",
-		"projectId",
-		"envId"
-	], ["signingRootVersion"]);
-	const orgId = readRegistrationIntentString(scope, "orgId", scopeLabel);
-	const projectId = readRegistrationIntentString(scope, "projectId", scopeLabel);
-	const envId = readRegistrationIntentString(scope, "envId", scopeLabel);
-	const signingRootVersion = readOptionalRegistrationIntentString(scope, "signingRootVersion", scopeLabel);
-	return signingRootVersion === void 0 ? {
-		orgId,
-		projectId,
-		envId
-	} : {
-		orgId,
-		projectId,
-		envId,
-		signingRootVersion
-	};
-}
-function readRegistrationIntentWalletId(record, label) {
-	const result = parseWalletId(readRegistrationIntentString(record, "walletId", label));
-	if (!result.ok) throw new Error(result.error.message);
-	return result.value;
-}
-function readRegistrationIntentAuthMethodId(record, field, label) {
-	const result = parseWalletAuthMethodId(readRegistrationIntentString(record, field, label));
-	if (!result.ok) throw new Error(result.error.message);
-	return result.value;
-}
-function parseAddSignerIntentV1(raw) {
-	const label = "addSignerIntent";
-	const intent = exactRegistrationIntentObject(raw, label, [
-		"version",
-		"walletId",
-		"signerSelection",
-		"nonceB64u"
-	], ["runtimePolicyScope"]);
-	if (readRegistrationIntentString(intent, "version", label) !== "add_signer_intent_v1") throw new Error(label + ".version is unsupported");
-	const walletId = readRegistrationIntentWalletId(intent, label);
-	const runtimePolicyScope = parseRegistrationIntentRuntimePolicyScopeV1(intent, label);
-	const nonceB64u = readRegistrationIntentString(intent, "nonceB64u", label);
-	const signerSelection = parseAddSignerIntentSelectionV1(readRegistrationIntentField(intent, "signerSelection", label));
-	return runtimePolicyScope === void 0 ? {
-		version: "add_signer_intent_v1",
-		walletId,
-		signerSelection,
-		nonceB64u
-	} : {
-		version: "add_signer_intent_v1",
-		walletId,
-		signerSelection,
-		runtimePolicyScope,
-		nonceB64u
-	};
-}
-function parseAddAuthMethodIntentV1(raw) {
-	const label = "addAuthMethodIntent";
-	const intent = exactRegistrationIntentObject(raw, label, [
-		"version",
-		"walletId",
-		"authMethod",
-		"targetWalletAuthMethodId",
-		"caller",
-		"nonceB64u"
-	], ["runtimePolicyScope", "source"]);
-	if (readRegistrationIntentString(intent, "version", label) !== "add_auth_method_intent_v1") throw new Error(label + ".version is unsupported");
-	const walletId = readRegistrationIntentWalletId(intent, label);
-	const targetWalletAuthMethodId = readRegistrationIntentAuthMethodId(intent, "targetWalletAuthMethodId", label);
-	const authMethod = parseAddAuthMethodInputV1(readRegistrationIntentField(intent, "authMethod", label));
-	const runtimePolicyScope = parseRegistrationIntentRuntimePolicyScopeV1(intent, label);
-	const nonceB64u = readRegistrationIntentString(intent, "nonceB64u", label);
-	switch (readRegistrationIntentString(intent, "caller", label)) {
-		case "same_device_addition":
-			validateAddAuthMethodIntentSourceV1(readRegistrationIntentField(intent, "source", label));
-			break;
-		case "linked_device_ceremony":
-			if (hasRegistrationIntentField(intent, "source")) throw new Error(label + ".source is not valid for linked_device_ceremony");
-			break;
-		default: throw new Error(label + ".caller is unsupported");
-	}
-	const parsedCaller = normalizeAddAuthMethodIntentCaller(intent);
-	if (!parsedCaller) throw new Error(label + ".caller is invalid");
-	const common = runtimePolicyScope === void 0 ? {
-		version: "add_auth_method_intent_v1",
-		walletId,
-		authMethod,
-		targetWalletAuthMethodId,
-		nonceB64u
-	} : {
-		version: "add_auth_method_intent_v1",
-		walletId,
-		authMethod,
-		targetWalletAuthMethodId,
-		runtimePolicyScope,
-		nonceB64u
-	};
-	switch (parsedCaller.caller) {
-		case "same_device_addition": return {
-			...common,
-			caller: parsedCaller.caller,
-			source: parsedCaller.source
-		};
-		case "linked_device_ceremony": return {
-			...common,
-			caller: parsedCaller.caller
-		};
-		default: return assertNeverAddAuthMethodIntentCaller(parsedCaller);
-	}
-}
-function assertNeverAddAuthMethodIntentCaller(value) {
-	throw new Error(`Unsupported add-auth-method intent caller: ${String(value)}`);
-}
-function sameRegistrationIntentNumberArray(left, right) {
-	if (left.length !== right.length) return false;
-	for (let index = 0; index < left.length; index += 1) if (!Number.isSafeInteger(left[index]) || left[index] !== right[index]) return false;
-	return true;
-}
-function sameAddSignerIntentChainTargetV1(left, right) {
-	switch (left.kind) {
-		case "evm": return right.kind === "evm" && left.namespace === right.namespace && left.chainId === right.chainId && left.networkSlug === right.networkSlug;
-		case "tempo": return right.kind === "tempo" && left.chainId === right.chainId && left.networkSlug === right.networkSlug;
-		default: return assertNeverThresholdEcdsaAddSignerChainTarget(left);
-	}
-}
-function assertNeverThresholdEcdsaAddSignerChainTarget(value) {
-	throw new Error(`Unsupported add-signer chain target: ${String(value)}`);
-}
-function sameAddSignerSelectionV1(left, right) {
-	if (left.mode !== right.mode) return false;
-	switch (left.mode) {
-		case "ed25519": return right.mode === "ed25519" && left.ed25519.mode === right.ed25519.mode && left.ed25519.signerSlot === right.ed25519.signerSlot && sameRegistrationIntentNumberArray(left.ed25519.participantIds, right.ed25519.participantIds) && left.ed25519.keyPurpose === right.ed25519.keyPurpose && left.ed25519.keyVersion === right.ed25519.keyVersion && left.ed25519.derivationVersion === right.ed25519.derivationVersion;
-		case "ecdsa":
-			if (right.mode !== "ecdsa" || left.ecdsa.chainTargets.length !== right.ecdsa.chainTargets.length) return false;
-			for (let index = 0; index < left.ecdsa.chainTargets.length; index += 1) if (!sameAddSignerIntentChainTargetV1(left.ecdsa.chainTargets[index], right.ecdsa.chainTargets[index])) return false;
-			return sameRegistrationIntentNumberArray(left.ecdsa.participantIds, right.ecdsa.participantIds);
-		default: return assertNeverAddSignerSelection(left);
-	}
-}
-function assertNeverAddSignerSelection(value) {
-	throw new Error(`Unsupported add-signer selection: ${String(value)}`);
-}
-function sameRegistrationIntentRuntimePolicyScope(left, right) {
-	if (left === void 0 || right === void 0) return left === right;
-	return left.orgId === right.orgId && left.projectId === right.projectId && left.envId === right.envId && left.signingRootVersion === right.signingRootVersion;
-}
-function sameAddSignerIntentV1(left, right) {
-	return left.version === right.version && left.walletId === right.walletId && sameAddSignerSelectionV1(left.signerSelection, right.signerSelection) && sameRegistrationIntentRuntimePolicyScope(left.runtimePolicyScope, right.runtimePolicyScope) && left.nonceB64u === right.nonceB64u;
-}
-function sameAddAuthMethodInputV1(left, right) {
-	if (left.kind !== right.kind) return false;
-	switch (left.kind) {
-		case "passkey": return right.kind === "passkey" && left.rpId === right.rpId;
-		case "email_otp": return right.kind === "email_otp" && left.email === right.email;
-		default: return assertNeverAddAuthMethodInput(left);
-	}
-}
-function assertNeverAddAuthMethodInput(value) {
-	throw new Error(`Unsupported add-auth-method input: ${String(value)}`);
-}
-function sameAddAuthMethodIntentV1(left, right) {
-	if (left.version !== right.version || left.walletId !== right.walletId || !sameAddAuthMethodInputV1(left.authMethod, right.authMethod) || left.targetWalletAuthMethodId !== right.targetWalletAuthMethodId || !sameRegistrationIntentRuntimePolicyScope(left.runtimePolicyScope, right.runtimePolicyScope) || left.nonceB64u !== right.nonceB64u) return false;
-	switch (left.caller) {
-		case "same_device_addition": return right.caller === "same_device_addition" && sameAddAuthMethodIntentSourceV1(left.source, right.source);
-		case "linked_device_ceremony": return right.caller === "linked_device_ceremony";
-		default: return assertNeverAddAuthMethodIntent(left);
-	}
-}
-function assertNeverAddAuthMethodIntent(value) {
-	throw new Error(`Unsupported add-auth-method intent: ${String(value)}`);
-}
-//#endregion
-export { addAuthMethodIntentGrantFromString, addSignerIntentGrantFromString, computeAddAuthMethodIntentDigestB64u, computeRegistrationIntentDigestB64u, normalizeAddAuthMethodIntentCaller, parseAddAuthMethodIntentV1, parseAddSignerIntentV1, sameAddAuthMethodIntentV1, sameAddSignerIntentV1 };
-
-//# sourceMappingURL=registrationIntent.js.map
+import "./registrationSignerPlan.js";