@seams/wallet 0.8.0 → 0.9.1

package/dist/esm/core/indexedDB/seamsWalletDB/ecdsaCapabilityManifestStore.js

@@ -1,28 +1,11 @@
-import { mpcMaterialActivationRefsEqual, parseMpcMaterialActivationRef, parseWalletId } from "../../../shared-ts/src/utils/domainIds.js";
-import { requireRecord } from "../../../shared-ts/src/utils/validation.js";
-import { base64UrlEncode } from "../../../shared-ts/src/utils/base64.js";
-import { parseCorrelationId } from "../../../shared-ts/src/utils/canonicalPrimitives.js";
-import { normalizeRuntimePolicyScope } from "../../../shared-ts/src/threshold/signingRootScope.js";
 import { secureRandomId } from "../../../shared-ts/src/utils/secureRandomId.js";
-import { routerAbMpcMaterialActivationRefFromWire } from "../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
-import { parseEcdsaClientVerifyingPublicKey33B64u, parseEcdsaRoleLocalPersistedMaterialRef } from "../../signingEngine/session/keyMaterialBrands.js";
-import { parseEcdsaCiphertextDigest, parseEcdsaMaterialSealingKeyId, parseEcdsaPendingCiphertextDigest } from "../../../shared-ts/src/utils/ecdsaCapabilityActivation.js";
-import { sameRouterAbEcdsaDerivationNormalSigningStateV1 } from "../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
-import { buildEcdsaRoleLocalPublicFacts } from "../../signingEngine/session/persistence/ecdsaRoleLocalRecords.js";
-import { buildActiveEcdsaCapabilityManifest, buildDurableEcdsaMaterialBinding, buildEcdsaServerActivationCommit, buildEncryptedEcdsaPendingCandidate, buildServerCommittedEcdsaActivationJournal, buildValidatedEncryptedEcdsaReadyMaterial } from "../../signingEngine/session/material/ecdsaCapabilityManifest.js";
-import { SEAMS_WALLET_INDEXES } from "../schemaNames.js";
-import { seamsWalletDB } from "../singletons.js";
-import { ecdsaClientPresignPoolKey, equalEcdsaClientPresignPoolIdentity, parseEcdsaClientPresignPoolIdentity } from "../../signingEngine/workerManager/ecdsaPresignPoolIdentity.js";
-import "../../signingEngine/workerManager/ecdsaPresignLifecycle.js";
-import { JOURNAL_STORE, MANIFEST_RECORD_VERSION, MANIFEST_STORE, MATERIAL_STORE, POINTER_STORE, PRESIGNATURE_STORE, SEALING_KEY_STORE, assertNever, buildPreparedJournalFromEncryptedCandidate, ciphertextDigestB64u, decryptStateBlob, ecdsaActivationCommitJournalsMatch, ecdsaActiveCapabilityManifestsMatch, ecdsaCapabilityScopesMatch, ecdsaDurableMaterialBindingsMatch, ecdsaRegisteredPublicFactsMatch, ecdsaRoleLocalMaterialBindingsMatch, ecdsaRoleLocalPublicFactsMatch, ecdsaServerActivationCommitsMatch, encryptStateBlob, generateMaterialSealingKey, materialMatchesManifest, normalizeSelector, parseActiveProof, parseCommittedJournal, parseJournalRow, parseManifestRow, parseMaterialLocator, parseMaterialRow, parsePointerRow, parseSealingKeyRow, preparedJournalProjection, runtimePolicyScopesMatch, selectorColumns, selectorFromJournal, selectorFromManifest, selectorFromSigner, selectorKey, selectorsMatch, storedJournalRow, storedMaterialRow, storedPointerRow, storedSealingKeyRow, walletAuthAuthorityRefsMatch } from "./ecdsaCapabilityManifestRecords.js";
-import { activeMaterialMatchesPresignature, decryptPresignatureBytes, deleteCursorRows, encryptPresignatureBytes, materialRefMatchesPoolIdentity, metadataFromPresignatureRow, parseDurableClientPresignatureRecordId, parsePresignatureTimestamp, parseSealedAvailableClientPresignatureRow, rawRecordId, readAvailableClientPresignatureRows, retireClientPresignaturesForActivationInTransaction, supportsStrictIndexedDbDurability } from "./ecdsaClientPresignatures.js";
-import { activeLookupUsesMaterialActivation, ecdsaManifestErrorMessage, isConstraintError, journalConstraintConflict, lookupInTransaction, materialRefOpenFailure, persistenceDigest, readActivationJournalRows, readActiveManifestRows, readPointerRowsForWallet, retryCorrelation } from "./ecdsaCapabilityManifestLookups.js";
+import { parseEcdsaCiphertextDigest, parseEcdsaMaterialSealingKeyId } from "../../../shared-ts/src/utils/ecdsaCapabilityActivation.js";
+import "../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
+import { buildActiveEcdsaCapabilityManifest, buildDurableEcdsaMaterialBinding, buildEcdsaServerActivationCommit, buildValidatedEncryptedEcdsaReadyMaterial } from "../../signingEngine/session/material/ecdsaCapabilityManifest.js";
+import { MANIFEST_RECORD_VERSION, MANIFEST_STORE, MATERIAL_STORE, POINTER_STORE, SEALING_KEY_STORE, encryptStateBlob, generateMaterialSealingKey, selectorColumns, selectorFromManifest, selectorKey, storedMaterialRow, storedPointerRow, storedSealingKeyRow } from "./ecdsaCapabilityManifestRecords.js";
+import { readActiveManifestRows } from "./ecdsaCapabilityManifestLookups.js";
 //#region src/core/indexedDB/seamsWalletDB/ecdsaCapabilityManifestStore.ts
 const MATERIAL_AAD_VERSION = 1;
-function activeManifestMatchesWalletCustodyImport(manifest, input, serverActivation) {
-	const binding = input.activationBinding;
-	return walletAuthAuthorityRefsMatch(manifest.signer.authority, binding.signer.authority) && ecdsaCapabilityScopesMatch(manifest.signer.scope, binding.signer.scope) && manifest.signer.walletId === binding.signer.walletId && manifest.signer.capability === binding.signer.capability && manifest.signer.materialOwner === binding.signer.materialOwner && manifest.signer.signingRootId === binding.signer.signingRootId && manifest.signer.signingRootVersion === binding.signer.signingRootVersion && ecdsaRegisteredPublicFactsMatch(manifest.signer.registeredPublicFacts, input.registeredPublicFacts) && ecdsaServerActivationCommitsMatch(manifest.activation.serverActivation, serverActivation) && mpcMaterialActivationRefsEqual(manifest.activation.materialActivation, routerAbMpcMaterialActivationRefFromWire(serverActivation.serverActivationReceipt.protocolReceipt.ecdsa_activation.material_activation)) && manifest.durableMaterial.bindingDigest === binding.bindingDigest && manifest.durableMaterial.durableMaterialRef === binding.durableMaterialRef && ecdsaRoleLocalMaterialBindingsMatch(manifest.durableMaterial.roleLocalBinding, binding.roleLocalBinding) && ecdsaRoleLocalPublicFactsMatch(manifest.durableMaterial.roleLocalPublicFacts, input.roleLocalPublicFacts) && sameRouterAbEcdsaDerivationNormalSigningStateV1(manifest.durableMaterial.routerAbEcdsaDerivationNormalSigning, input.routerAbEcdsaDerivationNormalSigning) && runtimePolicyScopesMatch(manifest.durableMaterial.runtimePolicyScope, normalizeRuntimePolicyScope(input.runtimePolicyScope));
-}
 var FinalizationControlError = class extends Error {
 	constructor(kind, message) {
 		super(message);
@@ -48,42 +31,6 @@ function activationBindingAadProjection(binding) {
 		durable_material_ref: binding.durableMaterialRef
 	};
 }
-function pendingAadProjection(input) {
-	if ("activationBinding" in input) return {
-		version: MATERIAL_AAD_VERSION,
-		stage: "activation_prepared",
-		journal_id: input.journalId,
-		expected_manifest: input.expectedManifest,
-		activation_command: {
-			kind: "ecdsa_server_activation_command",
-			correlationId: input.journalId,
-			expectedGeneration: input.expectedGeneration,
-			requestDigest: input.requestDigest,
-			canonicalRequest: input.canonicalRequest
-		},
-		activation_binding: activationBindingAadProjection(input.activationBinding),
-		created_at: input.createdAt
-	};
-	return {
-		version: MATERIAL_AAD_VERSION,
-		stage: "activation_prepared",
-		journal_id: input.journalId,
-		expected_manifest: input.expectedManifest,
-		activation_command: input.activationCommand,
-		activation_binding: activationBindingAadProjection(input.candidate.activationBinding),
-		created_at: input.createdAt
-	};
-}
-function readyAadProjection(input) {
-	if (input.kind === "server_activation_committed") return readyAadProjectionFor(input.candidate.activationBinding, input.serverActivation);
-	return readyAadProjectionFor({
-		targetManifest: input.identity,
-		signer: input.signer,
-		roleLocalBinding: input.durableMaterial.roleLocalBinding,
-		bindingDigest: input.durableMaterial.bindingDigest,
-		durableMaterialRef: input.durableMaterial.durableMaterialRef
-	}, input.activation.serverActivation);
-}
 function readyAadProjectionFor(activationBinding, serverActivation) {
 	return {
 		version: MATERIAL_AAD_VERSION,
@@ -119,13 +66,6 @@ function storedActiveManifestRow(proof) {
 		active_proof: storedActiveProof(proof)
 	};
 }
-function storedReplacedManifestRow(previous, replacement) {
-	return {
-		...manifestRowCommon(previous, "replaced"),
-		active_proof: storedActiveProof(previous),
-		replacement_proof: storedActiveProof(replacement)
-	};
-}
 async function prepareImportedWalletCustodyEcdsaContinuity(input) {
 	const serverActivation = buildEcdsaServerActivationCommit({
 		activationBinding: input.activationBinding,
@@ -191,1025 +131,7 @@ async function persistPreparedImportedWalletCustodyEcdsaContinuityInTransaction(
 	await context.store(MANIFEST_STORE).add(storedActiveManifestRow(activeProof));
 	await pointerStore.put(storedPointerRow(prepared.activeManifest));
 }
-function assertActiveProofInput(input) {
-	const parsed = parseActiveProof(storedActiveProof({
-		activationBinding: input.committedJournal.candidate.activationBinding,
-		serverActivation: input.committedJournal.serverActivation,
-		durableMaterial: input.readyMaterial.binding,
-		activeManifest: input.activeManifest,
-		committedAt: input.activeManifest.committedAt
-	}));
-	if (!ecdsaActiveCapabilityManifestsMatch(parsed.activeManifest, input.activeManifest) || !ecdsaDurableMaterialBindingsMatch(parsed.durableMaterial, input.readyMaterial.binding)) throw new Error("ECDSA finalization input does not describe one exact active manifest");
-	return parsed;
-}
-function assertExpectedPointer(expected, pointerRaw, selector) {
-	switch (expected.kind) {
-		case "no_current_manifest":
-			if (pointerRaw !== void 0) throw new FinalizationControlError("exact_record_conflict", "initial ECDSA activation found an existing current pointer");
-			return null;
-		case "exact_manifest": {
-			if (pointerRaw === void 0) throw new FinalizationControlError("exact_record_conflict", "replacement ECDSA activation is missing its expected current pointer");
-			let pointer;
-			try {
-				pointer = parsePointerRow(pointerRaw);
-			} catch (error) {
-				throw new FinalizationControlError("corrupt", ecdsaManifestErrorMessage(error));
-			}
-			if (!selectorsMatch(pointer.selector, selector) || pointer.manifestId !== expected.manifestId || pointer.manifestRevision !== expected.manifestRevision) throw new FinalizationControlError("exact_record_conflict", "replacement ECDSA activation pointer CAS did not match");
-			return pointer;
-		}
-	}
-	return assertNever(expected);
-}
-async function cancelPreparedActivationInTransaction(preparedJournal, context) {
-	const journalStore = context.store(JOURNAL_STORE);
-	const raw = await journalStore.get(preparedJournal.journalId);
-	if (raw === void 0) return { kind: "missing" };
-	let persisted;
-	try {
-		persisted = parseJournalRow(raw);
-	} catch {
-		return { kind: "corrupt" };
-	}
-	if (persisted.journal.journalId !== preparedJournal.journalId) return { kind: "corrupt" };
-	switch (persisted.journal.kind) {
-		case "server_activation_committed": return { kind: "server_activation_committed" };
-		case "activation_prepared":
-			if (!ecdsaActivationCommitJournalsMatch(persisted.journal, preparedJournal)) return { kind: "exact_record_conflict" };
-			await context.store(SEALING_KEY_STORE).delete(persisted.journal.candidate.encryptedPending.sealingKeyId);
-			await journalStore.delete(persisted.journal.journalId);
-			return { kind: "cancelled" };
-	}
-	return assertNever(persisted.journal);
-}
-function persistPreparedContinuity(manager, prepared) {
-	return manager.runTransaction([
-		MANIFEST_STORE,
-		POINTER_STORE,
-		MATERIAL_STORE,
-		SEALING_KEY_STORE
-	], "readwrite", (context) => persistPreparedImportedWalletCustodyEcdsaContinuityInTransaction(context, prepared));
-}
-async function importCommittedActivation(store, input, persist) {
-	const serverActivation = buildEcdsaServerActivationCommit({
-		activationBinding: input.activationBinding,
-		serverCommit: input.serverCommit
-	});
-	const selector = selectorFromSigner(input.activationBinding.signer);
-	const existing = await store.lookup(selector);
-	if (existing.kind === "active") {
-		if (activeManifestMatchesWalletCustodyImport(existing.manifest, input, serverActivation)) return {
-			kind: "committed",
-			manifest: existing.manifest,
-			material: existing.material
-		};
-		return {
-			kind: "exact_record_conflict",
-			selector,
-			conflictDigest: await persistenceDigest("custody_import_conflict", selector, "ECDSA custody import conflicts with the active manifest")
-		};
-	}
-	try {
-		const prepared = await prepareImportedWalletCustodyEcdsaContinuity(input);
-		await persist(prepared);
-		return {
-			kind: "committed",
-			manifest: prepared.activeManifest,
-			material: prepared.readyMaterial
-		};
-	} catch (error) {
-		if (error instanceof FinalizationControlError || isConstraintError(error)) {
-			const replay = await store.lookup(selector);
-			if (replay.kind === "active" && activeManifestMatchesWalletCustodyImport(replay.manifest, input, serverActivation)) return {
-				kind: "committed",
-				manifest: replay.manifest,
-				material: replay.material
-			};
-			return {
-				kind: "exact_record_conflict",
-				selector,
-				conflictDigest: await persistenceDigest("custody_import_conflict", selector, ecdsaManifestErrorMessage(error))
-			};
-		}
-		return {
-			kind: "corrupt",
-			selector,
-			corruptionDigest: await persistenceDigest("custody_import_corrupt", selector, ecdsaManifestErrorMessage(error))
-		};
-	}
-}
-var IndexedDbEcdsaCapabilityManifestStore = class {
-	constructor(manager = seamsWalletDB) {
-		this.manager = manager;
-	}
-	async admitClientPresignature(input) {
-		if (!supportsStrictIndexedDbDurability()) return { kind: "persistence_unavailable" };
-		const poolIdentity = parseEcdsaClientPresignPoolIdentity(input.poolIdentity);
-		const durableMaterialRef = parseEcdsaRoleLocalPersistedMaterialRef(input.durableMaterialRef);
-		if (!materialRefMatchesPoolIdentity(durableMaterialRef, poolIdentity)) return { kind: "persistence_unavailable" };
-		if (input.groupPublicKey33.length !== 33 || input.bigR33.length !== 33) return { kind: "persistence_unavailable" };
-		const createdAtMs = parsePresignatureTimestamp(input.createdAtMs, "createdAtMs");
-		const expiresAtMs = parsePresignatureTimestamp(input.expiresAtMs, "expiresAtMs");
-		if (createdAtMs > Date.now() + 3e5 || expiresAtMs <= createdAtMs || expiresAtMs > createdAtMs + 7776e6) return { kind: "persistence_unavailable" };
-		const presignatureId = String(input.presignatureId || "").trim();
-		if (!presignatureId || input.plaintext97.length !== 97) return { kind: "persistence_unavailable" };
-		let lookup;
-		try {
-			lookup = await this.lookupByMaterialRef(durableMaterialRef);
-		} catch {
-			return { kind: "persistence_unavailable" };
-		}
-		if (lookup.kind !== "active") return { kind: "persistence_unavailable" };
-		if (!activeMaterialMatchesPresignature(lookup.material, poolIdentity, durableMaterialRef)) return { kind: "persistence_unavailable" };
-		let sealingKey;
-		try {
-			sealingKey = await this.readMaterialSealingKey(lookup.material.sealingKeyId);
-		} catch {
-			return { kind: "persistence_unavailable" };
-		}
-		if (!sealingKey) return { kind: "persistence_unavailable" };
-		const recordId = parseDurableClientPresignatureRecordId(secureRandomId("ecdsa-client-presignature", 32, "ECDSA durable presignature record"));
-		const groupPublicKey33B64u = parseEcdsaClientVerifyingPublicKey33B64u(base64UrlEncode(input.groupPublicKey33));
-		const bigR33B64u = parseEcdsaClientVerifyingPublicKey33B64u(base64UrlEncode(input.bigR33));
-		const metadata = {
-			kind: "sealed_available_client_presignature_v1",
-			recordId,
-			poolIdentity,
-			durableMaterialRef,
-			presignatureId,
-			groupPublicKey33B64u,
-			bigR33B64u,
-			createdAtMs,
-			expiresAtMs,
-			sealingKeyId: lookup.material.sealingKeyId
-		};
-		let encrypted;
-		try {
-			encrypted = await encryptPresignatureBytes({
-				key: sealingKey,
-				plaintext97: input.plaintext97,
-				metadata
-			});
-		} catch {
-			input.plaintext97.fill(0);
-			return { kind: "persistence_unavailable" };
-		}
-		const row = {
-			kind: "sealed_available_client_presignature_v1",
-			record_id: recordId,
-			pool_identity: poolIdentity,
-			pool_identity_key: ecdsaClientPresignPoolKey(poolIdentity),
-			wallet_id: poolIdentity.walletId,
-			material_activation_id: poolIdentity.materialActivationId,
-			durable_material_ref: durableMaterialRef,
-			presignature_id: presignatureId,
-			group_public_key33_b64u: groupPublicKey33B64u,
-			big_r33_b64u: bigR33B64u,
-			created_at_ms: createdAtMs,
-			expires_at_ms: expiresAtMs,
-			sealed: {
-				kind: "ecdsa_activation_aes_gcm_v1",
-				sealing_key_id: lookup.material.sealingKeyId,
-				iv12_b64u: encrypted.iv12B64u,
-				ciphertext_b64u: encrypted.ciphertextB64u,
-				ciphertext_digest_b64u: encrypted.ciphertextDigestB64u
-			}
-		};
-		try {
-			const result = await this.manager.runTransaction([PRESIGNATURE_STORE, MATERIAL_STORE], "readwrite", async (context) => {
-				if ((await readAvailableClientPresignatureRows(context, poolIdentity, Date.now())).length >= 5) return { kind: "capacity_full" };
-				const materialRow = await context.store(MATERIAL_STORE).get(durableMaterialRef.durableMaterialRef);
-				if (materialRow === void 0) return { kind: "persistence_unavailable" };
-				try {
-					const locator = parseMaterialLocator(materialRow);
-					const materialRecord = requireRecord(materialRow, "ECDSA role-local material row");
-					if (locator.durableMaterialRef !== durableMaterialRef.durableMaterialRef || locator.bindingDigest !== durableMaterialRef.bindingDigest || locator.selector.capability !== lookup.manifest.signer.capability || String(locator.selector.authority.walletId) !== poolIdentity.walletId || parseEcdsaMaterialSealingKeyId(materialRecord.sealing_key_id) !== lookup.material.sealingKeyId) return { kind: "persistence_unavailable" };
-				} catch {
-					return { kind: "persistence_unavailable" };
-				}
-				await context.store(PRESIGNATURE_STORE).put(row);
-				return { kind: "stored" };
-			}, { durability: "strict" });
-			return result.kind === "stored" ? {
-				kind: "stored",
-				metadata
-			} : result;
-		} catch {
-			return { kind: "persistence_ambiguous" };
-		}
-	}
-	async listAvailableClientPresignatures(poolIdentityInput) {
-		if (!supportsStrictIndexedDbDurability()) return [];
-		const poolIdentity = parseEcdsaClientPresignPoolIdentity(poolIdentityInput);
-		const nowMs = Date.now();
-		try {
-			return await this.manager.runTransaction([PRESIGNATURE_STORE], "readwrite", async (context) => {
-				return (await readAvailableClientPresignatureRows(context, poolIdentity, nowMs)).map(metadataFromPresignatureRow).sort((left, right) => left.createdAtMs - right.createdAtMs);
-			});
-		} catch {
-			return [];
-		}
-	}
-	async takeClientPresignature(input) {
-		if (!supportsStrictIndexedDbDurability()) return { kind: "persistence_unavailable" };
-		const recordId = parseDurableClientPresignatureRecordId(input.recordId);
-		const poolIdentity = parseEcdsaClientPresignPoolIdentity(input.poolIdentity);
-		let row;
-		try {
-			const claimed = await this.manager.runTransaction([PRESIGNATURE_STORE], "readwrite", async (context) => {
-				const store = context.store(PRESIGNATURE_STORE);
-				const raw = await store.get(recordId);
-				if (raw === void 0) return { kind: "claimed_elsewhere" };
-				let parsed;
-				try {
-					parsed = parseSealedAvailableClientPresignatureRow(raw);
-				} catch {
-					const malformedRecordId = rawRecordId(raw);
-					if (malformedRecordId) await store.delete(malformedRecordId);
-					return { kind: "corrupt" };
-				}
-				if (!equalEcdsaClientPresignPoolIdentity(parsed.pool_identity, poolIdentity)) {
-					await store.delete(recordId);
-					return { kind: "binding_rejected" };
-				}
-				if (parsed.expires_at_ms <= Date.now()) {
-					await store.delete(recordId);
-					return { kind: "expired" };
-				}
-				await store.delete(recordId);
-				return {
-					kind: "claimed",
-					row: parsed
-				};
-			}, { durability: "strict" });
-			if (claimed.kind !== "claimed") return { kind: claimed.kind };
-			row = claimed.row;
-		} catch {
-			return { kind: "persistence_unavailable" };
-		}
-		let lookup;
-		try {
-			lookup = await this.lookupByMaterialRef(row.durable_material_ref);
-		} catch {
-			return { kind: "persistence_unavailable" };
-		}
-		if (lookup.kind !== "active" || !activeMaterialMatchesPresignature(lookup.material, poolIdentity, row.durable_material_ref) || lookup.material.sealingKeyId !== row.sealed.sealing_key_id) return { kind: "binding_rejected" };
-		let sealingKey;
-		try {
-			sealingKey = await this.readMaterialSealingKey(row.sealed.sealing_key_id);
-		} catch {
-			return { kind: "persistence_unavailable" };
-		}
-		if (!sealingKey) return { kind: "corrupt" };
-		const metadata = metadataFromPresignatureRow(row);
-		try {
-			return {
-				kind: "opened",
-				metadata,
-				plaintext97: await decryptPresignatureBytes({
-					key: sealingKey,
-					metadata,
-					sealed: row.sealed
-				})
-			};
-		} catch {
-			return { kind: "corrupt" };
-		}
-	}
-	async deleteClientPresignature(input) {
-		const recordId = parseDurableClientPresignatureRecordId(input.recordId);
-		const poolIdentity = parseEcdsaClientPresignPoolIdentity(input.poolIdentity);
-		await this.manager.runTransaction([PRESIGNATURE_STORE], "readwrite", async (context) => {
-			const store = context.store(PRESIGNATURE_STORE);
-			const raw = await store.get(recordId);
-			if (raw === void 0) return;
-			if (equalEcdsaClientPresignPoolIdentity(parseSealedAvailableClientPresignatureRow(raw).pool_identity, poolIdentity)) await store.delete(recordId);
-		});
-	}
-	async deleteClientPresignatures(target) {
-		return await this.manager.runTransaction([PRESIGNATURE_STORE], "readwrite", async (context) => {
-			const store = context.store(PRESIGNATURE_STORE);
-			let deletedCount = 0;
-			switch (target.kind) {
-				case "wallet": {
-					const walletId = String(target.walletId).trim();
-					if (!walletId) throw new Error("ECDSA durable presignature wallet id is required");
-					deletedCount = await deleteCursorRows(await store.index(SEAMS_WALLET_INDEXES.walletId).openCursor(walletId));
-					break;
-				}
-				case "all":
-					deletedCount = await deleteCursorRows(await store.openCursor());
-					break;
-			}
-			return deletedCount;
-		});
-	}
-	async listActiveWalletCapabilitySubjects(walletIdInput) {
-		const parsedWalletId = parseWalletId(walletIdInput);
-		if (!parsedWalletId.ok) return { kind: "invalid_current_state" };
-		let rows;
-		try {
-			rows = await this.manager.runTransaction([POINTER_STORE], "readonly", (context) => readPointerRowsForWallet(context, parsedWalletId.value));
-		} catch {
-			return { kind: "persistence_unavailable" };
-		}
-		const selectors = [];
-		try {
-			for (const row of rows) {
-				const pointer = parsePointerRow(row);
-				if (pointer.selector.authority.walletId === parsedWalletId.value) selectors.push(pointer.selector);
-			}
-		} catch {
-			return { kind: "invalid_current_state" };
-		}
-		const subjects = [];
-		for (const selector of selectors) {
-			const lookup = await this.lookup(selector);
-			if (lookup.kind === "persistence_unavailable") return { kind: "persistence_unavailable" };
-			if (lookup.kind !== "active") return { kind: "invalid_current_state" };
-			subjects.push({
-				capability: lookup.manifest.signer.capability,
-				authority: lookup.manifest.signer.authority,
-				ecdsaThresholdKeyId: lookup.manifest.durableMaterial.roleLocalBinding.ecdsaThresholdKeyId
-			});
-		}
-		return {
-			kind: "resolved",
-			subjects
-		};
-	}
-	async listWalletActivationJournalSelectors(walletIdInput) {
-		const parsedWalletId = parseWalletId(walletIdInput);
-		if (!parsedWalletId.ok) return { kind: "invalid_current_state" };
-		let rows;
-		try {
-			rows = await this.manager.runTransaction([JOURNAL_STORE], "readonly", readActivationJournalRows);
-		} catch {
-			return { kind: "persistence_unavailable" };
-		}
-		const selectors = [];
-		try {
-			for (const row of rows) {
-				const signer = parseJournalRow(row).journal.candidate.activationBinding.signer;
-				if (signer.authority.walletId !== parsedWalletId.value) continue;
-				selectors.push(selectorFromSigner(signer));
-			}
-		} catch {
-			return { kind: "invalid_current_state" };
-		}
-		return {
-			kind: "resolved",
-			selectors
-		};
-	}
-	async prepareActivation(input) {
-		const selector = selectorFromSigner(input.activationBinding.signer);
-		try {
-			const keyId = parseEcdsaMaterialSealingKeyId(secureRandomId("ecdsa-material-key", 32, "ECDSA activation material sealing key"));
-			const key = await generateMaterialSealingKey();
-			const encrypted = await encryptStateBlob({
-				key,
-				stateBlobB64u: input.pendingPayloadB64u,
-				aadProjection: pendingAadProjection(input)
-			});
-			const journal = buildPreparedJournalFromEncryptedCandidate({
-				preparation: input,
-				encryptedPending: buildEncryptedEcdsaPendingCandidate({
-					sealingKeyId: keyId,
-					iv12B64u: encrypted.iv12B64u,
-					ciphertextB64u: encrypted.ciphertextB64u,
-					ciphertextDigest: parseEcdsaPendingCiphertextDigest(encrypted.digestB64u)
-				})
-			});
-			await this.manager.runTransaction([SEALING_KEY_STORE, JOURNAL_STORE], "readwrite", async (context) => {
-				await context.store(SEALING_KEY_STORE).add(storedSealingKeyRow(keyId, key));
-				await context.store(JOURNAL_STORE).add(storedJournalRow(journal));
-			});
-			return {
-				kind: "stored",
-				journal
-			};
-		} catch (error) {
-			if (isConstraintError(error)) return await journalConstraintConflict(selector, error);
-			if (error instanceof DOMException && error.name === "OperationError") return {
-				kind: "corrupt",
-				corruptionDigest: await persistenceDigest("journal_encryption_failed", selector, ecdsaManifestErrorMessage(error))
-			};
-			if (error instanceof Error && !(error instanceof DOMException)) return {
-				kind: "corrupt",
-				corruptionDigest: await persistenceDigest("journal_preparation_invalid", selector, error.message)
-			};
-			return {
-				kind: "persistence_unavailable",
-				retryCorrelation: retryCorrelation()
-			};
-		}
-	}
-	async recordServerActivation(input) {
-		let committedJournal;
-		try {
-			committedJournal = buildServerCommittedEcdsaActivationJournal(input);
-		} catch (error) {
-			return {
-				kind: "corrupt",
-				corruptionDigest: await persistenceDigest("server_activation_commit_corrupt", selectorFromJournal(input.preparedJournal), ecdsaManifestErrorMessage(error))
-			};
-		}
-		return await this.putActivationJournal(committedJournal);
-	}
-	async putActivationJournal(journalInput) {
-		let journal;
-		try {
-			journal = parseCommittedJournal(journalInput);
-			if (await ciphertextDigestB64u(journal.candidate.encryptedPending.ciphertextB64u) !== journal.candidate.encryptedPending.ciphertextDigest) throw new Error("ECDSA pending material ciphertext digest is invalid");
-		} catch (error) {
-			return {
-				kind: "corrupt",
-				corruptionDigest: await persistenceDigest("journal_input_corrupt", selectorFromJournal(journalInput), ecdsaManifestErrorMessage(error))
-			};
-		}
-		const selector = selectorFromJournal(journal);
-		try {
-			const sealingKey = await this.readMaterialSealingKey(journal.candidate.encryptedPending.sealingKeyId);
-			if (!sealingKey) throw new FinalizationControlError("corrupt", "ECDSA activation journal references a missing sealing key");
-			await decryptStateBlob({
-				key: sealingKey,
-				iv12B64u: journal.candidate.encryptedPending.iv12B64u,
-				ciphertextB64u: journal.candidate.encryptedPending.ciphertextB64u,
-				aadProjection: pendingAadProjection(journal)
-			});
-			await this.manager.runTransaction([SEALING_KEY_STORE, JOURNAL_STORE], "readwrite", async (context) => {
-				const sealingKeyRaw = await context.store(SEALING_KEY_STORE).get(journal.candidate.encryptedPending.sealingKeyId);
-				if (sealingKeyRaw === void 0) throw new FinalizationControlError("corrupt", "ECDSA activation journal references a missing sealing key");
-				try {
-					parseSealingKeyRow(sealingKeyRaw);
-				} catch (error) {
-					throw new FinalizationControlError("corrupt", ecdsaManifestErrorMessage(error));
-				}
-				const journalStore = context.store(JOURNAL_STORE);
-				const existingRaw = await journalStore.get(journal.journalId);
-				if (existingRaw === void 0) throw new FinalizationControlError("exact_record_conflict", "ECDSA committed activation is missing its prepared journal");
-				let existing;
-				try {
-					existing = parseJournalRow(existingRaw);
-				} catch (error) {
-					throw new FinalizationControlError("corrupt", ecdsaManifestErrorMessage(error));
-				}
-				if (!selectorsMatch(existing.selector, selector) || existing.journal.kind === "activation_prepared" && !ecdsaActivationCommitJournalsMatch(existing.journal, preparedJournalProjection(journal)) || existing.journal.kind === "server_activation_committed" && !ecdsaActivationCommitJournalsMatch(existing.journal, journal)) throw new FinalizationControlError("exact_record_conflict", "ECDSA activation journal conflicts with its existing correlation");
-				await journalStore.put(storedJournalRow(journal));
-			});
-			return {
-				kind: "stored",
-				journal
-			};
-		} catch (error) {
-			if (error instanceof FinalizationControlError) {
-				const digest = await persistenceDigest(error.kind === "corrupt" ? "journal_corrupt" : "journal_conflict", selector, error.message);
-				return error.kind === "corrupt" ? {
-					kind: "corrupt",
-					corruptionDigest: digest
-				} : {
-					kind: "exact_record_conflict",
-					conflictDigest: digest
-				};
-			}
-			if (isConstraintError(error)) return await journalConstraintConflict(selector, error);
-			if (error instanceof DOMException && error.name === "OperationError") return {
-				kind: "corrupt",
-				corruptionDigest: await persistenceDigest("journal_ciphertext_corrupt", selector, ecdsaManifestErrorMessage(error))
-			};
-			return {
-				kind: "persistence_unavailable",
-				retryCorrelation: retryCorrelation()
-			};
-		}
-	}
-	async readActivationJournal(journalIdInput) {
-		const journalId = parseCorrelationId(journalIdInput);
-		try {
-			const raw = await this.manager.runTransaction([JOURNAL_STORE], "readonly", async (context) => await context.store(JOURNAL_STORE).get(journalId));
-			if (raw === void 0) return { kind: "missing" };
-			try {
-				const parsed = parseJournalRow(raw);
-				return parsed.journal.journalId === journalId ? {
-					kind: "found",
-					journal: parsed.journal
-				} : { kind: "corrupt" };
-			} catch {
-				return { kind: "corrupt" };
-			}
-		} catch {
-			return { kind: "persistence_unavailable" };
-		}
-	}
-	async discoverActivationJournal(selectorInput) {
-		let selector;
-		try {
-			selector = normalizeSelector(selectorInput);
-		} catch {
-			return { kind: "corrupt" };
-		}
-		try {
-			const raw = await this.manager.runTransaction([JOURNAL_STORE], "readonly", async (context) => await context.store(JOURNAL_STORE).index(SEAMS_WALLET_INDEXES.capabilityWalletAuthority).get(selectorKey(selector)));
-			if (raw === void 0) return { kind: "missing" };
-			try {
-				const parsed = parseJournalRow(raw);
-				return selectorsMatch(parsed.selector, selector) ? {
-					kind: "found",
-					journal: parsed.journal
-				} : { kind: "corrupt" };
-			} catch {
-				return { kind: "corrupt" };
-			}
-		} catch {
-			return { kind: "persistence_unavailable" };
-		}
-	}
-	async cancelPreparedActivation(preparedJournal) {
-		try {
-			return await this.manager.runTransaction([SEALING_KEY_STORE, JOURNAL_STORE], "readwrite", cancelPreparedActivationInTransaction.bind(void 0, preparedJournal));
-		} catch {
-			return { kind: "persistence_unavailable" };
-		}
-	}
-	async openPreparedActivation(journalIdInput) {
-		const read = await this.readActivationJournal(journalIdInput);
-		if (read.kind !== "found") return read;
-		const encryptedPending = read.journal.candidate.encryptedPending;
-		try {
-			if (await ciphertextDigestB64u(encryptedPending.ciphertextB64u) !== encryptedPending.ciphertextDigest) return { kind: "corrupt" };
-			const sealingKey = await this.readMaterialSealingKey(encryptedPending.sealingKeyId);
-			if (!sealingKey) return { kind: "corrupt" };
-			return {
-				kind: "found",
-				journal: read.journal,
-				pendingPayloadB64u: await decryptStateBlob({
-					key: sealingKey,
-					iv12B64u: encryptedPending.iv12B64u,
-					ciphertextB64u: encryptedPending.ciphertextB64u,
-					aadProjection: pendingAadProjection(read.journal)
-				})
-			};
-		} catch {
-			return { kind: "corrupt" };
-		}
-	}
-	async lookup(selectorInput) {
-		const selector = normalizeSelector(selectorInput);
-		let observation;
-		try {
-			observation = await this.manager.runTransaction([
-				MANIFEST_STORE,
-				POINTER_STORE,
-				MATERIAL_STORE,
-				SEALING_KEY_STORE
-			], "readonly", async (context) => await lookupInTransaction(context, selector));
-		} catch {
-			return {
-				kind: "persistence_unavailable",
-				selector,
-				retryCorrelation: retryCorrelation()
-			};
-		}
-		switch (observation.kind) {
-			case "active": return observation;
-			case "retired": return observation;
-			case "missing": return {
-				kind: "missing",
-				selector,
-				subject: observation.subject
-			};
-			case "exact_binding_mismatch": return {
-				kind: "exact_binding_mismatch",
-				selector,
-				failureDigest: await persistenceDigest(observation.kind, selector, observation.detail)
-			};
-			case "exact_record_conflict": return {
-				kind: "exact_record_conflict",
-				selector,
-				conflictDigest: await persistenceDigest(observation.kind, selector, observation.detail)
-			};
-			case "corrupt": return {
-				kind: "corrupt",
-				selector,
-				corruptionDigest: await persistenceDigest(observation.kind, selector, observation.detail)
-			};
-		}
-		return assertNever(observation);
-	}
-	async lookupByMaterialActivation(input) {
-		const walletIdResult = parseWalletId(input.walletId);
-		const materialActivationResult = parseMpcMaterialActivationRef(input.materialActivation);
-		const capability = materialActivationResult.ok ? materialActivationResult.value.capability : input.materialActivation.capability;
-		if (!walletIdResult.ok || !materialActivationResult.ok) return {
-			kind: "corrupt",
-			capability
-		};
-		const walletId = walletIdResult.value;
-		const materialActivation = materialActivationResult.value;
-		let rows;
-		try {
-			rows = await this.manager.runTransaction([POINTER_STORE], "readonly", async (context) => await readPointerRowsForWallet(context, walletId));
-		} catch {
-			return {
-				kind: "persistence_unavailable",
-				capability
-			};
-		}
-		const selectors = [];
-		try {
-			for (const row of rows) {
-				const pointer = parsePointerRow(row);
-				if (pointer.selector.authority.walletId === walletId) selectors.push(pointer.selector);
-			}
-		} catch {
-			return {
-				kind: "corrupt",
-				capability
-			};
-		}
-		if (selectors.length === 0) return {
-			kind: "missing",
-			subject: "capability",
-			capability
-		};
-		const exact = [];
-		for (const selector of selectors) {
-			const lookup = await this.lookup(selector);
-			switch (lookup.kind) {
-				case "active":
-					if (activeLookupUsesMaterialActivation(lookup, materialActivation)) exact.push(lookup);
-					break;
-				case "retired": break;
-				case "missing": return {
-					kind: "missing",
-					subject: lookup.subject,
-					capability
-				};
-				case "exact_binding_mismatch":
-				case "exact_record_conflict":
-				case "corrupt":
-				case "persistence_unavailable": return {
-					kind: lookup.kind,
-					capability
-				};
-			}
-		}
-		const requested = input.authority;
-		if (requested) {
-			const selected = exact.filter((candidate) => walletAuthAuthorityRefsMatch(candidate.manifest.signer.authority, requested));
-			if (selected.length > 1) return {
-				kind: "exact_record_conflict",
-				capability
-			};
-			return selected[0] ?? {
-				kind: "exact_binding_mismatch",
-				capability
-			};
-		}
-		if (exact.length > 1) return {
-			kind: "ambiguous_authority",
-			capability,
-			authorities: exact.map((candidate) => candidate.manifest.signer.authority)
-		};
-		return exact[0] ?? {
-			kind: "exact_binding_mismatch",
-			capability
-		};
-	}
-	async openActiveMaterial(selectorInput) {
-		const selector = normalizeSelector(selectorInput);
-		const lookup = await this.lookup(selector);
-		if (lookup.kind !== "active") return lookup;
-		return await this.openActiveMaterialLookup(lookup);
-	}
-	async lookupByMaterialRef(materialRefInput) {
-		const materialRef = parseEcdsaRoleLocalPersistedMaterialRef(materialRefInput);
-		const capability = materialRef.materialActivation.capability;
-		let raw;
-		try {
-			raw = await this.manager.runTransaction([MATERIAL_STORE], "readonly", async (context) => await context.store(MATERIAL_STORE).get(materialRef.durableMaterialRef));
-		} catch {
-			return {
-				kind: "persistence_unavailable",
-				capability
-			};
-		}
-		if (raw === void 0) return await this.lookupMissingMaterialByRef(materialRef);
-		let locator;
-		try {
-			locator = parseMaterialLocator(raw);
-		} catch {
-			return {
-				kind: "corrupt",
-				capability
-			};
-		}
-		if (locator.durableMaterialRef !== materialRef.durableMaterialRef || locator.bindingDigest !== materialRef.bindingDigest) return {
-			kind: "exact_binding_mismatch",
-			capability
-		};
-		const lookup = await this.lookup(locator.selector);
-		switch (lookup.kind) {
-			case "active":
-				if (lookup.manifest.durableMaterial.durableMaterialRef !== materialRef.durableMaterialRef || lookup.manifest.durableMaterial.bindingDigest !== materialRef.bindingDigest || !activeLookupUsesMaterialActivation(lookup, materialRef.materialActivation)) return {
-					kind: "exact_binding_mismatch",
-					capability
-				};
-				return lookup;
-			case "retired": return lookup;
-			case "missing": return {
-				kind: "missing",
-				subject: lookup.subject,
-				capability
-			};
-			case "exact_binding_mismatch":
-			case "exact_record_conflict":
-			case "corrupt":
-			case "persistence_unavailable": return {
-				kind: lookup.kind,
-				capability
-			};
-		}
-		return assertNever(lookup);
-	}
-	async lookupMissingMaterialByRef(materialRef) {
-		const capability = materialRef.materialActivation.capability;
-		let rows;
-		try {
-			rows = await this.manager.runTransaction([MANIFEST_STORE], "readonly", async (context) => await context.store(MANIFEST_STORE).getAll());
-		} catch {
-			return {
-				kind: "persistence_unavailable",
-				capability
-			};
-		}
-		const exact = [];
-		let bindingMismatch = false;
-		for (const raw of rows) {
-			let parsed;
-			try {
-				parsed = parseManifestRow(raw);
-			} catch {
-				return {
-					kind: "corrupt",
-					capability
-				};
-			}
-			const durableMaterial = parsed.activeProof.durableMaterial;
-			if (durableMaterial.durableMaterialRef !== materialRef.durableMaterialRef) continue;
-			if (durableMaterial.bindingDigest !== materialRef.bindingDigest || !mpcMaterialActivationRefsEqual(durableMaterial.materialActivation, materialRef.materialActivation)) {
-				bindingMismatch = true;
-				continue;
-			}
-			exact.push(parsed);
-		}
-		if (exact.length > 1) return {
-			kind: "exact_record_conflict",
-			capability
-		};
-		const [matched] = exact;
-		if (!matched) return bindingMismatch ? {
-			kind: "exact_binding_mismatch",
-			capability
-		} : {
-			kind: "missing",
-			subject: "material",
-			capability
-		};
-		if (matched.state === "replaced") return {
-			kind: "retired",
-			manifest: matched.manifest
-		};
-		return {
-			kind: "missing",
-			subject: "material",
-			capability
-		};
-	}
-	async openActiveMaterialLookup(lookup) {
-		const selector = selectorFromManifest(lookup.manifest);
-		try {
-			if (await ciphertextDigestB64u(lookup.material.ciphertextB64u) !== lookup.material.binding.ciphertextDigest) throw new Error("active ECDSA material ciphertext digest is invalid");
-			const sealingKey = await this.readMaterialSealingKey(lookup.material.sealingKeyId);
-			if (!sealingKey) throw new Error("active ECDSA material sealing key is missing");
-			return {
-				kind: "active",
-				manifest: lookup.manifest,
-				readyStateBlobB64u: await decryptStateBlob({
-					key: sealingKey,
-					iv12B64u: lookup.material.iv12B64u,
-					ciphertextB64u: lookup.material.ciphertextB64u,
-					aadProjection: readyAadProjection(lookup.manifest)
-				})
-			};
-		} catch (error) {
-			return {
-				kind: "corrupt",
-				selector,
-				corruptionDigest: await persistenceDigest("active_material_open_corrupt", selector, ecdsaManifestErrorMessage(error))
-			};
-		}
-	}
-	async openActiveMaterialByRef(materialRefInput) {
-		let lookup;
-		try {
-			lookup = await this.lookupByMaterialRef(materialRefInput);
-		} catch {
-			return { kind: "corrupt" };
-		}
-		if (lookup.kind !== "active") return materialRefOpenFailure(lookup);
-		const opened = await this.openActiveMaterialLookup(lookup);
-		return opened.kind === "active" ? opened : materialRefOpenFailure(opened);
-	}
-	async sealAndFinalizeActivation(input) {
-		const selector = selectorFromJournal(input.committedJournal);
-		try {
-			const parsedJournal = parseCommittedJournal(input.committedJournal);
-			const sealingKeyId = parsedJournal.candidate.encryptedPending.sealingKeyId;
-			const sealingKey = await this.readMaterialSealingKey(sealingKeyId);
-			if (!sealingKey) throw new Error("ECDSA activation material sealing key is missing");
-			const encrypted = await encryptStateBlob({
-				key: sealingKey,
-				stateBlobB64u: input.readyStateBlobB64u,
-				aadProjection: readyAadProjection(parsedJournal)
-			});
-			const durableMaterial = buildDurableEcdsaMaterialBinding({
-				activationBinding: parsedJournal.candidate.activationBinding,
-				serverActivation: parsedJournal.serverActivation,
-				routerAbEcdsaDerivationNormalSigning: input.routerAbEcdsaDerivationNormalSigning,
-				roleLocalPublicFacts: buildEcdsaRoleLocalPublicFacts(input.roleLocalPublicFacts),
-				ciphertextDigest: parseEcdsaCiphertextDigest(encrypted.digestB64u),
-				runtimePolicyScope: input.runtimePolicyScope
-			});
-			const readyMaterial = buildValidatedEncryptedEcdsaReadyMaterial({
-				binding: durableMaterial,
-				sealingKeyId,
-				iv12B64u: encrypted.iv12B64u,
-				ciphertextB64u: encrypted.ciphertextB64u
-			});
-			const activeManifest = buildActiveEcdsaCapabilityManifest({
-				activationBinding: parsedJournal.candidate.activationBinding,
-				serverActivation: parsedJournal.serverActivation,
-				registeredPublicFacts: input.registeredPublicFacts,
-				durableMaterial,
-				committedAt: input.committedAt
-			});
-			return await this.finalizeActivation({
-				committedJournal: parsedJournal,
-				readyMaterial,
-				activeManifest
-			});
-		} catch (error) {
-			return {
-				kind: "corrupt",
-				selector,
-				corruptionDigest: await persistenceDigest("activation_seal_corrupt", selector, ecdsaManifestErrorMessage(error))
-			};
-		}
-	}
-	async importCommittedWalletCustodyActivation(input) {
-		return await importCommittedActivation(this, input, (prepared) => persistPreparedContinuity(this.manager, prepared));
-	}
-	async persistPreparedWalletCustodyEcdsaContinuity(prepared) {
-		await persistPreparedContinuity(this.manager, prepared);
-	}
-	async readMaterialSealingKey(keyIdInput) {
-		const keyId = parseEcdsaMaterialSealingKeyId(keyIdInput);
-		const raw = await this.manager.runTransaction([SEALING_KEY_STORE], "readonly", async (context) => await context.store(SEALING_KEY_STORE).get(keyId));
-		if (raw === void 0) return null;
-		const parsed = parseSealingKeyRow(raw);
-		if (parsed.keyId !== keyId) throw new Error("ECDSA material sealing key row identity is inconsistent");
-		return parsed.key;
-	}
-	async finalizeActivation(input) {
-		let activeProof;
-		try {
-			activeProof = assertActiveProofInput(input);
-		} catch (error) {
-			const selector = selectorFromJournal(input.committedJournal);
-			return {
-				kind: "corrupt",
-				selector,
-				corruptionDigest: await persistenceDigest("finalization_input_corrupt", selector, ecdsaManifestErrorMessage(error))
-			};
-		}
-		const selector = selectorFromManifest(activeProof.activeManifest);
-		try {
-			if (await ciphertextDigestB64u(input.readyMaterial.ciphertextB64u) !== input.readyMaterial.binding.ciphertextDigest) throw new FinalizationControlError("corrupt", "ECDSA ready material ciphertext digest is invalid");
-			const sealingKey = await this.readMaterialSealingKey(input.readyMaterial.sealingKeyId);
-			if (!sealingKey) throw new FinalizationControlError("corrupt", "ECDSA ready material sealing key is missing");
-			await decryptStateBlob({
-				key: sealingKey,
-				iv12B64u: input.readyMaterial.iv12B64u,
-				ciphertextB64u: input.readyMaterial.ciphertextB64u,
-				aadProjection: readyAadProjection(input.committedJournal)
-			});
-			await this.manager.runTransaction([
-				MANIFEST_STORE,
-				POINTER_STORE,
-				MATERIAL_STORE,
-				JOURNAL_STORE,
-				SEALING_KEY_STORE,
-				PRESIGNATURE_STORE
-			], "readwrite", async (context) => {
-				await finalizeInTransaction(context, input, activeProof, selector);
-			});
-			return {
-				kind: "committed",
-				manifest: activeProof.activeManifest,
-				material: input.readyMaterial
-			};
-		} catch (error) {
-			if (error instanceof FinalizationControlError) {
-				const digest = await persistenceDigest(error.kind === "corrupt" ? "finalization_corrupt" : "finalization_conflict", selector, error.message);
-				return error.kind === "corrupt" ? {
-					kind: "corrupt",
-					selector,
-					corruptionDigest: digest
-				} : {
-					kind: "exact_record_conflict",
-					selector,
-					conflictDigest: digest
-				};
-			}
-			if (isConstraintError(error)) return {
-				kind: "exact_record_conflict",
-				selector,
-				conflictDigest: await persistenceDigest("finalization_constraint_conflict", selector, ecdsaManifestErrorMessage(error))
-			};
-			return {
-				kind: "persistence_unavailable",
-				selector,
-				retryCorrelation: retryCorrelation()
-			};
-		}
-	}
-};
-async function finalizeInTransaction(context, input, activeProof, selector) {
-	const journalStore = context.store(JOURNAL_STORE);
-	const journalRaw = await journalStore.get(input.committedJournal.journalId);
-	if (journalRaw === void 0) throw new FinalizationControlError("exact_record_conflict", "ECDSA finalization is missing its durable activation journal");
-	let persistedJournal;
-	try {
-		persistedJournal = parseJournalRow(journalRaw);
-	} catch (error) {
-		throw new FinalizationControlError("corrupt", ecdsaManifestErrorMessage(error));
-	}
-	if (persistedJournal.journal.kind !== "server_activation_committed" || !selectorsMatch(persistedJournal.selector, selector) || !ecdsaActivationCommitJournalsMatch(persistedJournal.journal, input.committedJournal)) throw new FinalizationControlError("exact_record_conflict", "ECDSA finalization journal does not match its committed activation");
-	const sealingKeyRaw = await context.store(SEALING_KEY_STORE).get(input.readyMaterial.sealingKeyId);
-	if (sealingKeyRaw === void 0) throw new FinalizationControlError("corrupt", "ECDSA finalization is missing its material sealing key");
-	try {
-		parseSealingKeyRow(sealingKeyRaw);
-	} catch (error) {
-		throw new FinalizationControlError("corrupt", ecdsaManifestErrorMessage(error));
-	}
-	const pointerStore = context.store(POINTER_STORE);
-	const pointerRaw = await pointerStore.get(selectorKey(selector));
-	const expected = input.committedJournal.expectedManifest;
-	const currentPointer = assertExpectedPointer(expected, pointerRaw, selector);
-	const activeRows = await readActiveManifestRows(context, selector);
-	let previousProof = null;
-	let previousSealingKeyId = null;
-	if (currentPointer === null) {
-		if (activeRows.length !== 0) throw new FinalizationControlError("exact_record_conflict", "initial ECDSA activation found an unpointed active manifest");
-	} else {
-		if (activeRows.length !== 1) throw new FinalizationControlError("exact_record_conflict", "replacement ECDSA activation found conflicting current manifests");
-		let previousManifest;
-		try {
-			previousManifest = parseManifestRow(activeRows[0]);
-		} catch (error) {
-			throw new FinalizationControlError("corrupt", ecdsaManifestErrorMessage(error));
-		}
-		if (previousManifest.state !== "active" || previousManifest.manifest.identity.manifestId !== currentPointer.manifestId) throw new FinalizationControlError("exact_record_conflict", "replacement ECDSA activation current manifest does not match its pointer");
-		if (input.committedJournal.activationCommand.expectedGeneration.kind !== "exact_generation" || previousManifest.activeProof.serverActivation.serverGeneration !== input.committedJournal.activationCommand.expectedGeneration.serverGeneration) throw new FinalizationControlError("exact_record_conflict", "replacement ECDSA activation server generation CAS did not match");
-		const previousMaterialRaw = await context.store(MATERIAL_STORE).get(previousManifest.manifest.durableMaterial.durableMaterialRef);
-		if (previousMaterialRaw === void 0) throw new FinalizationControlError("corrupt", "replacement ECDSA activation is missing prior material");
-		try {
-			const previousMaterial = parseMaterialRow(previousMaterialRaw, previousManifest.activeProof);
-			if (!materialMatchesManifest(previousMaterial, previousManifest.manifest)) throw new Error("prior ECDSA material does not match its active manifest");
-			if (previousMaterial.sealingKeyId === input.readyMaterial.sealingKeyId) throw new Error("replacement ECDSA activation must use a fresh material sealing key");
-			previousSealingKeyId = previousMaterial.sealingKeyId;
-		} catch (error) {
-			throw new FinalizationControlError("corrupt", ecdsaManifestErrorMessage(error));
-		}
-		previousProof = previousManifest.activeProof;
-	}
-	const manifestStore = context.store(MANIFEST_STORE);
-	const materialStore = context.store(MATERIAL_STORE);
-	if (previousProof) {
-		if (!previousSealingKeyId) throw new FinalizationControlError("corrupt", "replacement ECDSA activation is missing its prior sealing key identity");
-		await retireClientPresignaturesForActivationInTransaction(context, String(previousProof.durableMaterial.materialActivation.materialOwner), String(previousProof.durableMaterial.materialActivation.activationId));
-		await manifestStore.put(storedReplacedManifestRow(previousProof, activeProof));
-		await materialStore.delete(previousProof.durableMaterial.durableMaterialRef);
-		await context.store(SEALING_KEY_STORE).delete(previousSealingKeyId);
-	}
-	await materialStore.add(storedMaterialRow(input.readyMaterial, activeProof.activeManifest));
-	await manifestStore.add(storedActiveManifestRow(activeProof));
-	await pointerStore.put(storedPointerRow(activeProof.activeManifest));
-	await journalStore.delete(input.committedJournal.journalId);
-}
 //#endregion
-export { IndexedDbEcdsaCapabilityManifestStore, importCommittedActivation, persistPreparedImportedWalletCustodyEcdsaContinuityInTransaction, prepareImportedWalletCustodyEcdsaContinuity };
+export { persistPreparedImportedWalletCustodyEcdsaContinuityInTransaction, prepareImportedWalletCustodyEcdsaContinuity };
 
 //# sourceMappingURL=ecdsaCapabilityManifestStore.js.map