@seams/wallet 0.8.0 → 0.9.1

package/dist/esm/core/signingEngine/session/material/activeEcdsaCapabilityRuntime.js

@@ -1,31 +1,8 @@
 import { thresholdEcdsaChainTargetsEqual } from "../../interfaces/ecdsaChainTarget.js";
-import { resolveExactEcdsaSealedRuntime } from "./ecdsaSealedRuntime.js";
 //#region src/core/signingEngine/session/material/activeEcdsaCapabilityRuntime.ts
 function manifestCoversTarget(args) {
 	return args.manifest.signer.scope.targetMemberships.some((membership) => thresholdEcdsaChainTargetsEqual(membership, args.chainTarget));
 }
-async function listActiveManifestsForTarget(args) {
-	return (await args.ports.listActiveEcdsaCapabilityManifestsForWallet(args.walletId)).filter((manifest) => manifestCoversTarget({
-		manifest,
-		chainTarget: args.chainTarget
-	}));
-}
-async function listSealedEcdsaRecordsForWallet(args) {
-	const records = [];
-	const authMethods = args.authMethod ? [args.authMethod] : ["passkey", "email_otp"];
-	for (const authMethod of authMethods) {
-		const found = await args.ports.listExactSealedSessionsForWallet({
-			walletId: String(args.walletId),
-			filter: {
-				authMethod,
-				curve: "ecdsa",
-				chainTarget: args.chainTarget
-			}
-		}).catch(() => []);
-		for (const record of found) if (record.curve === "ecdsa") records.push(record);
-	}
-	return records;
-}
 async function resolveExactEcdsaCapabilityRuntime(args) {
 	if (!manifestCoversTarget({
 		manifest: args.manifest,
@@ -75,97 +52,7 @@ function exactTwoPartyParticipantIds(value) {
 	if (!Number.isSafeInteger(first) || !Number.isSafeInteger(second) || first <= 0 || second <= 0 || first === second) return null;
 	return [first, second];
 }
-async function narrowToSelectedMethod(ports, walletId, manifests) {
-	const selected = await ports.resolveSelectedWalletAuthority(String(walletId));
-	if (selected.kind !== "resolved") return manifests;
-	const selectedMethodId = String(selected.authMethod.walletAuthMethodId);
-	const matching = manifests.filter((manifest) => String(manifest.signer.authority.walletAuthMethodId) === selectedMethodId);
-	return matching.length > 0 ? matching : manifests;
-}
-async function resolveActiveEcdsaCapabilityRuntime(ports, args) {
-	const all = await listActiveManifestsForTarget({
-		ports,
-		...args
-	});
-	if (all.length === 0) return {
-		kind: "blocked",
-		reason: "missing_capability"
-	};
-	const manifests = all.length > 1 ? await narrowToSelectedMethod(ports, args.walletId, all) : all;
-	if (manifests.length !== 1) return {
-		kind: "blocked",
-		reason: "exact_record_conflict"
-	};
-	const manifest = manifests[0];
-	const sealedRecords = await listSealedEcdsaRecordsForWallet({
-		ports,
-		...args
-	});
-	const resolution = resolveExactEcdsaSealedRuntime({
-		manifest,
-		walletId: args.walletId,
-		chainTarget: args.chainTarget,
-		sealedRecords
-	});
-	return resolution.kind === "resolved" ? {
-		kind: "resolved",
-		manifest,
-		runtime: resolution.runtime
-	} : {
-		kind: "blocked",
-		reason: resolution.reason
-	};
-}
-function createActiveEcdsaCapabilityRuntimeResolver(ports) {
-	return resolveActiveEcdsaCapabilityRuntime.bind(null, ports);
-}
-/** Resolve by chain kind, taking the exact chain target from the manifest's own
-* target memberships. The warm-session envelope is keyed by kind (evm/tempo)
-* while correlation needs a full target, and the manifest is the authority on
-* which targets its capability covers. */
-async function resolveActiveEcdsaCapabilityRuntimeForChain(ports, args) {
-	const manifests = await ports.listActiveEcdsaCapabilityManifestsForWallet(args.walletId);
-	const matches = [];
-	for (const manifest of manifests) for (const membership of manifest.signer.scope.targetMemberships) {
-		if (membership.kind !== args.chain) continue;
-		matches.push({
-			manifest,
-			chainTarget: membership
-		});
-	}
-	if (matches.length === 0) return {
-		kind: "blocked",
-		reason: "missing_capability"
-	};
-	if (matches.length > 1) return {
-		kind: "blocked",
-		reason: "exact_record_conflict"
-	};
-	const match = matches[0];
-	const sealedRecords = await listSealedEcdsaRecordsForWallet({
-		ports,
-		walletId: args.walletId,
-		chainTarget: match.chainTarget
-	});
-	const resolution = resolveExactEcdsaSealedRuntime({
-		manifest: match.manifest,
-		walletId: args.walletId,
-		chainTarget: match.chainTarget,
-		sealedRecords
-	});
-	return resolution.kind === "resolved" ? {
-		kind: "resolved",
-		manifest: match.manifest,
-		runtime: resolution.runtime
-	} : {
-		kind: "blocked",
-		reason: resolution.reason
-	};
-}
-function createActiveEcdsaCapabilityRuntimeForChainResolver(ports) {
-	return resolveActiveEcdsaCapabilityRuntimeForChain.bind(null, ports);
-}
 //#endregion
-export { createActiveEcdsaCapabilityRuntimeForChainResolver, createActiveEcdsaCapabilityRuntimeResolver, resolveExactEcdsaCapabilityRuntime };
+export { resolveExactEcdsaCapabilityRuntime };
 
 //# sourceMappingURL=activeEcdsaCapabilityRuntime.js.map

package/dist/esm/core/signingEngine/session/material/activeWalletAuthorityEcdsaRuntime.js

@@ -1,15 +1,15 @@
 import { mpcMaterialActivationRefsEqual } from "../../../../shared-ts/src/utils/domainIds.js";
 import { base64UrlDecode } from "../../../../shared-ts/src/utils/base64.js";
 import { toWalletId } from "../../interfaces/ecdsaChainTarget.js";
-import { buildBaseEvmFamilyEcdsaKeyIdentity, buildPasskeyEcdsaAuthBinding, buildResolvedEvmFamilyEcdsaKey, buildVerifiedEcdsaPublicFacts, deriveEvmFamilyEcdsaKeyHandle, toRpId, toThresholdOwnerAddress } from "../identity/evmFamilyEcdsaIdentity.js";
 import { routerAbMpcMaterialActivationRefFromWire } from "../../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
 import { computeEcdsaDerivationRoleLocalRelayerKeyId } from "../../../../shared-ts/src/threshold/ecdsaDerivationRoleLocalBootstrap.js";
 import { isEmailOtpWalletAuthAuthority, isPasskeyWalletAuthAuthority, walletAuthAuthorityRef } from "../../../../shared-ts/src/utils/walletAuthAuthority.js";
 import { sameRouterAbEcdsaDerivationNormalSigningScopeV1 } from "../../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
 import { sameEcdsaSourceSigner, sameEcdsaTarget } from "../../../../shared-ts/src/device-linking/sourceContribution.js";
 import { isActiveEcdsaWalletAuthorityV1, isCombinedWalletSignerActivationSetV1 } from "../../../../shared-ts/src/authorization/walletAuthority.js";
-import { resolveLinkedEcdsaHolderRuntimeV1 } from "./linkedEcdsaHolderRuntime.js";
+import { buildBaseEvmFamilyEcdsaKeyIdentity, buildPasskeyEcdsaAuthBinding, buildResolvedEvmFamilyEcdsaKey, buildVerifiedEcdsaPublicFacts, deriveEvmFamilyEcdsaKeyHandle, toRpId, toThresholdOwnerAddress } from "../identity/evmFamilyEcdsaIdentity.js";
 import { bytesToHex } from "../../chains/evm/bytes.js";
+import { resolveLinkedEcdsaHolderRuntimeV1 } from "./linkedEcdsaHolderRuntime.js";
 //#region src/core/signingEngine/session/material/activeWalletAuthorityEcdsaRuntime.ts
 function blocked(reason, message) {
 	return message ? {

package/dist/esm/core/signingEngine/session/material/ecdsaCapabilityManifest.js

@@ -4,7 +4,7 @@ import { isoTimestampFromUnixMs } from "../../../../shared-ts/src/utils/canonica
 import { deriveSigningRootId, normalizeRuntimePolicyScope } from "../../../../shared-ts/src/threshold/signingRootScope.js";
 import { routerAbMpcMaterialActivationRefFromWire, routerAbMpcMaterialActivationRefToWire, sameRouterAbMpcMaterialActivationRef } from "../../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
 import { parseEcdsaActivationDigest, parseEcdsaLifecycleId } from "../../../../shared-ts/src/utils/ecdsaCapabilityActivation.js";
-import { parseRouterAbEcdsaRegistrationActivationReceiptV1, sameRegistrationRecipientKeys, sameRegistrationSignerSet, sameRouterAbEcdsaDerivationPublicIdentityV1, sameRouterAbServerIdentityV1 } from "../../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
+import { parseRouterAbEcdsaRegistrationActivationReceiptV1, sameRouterAbEcdsaDerivationPublicIdentityV1, sameRouterAbServerIdentityV1 } from "../../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
 //#region src/core/signingEngine/session/material/ecdsaCapabilityManifest.ts
 var EcdsaCapabilityManifestProof = class {
 	retainProof() {
@@ -28,33 +28,6 @@ var EcdsaManifestIdentityProof = class extends EcdsaCapabilityManifestProof {
 		this.manifestRevision = fields.manifestRevision;
 	}
 };
-var NoCurrentEcdsaManifestExpectationProof = class extends EcdsaCapabilityManifestProof {
-	constructor(..._args) {
-		super(..._args);
-		this.kind = "no_current_manifest";
-	}
-};
-var ExactEcdsaManifestExpectationProof = class extends EcdsaCapabilityManifestProof {
-	constructor(identity) {
-		super();
-		this.kind = "exact_manifest";
-		this.manifestId = identity.manifestId;
-		this.manifestRevision = identity.manifestRevision;
-	}
-};
-var NoCurrentEcdsaServerGenerationExpectationProof = class extends EcdsaCapabilityManifestProof {
-	constructor(..._args2) {
-		super(..._args2);
-		this.kind = "no_current_generation";
-	}
-};
-var ExactEcdsaServerGenerationExpectationProof = class extends EcdsaCapabilityManifestProof {
-	constructor(serverGeneration) {
-		super();
-		this.kind = "exact_generation";
-		this.serverGeneration = serverGeneration;
-	}
-};
 var EcdsaRoleLocalMaterialBindingProof = class extends EcdsaCapabilityManifestProof {
 	constructor(fields) {
 		super();
@@ -95,16 +68,6 @@ var RegisteredEvmFamilySignerProof = class extends EcdsaCapabilityManifestProof
 		this.registeredPublicFacts = fields.registeredPublicFacts;
 	}
 };
-var EncryptedEcdsaPendingCandidateProof = class extends EcdsaCapabilityManifestProof {
-	constructor(fields) {
-		super();
-		this.kind = "encrypted_ecdsa_pending_candidate";
-		this.sealingKeyId = fields.sealingKeyId;
-		this.iv12B64u = fields.iv12B64u;
-		this.ciphertextB64u = fields.ciphertextB64u;
-		this.ciphertextDigest = fields.ciphertextDigest;
-	}
-};
 var EcdsaActivationBindingProof = class extends EcdsaCapabilityManifestProof {
 	constructor(fields) {
 		super();
@@ -116,24 +79,6 @@ var EcdsaActivationBindingProof = class extends EcdsaCapabilityManifestProof {
 		this.durableMaterialRef = fields.durableMaterialRef;
 	}
 };
-var PreparedEcdsaActivationCandidateProof = class extends EcdsaCapabilityManifestProof {
-	constructor(fields) {
-		super();
-		this.kind = "prepared_ecdsa_activation_candidate";
-		this.activationBinding = fields.activationBinding;
-		this.encryptedPending = fields.encryptedPending;
-	}
-};
-var EcdsaServerActivationCommandProof = class extends EcdsaCapabilityManifestProof {
-	constructor(fields) {
-		super();
-		this.kind = "ecdsa_server_activation_command";
-		this.correlationId = fields.correlationId;
-		this.expectedGeneration = fields.expectedGeneration;
-		this.requestDigest = fields.requestDigest;
-		this.canonicalRequest = fields.canonicalRequest;
-	}
-};
 var EcdsaServerActivationReceiptProof = class extends EcdsaCapabilityManifestProof {
 	constructor(fields) {
 		super();
@@ -154,29 +99,6 @@ var EcdsaServerActivationCommitProof = class extends EcdsaCapabilityManifestProo
 		this.serverActivationReceipt = fields.serverActivationReceipt;
 	}
 };
-var PreparedEcdsaActivationJournalProof = class extends EcdsaCapabilityManifestProof {
-	constructor(fields) {
-		super();
-		this.kind = "activation_prepared";
-		this.journalId = fields.journalId;
-		this.expectedManifest = fields.expectedManifest;
-		this.activationCommand = fields.activationCommand;
-		this.candidate = fields.candidate;
-		this.createdAt = fields.createdAt;
-	}
-};
-var ServerCommittedEcdsaActivationJournalProof = class extends EcdsaCapabilityManifestProof {
-	constructor(fields) {
-		super();
-		this.kind = "server_activation_committed";
-		this.journalId = fields.journalId;
-		this.expectedManifest = fields.expectedManifest;
-		this.activationCommand = fields.activationCommand;
-		this.candidate = fields.candidate;
-		this.createdAt = fields.createdAt;
-		this.serverActivation = fields.serverActivation;
-	}
-};
 var DurableEcdsaMaterialBindingProof = class extends EcdsaCapabilityManifestProof {
 	constructor(fields) {
 		super();
@@ -215,19 +137,6 @@ var ActiveEcdsaCapabilityManifestProof = class extends EcdsaCapabilityManifestPr
 		this.committedAt = fields.committedAt;
 	}
 };
-var ReplacedEcdsaCapabilityManifestProof = class extends EcdsaCapabilityManifestProof {
-	constructor(fields) {
-		super();
-		this.kind = "replaced_ecdsa_capability_manifest";
-		this.identity = fields.identity;
-		this.signer = fields.signer;
-		this.retirement = fields.retirement;
-	}
-};
-function unwrapDomainId(result) {
-	if (!result.ok) throw new Error(result.error.message);
-	return result.value;
-}
 function buildEcdsaCapabilityScope(input) {
 	assertUniqueEcdsaTargetMemberships(input.targetMemberships);
 	return new EcdsaCapabilityScopeProof([...input.targetMemberships]);
@@ -235,18 +144,6 @@ function buildEcdsaCapabilityScope(input) {
 function buildEcdsaManifestIdentity(input) {
 	return new EcdsaManifestIdentityProof(input);
 }
-function buildNoCurrentEcdsaManifestExpectation() {
-	return new NoCurrentEcdsaManifestExpectationProof();
-}
-function buildExactEcdsaManifestExpectation(identity) {
-	return new ExactEcdsaManifestExpectationProof(identity);
-}
-function buildNoCurrentEcdsaServerGenerationExpectation() {
-	return new NoCurrentEcdsaServerGenerationExpectationProof();
-}
-function buildExactEcdsaServerGenerationExpectation(serverGeneration) {
-	return new ExactEcdsaServerGenerationExpectationProof(serverGeneration);
-}
 function buildEcdsaRoleLocalMaterialBinding(input) {
 	assertUniqueParticipantIds(input.participantIds);
 	return new EcdsaRoleLocalMaterialBindingProof({
@@ -260,32 +157,9 @@ function buildEcdsaRoleLocalMaterialBinding(input) {
 function buildPreparedEvmFamilySigner(input) {
 	return new PreparedEvmFamilySignerProof(input);
 }
-function buildEncryptedEcdsaPendingCandidate(input) {
-	return new EncryptedEcdsaPendingCandidateProof(input);
-}
 function buildEcdsaActivationBinding(input) {
 	return new EcdsaActivationBindingProof(input);
 }
-function buildPreparedEcdsaActivationCandidate(input) {
-	return new PreparedEcdsaActivationCandidateProof(input);
-}
-function buildPreparedEcdsaActivationJournal(input) {
-	assertTargetManifestTransition(input.expectedManifest, input.candidate.activationBinding.targetManifest);
-	assertExpectedStatePair(input.expectedManifest, input.expectedGeneration);
-	const activationCommand = new EcdsaServerActivationCommandProof({
-		correlationId: input.journalId,
-		expectedGeneration: input.expectedGeneration,
-		requestDigest: input.requestDigest,
-		canonicalRequest: input.canonicalRequest
-	});
-	return new PreparedEcdsaActivationJournalProof({
-		journalId: input.journalId,
-		expectedManifest: input.expectedManifest,
-		activationCommand,
-		candidate: input.candidate,
-		createdAt: input.createdAt
-	});
-}
 function buildEcdsaServerActivationCommit(input) {
 	const protocolReceipt = parseRouterAbEcdsaRegistrationActivationReceiptV1(input.serverCommit.protocolReceipt);
 	assertProtocolReceiptMatchesServerCommit(protocolReceipt, input.serverCommit);
@@ -303,21 +177,6 @@ function buildEcdsaServerActivationCommit(input) {
 		serverActivationReceipt
 	});
 }
-function buildServerCommittedEcdsaActivationJournal(input) {
-	assertServerCommitMatchesPreparedCommand(input.serverCommit, input.preparedJournal);
-	const serverActivation = buildEcdsaServerActivationCommit({
-		activationBinding: input.preparedJournal.candidate.activationBinding,
-		serverCommit: input.serverCommit
-	});
-	return new ServerCommittedEcdsaActivationJournalProof({
-		journalId: input.preparedJournal.journalId,
-		expectedManifest: input.preparedJournal.expectedManifest,
-		activationCommand: input.preparedJournal.activationCommand,
-		candidate: input.preparedJournal.candidate,
-		createdAt: input.preparedJournal.createdAt,
-		serverActivation
-	});
-}
 function buildDurableEcdsaMaterialBinding(input) {
 	assertServerActivationMatchesBinding(input.serverActivation, input.activationBinding);
 	const facts = input.roleLocalPublicFacts;
@@ -374,18 +233,6 @@ function buildActiveEcdsaCapabilityManifest(input) {
 		committedAt: input.committedAt
 	});
 }
-function buildReplacedEcdsaCapabilityManifest(input) {
-	assertValidEcdsaReplacement(input.activeManifest, input.replacementManifest);
-	return new ReplacedEcdsaCapabilityManifestProof({
-		identity: input.activeManifest.identity,
-		signer: input.activeManifest.signer,
-		retirement: {
-			kind: "replaced",
-			replacementManifest: input.replacementManifest.identity,
-			replacementActivation: input.replacementManifest.activation.serverActivation
-		}
-	});
-}
 function assertUniqueEcdsaTargetMemberships(targetMemberships) {
 	const targetKeys = targetMemberships.map(ecdsaTargetMembershipKey);
 	if (new Set(targetKeys).size !== targetKeys.length) throw new Error("ECDSA capability target memberships must be unique");
@@ -401,32 +248,6 @@ function assertUniqueParticipantIds(participantIds) {
 	const normalizedIds = participantIds.map(Number);
 	if (normalizedIds.some((participantId) => !Number.isSafeInteger(participantId) || participantId < 1) || new Set(normalizedIds).size !== normalizedIds.length) throw new Error("ECDSA participant ids must be unique positive integers");
 }
-function assertTargetManifestTransition(expected, target) {
-	switch (expected.kind) {
-		case "no_current_manifest":
-			if (Number(target.manifestRevision) !== 1) throw new Error("Initial ECDSA manifest revision must be 1");
-			return;
-		case "exact_manifest":
-			if (target.manifestId === expected.manifestId || Number(target.manifestRevision) !== Number(expected.manifestRevision) + 1) throw new Error("Replacement ECDSA manifest must use a fresh id and next revision");
-			return;
-		default: return assertNever(expected);
-	}
-}
-function assertExpectedStatePair(expectedManifest, expectedGeneration) {
-	switch (expectedManifest.kind) {
-		case "no_current_manifest":
-			if (expectedGeneration.kind !== "no_current_generation") throw new Error("Initial ECDSA activation cannot expect a server generation");
-			return;
-		case "exact_manifest":
-			if (expectedGeneration.kind !== "exact_generation") throw new Error("Replacement ECDSA activation requires an exact server generation");
-			return;
-		default: return assertNever(expectedManifest);
-	}
-}
-function assertServerCommitMatchesPreparedCommand(serverCommit, journal) {
-	const requestDigestNamesOuterOperation = JSON.parse(journal.activationCommand.canonicalRequest).operation === "wallet_registration_activate_v2";
-	if (serverCommit.correlationId !== journal.activationCommand.correlationId || !requestDigestNamesOuterOperation && serverCommit.activationRequestDigest !== journal.activationCommand.requestDigest) throw new Error("ECDSA server activation commit does not match the prepared command");
-}
 function assertProtocolReceiptMatchesActivationBinding(receipt, activationBinding) {
 	const publicIdentity = receipt.ecdsa_activation.public_identity;
 	const materialActivation = receipt.ecdsa_activation.material_activation;
@@ -468,9 +289,6 @@ function assertDurableMaterialMatchesActivation(durableMaterial, activationBindi
 		receipt: receipt.protocolReceipt
 	});
 }
-function routerAbEcdsaDerivationPublicCapabilitiesEqual(left, right) {
-	return left.kind === right.kind && left.context.application_binding_digest_b64u === right.context.application_binding_digest_b64u && sameRouterAbEcdsaDerivationPublicIdentityV1(left.public_identity, right.public_identity) && sameRouterAbMpcMaterialActivationRef(left.material_activation, right.material_activation) && sameRegistrationSignerSet(left.signer_set, right.signer_set) && sameRegistrationRecipientKeys(left.deriver_recipient_keys, right.deriver_recipient_keys) && left.router_id === right.router_id && left.client_id === right.client_id && left.activation_epoch === right.activation_epoch && left.registration_request_digest_b64u === right.registration_request_digest_b64u && left.proof_transcript_digest_b64u === right.proof_transcript_digest_b64u;
-}
 function assertNormalSigningMatchesActivation(input) {
 	const scope = input.normalSigning.scope;
 	const facts = input.roleLocalPublicFacts;
@@ -486,13 +304,10 @@ function assertNormalSigningMatchesActivation(input) {
 	});
 	if (scope.wallet_id !== String(input.activationBinding.signer.walletId) || scope.ecdsa_threshold_key_id !== String(input.activationBinding.roleLocalBinding.ecdsaThresholdKeyId) || scope.signing_root_id !== String(input.activationBinding.signer.signingRootId) || scope.signing_root_version !== String(input.activationBinding.signer.signingRootVersion) || scope.context.application_binding_digest_b64u !== input.receipt.ecdsa_activation.context.application_binding_digest_b64u || !sameRouterAbEcdsaDerivationPublicIdentityV1(scope.public_identity, input.receipt.ecdsa_activation.public_identity) || !sameRouterAbServerIdentityV1(scope.signing_worker, input.receipt.ecdsa_activation.signing_worker) || scope.activation_epoch !== input.receipt.ecdsa_activation.activation_epoch || scope.public_identity.context_binding_b64u !== facts.contextBinding32B64u || scope.public_identity.derivation_client_share_public_key33_b64u !== facts.derivationClientSharePublicKey33B64u || scope.public_identity.server_public_key33_b64u !== facts.relayerPublicKey33B64u || scope.public_identity.threshold_public_key33_b64u !== facts.groupPublicKey33B64u || !sameRouterAbMpcMaterialActivationRef(scope.material_activation, expectedMaterialActivationWire)) throw new Error("ECDSA normal-signing runtime does not match its activation");
 }
-function assertValidEcdsaReplacement(active, replacement) {
-	if (active.identity.manifestId === replacement.identity.manifestId || Number(replacement.identity.manifestRevision) !== Number(active.identity.manifestRevision) + 1 || active.signer.capability !== replacement.signer.capability || active.signer.signerId !== replacement.signer.signerId || active.signer.walletId !== replacement.signer.walletId || active.signer.authority.authorityDigest !== replacement.signer.authority.authorityDigest || active.signer.materialOwner !== replacement.signer.materialOwner || active.durableMaterial.durableMaterialRef === replacement.durableMaterial.durableMaterialRef || active.activation.serverActivation.serverGeneration === replacement.activation.serverActivation.serverGeneration) throw new Error("ECDSA replacement manifest does not exactly replace the active manifest");
-}
 function assertNever(value) {
 	throw new Error(`Unexpected ECDSA capability branch: ${String(value)}`);
 }
 //#endregion
-export { buildActiveEcdsaCapabilityManifest, buildDurableEcdsaMaterialBinding, buildEcdsaActivationBinding, buildEcdsaCapabilityScope, buildEcdsaManifestIdentity, buildEcdsaRoleLocalMaterialBinding, buildEcdsaServerActivationCommit, buildEncryptedEcdsaPendingCandidate, buildExactEcdsaManifestExpectation, buildExactEcdsaServerGenerationExpectation, buildNoCurrentEcdsaManifestExpectation, buildNoCurrentEcdsaServerGenerationExpectation, buildPreparedEcdsaActivationCandidate, buildPreparedEcdsaActivationJournal, buildPreparedEvmFamilySigner, buildReplacedEcdsaCapabilityManifest, buildServerCommittedEcdsaActivationJournal, buildValidatedEncryptedEcdsaReadyMaterial, routerAbEcdsaDerivationPublicCapabilitiesEqual, unwrapDomainId };
+export { buildActiveEcdsaCapabilityManifest, buildDurableEcdsaMaterialBinding, buildEcdsaActivationBinding, buildEcdsaCapabilityScope, buildEcdsaManifestIdentity, buildEcdsaRoleLocalMaterialBinding, buildEcdsaServerActivationCommit, buildPreparedEvmFamilySigner, buildValidatedEncryptedEcdsaReadyMaterial };
 
 //# sourceMappingURL=ecdsaCapabilityManifest.js.map

package/dist/esm/core/signingEngine/session/material/ecdsaRoleLocalMaterialResolver.js

@@ -1,8 +1,6 @@
-import { mpcMaterialActivationRefsEqual, parseMpcMaterialActivationRef } from "../../../../shared-ts/src/utils/domainIds.js";
-import { parseWalletAuthAuthorityRef } from "../../../../shared-ts/src/utils/walletAuthAuthority.js";
+import { mpcMaterialActivationRefsEqual } from "../../../../shared-ts/src/utils/domainIds.js";
 import { openEcdsaRoleLocalSigningMaterialWasm } from "../../threshold/crypto/ecdsaDerivationClientWasm.js";
 //#region src/core/signingEngine/session/material/ecdsaRoleLocalMaterialResolver.ts
-const persistedMaterialBrand = Symbol("persisted-ecdsa-role-local-material");
 function materialRefMatchesPublicFacts(materialRef, publicFacts) {
 	return materialRef.bindingDigest === publicFacts.contextBinding32B64u;
 }
@@ -43,20 +41,6 @@ function resolutionFromRehydrationFailure(args) {
 		}
 	}
 }
-function buildPersistedEcdsaRoleLocalMaterial(input) {
-	const authority = parseWalletAuthAuthorityRef(input.authority);
-	if (!authority) throw new Error("ECDSA role-local persisted material authority is invalid");
-	const materialActivationResult = parseMpcMaterialActivationRef(input.materialActivation);
-	if (!materialActivationResult.ok) throw new Error(materialActivationResult.error.message);
-	if (authority.walletId !== input.publicFacts.walletId) throw new Error("ECDSA role-local persisted material authority does not match its wallet");
-	return {
-		[persistedMaterialBrand]: true,
-		kind: "persisted_ecdsa_role_local_material_v1",
-		authority,
-		materialActivation: materialActivationResult.value,
-		publicFacts: input.publicFacts
-	};
-}
 function ecdsaRoleLocalPersistedMaterialSource(persistedMaterial) {
 	return {
 		kind: "persisted",
@@ -104,6 +88,6 @@ async function resolveEcdsaRoleLocalMaterial(input) {
 	}
 }
 //#endregion
-export { buildPersistedEcdsaRoleLocalMaterial, ecdsaRoleLocalPersistedMaterialSource, resolveEcdsaRoleLocalMaterial };
+export { ecdsaRoleLocalPersistedMaterialSource, resolveEcdsaRoleLocalMaterial };
 
 //# sourceMappingURL=ecdsaRoleLocalMaterialResolver.js.map

package/dist/esm/core/signingEngine/session/material/ecdsaSigningCapability.js

@@ -1,6 +1,6 @@
 import { mpcMaterialActivationRefsEqual } from "../../../../shared-ts/src/utils/domainIds.js";
 import { thresholdEcdsaChainTargetsEqual } from "../../interfaces/ecdsaChainTarget.js";
-import { isEmailOtpWalletAuthAuthority, isPasskeyWalletAuthAuthority, walletAuthAuthoritiesMatch, walletAuthAuthorityRef } from "../../../../shared-ts/src/utils/walletAuthAuthority.js";
+import { isEmailOtpWalletAuthAuthority, isPasskeyWalletAuthAuthority, walletAuthAuthoritiesMatch } from "../../../../shared-ts/src/utils/walletAuthAuthority.js";
 //#region src/core/signingEngine/session/material/ecdsaSigningCapability.ts
 function exactEcdsaSubjectMatches(args) {
 	return args.session.capabilitySubjects.filter((subject) => subject.kind === "sign" && subject.keyFamily === "ecdsa_secp256k1" && mpcMaterialActivationRefsEqual(subject.materialActivation, args.materialActivation)).length === 1;
@@ -69,67 +69,6 @@ function exactAuthorizationMatchesCapability(args) {
 	if (runtime.keyHandle !== String(capability.material.publicFacts.keyHandle) || runtime.ecdsaThresholdKeyId !== String(capability.material.publicFacts.ecdsaThresholdKeyId) || runtime.thresholdEcdsaPublicKeyB64u !== String(capability.material.publicFacts.groupPublicKey33B64u) || !participantIdsMatch(runtime.participantIds, capability.material.publicFacts.participantIds)) return false;
 	return true;
 }
-function isExactPasskeyWalletSessionRuntime(runtime) {
-	return runtime.authBinding.kind === "passkey";
-}
-function isExactEmailOtpWalletSessionRuntime(runtime) {
-	return runtime.authBinding.kind === "email_otp";
-}
-function buildPreprocessingSessionBinding(input) {
-	if (isExactPasskeyWalletSessionRuntime(input.runtime) && input.selected.authMethod.kind === "passkey") return {
-		kind: "ecdsa_preprocessing_session",
-		selectedAuthority: input.selected.authority,
-		selectedAuthMethod: input.selected.authMethod,
-		session: input.session,
-		operationCredential: input.operationCredential,
-		runtime: input.runtime
-	};
-	if (isExactEmailOtpWalletSessionRuntime(input.runtime) && input.selected.authMethod.kind === "email_otp") return {
-		kind: "ecdsa_preprocessing_session",
-		selectedAuthority: input.selected.authority,
-		selectedAuthMethod: input.selected.authMethod,
-		session: input.session,
-		operationCredential: input.operationCredential,
-		runtime: input.runtime
-	};
-	throw new Error("ECDSA preprocessing session auth method is inconsistent");
-}
-function directRuntimeAuthBinding(authority) {
-	if (isPasskeyWalletAuthAuthority(authority)) return {
-		kind: "passkey",
-		rpId: String(authority.verifier.rpId),
-		credentialIdB64u: String(authority.factor.credentialIdB64u)
-	};
-	if (isEmailOtpWalletAuthAuthority(authority)) return {
-		kind: "email_otp",
-		providerSubjectId: String(authority.factor.providerUserId),
-		emailHashHex: String(authority.verifier.emailHashHex),
-		emailOtpAuthority: authority
-	};
-	return authority;
-}
-function buildExactEcdsaDirectCapabilityRuntime(args) {
-	if (!Number.isSafeInteger(args.status.expiresAtMs) || args.status.expiresAtMs <= 0 || !Number.isSafeInteger(args.status.remainingUses) || args.status.remainingUses < 0) throw new Error("Exact ECDSA direct capability requires valid session facts");
-	return {
-		kind: "exact_ecdsa_direct_capability_runtime_v1",
-		walletId: args.runtime.walletId,
-		chainTarget: args.runtime.chainTarget,
-		materialActivation: args.runtime.materialActivation,
-		normalSigning: args.runtime.normalSigning,
-		relayerUrl: args.runtime.relayerUrl,
-		relayerKeyId: args.runtime.relayerKeyId,
-		clientVerifyingPublicKey33B64u: args.runtime.clientVerifyingPublicKey33B64u,
-		participantIds: args.runtime.participantIds,
-		ecdsaThresholdKeyId: args.runtime.ecdsaThresholdKeyId,
-		thresholdEcdsaPublicKeyB64u: args.runtime.thresholdEcdsaPublicKeyB64u,
-		keyHandle: args.runtime.keyHandle,
-		runtimePolicyScope: args.runtime.runtimePolicyScope,
-		roleLocalMaterialRef: args.runtime.roleLocalMaterialRef,
-		authBinding: directRuntimeAuthBinding(args.authority),
-		expiresAtMs: args.status.expiresAtMs,
-		remainingUses: args.status.remainingUses
-	};
-}
 function exactEcdsaAuthBindingsMatch(left, right) {
 	if (left.kind !== right.kind) return false;
 	switch (left.kind) {
@@ -146,60 +85,6 @@ function exactEcdsaWalletSessionRuntimesMatch(left, right) {
 		default: return left;
 	}
 }
-function validateExactSessionAuthorization(input) {
-	const walletId = input.session.walletId;
-	if (!Number.isSafeInteger(input.nowMs) || input.nowMs < 0) throw new Error("Exact EVM-family Wallet Session authorization requires a valid timestamp");
-	if (!selectedAuthorityComponentsAreExact({
-		selectedAuthority: input.selected.authority,
-		selectedAuthMethod: input.selected.authMethod,
-		walletId
-	}) || input.selected.selection.walletId !== walletId || input.selected.selection.walletAuthMethodId !== input.selected.authMethod.walletAuthMethodId || input.selected.selection.lockState !== "unlocked") throw new Error("Exact EVM-family Wallet Session authorization selected authority is invalid");
-	const authorization = buildPreprocessingSessionBinding(input);
-	if (!exactAuthorizationMatchesCapability({
-		capability: input.capability,
-		authorization,
-		nowMs: input.nowMs
-	})) throw new Error("Exact EVM-family Wallet Session authorization identity is inconsistent");
-	return authorization;
-}
-function buildExactEvmFamilyWalletSessionAuthorization(input) {
-	const authorization = signingAuthorizationFromPreprocessing(buildEcdsaPreprocessingCapability(input), input.nowMs);
-	if (!authorization) throw new Error("Exact ECDSA signing authorization requires remaining signing uses");
-	return authorization;
-}
-function buildEcdsaPreprocessingCapability(input) {
-	return {
-		kind: "authorized_ecdsa_preprocessing_capability",
-		capability: input.capability,
-		authorization: validateExactSessionAuthorization(input)
-	};
-}
-function signingAuthorizationFromPreprocessing(input, nowMs) {
-	const authorization = input.authorization;
-	const runtime = authorization.runtime;
-	if (runtime.remainingUses <= 0 || !exactAuthorizationMatchesCapability({
-		capability: input.capability,
-		authorization,
-		nowMs
-	})) return null;
-	if (isExactPasskeyWalletSessionRuntime(runtime) && authorization.selectedAuthMethod.kind === "passkey") return {
-		kind: "exact_evm_family_wallet_session_authorization_v1",
-		selectedAuthority: authorization.selectedAuthority,
-		selectedAuthMethod: authorization.selectedAuthMethod,
-		session: authorization.session,
-		operationCredential: authorization.operationCredential,
-		runtime
-	};
-	if (isExactEmailOtpWalletSessionRuntime(runtime) && authorization.selectedAuthMethod.kind === "email_otp") return {
-		kind: "exact_evm_family_wallet_session_authorization_v1",
-		selectedAuthority: authorization.selectedAuthority,
-		selectedAuthMethod: authorization.selectedAuthMethod,
-		session: authorization.session,
-		operationCredential: authorization.operationCredential,
-		runtime
-	};
-	return null;
-}
 function authorizeEvmFamilyEcdsaSigningCapability(input) {
 	if (input.authorization.runtime.remainingUses <= 0 || !exactAuthorizationMatchesCapability({
 		capability: input.capability,
@@ -212,20 +97,7 @@ function authorizeEvmFamilyEcdsaSigningCapability(input) {
 		authorization: input.authorization
 	};
 }
-async function buildCanonicalEvmFamilyEcdsaSigningCapability(input) {
-	const signer = input.manifest.signer;
-	const registeredPublicFacts = signer.registeredPublicFacts;
-	const materialPublicFacts = input.material.publicFacts;
-	const authorityRef = await walletAuthAuthorityRef({ authority: input.authority });
-	if (authorityRef.authorityDigest !== signer.authority.authorityDigest || authorityRef.walletId !== signer.walletId || input.material.authority.walletId !== signer.walletId || input.material.authority.authorityDigest !== signer.authority.authorityDigest || !mpcMaterialActivationRefsEqual(input.material.materialActivation, input.manifest.activation.materialActivation) || materialPublicFacts.walletId !== signer.walletId || materialPublicFacts.keyHandle !== registeredPublicFacts.keyHandle || String(materialPublicFacts.groupPublicKey33B64u) !== String(registeredPublicFacts.publicKeyB64u) || materialPublicFacts.ethereumAddress !== registeredPublicFacts.thresholdOwnerAddress || materialPublicFacts.participantIds.length !== registeredPublicFacts.participantIds.length || materialPublicFacts.participantIds.some((participantId, index) => participantId !== registeredPublicFacts.participantIds[index])) throw new Error("Canonical EVM-family ECDSA signing capability identity is inconsistent");
-	return {
-		kind: "canonical_evm_family_ecdsa_signing_capability",
-		authority: input.authority,
-		manifest: input.manifest,
-		material: input.material
-	};
-}
 //#endregion
-export { authorizeEvmFamilyEcdsaSigningCapability, buildCanonicalEvmFamilyEcdsaSigningCapability, buildEcdsaPreprocessingCapability, buildExactEcdsaDirectCapabilityRuntime, buildExactEvmFamilyWalletSessionAuthorization, exactAuthorizationMatchesCapability, exactEcdsaWalletSessionRuntimesMatch, signingAuthorizationFromPreprocessing };
+export { authorizeEvmFamilyEcdsaSigningCapability, exactAuthorizationMatchesCapability, exactEcdsaWalletSessionRuntimesMatch };
 
 //# sourceMappingURL=ecdsaSigningCapability.js.map

package/dist/esm/core/signingEngine/session/material/linkedEcdsaHolderRuntime.js

@@ -1,36 +1,12 @@
-import { mpcMaterialActivationRefsEqual } from "../../../../shared-ts/src/utils/domainIds.js";
 //#region src/core/signingEngine/session/material/linkedEcdsaHolderRuntime.ts
 const linkedHolderRuntimes = /* @__PURE__ */ new Map();
 function runtimeKey(input) {
 	return `${String(input.walletId)}\0${input.materialActivation.activationId}`;
 }
-function installLinkedEcdsaHolderRuntimeV1(runtime) {
-	const key = runtimeKey(runtime);
-	const existing = linkedHolderRuntimes.get(key);
-	if (existing && (existing.authorityId !== runtime.authorityId || existing.walletAuthMethodId !== runtime.walletAuthMethodId || existing.factorAuthority.walletId !== runtime.factorAuthority.walletId || existing.factorAuthority.bindingId !== runtime.factorAuthority.bindingId || existing.holderHandleId !== runtime.holderHandleId || !mpcMaterialActivationRefsEqual(existing.materialActivation, runtime.materialActivation))) throw new Error("linked ECDSA holder runtime conflicts with the active authority");
-	linkedHolderRuntimes.set(key, runtime);
-}
 function resolveLinkedEcdsaHolderRuntimeV1(input) {
 	return linkedHolderRuntimes.get(runtimeKey(input)) ?? null;
 }
-function listLinkedEcdsaHolderRuntimesV1(walletId) {
-	return [...linkedHolderRuntimes.values()].filter((runtime) => walletId === void 0 || runtime.walletId === walletId);
-}
-function removeLinkedEcdsaHolderRuntimeV1(input) {
-	const key = runtimeKey(input);
-	const runtime = linkedHolderRuntimes.get(key);
-	if (!runtime) return;
-	if (runtime.holderHandleId !== input.holderHandleId) throw new Error("linked ECDSA holder runtime changed before removal");
-	linkedHolderRuntimes.delete(key);
-}
-function clearLinkedEcdsaHolderRuntimesV1(walletId) {
-	if (!walletId) {
-		linkedHolderRuntimes.clear();
-		return;
-	}
-	for (const [key, runtime] of linkedHolderRuntimes) if (runtime.walletId === walletId) linkedHolderRuntimes.delete(key);
-}
 //#endregion
-export { clearLinkedEcdsaHolderRuntimesV1, installLinkedEcdsaHolderRuntimeV1, listLinkedEcdsaHolderRuntimesV1, removeLinkedEcdsaHolderRuntimeV1, resolveLinkedEcdsaHolderRuntimeV1 };
+export { resolveLinkedEcdsaHolderRuntimeV1 };
 
 //# sourceMappingURL=linkedEcdsaHolderRuntime.js.map