@seams/wallet 0.8.0 → 0.9.1

package/dist/esm/SeamsWeb/operations/auth/scheduleEcdsaSessionPresignaturePrefill.js

@@ -1,41 +0,0 @@
-import { emitSigningSessionFlowTrace } from "../../../core/signingEngine/session/operationState/trace.js";
-//#region src/SeamsWeb/operations/auth/scheduleEcdsaSessionPresignaturePrefill.ts
-async function scheduleEcdsaSessionPresignaturePrefill(args) {
-	const startedAt = performance.now();
-	emitSigningSessionFlowTrace("evm-family", {
-		event: "ecdsa_session_prefill",
-		trigger: args.trigger,
-		chainTarget: args.chainTarget,
-		status: "started",
-		startedAtMs: startedAt
-	});
-	try {
-		const result = await args.signingEngine.scheduleRouterAbEcdsaDerivationLoginPresignaturePrefill({
-			walletId: args.walletId,
-			chainTarget: args.chainTarget
-		}, args.statusReads);
-		emitSigningSessionFlowTrace("evm-family", {
-			event: "ecdsa_session_prefill",
-			trigger: args.trigger,
-			chainTarget: args.chainTarget,
-			status: result.status,
-			reason: result.reason,
-			scheduleReason: "schedule" in result ? result.schedule.reason : null,
-			walletSessionId: result.walletSessionId,
-			durationMs: performance.now() - startedAt
-		});
-	} catch {
-		emitSigningSessionFlowTrace("evm-family", {
-			event: "ecdsa_session_prefill",
-			trigger: args.trigger,
-			chainTarget: args.chainTarget,
-			status: "failed",
-			reason: "unexpected_error",
-			durationMs: performance.now() - startedAt
-		});
-	}
-}
-//#endregion
-export { scheduleEcdsaSessionPresignaturePrefill };
-
-//# sourceMappingURL=scheduleEcdsaSessionPresignaturePrefill.js.map

package/dist/esm/SeamsWeb/operations/auth/scheduleLinkedDevicePresignaturePrefill.js

@@ -1,64 +0,0 @@
-import { deriveEvmFamilyEcdsaKeyHandle } from "../../../core/signingEngine/session/identity/evmFamilyEcdsaIdentity.js";
-import { routerAbMpcMaterialActivationRefToWire } from "../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
-import { parseEcdsaKeyHandle } from "../../../shared-ts/src/threshold/keyMaterialBrands.js";
-import { MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS } from "../../../core/signingEngine/workerManager/ecdsaPresignLifecycle.js";
-import { resolveLinkedEcdsaHolderRuntimeV1 } from "../../../core/signingEngine/session/material/linkedEcdsaHolderRuntime.js";
-import { emitSigningSessionFlowTrace } from "../../../core/signingEngine/session/operationState/trace.js";
-import { buildRouterAbEcdsaDerivationSigningMaterialRef } from "../../../core/signingEngine/routerAb/ecdsaDerivation/signingMaterialRef.js";
-import { scheduleRouterAbEcdsaDerivationClientPresignaturePoolRefill } from "../../../core/signingEngine/routerAb/ecdsaDerivation/presignaturePool.js";
-import { createLinkedHolderClientSigningMaterialSource } from "../../../core/signingEngine/flows/signEvmFamily/signers/ecdsaDerivationClientSigningMaterialSource.js";
-//#region src/SeamsWeb/operations/auth/scheduleLinkedDevicePresignaturePrefill.ts
-async function scheduleLinkedDevicePresignaturePrefill(args) {
-	try {
-		const scope = args.runtime.activationReceipt.normalSigning.scope;
-		const material = buildRouterAbEcdsaDerivationSigningMaterialRef({ routerAbState: args.runtime.activationReceipt.normalSigning });
-		const keyHandle = await deriveEvmFamilyEcdsaKeyHandle({
-			ecdsaThresholdKeyId: scope.ecdsa_threshold_key_id,
-			signingRootId: scope.signing_root_id,
-			signingRootVersion: scope.signing_root_version
-		});
-		if (resolveLinkedEcdsaHolderRuntimeV1(args.runtime) !== args.runtime) return;
-		const result = scheduleRouterAbEcdsaDerivationClientPresignaturePoolRefill({
-			relayerUrl: args.relayerUrl,
-			keyHandle: parseEcdsaKeyHandle(keyHandle),
-			ecdsaThresholdKeyId: material.ecdsaThresholdKeyId,
-			clientVerifyingShareB64u: material.clientVerifier33B64u,
-			clientSigningMaterial: createLinkedHolderClientSigningMaterialSource(args.runtime.holderHandleId),
-			thresholdEcdsaPublicKeyB64u: material.thresholdVerifier33B64u,
-			relayerVerifyingShareB64u: material.serverVerifier33B64u,
-			credential: {
-				kind: "wallet_session_opaque",
-				walletSessionToken: args.operationCredential.token
-			},
-			authorization: {
-				kind: "reusable_wallet_session",
-				wallet_session_id: args.operationCredential.walletSessionId
-			},
-			materialActivation: routerAbMpcMaterialActivationRefToWire(args.runtime.materialActivation),
-			routerAbEcdsaDerivationPoolFill: {
-				kind: "router_ab_ecdsa_derivation_signing_worker_pool",
-				scope,
-				ceremonyExpiresAtMs: args.expiresAtMs,
-				materialExpiresAtMs: Date.now() + MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS
-			},
-			workerCtx: args.workerCtx
-		});
-		emitSigningSessionFlowTrace("evm-family", {
-			event: "ecdsa_linked_device_prefill",
-			scheduled: result.scheduled,
-			reason: result.reason,
-			depth: result.depth,
-			targetDepth: result.targetDepth
-		});
-	} catch {
-		emitSigningSessionFlowTrace("evm-family", {
-			event: "ecdsa_linked_device_prefill",
-			scheduled: false,
-			reason: "unexpected_error"
-		});
-	}
-}
-//#endregion
-export { scheduleLinkedDevicePresignaturePrefill };
-
-//# sourceMappingURL=scheduleLinkedDevicePresignaturePrefill.js.map

package/dist/esm/SeamsWeb/operations/auth/walletAuth.js

@@ -1,142 +0,0 @@
-import { SIGNER_AUTH_METHODS } from "../../../shared-ts/src/utils/signerDomain.js";
-import { toWalletId } from "../../../core/signingEngine/interfaces/ecdsaChainTarget.js";
-import { toError } from "../../../shared-ts/src/utils/errors.js";
-import { IndexedDBManager } from "../../../core/indexedDB/index.js";
-import { resolveWalletUnlockSubjectSet } from "./walletUnlockSubject.js";
-import { getRecentUnlocks, getWalletSession, lock, logout, unlockResolvedWalletSubjectSet } from "./login.js";
-import { walletIframeUnlockRequestFromLoginHooks } from "../../walletIframe/shared/unlockOptions.js";
-//#region src/SeamsWeb/operations/auth/walletAuth.ts
-function walletUnlockCapabilityScope(selection) {
-	switch (selection?.mode) {
-		case "ed25519_only": return { kind: "near_ed25519_only" };
-		case "ecdsa_only": return { kind: "evm_family_ecdsa_only" };
-		case "ed25519_and_ecdsa":
-		case void 0: return { kind: "all_registered_mpc" };
-	}
-	throw new Error("wallet unlock selection is unsupported");
-}
-async function requireWalletUnlockSubjectSet(args) {
-	const resolution = await resolveWalletUnlockSubjectSet({
-		walletId: args.walletId,
-		requestedCapabilityFamilies: walletUnlockCapabilityScope(args.selection)
-	});
-	switch (resolution.kind) {
-		case "resolved": return resolution.subjectSet;
-		case "missing_requested_capability_subject": throw new Error("wallet unlock is missing the requested capability subject");
-		case "capability_subject_resolution_failed": throw new Error(`wallet unlock subject resolution failed: ${resolution.reason}`);
-	}
-	throw new Error("wallet unlock subject resolution returned an unknown result");
-}
-function selectNearSubjectForActivation(subjectSet) {
-	let match = null;
-	for (const subject of subjectSet.subjects) {
-		if (subject.kind !== "near_ed25519_wallet") continue;
-		if (match) throw new Error("wallet unlock resolved multiple NEAR Ed25519 subjects");
-		match = subject;
-	}
-	return match;
-}
-async function unlockDomain(deps, walletId, options) {
-	const resolvedWalletId = String(walletId || "").trim();
-	if (!resolvedWalletId) throw new Error("unlock requires walletId");
-	if (deps.walletIframe.shouldUseWalletIframe()) try {
-		const result = await (await deps.walletIframe.requireRouter(resolvedWalletId)).unlock(walletIframeUnlockRequestFromLoginHooks({
-			walletId: resolvedWalletId,
-			options
-		}));
-		if (!result.success) {
-			const unlockError = new Error(result.error || "Login failed");
-			await options?.onError?.(unlockError);
-			await options?.afterCall?.(false, void 0, unlockError);
-			return result;
-		}
-		await deps.initWalletIframe(resolvedWalletId);
-		await options?.afterCall?.(true, result);
-		return result;
-	} catch (error) {
-		const wrappedError = toError(error);
-		await options?.onError?.(wrappedError);
-		await options?.afterCall?.(false);
-		throw wrappedError;
-	}
-	const subjectSet = await requireWalletUnlockSubjectSet({
-		walletId: resolvedWalletId,
-		selection: options?.unlockSelection
-	});
-	const result = await unlockResolvedWalletSubjectSet(deps.getContext(), subjectSet, options);
-	let activatedWalletId = null;
-	if (result?.success) {
-		activatedWalletId = String(subjectSet.walletId);
-		const nearSubject = selectNearSubjectForActivation(subjectSet);
-		if (nearSubject) await deps.signingEngine.activateAuthenticatedWalletState({
-			walletId: nearSubject.walletId,
-			nearAccountId: nearSubject.nearAccountId,
-			signerSlot: nearSubject.signerSlot,
-			nearClient: deps.nearClient
-		});
-	}
-	await deps.initWalletIframe(activatedWalletId || void 0);
-	return result;
-}
-async function lockDomain(deps) {
-	if (deps.walletIframe.shouldUseWalletIframe()) {
-		await (await deps.walletIframe.requireRouter()).lock();
-		return;
-	}
-	await lock(deps.getContext());
-}
-async function logoutDomain(deps) {
-	if (deps.walletIframe.shouldUseWalletIframe()) {
-		await (await deps.walletIframe.requireRouter()).logout();
-		return;
-	}
-	await logout(deps.getContext());
-}
-async function getWalletSessionDomain(deps, walletId) {
-	if (deps.walletIframe.shouldUseWalletIframe()) {
-		const router = await deps.walletIframe.requireRouter(walletId);
-		const session = await router.getWalletSession(walletId);
-		try {
-			await router.prefetchBlockheight();
-		} catch {}
-		return session;
-	}
-	return await getWalletSession(deps.getContext(), walletId);
-}
-async function hasPasskeyCredentialDomain(deps, walletId) {
-	const resolvedWalletId = String(walletId || "").trim();
-	if (!resolvedWalletId) return false;
-	if (deps.walletIframe.shouldUseWalletIframe()) return await (await deps.walletIframe.requireRouter()).hasPasskeyCredential(resolvedWalletId);
-	return (await IndexedDBManager.listWalletAuthMethodsV2ForWallet(resolvedWalletId).catch(() => [])).some((record) => record.kind === SIGNER_AUTH_METHODS.passkey && record.status === "active");
-}
-async function getRecentUnlocksDomain(deps) {
-	if (deps.walletIframe.shouldUseWalletIframe()) try {
-		return await (await deps.walletIframe.requireRouter()).getRecentUnlocks();
-	} catch {
-		return {
-			walletIds: [],
-			accountIds: [],
-			lastUsedAccount: null
-		};
-	}
-	return await getRecentUnlocks(deps.getContext());
-}
-async function prefillRouterAbEcdsaDerivationPresignaturePoolDomain(deps, args, statusReads) {
-	if (deps.walletIframe.shouldUseWalletIframe()) return await (await deps.walletIframe.requireRouter(args.walletSession.walletId)).prefillRouterAbEcdsaDerivationPresignaturePool({
-		walletSession: args.walletSession,
-		options: {
-			chainTarget: args.chainTarget,
-			...typeof args.waitForPoolReady === "boolean" ? { waitForPoolReady: args.waitForPoolReady } : {}
-		}
-	});
-	const walletId = toWalletId(args.walletSession.walletId);
-	return await deps.signingEngine.scheduleRouterAbEcdsaDerivationLoginPresignaturePrefill({
-		walletId,
-		chainTarget: args.chainTarget,
-		...typeof args.waitForPoolReady === "boolean" ? { waitForPoolReady: args.waitForPoolReady } : {}
-	}, statusReads);
-}
-//#endregion
-export { getRecentUnlocksDomain, getWalletSessionDomain, hasPasskeyCredentialDomain, lockDomain, logoutDomain, prefillRouterAbEcdsaDerivationPresignaturePoolDomain, unlockDomain };
-
-//# sourceMappingURL=walletAuth.js.map

package/dist/esm/SeamsWeb/operations/auth/walletUnlockEcdsaSubject.js

@@ -1,33 +0,0 @@
-import { IndexedDbEcdsaCapabilityManifestStore } from "../../../core/indexedDB/seamsWalletDB/ecdsaCapabilityManifestStore.js";
-//#region src/SeamsWeb/operations/auth/walletUnlockEcdsaSubject.ts
-const ecdsaCapabilityManifestStore = new IndexedDbEcdsaCapabilityManifestStore();
-async function resolveEvmFamilyEcdsaWalletUnlockSubjects(walletId) {
-	const resolved = await ecdsaCapabilityManifestStore.listActiveWalletCapabilitySubjects(walletId);
-	if (resolved.kind === "persistence_unavailable") return {
-		kind: "failed",
-		reason: "capability_subject_lookup_failed"
-	};
-	if (resolved.kind === "invalid_current_state") return {
-		kind: "failed",
-		reason: "invalid_capability_subject"
-	};
-	const subjects = [];
-	for (const subject of resolved.subjects) subjects.push({
-		kind: "evm_family_ecdsa_wallet",
-		walletId,
-		capability: subject.capability,
-		authority: subject.authority,
-		ecdsaThresholdKeyId: subject.ecdsaThresholdKeyId
-	});
-	return {
-		kind: "resolved",
-		subjects
-	};
-}
-async function resolveEcdsaActivationJournalSelectors(walletId) {
-	return await ecdsaCapabilityManifestStore.listWalletActivationJournalSelectors(walletId);
-}
-//#endregion
-export { resolveEcdsaActivationJournalSelectors, resolveEvmFamilyEcdsaWalletUnlockSubjects };
-
-//# sourceMappingURL=walletUnlockEcdsaSubject.js.map

package/dist/esm/SeamsWeb/operations/auth/walletUnlockSubject.js

@@ -1,288 +0,0 @@
-import { toAccountId } from "../../../core/types/accountIds.js";
-import { parseNearEd25519SigningKeyId } from "../../../shared-ts/src/utils/registrationIds.js";
-import { toWalletId } from "../../../core/signingEngine/interfaces/ecdsaChainTarget.js";
-import { parseSignerSlot } from "../../../shared-ts/src/utils/signerSlot.js";
-import { IndexedDBManager } from "../../../core/indexedDB/index.js";
-import { resolveEvmFamilyEcdsaWalletUnlockSubjects } from "./walletUnlockEcdsaSubject.js";
-//#region src/SeamsWeb/operations/auth/walletUnlockSubject.ts
-function requiredWalletUnlockMetadataString(metadata, field) {
-	const value = metadata?.[field];
-	if (typeof value !== "string" || !value.trim()) throw new Error(`wallet unlock signer metadata requires ${field}`);
-	return value.trim();
-}
-function nearEd25519WalletUnlockSubjectFromSigner(walletId, signer) {
-	try {
-		const metadataWalletId = String(signer.metadata?.walletId || "").trim();
-		if (metadataWalletId && metadataWalletId !== String(walletId)) return { kind: "invalid" };
-		const signerSlot = parseSignerSlot(signer.signerSlot);
-		if (!signerSlot) return { kind: "invalid" };
-		return {
-			kind: "valid",
-			subject: {
-				kind: "near_ed25519_wallet",
-				walletId,
-				nearAccountId: toAccountId(requiredWalletUnlockMetadataString(signer.metadata, "nearAccountId")),
-				nearEd25519SigningKeyId: parseNearEd25519SigningKeyId(requiredWalletUnlockMetadataString(signer.metadata, "nearEd25519SigningKeyId")),
-				signerSlot
-			}
-		};
-	} catch {
-		return { kind: "invalid" };
-	}
-}
-async function resolveNearEd25519WalletUnlockSubjects(walletId) {
-	const subjects = [];
-	let signers;
-	try {
-		signers = await IndexedDBManager.listActiveWalletSigners({
-			walletId,
-			signerFamily: "ed25519"
-		});
-	} catch {
-		return {
-			kind: "failed",
-			reason: "capability_subject_lookup_failed"
-		};
-	}
-	for (const signer of signers) {
-		const parsed = nearEd25519WalletUnlockSubjectFromSigner(walletId, signer);
-		if (parsed.kind !== "valid") return {
-			kind: "failed",
-			reason: "invalid_capability_subject"
-		};
-		subjects.push(parsed.subject);
-	}
-	return {
-		kind: "resolved",
-		subjects
-	};
-}
-function walletUnlockSubjectKey(subject) {
-	switch (subject.kind) {
-		case "near_ed25519_wallet": return [
-			subject.kind,
-			subject.walletId,
-			subject.nearAccountId,
-			subject.nearEd25519SigningKeyId,
-			subject.signerSlot
-		].join("\0");
-		case "evm_family_ecdsa_wallet": return [
-			subject.kind,
-			subject.walletId,
-			subject.capability,
-			subject.authority.authorityDigest,
-			subject.ecdsaThresholdKeyId
-		].join("\0");
-	}
-	return "";
-}
-function walletUnlockSubjectsIncludeKey(subjects, key) {
-	for (const subject of subjects) if (walletUnlockSubjectKey(subject) === key) return true;
-	return false;
-}
-function appendUniqueWalletUnlockSubject(subjects, subject) {
-	if (walletUnlockSubjectsIncludeKey(subjects, walletUnlockSubjectKey(subject))) return;
-	subjects.push(subject);
-}
-function isNearEd25519WalletUnlockSubject(subject) {
-	return subject.kind === "near_ed25519_wallet";
-}
-function parseWalletSessionReadWalletId(raw) {
-	const value = String(raw || "").trim();
-	if (!value) return null;
-	try {
-		return toWalletId(value);
-	} catch {
-		return null;
-	}
-}
-function parseWalletSessionReadProfileId(raw) {
-	const value = String(raw || "").trim();
-	return value ? value : null;
-}
-function lastProfileWalletSessionReadTarget(lastProfileState) {
-	const profileId = parseWalletSessionReadProfileId(lastProfileState?.profileId);
-	if (!profileId) return { kind: "none" };
-	return {
-		kind: "last_used_profile",
-		profileId
-	};
-}
-async function resolveLastUsedWalletSessionReadTarget() {
-	return lastProfileWalletSessionReadTarget(await IndexedDBManager.getLastProfileState().catch(() => null));
-}
-async function resolveWalletSessionReadTarget(walletId) {
-	const explicitWalletId = parseWalletSessionReadWalletId(walletId);
-	if (explicitWalletId) return {
-		kind: "explicit_wallet",
-		walletId: explicitWalletId
-	};
-	if (walletId) return { kind: "none" };
-	return await resolveLastUsedWalletSessionReadTarget();
-}
-function signerMetadataWalletId(signer) {
-	const value = String(signer.metadata?.walletId || "").trim();
-	if (!value) return null;
-	try {
-		return toWalletId(value);
-	} catch {
-		return null;
-	}
-}
-function uniqueSignerMetadataWalletIds(signers) {
-	const walletIds = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const signer of signers) {
-		const walletId = signerMetadataWalletId(signer);
-		if (!walletId) return { kind: "invalid" };
-		const key = String(walletId);
-		if (seen.has(key)) continue;
-		seen.add(key);
-		walletIds.push(walletId);
-	}
-	return {
-		kind: "resolved",
-		walletIds
-	};
-}
-async function resolveWalletIdForLastUsedProfile(profileId) {
-	let profile;
-	try {
-		profile = await IndexedDBManager.getProfile(profileId);
-	} catch {
-		return {
-			kind: "unresolvable_profile",
-			reason: "capability_subject_lookup_failed"
-		};
-	}
-	if (!profile) return {
-		kind: "unresolvable_profile",
-		reason: "missing_wallet_profile"
-	};
-	let signers;
-	try {
-		signers = await IndexedDBManager.listAccountSignersByProfile({
-			profileId,
-			status: "active"
-		});
-	} catch {
-		return {
-			kind: "unresolvable_profile",
-			reason: "capability_subject_lookup_failed"
-		};
-	}
-	if (signers.length === 0) return {
-		kind: "unresolvable_profile",
-		reason: "missing_requested_capability_subject"
-	};
-	const walletIdResolution = uniqueSignerMetadataWalletIds(signers);
-	if (walletIdResolution.kind === "invalid") return {
-		kind: "unresolvable_profile",
-		reason: "invalid_wallet_profile"
-	};
-	const walletIds = walletIdResolution.walletIds;
-	if (walletIds.length === 0) return {
-		kind: "unresolvable_profile",
-		reason: "invalid_wallet_profile"
-	};
-	if (walletIds.length > 1) return {
-		kind: "unresolvable_profile",
-		reason: "ambiguous_wallet_profile"
-	};
-	return {
-		kind: "resolved_wallet",
-		walletId: walletIds[0]
-	};
-}
-function buildWalletUnlockSubjectSet(walletId, subjects) {
-	const first = subjects[0];
-	if (!first) return { kind: "missing_requested_capability_subject" };
-	return {
-		kind: "resolved",
-		subjectSet: {
-			kind: "wallet_unlock_subject_set",
-			walletId,
-			subjects: [first, ...subjects.slice(1)]
-		}
-	};
-}
-function walletSessionReadFailureForSubjectSet(subjectSet) {
-	if (subjectSet.subjects.filter(isNearEd25519WalletUnlockSubject).length > 1) return "ambiguous_wallet_profile";
-	return null;
-}
-async function resolveWalletUnlockSubjectSet(args) {
-	const normalizedWalletId = toWalletId(args.walletId);
-	const subjects = [];
-	switch (args.requestedCapabilityFamilies.kind) {
-		case "near_ed25519_only":
-		case "all_registered_mpc": {
-			const nearResolution = await resolveNearEd25519WalletUnlockSubjects(normalizedWalletId);
-			if (nearResolution.kind === "failed") return {
-				kind: "capability_subject_resolution_failed",
-				reason: nearResolution.reason
-			};
-			for (const subject of nearResolution.subjects) appendUniqueWalletUnlockSubject(subjects, subject);
-			if (args.requestedCapabilityFamilies.kind === "near_ed25519_only") return buildWalletUnlockSubjectSet(normalizedWalletId, subjects);
-			break;
-		}
-		case "evm_family_ecdsa_only": break;
-		default: args.requestedCapabilityFamilies;
-	}
-	const ecdsaResolution = await resolveEvmFamilyEcdsaWalletUnlockSubjects(normalizedWalletId);
-	if (ecdsaResolution.kind === "failed") return {
-		kind: "capability_subject_resolution_failed",
-		reason: ecdsaResolution.reason
-	};
-	for (const subject of ecdsaResolution.subjects) appendUniqueWalletUnlockSubject(subjects, subject);
-	return buildWalletUnlockSubjectSet(normalizedWalletId, subjects);
-}
-async function resolveWalletCapabilitySubjectResolution(walletId) {
-	const target = await resolveWalletSessionReadTarget(walletId);
-	if (target.kind === "none") return { kind: "no_session_request" };
-	let resolvedWalletId;
-	let source;
-	if (target.kind === "last_used_profile") {
-		const walletTarget = await resolveWalletIdForLastUsedProfile(target.profileId);
-		if (walletTarget.kind === "unresolvable_profile") return {
-			kind: "unresolvable_profile",
-			profileId: target.profileId,
-			reason: walletTarget.reason
-		};
-		resolvedWalletId = walletTarget.walletId;
-		source = "host_last_used_profile";
-	} else {
-		resolvedWalletId = target.walletId;
-		source = "profile_projection";
-	}
-	const subjectResolution = await resolveWalletUnlockSubjectSet({
-		walletId: String(resolvedWalletId),
-		requestedCapabilityFamilies: { kind: "all_registered_mpc" }
-	});
-	if (subjectResolution.kind === "missing_requested_capability_subject") return {
-		kind: "no_session_for_wallet",
-		walletId: resolvedWalletId,
-		reason: "missing_requested_capability_subject"
-	};
-	if (subjectResolution.kind === "capability_subject_resolution_failed") return {
-		kind: "unresolvable",
-		walletId: resolvedWalletId,
-		reason: subjectResolution.reason
-	};
-	const subjectSet = subjectResolution.subjectSet;
-	const failure = walletSessionReadFailureForSubjectSet(subjectSet);
-	if (failure) return {
-		kind: "unresolvable",
-		walletId: resolvedWalletId,
-		reason: failure
-	};
-	return {
-		kind: "resolved",
-		walletId: resolvedWalletId,
-		subjectSet,
-		source
-	};
-}
-//#endregion
-export { resolveWalletCapabilitySubjectResolution, resolveWalletUnlockSubjectSet };
-
-//# sourceMappingURL=walletUnlockSubject.js.map

package/dist/esm/SeamsWeb/operations/authMethods/addAuthMethodSourceClaim.js

@@ -1,72 +0,0 @@
-import { walletSessionAuthorizations } from "../../../core/indexedDB/seamsWalletDB/walletSessionAuthorizationStore.js";
-import { IndexedDBManager } from "../../../core/indexedDB/index.js";
-//#region src/SeamsWeb/operations/authMethods/addAuthMethodSourceClaim.ts
-/**
-* The source claim a same-device addition puts in its intent.
-*
-* The intent digest is what the fresh source proof signs, so every identity the
-* proof is meant to bind has to be inside it. The server resolves the true
-* source from the presented credential and refuses the ceremony when the two
-* disagree, which is what makes this a claim rather than an authority: a client
-* that lies here fails closed at `start` instead of authorizing anything.
-*
-* The authority digest is read from the persisted `WalletAuthorityV1`, not from
-* the Wallet Session's `authorityDigest`. Those are different values under
-* different brands, and only the authority record's is what the server
-* revalidates against.
-*/
-async function resolveAddAuthMethodSourceClaimV1(walletId) {
-	const selected = await IndexedDBManager.resolveSelectedWalletAuthority(String(walletId));
-	if (selected.kind !== "resolved") return {
-		kind: "unavailable",
-		reason: `selected wallet authority is ${selected.kind}`
-	};
-	if (selected.authMethod.status !== "active") return {
-		kind: "unavailable",
-		reason: "selected auth method is not active"
-	};
-	if (selected.authority.state !== "active") return {
-		kind: "unavailable",
-		reason: "selected wallet authority is not active"
-	};
-	if (selected.selection.lockState !== "unlocked" || selected.selection.walletId !== walletId || selected.selection.walletAuthMethodId !== selected.authMethod.walletAuthMethodId || selected.authMethod.walletId !== walletId || selected.authMethod.walletAuthorityId !== selected.authority.authorityId || selected.authority.walletId !== walletId) return {
-		kind: "unavailable",
-		reason: "selected wallet authority identity is invalid"
-	};
-	let session;
-	try {
-		session = await walletSessionAuthorizations.readExactWithOperationCredential({
-			walletId,
-			authorityId: selected.authority.authorityId,
-			authMethodId: selected.authMethod.walletAuthMethodId
-		});
-	} catch {
-		return {
-			kind: "unavailable",
-			reason: "exact Wallet Session state is corrupt"
-		};
-	}
-	if (session.kind !== "found") return {
-		kind: "unavailable",
-		reason: `exact Wallet Session is ${session.kind}`
-	};
-	if (session.record.walletId !== walletId || session.record.authorityId !== selected.authority.authorityId || session.record.authMethodId !== selected.authMethod.walletAuthMethodId || session.record.authorityDigestB64u !== selected.authority.authorityDigestB64u || session.record.authorityRevocationEpoch !== selected.authority.revocationEpoch || session.record.expiresAtMs <= Date.now()) return {
-		kind: "unavailable",
-		reason: "exact Wallet Session identity is invalid or expired"
-	};
-	return {
-		kind: "resolved",
-		sourceAuthMethod: selected.authMethod,
-		source: {
-			walletAuthorityId: selected.authMethod.walletAuthorityId,
-			walletAuthMethodId: selected.authMethod.walletAuthMethodId,
-			walletSessionId: String(session.operationCredential.walletSessionId),
-			authorityDigestB64u: String(selected.authority.authorityDigestB64u),
-			revocationEpoch: selected.authority.revocationEpoch
-		}
-	};
-}
-//#endregion
-export { resolveAddAuthMethodSourceClaimV1 };
-
-//# sourceMappingURL=addAuthMethodSourceClaim.js.map