@seams/wallet 0.7.3 → 0.8.0

package/dist/esm/react/core/indexedDB/seamsWalletDB/schema.js

@@ -1,23 +0,0 @@
-import { SEAMS_WALLET_DB_NAME, SEAMS_WALLET_SCHEMA_MANIFEST } from "../schemaNames.js";
-//#region src/core/indexedDB/seamsWalletDB/schema.ts
-const SEAMS_WALLET_DB_CONFIG = {
-	dbName: SEAMS_WALLET_DB_NAME,
-	dbVersion: 24
-};
-function keyPathForIndexedDB(keyPath) {
-	return typeof keyPath === "string" ? keyPath : [...keyPath];
-}
-function createCanonicalStore(db, definition) {
-	const store = db.createObjectStore(definition.store, { keyPath: keyPathForIndexedDB(definition.keyPath) });
-	for (const index of definition.indexes) store.createIndex(index.name, keyPathForIndexedDB(index.keyPath), { unique: index.unique });
-}
-function upgradeSeamsWalletDBSchema(db) {
-	for (const definition of SEAMS_WALLET_SCHEMA_MANIFEST) {
-		if (db.objectStoreNames.contains(definition.store)) continue;
-		createCanonicalStore(db, definition);
-	}
-}
-//#endregion
-export { SEAMS_WALLET_DB_CONFIG, upgradeSeamsWalletDBSchema };
-
-//# sourceMappingURL=schema.js.map

package/dist/esm/react/core/indexedDB/seamsWalletDB/signingSessionSeals.js

@@ -1,205 +0,0 @@
-import { SEAMS_WALLET_INDEXES, SEAMS_WALLET_STORES } from "../schemaNames.js";
-import { seamsWalletDB } from "../singletons.js";
-import { unwrap } from "idb";
-//#region src/core/indexedDB/seamsWalletDB/signingSessionSeals.ts
-const SIGNING_SESSION_SEALS_STORE_NAME = SEAMS_WALLET_STORES.signingSessionSeals;
-const SIGNING_SESSION_RESTORE_LEASES_STORE_NAME = SEAMS_WALLET_STORES.signingSessionRestoreLeases;
-const SEALED_RECORD_THRESHOLD_SESSION_INDEXES = [SEAMS_WALLET_INDEXES.ed25519ThresholdSessionId, SEAMS_WALLET_INDEXES.ecdsaThresholdSessionId];
-function requestToPromise(request) {
-	return new Promise((resolve, reject) => {
-		request.onsuccess = () => resolve(request.result);
-		request.onerror = () => reject(request.error || /* @__PURE__ */ new Error("IndexedDB request failed"));
-	});
-}
-function transactionDone(tx) {
-	return new Promise((resolve, reject) => {
-		tx.oncomplete = () => resolve();
-		tx.onabort = () => reject(tx.error || /* @__PURE__ */ new Error("IndexedDB transaction aborted"));
-		tx.onerror = () => reject(tx.error || /* @__PURE__ */ new Error("IndexedDB transaction failed"));
-	});
-}
-async function getSigningSessionSealsDb() {
-	if (seamsWalletDB.isDisabled()) return null;
-	try {
-		return unwrap(await seamsWalletDB.getDB());
-	} catch {
-		return null;
-	}
-}
-function collectIndexedRawSealedRecordEntries(index, thresholdSessionId) {
-	return new Promise((resolve, reject) => {
-		const entries = [];
-		const request = index.openCursor(thresholdSessionId);
-		request.onsuccess = () => {
-			const cursor = request.result;
-			if (!cursor) {
-				resolve(entries);
-				return;
-			}
-			entries.push({
-				primaryKey: cursor.primaryKey,
-				value: cursor.value
-			});
-			cursor.continue();
-		};
-		request.onerror = () => reject(request.error || /* @__PURE__ */ new Error("IndexedDB cursor failed"));
-	});
-}
-function collectAllRawSealedRecordEntriesFromStore(store) {
-	return new Promise((resolve, reject) => {
-		const entries = [];
-		const request = store.openCursor();
-		request.onsuccess = () => {
-			const cursor = request.result;
-			if (!cursor) {
-				resolve(entries);
-				return;
-			}
-			entries.push({
-				primaryKey: cursor.primaryKey,
-				value: cursor.value
-			});
-			cursor.continue();
-		};
-		request.onerror = () => reject(request.error || /* @__PURE__ */ new Error("IndexedDB cursor failed"));
-	});
-}
-async function collectRawSealedRecordEntriesByThresholdSessionIdFromStore(store, thresholdSessionId) {
-	const entriesByPrimaryKey = /* @__PURE__ */ new Map();
-	for (const indexName of SEALED_RECORD_THRESHOLD_SESSION_INDEXES) try {
-		const entries = await collectIndexedRawSealedRecordEntries(store.index(indexName), thresholdSessionId);
-		for (const entry of entries) entriesByPrimaryKey.set(String(entry.primaryKey), entry);
-	} catch {}
-	if (entriesByPrimaryKey.size) return [...entriesByPrimaryKey.values()];
-	return await collectAllRawSealedRecordEntriesFromStore(store).catch(() => []);
-}
-var SigningSessionSealsRepository = class {
-	async getRawSealedRecordEntry(primaryKey) {
-		const db = await getSigningSessionSealsDb();
-		if (!db) return null;
-		const tx = db.transaction(SIGNING_SESSION_SEALS_STORE_NAME, "readonly");
-		const value = await requestToPromise(tx.objectStore(SIGNING_SESSION_SEALS_STORE_NAME).get(primaryKey));
-		await transactionDone(tx).catch(() => void 0);
-		return value === void 0 ? null : {
-			primaryKey,
-			value
-		};
-	}
-	async collectRawSealedRecordEntriesByEnrollmentId(enrollmentId) {
-		const db = await getSigningSessionSealsDb();
-		if (!db) return [];
-		const tx = db.transaction(SIGNING_SESSION_SEALS_STORE_NAME, "readonly");
-		const entries = await collectIndexedRawSealedRecordEntries(tx.objectStore(SIGNING_SESSION_SEALS_STORE_NAME).index(SEAMS_WALLET_INDEXES.enrollmentId), enrollmentId);
-		await transactionDone(tx).catch(() => void 0);
-		return entries;
-	}
-	async collectAllRawSealedRecordEntries() {
-		const db = await getSigningSessionSealsDb();
-		if (!db) return [];
-		const tx = db.transaction(SIGNING_SESSION_SEALS_STORE_NAME, "readonly");
-		const entries = await collectAllRawSealedRecordEntriesFromStore(tx.objectStore(SIGNING_SESSION_SEALS_STORE_NAME));
-		await transactionDone(tx).catch(() => void 0);
-		return entries;
-	}
-	async collectRawSealedRecordEntriesByThresholdSessionId(thresholdSessionId) {
-		const db = await getSigningSessionSealsDb();
-		if (!db) return [];
-		const tx = db.transaction(SIGNING_SESSION_SEALS_STORE_NAME, "readonly");
-		const entries = await collectRawSealedRecordEntriesByThresholdSessionIdFromStore(tx.objectStore(SIGNING_SESSION_SEALS_STORE_NAME), thresholdSessionId);
-		await transactionDone(tx).catch(() => void 0);
-		return entries;
-	}
-	async putSealedRecord(row) {
-		const db = await getSigningSessionSealsDb();
-		if (!db) return false;
-		const tx = db.transaction(SIGNING_SESSION_SEALS_STORE_NAME, "readwrite");
-		tx.objectStore(SIGNING_SESSION_SEALS_STORE_NAME).put(row);
-		await transactionDone(tx);
-		return true;
-	}
-	async replaceSealedRecord(args) {
-		const db = await getSigningSessionSealsDb();
-		if (!db) return;
-		const tx = db.transaction(SIGNING_SESSION_SEALS_STORE_NAME, "readwrite");
-		const store = tx.objectStore(SIGNING_SESSION_SEALS_STORE_NAME);
-		for (const storeKey of args.staleStoreKeys) store.delete(storeKey);
-		store.put(args.row);
-		await transactionDone(tx);
-	}
-	async replaceSealedRecordAndDeleteRestoreLease(args) {
-		const db = await getSigningSessionSealsDb();
-		if (!db) return false;
-		const tx = db.transaction([SIGNING_SESSION_SEALS_STORE_NAME, SIGNING_SESSION_RESTORE_LEASES_STORE_NAME], "readwrite");
-		const sealStore = tx.objectStore(SIGNING_SESSION_SEALS_STORE_NAME);
-		for (const storeKey of args.staleStoreKeys) sealStore.delete(storeKey);
-		sealStore.put(args.row);
-		tx.objectStore(SIGNING_SESSION_RESTORE_LEASES_STORE_NAME).delete(args.restoreLeaseKey);
-		await transactionDone(tx);
-		return true;
-	}
-	async deleteSealedRecords(primaryKeys) {
-		if (!primaryKeys.length) return;
-		const db = await getSigningSessionSealsDb();
-		if (!db) return;
-		const tx = db.transaction(SIGNING_SESSION_SEALS_STORE_NAME, "readwrite");
-		const store = tx.objectStore(SIGNING_SESSION_SEALS_STORE_NAME);
-		for (const primaryKey of primaryKeys) store.delete(primaryKey);
-		await transactionDone(tx).catch(() => void 0);
-	}
-	async deleteRestoreLease(leaseKey) {
-		const db = await getSigningSessionSealsDb();
-		if (!db) return;
-		const tx = db.transaction(SIGNING_SESSION_RESTORE_LEASES_STORE_NAME, "readwrite");
-		tx.objectStore(SIGNING_SESSION_RESTORE_LEASES_STORE_NAME).delete(leaseKey);
-		await transactionDone(tx).catch(() => void 0);
-	}
-	async deleteRestoreLeaseIf(args) {
-		const db = await getSigningSessionSealsDb();
-		if (!db) return;
-		const tx = db.transaction(SIGNING_SESSION_RESTORE_LEASES_STORE_NAME, "readwrite");
-		const store = tx.objectStore(SIGNING_SESSION_RESTORE_LEASES_STORE_NAME);
-		const rawLease = await requestToPromise(store.get(args.leaseKey));
-		if (args.shouldDelete(rawLease)) store.delete(args.leaseKey);
-		await transactionDone(tx).catch(() => void 0);
-	}
-	async withRestoreLeaseTransaction(thresholdSessionId, task) {
-		const db = await getSigningSessionSealsDb();
-		if (!db) return null;
-		try {
-			const idbTx = db.transaction([SIGNING_SESSION_SEALS_STORE_NAME, SIGNING_SESSION_RESTORE_LEASES_STORE_NAME], "readwrite");
-			const sealStore = idbTx.objectStore(SIGNING_SESSION_SEALS_STORE_NAME);
-			const leaseStore = idbTx.objectStore(SIGNING_SESSION_RESTORE_LEASES_STORE_NAME);
-			const entries = await collectRawSealedRecordEntriesByThresholdSessionIdFromStore(sealStore, thresholdSessionId);
-			let abortRequested = false;
-			const result = await task({
-				entries,
-				getRawRestoreLease: async (leaseKey) => await requestToPromise(leaseStore.get(leaseKey)),
-				putRestoreLease: (row) => leaseStore.put(row),
-				abort: () => {
-					abortRequested = true;
-				}
-			});
-			if (abortRequested) {
-				idbTx.abort();
-				return result;
-			}
-			await transactionDone(idbTx);
-			return result;
-		} catch {
-			return null;
-		}
-	}
-	async clearAll() {
-		const db = await getSigningSessionSealsDb();
-		if (!db) return;
-		const tx = db.transaction([SIGNING_SESSION_SEALS_STORE_NAME, SIGNING_SESSION_RESTORE_LEASES_STORE_NAME], "readwrite");
-		tx.objectStore(SIGNING_SESSION_SEALS_STORE_NAME).clear();
-		tx.objectStore(SIGNING_SESSION_RESTORE_LEASES_STORE_NAME).clear();
-		await transactionDone(tx).catch(() => void 0);
-	}
-};
-const signingSessionSealsRepository = new SigningSessionSealsRepository();
-//#endregion
-export { signingSessionSealsRepository };
-
-//# sourceMappingURL=signingSessionSeals.js.map

package/dist/esm/react/core/indexedDB/seamsWalletDB/walletCustodyEcdsaContinuity.js

@@ -1,198 +0,0 @@
-import { base64UrlEncode } from "../../../shared-ts/src/utils/base64.js";
-import { secureRandomId } from "../../../shared-ts/src/utils/secureRandomId.js";
-import { normalizeRuntimePolicyScope } from "../../../shared-ts/src/threshold/signingRootScope.js";
-import { mpcMaterialActivationRefsEqual } from "../../../shared-ts/src/utils/domainIds.js";
-import { parseDigestB64u, parseIsoTimestamp } from "../../../shared-ts/src/utils/canonicalPrimitives.js";
-import { parseEcdsaCapabilityManifestId, parseEcdsaCapabilityManifestRevision, parseEvmFamilyEcdsaSignerId } from "../../../shared-ts/src/utils/ecdsaCapabilityActivation.js";
-import { routerAbMpcMaterialActivationRefFromWire } from "../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
-import { parseWalletAuthAuthorityRef } from "../../../shared-ts/src/utils/walletAuthAuthority.js";
-import { parseRouterAbEcdsaDerivationPublicCapabilityV1, parseRouterAbEcdsaRegistrationActivationReceiptV1 } from "../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
-import { parseSdkEcdsaDerivationSigningRootId, parseSdkEcdsaDerivationSigningRootVersion } from "../../../shared-ts/src/threshold/ecdsaDerivationRoleLocalBootstrap.js";
-import { buildVerifiedEcdsaPublicFacts, toEvmFamilyEcdsaKeyHandle, toParticipantId } from "../../signingEngine/session/identity/evmFamilyEcdsaIdentity.js";
-import { seamsWalletDB } from "../singletons.js";
-import { parseEcdsaKeyHandle, parseEcdsaRelayerKeyId } from "../../../shared-ts/src/threshold/keyMaterialBrands.js";
-import { parseEcdsaClientVerifyingPublicKey33B64u, parseEcdsaRoleLocalBindingDigest, parseEcdsaRoleLocalDurableMaterialRef, parseEcdsaThresholdKeyId } from "../../signingEngine/session/keyMaterialBrands.js";
-import { SeamsWalletRepositories } from "./repositories.js";
-import { buildEcdsaRoleLocalPublicFacts } from "../../signingEngine/session/persistence/ecdsaRoleLocalRecords.js";
-import { buildEcdsaActivationBinding, buildEcdsaCapabilityScope, buildEcdsaManifestIdentity, buildEcdsaRoleLocalMaterialBinding, buildPreparedEvmFamilySigner } from "../../signingEngine/session/material/ecdsaCapabilityManifest.js";
-import { ecdsaRegisteredPublicFactsMatch, ecdsaRoleLocalMaterialBindingsMatch, ecdsaRoleLocalPublicFactsMatch } from "./ecdsaCapabilityManifestRecords.js";
-import { IndexedDbEcdsaCapabilityManifestStore, importCommittedActivation, prepareImportedWalletCustodyEcdsaContinuity } from "./ecdsaCapabilityManifestStore.js";
-//#region src/core/indexedDB/seamsWalletDB/walletCustodyEcdsaContinuity.ts
-function buildWalletCustodyEcdsaContinuityImportInput(input) {
-	const authority = parseWalletAuthAuthorityRef(input.authority);
-	if (!authority || String(authority.walletId) !== String(input.walletId)) throw new Error("ECDSA custody import authority is invalid");
-	const publicCapability = parseRouterAbEcdsaDerivationPublicCapabilityV1(input.publicCapability);
-	const receipt = parseRouterAbEcdsaRegistrationActivationReceiptV1(input.activationReceipt);
-	const materialActivation = routerAbMpcMaterialActivationRefFromWire(receipt.ecdsa_activation.material_activation);
-	if (!mpcMaterialActivationRefsEqual(materialActivation, routerAbMpcMaterialActivationRefFromWire(publicCapability.material_activation))) throw new Error("ECDSA custody continuity changed the material activation");
-	const participantIds = [toParticipantId(input.participantIds[0]), toParticipantId(input.participantIds[1])];
-	const roleLocalBinding = buildEcdsaRoleLocalMaterialBinding({
-		keyHandle: parseEcdsaKeyHandle(input.keyHandle),
-		ecdsaThresholdKeyId: parseEcdsaThresholdKeyId(input.ecdsaThresholdKeyId),
-		clientVerifyingPublicKey33B64u: parseEcdsaClientVerifyingPublicKey33B64u(input.publicFacts.derivationClientSharePublicKey33B64u),
-		participantIds,
-		relayerKeyId: parseEcdsaRelayerKeyId(input.relayerKeyId)
-	});
-	const signer = buildPreparedEvmFamilySigner({
-		capability: materialActivation.capability,
-		signerId: parseEvmFamilyEcdsaSignerId(secureRandomId("ecdsa-signer", 32, "ECDSA custody signer identities")),
-		authority,
-		scope: buildEcdsaCapabilityScope({ targetMemberships: input.chainTargets }),
-		materialOwner: materialActivation.materialOwner,
-		signingRootId: parseSdkEcdsaDerivationSigningRootId(input.signingRootId),
-		signingRootVersion: parseSdkEcdsaDerivationSigningRootVersion(input.signingRootVersion)
-	});
-	const activationBinding = buildEcdsaActivationBinding({
-		targetManifest: buildEcdsaManifestIdentity({
-			manifestId: parseEcdsaCapabilityManifestId(secureRandomId("ecdsa-manifest", 32, "ECDSA custody manifest identities")),
-			manifestRevision: parseEcdsaCapabilityManifestRevision(1)
-		}),
-		signer,
-		roleLocalBinding,
-		bindingDigest: parseEcdsaRoleLocalBindingDigest(input.publicFacts.contextBinding32B64u),
-		durableMaterialRef: parseEcdsaRoleLocalDurableMaterialRef(secureRandomId("ecdsa-role-local-material", 32, "ECDSA custody material identities"))
-	});
-	const ethereumAddress = input.publicFacts.ethereumAddress;
-	const registeredPublicFacts = buildVerifiedEcdsaPublicFacts({
-		keyHandle: toEvmFamilyEcdsaKeyHandle(input.keyHandle),
-		publicKeyB64u: input.publicFacts.groupPublicKey33B64u,
-		participantIds,
-		thresholdOwnerAddress: ethereumAddress
-	});
-	const roleLocalPublicFacts = buildEcdsaRoleLocalPublicFacts({
-		walletId: authority.walletId,
-		chainTarget: input.chainTargets[0],
-		keyHandle: roleLocalBinding.keyHandle,
-		ecdsaThresholdKeyId: roleLocalBinding.ecdsaThresholdKeyId,
-		signingRootId: signer.signingRootId,
-		signingRootVersion: signer.signingRootVersion,
-		applicationBindingDigestB64u: publicCapability.context.application_binding_digest_b64u,
-		clientParticipantId: participantIds[0],
-		relayerParticipantId: participantIds[1],
-		participantIds,
-		contextBinding32B64u: input.publicFacts.contextBinding32B64u,
-		derivationClientSharePublicKey33B64u: input.publicFacts.derivationClientSharePublicKey33B64u,
-		relayerPublicKey33B64u: input.publicFacts.relayerPublicKey33B64u,
-		groupPublicKey33B64u: input.publicFacts.groupPublicKey33B64u,
-		ethereumAddress,
-		publicCapability
-	});
-	const normalSigning = {
-		kind: "router_ab_ecdsa_derivation_normal_signing_v1",
-		scope: {
-			wallet_id: String(authority.walletId),
-			ecdsa_threshold_key_id: String(roleLocalBinding.ecdsaThresholdKeyId),
-			signing_root_id: String(signer.signingRootId),
-			signing_root_version: String(signer.signingRootVersion),
-			context: receipt.ecdsa_activation.context,
-			public_identity: receipt.ecdsa_activation.public_identity,
-			material_activation: receipt.ecdsa_activation.material_activation,
-			signing_worker: receipt.ecdsa_activation.signing_worker,
-			activation_epoch: receipt.ecdsa_activation.activation_epoch
-		}
-	};
-	return {
-		activationBinding,
-		serverCommit: {
-			correlationId: receipt.activation_correlation_id,
-			activationRequestDigest: parseDigestB64u(base64UrlEncode(Uint8Array.from(receipt.activation_request_digest.bytes))),
-			serverGeneration: receipt.server_generation,
-			protocolReceipt: receipt
-		},
-		readyStateBlobB64u: input.readyStateBlobB64u,
-		registeredPublicFacts,
-		roleLocalPublicFacts,
-		routerAbEcdsaDerivationNormalSigning: normalSigning,
-		runtimePolicyScope: normalizeRuntimePolicyScope(input.runtimePolicyScope),
-		committedAt: parseIsoTimestamp(new Date(receipt.ecdsa_activation.activated_at_ms).toISOString())
-	};
-}
-async function prepareWalletCustodyEcdsaContinuity(input) {
-	return prepareImportedWalletCustodyEcdsaContinuity(buildWalletCustodyEcdsaContinuityImportInput(input));
-}
-async function importWalletCustodyEcdsaContinuity(input) {
-	return await importCommittedActivation(input.store, buildWalletCustodyEcdsaContinuityImportInput(input), (prepared) => input.store.persistPreparedWalletCustodyEcdsaContinuity(prepared));
-}
-async function assertSharedWalletAuthorityMembership(input) {
-	const repositories = new SeamsWalletRepositories(seamsWalletDB);
-	for (const walletAuthMethodId of input.walletAuthMethodIds) {
-		const authMethod = await repositories.getWalletAuthMethodV2(String(walletAuthMethodId));
-		if (!authMethod || authMethod.status !== "active" || authMethod.walletId !== input.walletId || authMethod.walletAuthorityId !== input.walletAuthorityId) throw new Error(`ECDSA custody continuity method ${String(walletAuthMethodId)} is not an active member of the wallet authority`);
-	}
-}
-/**
-* Give an added auth method its own encrypted access projection over the
-* activation the wallet already has. The activation is not re-created and the
-* source credential's authority is not widened; only a second method-bound
-* record over the same material appears.
-*
-* The membership check is the whole safety argument. Copying access to a method
-* on another wallet authority would hand that credential custody it was never
-* granted, so both methods are read back and required to be active members of
-* the exact same authority before anything is opened.
-*/
-async function copyWalletCustodyEcdsaContinuityToAuthMethod(input) {
-	if (input.targetAuthority.walletId !== input.walletId || input.targetAuthority.walletAuthMethodId === input.sourceWalletAuthMethodId) throw new Error("ECDSA custody continuity target is invalid");
-	await assertSharedWalletAuthorityMembership({
-		walletId: input.walletId,
-		walletAuthorityId: input.walletAuthorityId,
-		walletAuthMethodIds: [input.sourceWalletAuthMethodId, input.targetAuthority.walletAuthMethodId]
-	});
-	const store = new IndexedDbEcdsaCapabilityManifestStore();
-	const listed = await store.listActiveWalletCapabilitySubjects(input.walletId);
-	if (listed.kind !== "resolved") throw new Error(`ECDSA custody continuity inventory is ${listed.kind}`);
-	if (listed.subjects.length === 0) return;
-	const sources = listed.subjects.filter((subject) => subject.authority.walletAuthMethodId === input.sourceWalletAuthMethodId);
-	if (sources.length === 0) throw new Error(`ECDSA custody continuity found no active capability for source method ${String(input.sourceWalletAuthMethodId)} among [${listed.subjects.map((subject) => String(subject.authority.walletAuthMethodId)).join(", ")}]`);
-	for (const source of sources) {
-		const sourceLookup = await store.lookup(source);
-		if (sourceLookup.kind !== "active") throw new Error(`ECDSA custody continuity source is ${sourceLookup.kind}`);
-		const targetSelector = {
-			capability: source.capability,
-			authority: input.targetAuthority
-		};
-		const targetLookup = await store.lookup(targetSelector);
-		if (targetLookup.kind === "active") {
-			const targetMaterial = targetLookup.manifest.durableMaterial;
-			const sourceMaterial = sourceLookup.manifest.durableMaterial;
-			if (targetMaterial.activationDigest !== sourceMaterial.activationDigest || targetMaterial.bindingDigest !== sourceMaterial.bindingDigest || targetMaterial.roleLocalBinding.ecdsaThresholdKeyId !== sourceMaterial.roleLocalBinding.ecdsaThresholdKeyId || !ecdsaRoleLocalMaterialBindingsMatch(targetMaterial.roleLocalBinding, sourceMaterial.roleLocalBinding) || !ecdsaRoleLocalPublicFactsMatch(targetMaterial.roleLocalPublicFacts, sourceMaterial.roleLocalPublicFacts) || !ecdsaRegisteredPublicFactsMatch(targetLookup.manifest.signer.registeredPublicFacts, sourceLookup.manifest.signer.registeredPublicFacts)) throw new Error("ECDSA custody continuity target conflicts with source material");
-			continue;
-		}
-		if (targetLookup.kind !== "missing") throw new Error(`ECDSA custody continuity target is ${targetLookup.kind}`);
-		const opened = await store.openActiveMaterialLookup(sourceLookup);
-		if (opened.kind !== "active") throw new Error(`ECDSA custody continuity material is ${opened.kind}`);
-		const manifest = opened.manifest;
-		const publicFacts = manifest.durableMaterial.roleLocalPublicFacts;
-		const imported = await importWalletCustodyEcdsaContinuity({
-			store,
-			authority: input.targetAuthority,
-			chainTargets: manifest.signer.scope.targetMemberships,
-			walletId: String(input.walletId),
-			keyHandle: publicFacts.keyHandle,
-			ecdsaThresholdKeyId: String(publicFacts.ecdsaThresholdKeyId),
-			signingRootId: String(publicFacts.signingRootId),
-			signingRootVersion: String(publicFacts.signingRootVersion),
-			relayerKeyId: String(manifest.durableMaterial.roleLocalBinding.relayerKeyId),
-			participantIds: publicFacts.participantIds,
-			publicCapability: publicFacts.publicCapability,
-			activationReceipt: manifest.activation.serverActivation.serverActivationReceipt.protocolReceipt,
-			runtimePolicyScope: manifest.durableMaterial.runtimePolicyScope,
-			readyStateBlobB64u: opened.readyStateBlobB64u,
-			publicFacts: {
-				contextBinding32B64u: publicFacts.contextBinding32B64u,
-				derivationClientSharePublicKey33B64u: publicFacts.derivationClientSharePublicKey33B64u,
-				clientVerifyingShare33B64u: publicFacts.publicCapability.public_identity.derivation_client_share_public_key33_b64u,
-				relayerPublicKey33B64u: publicFacts.relayerPublicKey33B64u,
-				groupPublicKey33B64u: publicFacts.groupPublicKey33B64u,
-				ethereumAddress: publicFacts.ethereumAddress,
-				clientShareRetryCounter: publicFacts.publicCapability.public_identity.client_share_retry_counter,
-				relayerShareRetryCounter: publicFacts.publicCapability.public_identity.server_share_retry_counter
-			}
-		});
-		if (imported.kind !== "committed") throw new Error(`ECDSA custody continuity import is ${imported.kind}`);
-	}
-}
-//#endregion
-export { copyWalletCustodyEcdsaContinuityToAuthMethod, importWalletCustodyEcdsaContinuity, prepareWalletCustodyEcdsaContinuity };
-
-//# sourceMappingURL=walletCustodyEcdsaContinuity.js.map