@seams/wallet-server 0.6.2 → 0.7.3

package/dist/esm/shared-ts/src/signing-lanes/rotationProtocolParsers.js

@@ -0,0 +1,323 @@
+import { parseEcdsaRelayerKeyId, parseEd25519YaoSuiteId, parseLaneOperationIdempotencyKey, parseThresholdEcdsaSessionId } from "../utils/domainIds.js";
+import { requireRecord } from "../utils/validation.js";
+import { exactRecord } from "../utils/exactRecord.js";
+import { wireLiteral, wireNonEmptyArray, wireObject, wireResult, wireUnion } from "../utils/wireSchema.js";
+import { parseEd25519PublicKeyB64u, parseKeyCreationSignerSlot, parseSecp256k1CompressedPublicKeyB64u } from "../passkey-custody/primitives.js";
+import { parseEvmFamilySigningKeySlotId } from "./evmFamilySigningKeySlotId.js";
+import { parseSdkEcdsaDerivationThresholdKeyId } from "../threshold/ecdsaDerivationRoleLocalBootstrap.js";
+import { parseEcdsaCapabilityManifestId, parseEcdsaCapabilityManifestRevision, parseEcdsaServerGeneration } from "../utils/ecdsaCapabilityActivation.js";
+import { parseNearEd25519SigningKeyId } from "../utils/registrationIds.js";
+import { parseHpkePublicKeyB64u, parseLaneCustodyBindingDigestB64u, parseLaneHolderCustodyBindingId, parseLaneHolderParticipantId, parseSigningWorkerParticipantId, parseSigningWorkerRecipientKeyDigestB64u, parseSigningWorkerRecipientKeyId } from "./participants.js";
+import { digest, digestString, laneEnrollmentId, laneOperationId, laneParticipantBindingDigest, laneShareEpoch, materialActivation, materialActivationId, parseAuthorization, parseLaneKind, requiredInteger, requiredString, signingLaneId, walletId, walletKeyId } from "./rotationWireFields.js";
+import { parseOwnerLaneParticipantContinuityV1 } from "./ownerContinuity.js";
+//#region ../shared-ts/src/signing-lanes/rotationProtocolParsers.ts
+const hpkePublicKey = /* @__PURE__ */ wireResult(parseHpkePublicKeyB64u);
+const hpkePublicKeyDigest = /* @__PURE__ */ wireResult(parseSigningWorkerRecipientKeyDigestB64u);
+const signingWorkerRecipientKeyId = /* @__PURE__ */ wireResult(parseSigningWorkerRecipientKeyId);
+const laneHolderParticipantId = /* @__PURE__ */ wireResult(parseLaneHolderParticipantId);
+const signingWorkerParticipantId = /* @__PURE__ */ wireResult(parseSigningWorkerParticipantId);
+const laneOperationIdempotencyKey = /* @__PURE__ */ wireResult(parseLaneOperationIdempotencyKey);
+const ed25519YaoSuiteId = /* @__PURE__ */ wireResult(parseEd25519YaoSuiteId);
+function sourceKind(expected) {
+	return (raw, label) => {
+		if (raw !== expected) throw new Error(`${label} must be ${expected}`);
+		return expected;
+	};
+}
+const participantBindingDigestString = laneParticipantBindingDigest;
+function ownerLaneProtocolSourceV1() {
+	return wireObject({
+		sourceKind: sourceKind("owner_registration"),
+		laneId: signingLaneId,
+		laneKind: wireLiteral("owner_passkey", "owner_email_otp"),
+		laneShareEpoch,
+		revocationEpoch: requiredInteger,
+		ownerParticipantContinuity: parseOwnerLaneParticipantContinuityV1,
+		participantBindingDigestB64u: participantBindingDigestString,
+		materialActivation
+	});
+}
+function provisionedLaneProtocolSourceV1() {
+	return wireObject({
+		sourceKind: sourceKind("provisioned_lane"),
+		laneId: signingLaneId,
+		laneKind: wireLiteral("linked_device", "delegated_execution", "recovery", "break_glass"),
+		laneShareEpoch,
+		revocationEpoch: requiredInteger,
+		holderParticipantId: laneHolderParticipantId,
+		signingWorkerParticipantId,
+		signingWorkerRecipientKeyId,
+		participantBindingDigestB64u: participantBindingDigestString,
+		materialActivation
+	});
+}
+function parseSource(raw, label) {
+	const record = requireRecord(raw, label);
+	const laneKind = parseLaneKind(record.laneKind, `${label}.laneKind`);
+	return laneKind === "owner_passkey" || laneKind === "owner_email_otp" ? ownerLaneProtocolSourceV1()(record, label) : provisionedLaneProtocolSourceV1()(record, label);
+}
+function laneTargetHolderV1() {
+	return wireObject({
+		participantId: laneHolderParticipantId,
+		participantBindingDigestB64u: laneParticipantBindingDigest,
+		custodyBindingId: wireResult(parseLaneHolderCustodyBindingId),
+		custodyBindingDigestB64u: wireResult(parseLaneCustodyBindingDigestB64u),
+		hpkePublicKeyB64u: hpkePublicKey,
+		hpkePublicKeyDigestB64u: hpkePublicKeyDigest
+	});
+}
+function laneTargetSigningWorkerV1() {
+	return wireObject({
+		participantId: signingWorkerParticipantId,
+		participantBindingDigestB64u: laneParticipantBindingDigest,
+		recipientKeyId: signingWorkerRecipientKeyId,
+		hpkePublicKeyB64u: hpkePublicKey,
+		hpkePublicKeyDigestB64u: hpkePublicKeyDigest
+	});
+}
+function buildLaneCreationTargetV1(args) {
+	return {
+		operation: "create_lane",
+		laneId: args.laneId,
+		laneKind: "linked_device",
+		laneShareEpoch: args.laneShareEpoch,
+		expectedTargetState: "absent"
+	};
+}
+function buildLaneRefreshTargetV1(args) {
+	return {
+		operation: "refresh_lane",
+		laneId: args.laneId,
+		laneKind: args.laneKind,
+		laneShareEpoch: args.laneShareEpoch,
+		expectedTargetState: "active_previous_epoch",
+		priorMaterialActivation: args.priorMaterialActivation
+	};
+}
+function parseTarget(raw, source, label) {
+	const record = requireRecord(raw, label);
+	if (record.operation === "create_lane") {
+		const value = exactRecord(record, [
+			"operation",
+			"laneId",
+			"laneKind",
+			"laneShareEpoch",
+			"expectedTargetState"
+		], label);
+		if (value.laneKind !== "linked_device" || value.expectedTargetState !== "absent") throw new Error(`${label} create branch has invalid target state`);
+		const target = buildLaneCreationTargetV1({
+			laneId: signingLaneId(value.laneId, `${label}.laneId`),
+			laneShareEpoch: laneShareEpoch(value.laneShareEpoch, `${label}.laneShareEpoch`)
+		});
+		if (source.laneKind === "linked_device" || source.laneKind === "delegated_execution") throw new Error(`${label} creation requires an owner-controlled source lane`);
+		if (String(target.laneId) === String(source.laneId)) throw new Error(`${label}.laneId must differ from source.laneId for creation`);
+		return target;
+	}
+	if (record.operation === "refresh_lane") {
+		const value = exactRecord(record, [
+			"operation",
+			"laneId",
+			"laneKind",
+			"laneShareEpoch",
+			"expectedTargetState",
+			"priorMaterialActivation"
+		], label);
+		if (value.expectedTargetState !== "active_previous_epoch") throw new Error(`${label} refresh branch has invalid target state`);
+		const laneId = signingLaneId(value.laneId, `${label}.laneId`);
+		if (String(laneId) !== String(source.laneId)) throw new Error(`${label}.laneId must match source.laneId for refresh`);
+		const shareEpoch = laneShareEpoch(value.laneShareEpoch, `${label}.laneShareEpoch`);
+		if (String(shareEpoch) === String(source.laneShareEpoch)) throw new Error(`${label}.laneShareEpoch must advance source.laneShareEpoch`);
+		const laneKind = parseLaneKind(value.laneKind, `${label}.laneKind`);
+		if (laneKind !== source.laneKind) throw new Error(`${label}.laneKind must match source.laneKind for refresh`);
+		if (laneKind !== "delegated_execution") return buildLaneRefreshTargetV1({
+			laneId,
+			laneKind,
+			laneShareEpoch: shareEpoch,
+			priorMaterialActivation: materialActivation(value.priorMaterialActivation, `${label}.priorMaterialActivation`)
+		});
+	}
+	throw new Error(`${label}.operation is invalid`);
+}
+function parseOperation(rawTarget, rawAuthorization, source, label) {
+	const target = parseTarget(rawTarget, source, `${label}.target`);
+	const authorization = parseAuthorization(rawAuthorization, `${label}.authorization`);
+	if (target.operation === "create_lane") {
+		if (authorization.kind !== "linked_device_enrollment") throw new Error(`${label}.authorization must be linked-device enrollment for creation`);
+		return {
+			target,
+			authorization
+		};
+	}
+	if (authorization.kind !== "owner_lane_refresh") throw new Error(`${label}.authorization must be owner refresh for refresh`);
+	return {
+		target,
+		authorization
+	};
+}
+function isParsedCreationOperation(value) {
+	return value.target.operation === "create_lane";
+}
+function parseCommonJob(record, label) {
+	const source = parseSource(record.source, `${label}.source`);
+	const targetHolder = laneTargetHolderV1()(record.targetHolder, `${label}.targetHolder`);
+	const targetSigningWorker = laneTargetSigningWorkerV1()(record.targetSigningWorker, `${label}.targetSigningWorker`);
+	const targetMaterialActivationId = materialActivationId(record.targetMaterialActivationId, `${label}.targetMaterialActivationId`);
+	if (String(targetMaterialActivationId) === String(source.materialActivation.activationId)) throw new Error(`${label}.targetMaterialActivationId must be fresh`);
+	if (record.protocolVersion !== "rotatable_signing_lane_protocol_v1") throw new Error(`${label}.protocolVersion is invalid`);
+	return {
+		operationId: laneOperationId(record.operationId, `${label}.operationId`),
+		enrollmentId: laneEnrollmentId(record.enrollmentId, `${label}.enrollmentId`),
+		idempotencyKey: laneOperationIdempotencyKey(record.idempotencyKey, `${label}.idempotencyKey`),
+		walletId: walletId(record.walletId, `${label}.walletId`),
+		walletKeyId: walletKeyId(record.walletKeyId, `${label}.walletKeyId`),
+		source,
+		targetHolder,
+		targetSigningWorker,
+		targetMaterialActivationId,
+		protocolVersion: "rotatable_signing_lane_protocol_v1",
+		expiresAtMs: requiredInteger(record.expiresAtMs, `${label}.expiresAtMs`)
+	};
+}
+function ecdsaSourceCapabilityBindingV1() {
+	return wireObject({
+		manifestId: parseEcdsaCapabilityManifestId,
+		manifestRevision: parseEcdsaCapabilityManifestRevision,
+		serverGeneration: parseEcdsaServerGeneration,
+		ecdsaThresholdKeyId: parseSdkEcdsaDerivationThresholdKeyId,
+		relayerKeyId: wireResult(parseEcdsaRelayerKeyId)
+	});
+}
+function thresholdEcdsaChainTarget() {
+	return wireUnion("kind", [wireObject({
+		kind: wireLiteral("evm"),
+		namespace: wireLiteral("eip155"),
+		chainId: requiredInteger,
+		networkSlug: requiredString
+	}), wireObject({
+		kind: wireLiteral("tempo"),
+		chainId: requiredInteger,
+		networkSlug: requiredString
+	})]);
+}
+function ecdsaTargetCapabilityBindingV1() {
+	return wireObject({
+		manifestId: parseEcdsaCapabilityManifestId,
+		manifestRevision: parseEcdsaCapabilityManifestRevision,
+		ecdsaThresholdKeyId: parseSdkEcdsaDerivationThresholdKeyId,
+		orderedThresholdSessions: wireNonEmptyArray(wireObject({
+			chainTarget: thresholdEcdsaChainTarget(),
+			thresholdSessionId: wireResult(parseThresholdEcdsaSessionId),
+			participantBindingDigestB64u: digestString
+		}))
+	});
+}
+const LANE_JOB_FIELDS = [
+	"kind",
+	"keyFamily",
+	"operationId",
+	"enrollmentId",
+	"idempotencyKey",
+	"walletId",
+	"walletKeyId",
+	"source",
+	"targetHolder",
+	"targetSigningWorker",
+	"targetMaterialActivationId",
+	"protocolVersion",
+	"expiresAtMs",
+	"target",
+	"authorization"
+];
+function parseEcdsaJob(record, label) {
+	const value = exactRecord(record, [
+		...LANE_JOB_FIELDS,
+		"evmFamilySigningKeySlotId",
+		"thresholdPublicKey33B64u",
+		"evmAddress",
+		"sourceCapability",
+		"targetCapability",
+		"sourceHolderVerifyingShare33B64u",
+		"sourceServerVerifyingShare33B64u",
+		"reshareChannelBindingDigestB64u",
+		"transcriptEncoding"
+	], label);
+	if (value.kind !== "ecdsa_additive_lane_job_v1" || value.keyFamily !== "ecdsa_secp256k1") throw new Error(`${label} kind/keyFamily is invalid`);
+	if (value.transcriptEncoding !== "ecdsa_additive_lane_transcript_v1") throw new Error(`${label}.transcriptEncoding is invalid`);
+	const common = parseCommonJob(value, label);
+	const operation = parseOperation(value.target, value.authorization, common.source, `${label}.operation`);
+	const curve = {
+		kind: "ecdsa_additive_lane_job_v1",
+		keyFamily: "ecdsa_secp256k1",
+		evmFamilySigningKeySlotId: (() => {
+			const parsed = parseEvmFamilySigningKeySlotId(value.evmFamilySigningKeySlotId);
+			if (parsed.ok) return parsed.value;
+			throw new Error(`${label}.evmFamilySigningKeySlotId is invalid`);
+		})(),
+		thresholdPublicKey33B64u: parseSecp256k1CompressedPublicKeyB64u(value.thresholdPublicKey33B64u),
+		evmAddress: requiredString(value.evmAddress, `${label}.evmAddress`),
+		sourceCapability: ecdsaSourceCapabilityBindingV1()(value.sourceCapability, `${label}.sourceCapability`),
+		targetCapability: ecdsaTargetCapabilityBindingV1()(value.targetCapability, `${label}.targetCapability`),
+		sourceHolderVerifyingShare33B64u: parseSecp256k1CompressedPublicKeyB64u(value.sourceHolderVerifyingShare33B64u, `${label}.sourceHolderVerifyingShare33B64u`),
+		sourceServerVerifyingShare33B64u: parseSecp256k1CompressedPublicKeyB64u(value.sourceServerVerifyingShare33B64u, `${label}.sourceServerVerifyingShare33B64u`),
+		reshareChannelBindingDigestB64u: digest(value.reshareChannelBindingDigestB64u, `${label}.reshareChannelBindingDigestB64u`),
+		transcriptEncoding: "ecdsa_additive_lane_transcript_v1"
+	};
+	return {
+		...common,
+		...operation,
+		...curve
+	};
+}
+function parseEdJob(record, label) {
+	const value = exactRecord(record, [
+		...LANE_JOB_FIELDS,
+		"yaoRequestKind",
+		"registeredPublicKeyB64u",
+		"nearEd25519SigningKeyId",
+		"keyCreationSignerSlot",
+		"stableContextBindingB64u",
+		"yaoSuiteId",
+		"circuitDigestB64u"
+	], label);
+	if (value.kind !== "ed25519_yao_lane_job_v1" || value.keyFamily !== "ed25519") throw new Error(`${label} kind/keyFamily is invalid`);
+	const common = parseCommonJob(value, label);
+	const operation = parseOperation(value.target, value.authorization, common.source, `${label}.operation`);
+	const yaoRequestKind = requiredString(value.yaoRequestKind, `${label}.yaoRequestKind`);
+	const curve = {
+		kind: "ed25519_yao_lane_job_v1",
+		keyFamily: "ed25519",
+		registeredPublicKeyB64u: parseEd25519PublicKeyB64u(value.registeredPublicKeyB64u),
+		nearEd25519SigningKeyId: parseNearEd25519SigningKeyId(value.nearEd25519SigningKeyId),
+		keyCreationSignerSlot: parseKeyCreationSignerSlot(value.keyCreationSignerSlot),
+		stableContextBindingB64u: digest(value.stableContextBindingB64u, `${label}.stableContextBindingB64u`),
+		yaoSuiteId: ed25519YaoSuiteId(value.yaoSuiteId, `${label}.yaoSuiteId`),
+		circuitDigestB64u: digest(value.circuitDigestB64u, `${label}.circuitDigestB64u`)
+	};
+	if (isParsedCreationOperation(operation)) {
+		if (yaoRequestKind !== "lane_provisioning") throw new Error(`${label}.yaoRequestKind must be lane_provisioning for creation`);
+		return {
+			...common,
+			...operation,
+			yaoRequestKind,
+			...curve
+		};
+	}
+	if (yaoRequestKind !== "lane_refresh") throw new Error(`${label}.yaoRequestKind must be lane_refresh for refresh`);
+	return {
+		...common,
+		...operation,
+		yaoRequestKind,
+		...curve
+	};
+}
+function parseRotatableSigningLaneJobV1(raw, label = "laneProtocolJob") {
+	const record = requireRecord(raw, label);
+	if (record.kind === "ed25519_yao_lane_job_v1") return parseEdJob(record, label);
+	if (record.kind === "ecdsa_additive_lane_job_v1") return parseEcdsaJob(record, label);
+	throw new Error(`${label}.kind is invalid`);
+}
+const parseLaneProtocolJobV1 = parseRotatableSigningLaneJobV1;
+//#endregion
+export { parseLaneProtocolJobV1, parseRotatableSigningLaneJobV1 };
+
+//# sourceMappingURL=rotationProtocolParsers.js.map

package/dist/esm/shared-ts/src/signing-lanes/rotationWireFields.js

@@ -0,0 +1,59 @@
+import { hasWhitespaceOrControlCharacters, parseLaneEnrollmentId, parseLaneOperationId, parseLaneShareEpoch, parseLinkedDeviceEnrollmentId, parseMpcMaterialActivationId, parseMpcMaterialActivationRef, parseSigningLaneId, parseWalletId, parseWalletKeyId } from "../utils/domainIds.js";
+import { parseAuthorizedOperationId } from "../authorization/capabilityKinds.js";
+import { parseDigestB64u } from "../utils/canonicalPrimitives.js";
+import { wireLabeled, wireLiteral, wireObject, wireResult, wireUnion } from "../utils/wireSchema.js";
+import { parseLaneParticipantBindingDigestB64u } from "./participants.js";
+//#region ../shared-ts/src/signing-lanes/rotationWireFields.ts
+function requiredString(raw, label) {
+	if (typeof raw !== "string") throw new Error(`${label} must be a string`);
+	const value = raw.trim();
+	if (!value) throw new Error(`${label} is required`);
+	if (hasWhitespaceOrControlCharacters(value)) throw new Error(`${label} must not contain whitespace or control characters`);
+	return value;
+}
+function requiredInteger(raw, label) {
+	if (!Number.isSafeInteger(raw) || Number(raw) < 0) throw new Error(`${label} must be a non-negative safe integer`);
+	return Number(raw);
+}
+function parseLaneKind(raw, label) {
+	switch (raw) {
+		case "owner_passkey":
+		case "owner_email_otp":
+		case "linked_device":
+		case "delegated_execution":
+		case "recovery":
+		case "break_glass": return raw;
+		default: throw new Error(`${label} must be a known signing lane kind`);
+	}
+}
+const laneOperationId = /* @__PURE__ */ wireResult(parseLaneOperationId);
+const laneEnrollmentId = /* @__PURE__ */ wireResult(parseLaneEnrollmentId);
+const walletId = /* @__PURE__ */ wireResult(parseWalletId);
+const walletKeyId = /* @__PURE__ */ wireResult(parseWalletKeyId);
+const signingLaneId = /* @__PURE__ */ wireResult(parseSigningLaneId);
+const laneShareEpoch = /* @__PURE__ */ wireResult(parseLaneShareEpoch);
+const materialActivationId = /* @__PURE__ */ wireResult(parseMpcMaterialActivationId);
+const materialActivation = /* @__PURE__ */ wireResult(parseMpcMaterialActivationRef);
+const laneParticipantBindingDigest = /* @__PURE__ */ wireResult(parseLaneParticipantBindingDigestB64u);
+const digest = /* @__PURE__ */ wireLabeled(parseDigestB64u);
+const digestString = digest;
+const authorizedOperationId = /* @__PURE__ */ wireResult(parseAuthorizedOperationId);
+function laneOperationAuthorizationBindingV1() {
+	return wireUnion("kind", [wireObject({
+		kind: wireLiteral("linked_device_enrollment"),
+		authorizedOperationId,
+		linkedDeviceEnrollmentId: wireResult(parseLinkedDeviceEnrollmentId),
+		linkedDevicePermissionDigestB64u: digestString
+	}), wireObject({
+		kind: wireLiteral("owner_lane_refresh"),
+		authorizedOperationId,
+		ownerLaneRefreshDigestB64u: digestString
+	})]);
+}
+function parseAuthorization(raw, label) {
+	return laneOperationAuthorizationBindingV1()(raw, label);
+}
+//#endregion
+export { digest, digestString, laneEnrollmentId, laneOperationId, laneParticipantBindingDigest, laneShareEpoch, materialActivation, materialActivationId, parseAuthorization, parseLaneKind, requiredInteger, requiredString, signingLaneId, walletId, walletKeyId };
+
+//# sourceMappingURL=rotationWireFields.js.map

package/dist/esm/shared-ts/src/tenant-root/tenantRootIdentifier.js

@@ -0,0 +1,12 @@
+//#region ../shared-ts/src/tenant-root/tenantRootIdentifier.ts
+function hasControlCharacters(value) {
+	for (const character of value) {
+		const codePoint = character.codePointAt(0) ?? 0;
+		if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) return true;
+	}
+	return false;
+}
+//#endregion
+export { hasControlCharacters };
+
+//# sourceMappingURL=tenantRootIdentifier.js.map

package/dist/esm/shared-ts/src/tenant-root/tenantRootIdentity.js

@@ -1,6 +1,6 @@
+import { hasControlCharacters } from "./tenantRootIdentifier.js";
 //#region ../shared-ts/src/tenant-root/tenantRootIdentity.ts
 const TENANT_ROOT_IDENTITY_DOMAIN_V1 = new TextEncoder().encode("seams/tenant-root-identity/v1");
-const TENANT_ROOT_IDENTITY_MAX_IDENTIFIER_BYTES_V1 = 256;
 /**
 * The identity proof is only emitted by the authenticated builder or exact
 * wire decoder. Its private method makes raw object literals structurally
@@ -49,13 +49,6 @@ function hasLeadingOrTrailingRustWhitespace(value) {
 	const codePoints = Array.from(value, (character) => character.codePointAt(0) ?? 0);
 	return codePoints.length > 0 && (isRustWhitespace(codePoints[0]) || isRustWhitespace(codePoints[codePoints.length - 1]));
 }
-function hasControlCharacters(value) {
-	for (const character of value) {
-		const codePoint = character.codePointAt(0) ?? 0;
-		if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) return true;
-	}
-	return false;
-}
 function hasUnpairedSurrogate(value) {
 	for (let index = 0; index < value.length; index += 1) {
 		const codeUnit = value.charCodeAt(index);
@@ -73,7 +66,7 @@ function isCanonicalTenantRootIdentityField(value) {
 	if (typeof value !== "string" || value.length === 0) return false;
 	if (hasLeadingOrTrailingRustWhitespace(value) || hasControlCharacters(value)) return false;
 	if (hasUnpairedSurrogate(value)) return false;
-	return new TextEncoder().encode(value).length <= TENANT_ROOT_IDENTITY_MAX_IDENTIFIER_BYTES_V1;
+	return new TextEncoder().encode(value).length <= 256;
 }
 /** Checks one already-resolved field without normalizing it. */
 function isTenantRootIdentityFieldCanonicalV1(field, value) {

package/dist/esm/shared-ts/src/tenant-root/tenantRootOperationRecord.js

@@ -1,9 +1,10 @@
 import { base64UrlDecode, base64UrlEncode } from "../utils/base64.js";
 import { alphabetizeStringify, sha256Bytes } from "../utils/digests.js";
+import { hasExactKeys } from "../utils/exactKeys.js";
 import { isTenantRootIdentityFieldCanonicalV1 } from "./tenantRootIdentity.js";
 //#region ../shared-ts/src/tenant-root/tenantRootOperationRecord.ts
 /**
-* The console operation record (Refactor 121).
+* The console operation record.
 *
 * The console builds these records in TypeScript and the control plane
 * consumes their digests in Rust, so both sides must produce identical
@@ -126,10 +127,6 @@ const RESTORE_ROLE_IMPORT_KEY_RECORD_KEYS_V1 = [
 	"subject",
 	"tenantRootIdentityDigest"
 ];
-function hasExactKeys(record, keys) {
-	const actual = Object.keys(record);
-	return actual.length === keys.length && keys.every((key) => actual.includes(key));
-}
 function parseRestoreRoleImportKeyIssueRecord(raw) {
 	if (!hasExactKeys(raw, RESTORE_ROLE_IMPORT_KEY_RECORD_KEYS_V1)) return null;
 	if (raw.formatVersion !== TENANT_ROOT_OPERATION_RECORD_FORMAT_V1) return null;

package/dist/esm/shared-ts/src/threshold/ecdsaDerivationRoleLocalBootstrap.js

@@ -5,7 +5,6 @@ import { deriveEvmFamilySigningKeySlotId } from "../signing-lanes/evmFamilySigni
 //#region ../shared-ts/src/threshold/ecdsaDerivationRoleLocalBootstrap.ts
 const THRESHOLD_SECP256K1_ECDSA_2P_V1_SCHEME_ID = "threshold-secp256k1-ecdsa-2p-v1";
 const SDK_ECDSA_DERIVATION_APPLICATION_BINDING_DOMAIN_V1 = "seams-sdk:ecdsa-derivation:application-binding:v1";
-const ECDSA_DERIVATION_ROLE_LOCAL_FIRST_BOOTSTRAP_ROOT_PROOF_VERSION = "ecdsa-derivation:role-local:first-bootstrap-root-proof:v2";
 function ecdsaClientRootPublicKey33B64uFromString(value) {
 	const normalized = value.trim();
 	const bytes = base64UrlDecode(normalized);
@@ -80,6 +79,6 @@ async function computeEcdsaDerivationRoleLocalRelayerKeyId(input) {
 	})))}`;
 }
 //#endregion
-export { ECDSA_DERIVATION_ROLE_LOCAL_FIRST_BOOTSTRAP_ROOT_PROOF_VERSION, computeEcdsaDerivationRoleLocalRelayerKeyId, computeEcdsaDerivationRoleLocalThresholdKeyId, computeSdkEcdsaDerivationApplicationBindingDigestB64u, derivationClientSharePublicKey33B64uFromString, ecdsaClientRootPublicKey33B64uFromString, parseSdkEcdsaDerivationSigningRootId, parseSdkEcdsaDerivationSigningRootVersion, parseSdkEcdsaDerivationThresholdKeyId };
+export { computeEcdsaDerivationRoleLocalRelayerKeyId, computeEcdsaDerivationRoleLocalThresholdKeyId, computeSdkEcdsaDerivationApplicationBindingDigestB64u, derivationClientSharePublicKey33B64uFromString, ecdsaClientRootPublicKey33B64uFromString, parseSdkEcdsaDerivationSigningRootId, parseSdkEcdsaDerivationSigningRootVersion, parseSdkEcdsaDerivationThresholdKeyId };
 
 //# sourceMappingURL=ecdsaDerivationRoleLocalBootstrap.js.map

package/dist/esm/shared-ts/src/threshold/keyMaterialBrands.js

@@ -0,0 +1,49 @@
+//#region ../shared-ts/src/threshold/keyMaterialBrands.ts
+function parseNonEmptyBrand(value, label) {
+	const normalized = String(value ?? "").trim();
+	if (!normalized) throw new Error(`${label} must be a non-empty string`);
+	return normalized;
+}
+function parseEcdsaDerivationKeyVersion(value) {
+	return parseNonEmptyBrand(value, "ECDSA DERIVATION key version");
+}
+function parseSigningSessionSealKeyVersion(value) {
+	return parseNonEmptyBrand(value, "signing-session seal key version");
+}
+function parseEcdsaClientVerifyingShareB64u(value) {
+	return parseNonEmptyBrand(value, "ECDSA client verifying share");
+}
+function parseEd25519RelayerKeyId(value) {
+	return parseNonEmptyBrand(value, "Ed25519 relayer key id");
+}
+function parseEcdsaRelayerKeyId(value) {
+	return parseNonEmptyBrand(value, "ECDSA relayer key id");
+}
+function parseEcdsaKeyHandle(value) {
+	return parseNonEmptyBrand(value, "ECDSA key handle");
+}
+function formatEcdsaDerivationKeyVersionForWire(value) {
+	return value;
+}
+function formatSigningSessionSealKeyVersionForWire(value) {
+	return value;
+}
+function formatEcdsaClientVerifyingShareB64uForWire(value) {
+	return value;
+}
+function formatEd25519RelayerKeyIdForWire(value) {
+	return value;
+}
+function formatEcdsaRelayerKeyIdForWire(value) {
+	return value;
+}
+function formatEcdsaThresholdKeyIdForWire(value) {
+	return value;
+}
+function formatEcdsaKeyHandleForWire(value) {
+	return value;
+}
+//#endregion
+export { formatEcdsaClientVerifyingShareB64uForWire, formatEcdsaDerivationKeyVersionForWire, formatEcdsaKeyHandleForWire, formatEcdsaRelayerKeyIdForWire, formatEcdsaThresholdKeyIdForWire, formatEd25519RelayerKeyIdForWire, formatSigningSessionSealKeyVersionForWire, parseEcdsaClientVerifyingShareB64u, parseEcdsaDerivationKeyVersion, parseEcdsaKeyHandle, parseEcdsaRelayerKeyId, parseEd25519RelayerKeyId, parseNonEmptyBrand, parseSigningSessionSealKeyVersion };
+
+//# sourceMappingURL=keyMaterialBrands.js.map

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

@@ -5,10 +5,9 @@ import { parseWebAuthnRpId } from "./domainIds.js";
 *
 * This lives in the shared package because three parties read the same record:
 * the server that mints it, the browser that passes it to
-* `navigator.credentials.create`, and — since Refactor 103 Phase 8 — the
-* linked-device target preparation that carries it to Device 2. One
-* declaration, so a change to the ceremony cannot silently diverge from what a
-* linked device creates its passkey against.
+* `navigator.credentials.create`, and the linked-device target preparation that
+* carries it to Device 2. One declaration, so a change to the ceremony cannot
+* silently diverge from what a linked device creates its passkey against.
 *
 * Everything here is fixed by the canonical add-auth-method ceremony: two
 * algorithms in a fixed order, a resident key, no attestation, and PRF

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

@@ -1,4 +1,5 @@
 import { base64UrlDecode, base64UrlEncode } from "./base64.js";
+import { sha256Bytes, sha256BytesUtf8 } from "./digests.js";
 //#region ../shared-ts/src/utils/canonicalPrimitives.ts
 function parseCorrelationId(value) {
 	if (typeof value !== "string" || value.trim() !== value || value.length === 0) throw new Error("correlation id must be a non-empty canonical string");
@@ -21,7 +22,13 @@ function parseIsoTimestamp(value) {
 	if (!Number.isFinite(timestampMs) || new Date(timestampMs).toISOString() !== value) throw new Error("timestamp must be canonical ISO-8601 UTC");
 	return value;
 }
+async function sha256DigestB64u(bytes) {
+	return parseDigestB64u(base64UrlEncode(await sha256Bytes(bytes)));
+}
+async function sha256Utf8DigestB64u(text) {
+	return parseDigestB64u(base64UrlEncode(await sha256BytesUtf8(text)));
+}
 //#endregion
-export { parseCorrelationId, parseDigestB64u, parseIsoTimestamp };
+export { parseCorrelationId, parseDigestB64u, parseIsoTimestamp, sha256DigestB64u, sha256Utf8DigestB64u };
 
 //# sourceMappingURL=canonicalPrimitives.js.map

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

@@ -0,0 +1,63 @@
+import { base64UrlDecode, base64UrlEncode } from "./base64.js";
+import { parseDigestB64u } from "./canonicalPrimitives.js";
+//#region ../shared-ts/src/utils/digestEncoding.ts
+const TEXT_ENCODER = new TextEncoder();
+function concat(parts) {
+	let length = 0;
+	for (const part of parts) length += part.length;
+	const output = new Uint8Array(length);
+	let offset = 0;
+	for (const part of parts) {
+		output.set(part, offset);
+		offset += part.length;
+	}
+	return output;
+}
+function u32(value, label) {
+	if (!Number.isSafeInteger(value) || value < 0 || value > 4294967295) throw new Error(`${label} must be a non-negative u32`);
+	return Uint8Array.from([
+		value >>> 24 & 255,
+		value >>> 16 & 255,
+		value >>> 8 & 255,
+		value & 255
+	]);
+}
+function u64(value, label) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new Error(`${label} must be a non-negative safe integer`);
+	let remaining = BigInt(value);
+	const output = new Uint8Array(8);
+	for (let index = 7; index >= 0; index -= 1) {
+		output[index] = Number(remaining & 255n);
+		remaining >>= 8n;
+	}
+	return output;
+}
+function lp32(value, label) {
+	return concat([u32(value.length, `${label}.length`), value]);
+}
+function text(value, label) {
+	if (typeof value !== "string") throw new Error(`${label} must be a string`);
+	return lp32(TEXT_ENCODER.encode(value), label);
+}
+function rawDigest(value, label) {
+	try {
+		const decoded = base64UrlDecode(parseDigestB64u(value));
+		if (decoded.length !== 32) throw new Error("must decode to 32 bytes");
+		return decoded;
+	} catch (error) {
+		throw new Error(`${label} ${error instanceof Error ? error.message : "is invalid"}`);
+	}
+}
+function rawPublicKey(value, label) {
+	try {
+		const decoded = base64UrlDecode(value);
+		if (decoded.length === 0 || base64UrlEncode(decoded) !== value) throw new Error("must be canonical base64url");
+		return decoded;
+	} catch (error) {
+		throw new Error(`${label} ${error instanceof Error ? error.message : "is invalid"}`);
+	}
+}
+//#endregion
+export { concat, lp32, rawDigest, rawPublicKey, text, u32, u64 };
+
+//# sourceMappingURL=digestEncoding.js.map

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

@@ -1,10 +1,8 @@
 import { base64UrlEncode } from "./base64.js";
 import { alphabetizeStringify, sha256BytesUtf8 } from "./digests.js";
 import "./encoders.js";
+import { thresholdEcdsaChainTargetKey } from "./thresholdEcdsaChainTarget.js";
 //#region ../shared-ts/src/utils/ecdsaKeyFactsInventory.ts
-function chainTargetKey(target) {
-	return target.kind === "evm" ? `evm:eip155:${target.chainId}` : `tempo:${target.chainId}`;
-}
 function normalizeChainTarget(target) {
 	if (target.kind === "evm") return {
 		kind: "evm",
@@ -22,7 +20,7 @@ function canonicalizeWalletEcdsaKeyFactsInventoryChallenge(input) {
 	const keyTargets = input.keyTargets.map((target) => ({
 		keyHandle: target.keyHandle,
 		chainTarget: normalizeChainTarget(target.chainTarget),
-		targetKey: chainTargetKey(target.chainTarget)
+		targetKey: thresholdEcdsaChainTargetKey(target.chainTarget)
 	})).sort((left, right) => {
 		const leftKey = `${left.keyHandle}:${left.targetKey}`;
 		const rightKey = `${right.keyHandle}:${right.targetKey}`;

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

@@ -5,7 +5,6 @@ const ECDSA_TIMING_METRICS = new Set([
 	"ecdsa_sign_proxy",
 	"ecdsa_sign_complete",
 	"ecdsa_sign_total",
-	"ecdsa_presign_queue",
 	"ecdsa_presign_authenticate",
 	"ecdsa_presign_material",
 	"ecdsa_presign_admit",