@seams/wallet 0.8.0 → 0.9.1

package/dist/esm/core/signingEngine/walletCustody/ed25519ActiveClient.js

@@ -1,100 +0,0 @@
-//#region src/core/signingEngine/walletCustody/ed25519ActiveClient.ts
-function requireNonEmpty(value, label) {
-	const normalized = String(value ?? "").trim();
-	if (!normalized) throw new Error(`${label} is required`);
-	return normalized;
-}
-function cloneMetadata(metadata) {
-	return {
-		kind: metadata.kind,
-		scope: {
-			lifecycle_id: metadata.scope.lifecycle_id,
-			root_share_epoch: metadata.scope.root_share_epoch,
-			account_id: metadata.scope.account_id,
-			threshold_session_id: metadata.scope.threshold_session_id,
-			signer_set_id: metadata.scope.signer_set_id,
-			signing_worker_id: metadata.scope.signing_worker_id,
-			material_activation: metadata.scope.material_activation
-		},
-		applicationBinding: {
-			wallet_id: metadata.applicationBinding.wallet_id,
-			near_ed25519_signing_key_id: metadata.applicationBinding.near_ed25519_signing_key_id,
-			signing_root_id: metadata.applicationBinding.signing_root_id,
-			key_creation_signer_slot: metadata.applicationBinding.key_creation_signer_slot
-		},
-		participantIds: [metadata.participantIds[0], metadata.participantIds[1]],
-		registeredPublicKey: metadata.registeredPublicKey.slice(),
-		signingWorkerVerifyingShare: metadata.signingWorkerVerifyingShare.slice(),
-		stateEpoch: metadata.stateEpoch,
-		transcript: metadata.transcript.slice(),
-		activeCapabilityBinding: [...metadata.activeCapabilityBinding],
-		materialActivation: metadata.materialActivation
-	};
-}
-function activeHandle(lifecycle) {
-	if (lifecycle.kind === "active") return lifecycle.handle;
-	throw new Error("Wallet custody Ed25519 active client is disposed");
-}
-function scheduleDisposal(args) {
-	args.workerContext.requestWorkerOperation({
-		kind: "emailOtp",
-		request: {
-			type: "disposeEmailOtpEd25519YaoActiveClient",
-			payload: { activeClientHandle: args.handle }
-		}
-	}).catch(() => void 0);
-}
-async function disposeWalletCustodyEd25519ActiveClientV1(args) {
-	return (await args.workerContext.requestWorkerOperation({
-		kind: "emailOtp",
-		request: {
-			type: "disposeEmailOtpEd25519YaoActiveClient",
-			payload: { activeClientHandle: requireNonEmpty(args.activeClientHandle, "activeClientHandle") }
-		}
-	})).removed;
-}
-/**
-* The worker owns the opened custody material. The browser only keeps this
-* opaque handle while the active signing lane is registered.
-*/
-var WalletCustodyEd25519ActiveClientV1 = class {
-	constructor(workerContext, activeClientHandle, metadata) {
-		this.workerContext = workerContext;
-		this.lifecycle = {
-			kind: "active",
-			handle: requireNonEmpty(activeClientHandle, "activeClientHandle")
-		};
-		this.activeMetadata = cloneMetadata(metadata);
-	}
-	async createSigningShare(input) {
-		return await this.workerContext.requestWorkerOperation({
-			kind: "emailOtp",
-			request: {
-				type: "createEmailOtpEd25519YaoSigningShare",
-				payload: {
-					activeClientHandle: activeHandle(this.lifecycle),
-					input
-				}
-			}
-		});
-	}
-	metadata() {
-		return cloneMetadata(this.activeMetadata);
-	}
-	status() {
-		return this.lifecycle.kind === "active" ? { kind: "active" } : { kind: "disposed" };
-	}
-	dispose() {
-		if (this.lifecycle.kind !== "active") return;
-		const handle = this.lifecycle.handle;
-		this.lifecycle = { kind: "disposed" };
-		scheduleDisposal({
-			workerContext: this.workerContext,
-			handle
-		});
-	}
-};
-//#endregion
-export { WalletCustodyEd25519ActiveClientV1, disposeWalletCustodyEd25519ActiveClientV1 };
-
-//# sourceMappingURL=ed25519ActiveClient.js.map

package/dist/esm/core/signingEngine/walletCustody/ed25519Projection.js

@@ -1,32 +0,0 @@
-import { mpcMaterialActivationRefsEqual } from "../../../shared-ts/src/utils/domainIds.js";
-//#region src/core/signingEngine/walletCustody/ed25519Projection.ts
-function requireNonEmpty(value, field) {
-	const normalized = value.trim();
-	if (!normalized) throw new Error(`Wallet custody Ed25519 projection requires ${field}`);
-	return normalized;
-}
-/**
-* `providerSubject` is the Email OTP provider's subject id (e.g. `google:<sub>`)
-* and is passed as its own argument. It must never be read off
-* `walletSession.walletSessionUserId`: that field is a wallet-scoped identity,
-* independent of the authentication provider subject.
-*/
-async function resolveWalletCustodyEd25519ProjectionV1(deps, walletSession, providerSubjectId, expectedMaterialActivation) {
-	const walletId = String(walletSession.walletId);
-	const providerSubject = requireNonEmpty(String(providerSubjectId), "providerSubject");
-	const references = (await deps.listPublicCapabilityReferences()).filter((identity) => String(identity.walletId) === walletId && mpcMaterialActivationRefsEqual(identity.materialActivation, expectedMaterialActivation));
-	if (references.length === 0) return null;
-	if (references.length !== 1 || !references[0]) throw new Error("Wallet custody Ed25519 requires one exact public capability reference");
-	const identity = references[0];
-	const users = (await deps.listUsers()).filter((user) => String(user.walletId) === walletId && String(user.nearAccountId) === String(identity.nearAccountId));
-	if (users.length !== 1 || !users[0]) throw new Error("Wallet custody Ed25519 requires one exact persisted signer projection");
-	return {
-		identity,
-		user: users[0],
-		providerSubject
-	};
-}
-//#endregion
-export { resolveWalletCustodyEd25519ProjectionV1 };
-
-//# sourceMappingURL=ed25519Projection.js.map

package/dist/esm/core/signingEngine/walletCustody/ed25519SeedMaterial.js

@@ -1,92 +0,0 @@
-import { buildNearAccountRefs } from "../../accountData/near/accountRefs.js";
-import { getAccountKeyMaterial, resolveAccountKeyMaterialTarget } from "../../indexedDB/accountKeyMaterial.js";
-import { WALLET_CUSTODY_ED25519_MATERIAL_KEY_KIND, assertWalletCustodyEd25519MaterialBindingV1, buildWalletCustodyEd25519MaterialRecordV1 } from "../../indexedDB/walletCustodyEd25519MaterialRecord.js";
-//#region src/core/signingEngine/walletCustody/ed25519SeedMaterial.ts
-async function persistWalletCustodyEd25519MaterialV1(input) {
-	const target = await resolveAccountKeyMaterialTarget(input.store, { accountRefs: buildNearAccountRefs(input.binding.nearAccountId) });
-	if (!target) throw new Error("Wallet custody Ed25519 material requires a persisted wallet profile");
-	await input.store.storeKeyMaterial(buildWalletCustodyEd25519MaterialRecordV1({
-		target,
-		...input
-	}));
-}
-async function deleteWalletCustodyEd25519MaterialV1(input) {
-	const target = await resolveAccountKeyMaterialTarget(input.store, { accountRefs: buildNearAccountRefs(input.nearAccountId) });
-	if (!target) return;
-	await input.store.deleteKeyMaterial(target.profileId, input.signerSlot, target.chainIdKey, WALLET_CUSTODY_ED25519_MATERIAL_KEY_KIND);
-}
-/**
-* Reads the cache the ceremony wrote.
-*
-* The counterpart to `persistWalletCustodyEd25519MaterialV1`, which shipped
-* without one — the row was written at registration and never read, so every
-* unlock paid for a Router round the cache existed to avoid.
-*
-* Returns the sealed halves rather than opening them. Opening needs the cache
-* key derived from the wallet custody seed, which lives behind the ceremony's
-* wasm boundary; a loader that could open would need the seed on this side,
-* and that is the property this module exists to keep.
-*
-* The caller states which key set it expects. A row that names a different
-* registered public key is reported unusable rather than returned: it is a
-* cache entry for a key set this unlock is not performing, and importing it
-* would install material for the wrong key.
-*/
-async function loadWalletCustodyEd25519MaterialV1(input) {
-	const record = await getAccountKeyMaterial({
-		deps: {
-			clientDB: input.store,
-			keyMaterialStore: input.store
-		},
-		accountRefs: buildNearAccountRefs(input.nearAccountId),
-		signerSlot: input.signerSlot,
-		keyKind: WALLET_CUSTODY_ED25519_MATERIAL_KEY_KIND
-	});
-	if (!record) return { kind: "absent" };
-	const envelope = record.payloadEnvelope;
-	if (!envelope?.ciphertext || !envelope.nonce) return {
-		kind: "unusable",
-		reason: "cached custody material has no sealed payload"
-	};
-	if (envelope.alg !== "chacha20poly1305-hkdf-sha256-wallet-custody-seed-v1") return {
-		kind: "unusable",
-		reason: "cached custody material was sealed under another key"
-	};
-	const binding = record.payload?.binding;
-	if (!binding || typeof binding !== "object") return {
-		kind: "unusable",
-		reason: "cached custody material has no binding"
-	};
-	const candidate = binding;
-	if (candidate.kind !== "wallet_custody_ed25519_active_client_v1") return {
-		kind: "unusable",
-		reason: "cached custody material is not a wallet custody record"
-	};
-	try {
-		assertWalletCustodyEd25519MaterialBindingV1(candidate);
-	} catch (error) {
-		return {
-			kind: "unusable",
-			reason: error instanceof Error ? error.message : "cached custody binding is incomplete"
-		};
-	}
-	const expected = String(input.expectedRegisteredPublicKeyB64u || "").trim();
-	if (expected && expected !== String(candidate.registeredPublicKeyB64u || "").trim()) return {
-		kind: "unusable",
-		reason: "cached custody material is for another key set"
-	};
-	return {
-		kind: "found",
-		material: {
-			binding: candidate,
-			sealed: {
-				ciphertextB64u: envelope.ciphertext,
-				nonceB64u: envelope.nonce
-			}
-		}
-	};
-}
-//#endregion
-export { deleteWalletCustodyEd25519MaterialV1, loadWalletCustodyEd25519MaterialV1, persistWalletCustodyEd25519MaterialV1 };
-
-//# sourceMappingURL=ed25519SeedMaterial.js.map

package/dist/esm/core/signingEngine/walletCustody/emailOtpLink.js

@@ -1,132 +0,0 @@
-import { parsePasskeyEnvelopeId } from "../../../shared-ts/src/utils/domainIds.js";
-import { parseDigestField, parseEnvelopeCiphertextB64u, parseEnvelopeNonceB64u, parseEnvelopeRevision } from "../../../shared-ts/src/passkey-custody/primitives.js";
-import { toWalletId } from "../interfaces/ecdsaChainTarget.js";
-import { secureRandomId } from "../../../shared-ts/src/utils/secureRandomId.js";
-import { buildEmailOtpEnvelopeFactor, buildMethodBoundEnvelopeOwnership, buildPasskeyCustodyEnvelopeRecord, custodyEnvelopeBindingJsonV1, parsePasskeyCustodyEnvelopeRecord } from "../../../shared-ts/src/passkey-custody/custodyEnvelope.js";
-import "../../../shared-ts/src/passkey-custody/index.js";
-import { finalizeWalletAddAuthMethod, startWalletAddAuthMethod } from "../../rpcClients/relayer/walletRegistration.js";
-//#region src/core/signingEngine/walletCustody/emailOtpLink.ts
-/**
-* Sealing the wallet's existing custody seed under a newly verified
-* Email OTP factor.
-*
-* The mirror of `passkeyLink`, and deliberately the same shape: open the source
-* envelope with the factor secret the caller already collected, reseal the same
-* seed under the new factor, commit the ciphertext with the auth method in one
-* server call. No ceremony runs — nothing is derived and no key manifest is
-* verified, because the seed is the wallet's own and the envelope it came from
-* already proved that.
-*
-* The Email factor secret is generated here and never returned. It is sealed to
-* the server's enrollment key so a future OTP verification can release it back,
-* and it is used once, in the worker, to seal the new envelope.
-*/
-function requireResealedEnvelope(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Email OTP custody worker returned no resealed envelope");
-	const record = value;
-	return {
-		nonceB64u: parseEnvelopeNonceB64u(record.nonceB64u, "resealed envelope nonceB64u"),
-		sealedCustodySecretB64u: parseEnvelopeCiphertextB64u(record.sealedCustodySecretB64u, "resealed envelope sealedCustodySecretB64u"),
-		aadHashB64u: parseDigestField(record.aadHashB64u, "resealed envelope aadHashB64u"),
-		ciphertextDigestB64u: parseDigestField(record.ciphertextDigestB64u, "resealed envelope ciphertextDigestB64u")
-	};
-}
-/** Complete add-email-code custody linking from the browser boundary. */
-async function linkWalletEmailOtpCustody(input) {
-	const started = await startWalletAddAuthMethod({
-		relayerUrl: input.relayerUrl,
-		walletId: input.walletId,
-		addAuthMethodIntentGrant: input.addAuthMethodIntentGrant,
-		addAuthMethodIntentDigestB64u: input.addAuthMethodIntentDigestB64u,
-		intent: input.intent,
-		auth: input.auth,
-		authority: input.authority
-	});
-	if (!started.custodyEnvelope) throw new Error("Email OTP add-auth-method start omitted the source custody envelope");
-	const sourceEnvelope = started.custodyEnvelope;
-	const clientSecret32 = crypto.getRandomValues(new Uint8Array(32));
-	const replacementFactorSecret = clientSecret32.slice();
-	let enrollment;
-	try {
-		enrollment = await input.context.signingEngine.prepareEmailOtpRegistrationEnrollmentMaterialInternal({
-			relayUrl: input.relayerUrl,
-			walletId: toWalletId(String(input.walletId)),
-			userId: input.providerSubject,
-			clientSecret32
-		});
-	} catch (error) {
-		replacementFactorSecret.fill(0);
-		throw error;
-	} finally {
-		clientSecret32.fill(0);
-	}
-	const envelopeIdResult = parsePasskeyEnvelopeId(secureRandomId("wallet-custody-envelope", 24, "wallet custody envelope ids"));
-	if (!envelopeIdResult.ok) throw new Error(envelopeIdResult.error.message);
-	const factor = buildEmailOtpEnvelopeFactor({
-		enrollmentId: enrollment.enrollmentId,
-		enrollmentSealKeyVersion: enrollment.enrollmentSealKeyVersion
-	});
-	const ownership = buildMethodBoundEnvelopeOwnership(input.walletAuthMethodId);
-	const envelopeRevision = parseEnvelopeRevision(1);
-	const replacementBindingJson = custodyEnvelopeBindingJsonV1({
-		walletId: sourceEnvelope.walletId,
-		envelopeId: envelopeIdResult.value,
-		factor,
-		envelopeRevision,
-		binding: sourceEnvelope.binding,
-		ownership
-	});
-	const existingFactorSecret = input.existingFactorSecret.slice();
-	let resealed;
-	try {
-		resealed = requireResealedEnvelope(await input.worker.requestOperation({
-			kind: "walletCustodyCeremony",
-			request: {
-				type: "linkWalletCustodyPasskey",
-				payload: {
-					existingEnvelope: sourceEnvelope,
-					existingFactorSecret: existingFactorSecret.buffer,
-					replacementEnvelopeBindingJson: replacementBindingJson,
-					replacementFactorSecret: replacementFactorSecret.buffer
-				},
-				transfer: [existingFactorSecret.buffer, replacementFactorSecret.buffer]
-			}
-		}));
-	} finally {
-		if (existingFactorSecret.byteLength > 0) existingFactorSecret.fill(0);
-		if (replacementFactorSecret.byteLength > 0) replacementFactorSecret.fill(0);
-	}
-	const nowMs = (input.nowMs ?? Date.now)();
-	const custodyEnvelope = parsePasskeyCustodyEnvelopeRecord(buildPasskeyCustodyEnvelopeRecord({
-		envelopeId: envelopeIdResult.value,
-		walletId: sourceEnvelope.walletId,
-		ownership,
-		binding: sourceEnvelope.binding,
-		factor,
-		envelopeRevision,
-		nonceB64u: resealed.nonceB64u,
-		sealedCustodySecretB64u: resealed.sealedCustodySecretB64u,
-		ciphertextDigestB64u: resealed.ciphertextDigestB64u,
-		aadHashB64u: resealed.aadHashB64u,
-		lifecycle: {
-			state: "active",
-			activatedAtMs: nowMs
-		},
-		createdAtMs: nowMs,
-		updatedAtMs: nowMs
-	}));
-	return { finalized: await finalizeWalletAddAuthMethod({
-		relayerUrl: input.relayerUrl,
-		walletId: input.walletId,
-		addAuthMethodCeremonyId: started.addAuthMethodCeremonyId,
-		custodyEnvelope,
-		emailOtpTarget: {
-			kind: "new_enrollment",
-			enrollment: enrollment.emailOtpEnrollment
-		}
-	}) };
-}
-//#endregion
-export { linkWalletEmailOtpCustody };
-
-//# sourceMappingURL=emailOtpLink.js.map

package/dist/esm/core/signingEngine/walletCustody/joinCustodyWire.js

@@ -1,64 +0,0 @@
-import { custodyEnvelopeOwnershipWireV1, parsePasskeyCustodyEnvelopeRecord } from "../../../shared-ts/src/passkey-custody/custodyEnvelope.js";
-import "../../../shared-ts/src/passkey-custody/index.js";
-//#region src/core/signingEngine/walletCustody/joinCustodyWire.ts
-/**
-* Turning a fetched custody envelope into the wire the ceremony joins with.
-*
-* Two things make this more than a rename.
-*
-* **`envelopeBinding` is a composite, not the record's `binding`.** It is
-* `{walletId, envelopeId, factor, envelopeRevision, binding}` — the values the
-* envelope was sealed against. Passing the inner binding alone would send a
-* wire that decrypts against the wrong AAD, and the failure would read as a
-* bad passkey rather than a bad projection.
-*
-* **The wasm side parses with `deny_unknown_fields`.** Handing it the stored
-* record, or a superset, fails at the boundary. So this projects exactly the
-* five fields `JoinCustodyWireV1` declares, and the test that pins the key set
-* is load-bearing rather than decorative.
-*
-* Lifecycle is checked here as well as on the server. The server gates what it
-* serves, but this also runs against the same-device continuity cache, and a
-* revoked envelope read from local storage must not open custody either.
-*/
-function joinCustodyWireFromEnvelopeRecord(record) {
-	let envelope;
-	try {
-		envelope = parsePasskeyCustodyEnvelopeRecord(record, "custody envelope");
-	} catch (error) {
-		return {
-			ok: false,
-			reason: error instanceof Error ? error.message : "custody envelope is invalid"
-		};
-	}
-	const state = envelope.lifecycle.state;
-	if (state !== "active") return {
-		ok: false,
-		reason: `custody envelope is ${state}`
-	};
-	if (envelope.binding.kind !== "wallet_custody_seed_v1") return {
-		ok: false,
-		reason: "generic custody wire rejects non-seed envelopes"
-	};
-	return {
-		ok: true,
-		custodyJson: JSON.stringify({
-			envelopeBinding: {
-				walletId: envelope.walletId,
-				envelopeId: envelope.envelopeId,
-				factor: envelope.factor,
-				envelopeRevision: envelope.envelopeRevision,
-				binding: envelope.binding,
-				ownership: custodyEnvelopeOwnershipWireV1(envelope.ownership)
-			},
-			nonceB64u: envelope.nonceB64u,
-			sealedCustodySecretB64u: envelope.sealedCustodySecretB64u,
-			aadHashB64u: envelope.aadHashB64u,
-			ciphertextDigestB64u: envelope.ciphertextDigestB64u
-		})
-	};
-}
-//#endregion
-export { joinCustodyWireFromEnvelopeRecord };
-
-//# sourceMappingURL=joinCustodyWire.js.map

package/dist/esm/core/signingEngine/walletCustody/openCustodyCache.js

@@ -1,126 +0,0 @@
-import { base64UrlDecode, base64UrlEncode } from "../../../shared-ts/src/utils/base64.js";
-import { isWalletCustodySeedBinding } from "../../../shared-ts/src/passkey-custody/custodySecretBinding.js";
-import { custodyEnvelopeBindingJsonV1 } from "../../../shared-ts/src/passkey-custody/custodyEnvelope.js";
-import "../../../shared-ts/src/passkey-custody/index.js";
-import { routerAbMpcMaterialActivationRefToWire } from "../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
-import { ROUTER_AB_ED25519_YAO_ACTIVE_CLIENT_KIND_V1, RouterAbEd25519YaoClientV1 } from "../threshold/ed25519/yaoClient.js";
-//#region src/core/signingEngine/walletCustody/openCustodyCache.ts
-function walletCustodyActivationFactsFromActiveClientMetadataV1(metadata) {
-	return {
-		materialActivation: metadata.materialActivation,
-		lifecycleId: metadata.scope.lifecycle_id,
-		signingRootVersion: metadata.scope.root_share_epoch,
-		signingRootId: metadata.applicationBinding.signing_root_id,
-		signerSetId: metadata.scope.signer_set_id,
-		thresholdSessionId: metadata.scope.threshold_session_id,
-		activationTranscriptB64u: base64UrlEncode(metadata.transcript),
-		activationCapabilityBindingB64u: base64UrlEncode(Uint8Array.from(metadata.activeCapabilityBinding))
-	};
-}
-function walletCustodyCacheEnvelopeFromRecordV1(envelope) {
-	if (!isWalletCustodySeedBinding(envelope.binding)) throw new Error("wallet custody cache accepts wallet custody seed envelopes only");
-	return {
-		bindingJson: custodyEnvelopeBindingJsonV1(envelope),
-		nonceB64u: envelope.nonceB64u,
-		ciphertextB64u: envelope.sealedCustodySecretB64u,
-		aadHashB64u: envelope.aadHashB64u,
-		ciphertextDigestB64u: envelope.ciphertextDigestB64u
-	};
-}
-function walletCustodyActiveClientMetadataV1(input) {
-	const { binding } = input.material;
-	const { activation } = input;
-	return {
-		kind: ROUTER_AB_ED25519_YAO_ACTIVE_CLIENT_KIND_V1,
-		scope: {
-			lifecycle_id: activation.lifecycleId,
-			root_share_epoch: activation.signingRootVersion,
-			account_id: binding.walletId,
-			threshold_session_id: activation.thresholdSessionId,
-			signer_set_id: activation.signerSetId,
-			signing_worker_id: binding.signingWorkerId,
-			material_activation: routerAbMpcMaterialActivationRefToWire(activation.materialActivation)
-		},
-		applicationBinding: {
-			wallet_id: binding.walletId,
-			near_ed25519_signing_key_id: binding.nearEd25519SigningKeyId,
-			signing_root_id: activation.signingRootId,
-			key_creation_signer_slot: binding.signerSlot
-		},
-		participantIds: binding.participantIds,
-		registeredPublicKey: base64UrlDecode(binding.registeredPublicKeyB64u),
-		signingWorkerVerifyingShare: base64UrlDecode(binding.signingWorkerVerifyingShareB64u),
-		stateEpoch: BigInt(binding.stateEpoch),
-		transcript: base64UrlDecode(activation.activationTranscriptB64u),
-		activeCapabilityBinding: Array.from(base64UrlDecode(activation.activationCapabilityBindingB64u)),
-		materialActivation: activation.materialActivation
-	};
-}
-/**
-* The warm path: cached material plus any enrolled factor, no Router round.
-*
-* The factor secret is handed straight through to wasm, which zeroes it. It is
-* not copied here and nothing above this call keeps it — the seed it unwraps
-* lives for exactly one call inside the module.
-*/
-async function openWalletCustodyEd25519ActiveClientV1(input) {
-	const metadata = walletCustodyActiveClientMetadataV1({
-		material: input.material,
-		activation: input.activation
-	});
-	return (await RouterAbEd25519YaoClientV1.initializeBundled()).openCustodyCache({
-		ownedFactorSecret: input.ownedFactorSecret,
-		envelope: {
-			bindingJson: input.envelope.bindingJson,
-			nonce: base64UrlDecode(input.envelope.nonceB64u),
-			ciphertext: base64UrlDecode(input.envelope.ciphertextB64u),
-			aadHash: base64UrlDecode(input.envelope.aadHashB64u),
-			ciphertextDigest: base64UrlDecode(input.envelope.ciphertextDigestB64u)
-		},
-		applicationBindingDigest: base64UrlDecode(input.material.binding.applicationBindingDigestB64u),
-		sealed: {
-			kind: "router_ab_ed25519_yao_sealed_local_material_v1",
-			nonce: base64UrlDecode(input.material.sealed.nonceB64u),
-			ciphertext: base64UrlDecode(input.material.sealed.ciphertextB64u)
-		},
-		metadata
-	});
-}
-/**
-* Chooses between opening the cache and rejoining the key set.
-*
-* **The envelope is needed either way.** The custody seed is never stored — it
-* is re-derived by opening the envelope on every unlock, so a cache hit saves
-* the Router round, not the envelope. That is the honest saving and it is
-* worth stating, because "warm unlock" otherwise sounds like it needs nothing.
-*
-* An unusable cached row takes the same branch as a missing one, but the
-* reason is preserved rather than flattened: the two arrive here for different
-* causes and a caller that logs them identically cannot tell a fresh device
-* from a stale row that will keep failing.
-*
-* This deliberately does not perform the rejoin. Rejoining runs a Router
-* ceremony and needs the step runner, the admission and the application facts
-* this layer has no business holding; it reports that one is required and the
-* unlock path drives it.
-*/
-async function openOrRejoinWalletCustodyEd25519V1(input) {
-	const cached = await input.loadCachedMaterial();
-	if (cached.kind !== "found") {
-		input.ownedFactorSecret.fill(0);
-		return { kind: "rejoin_required" };
-	}
-	return {
-		kind: "opened",
-		activeClient: await openWalletCustodyEd25519ActiveClientV1({
-			material: cached.material,
-			activation: input.activation,
-			envelope: input.envelope,
-			ownedFactorSecret: input.ownedFactorSecret
-		})
-	};
-}
-//#endregion
-export { openOrRejoinWalletCustodyEd25519V1, openWalletCustodyEd25519ActiveClientV1, walletCustodyActivationFactsFromActiveClientMetadataV1, walletCustodyActiveClientMetadataV1, walletCustodyCacheEnvelopeFromRecordV1 };
-
-//# sourceMappingURL=openCustodyCache.js.map