@seams/wallet-server 0.20.0 → 0.21.0

package/dist/esm/threshold/session/signingSessionSeal/crypto/cipher.js

@@ -73,6 +73,17 @@ function normalizeConfig(config) {
 	};
 }
 function encodeSigningSessionSealServerLockContext(input) {
+	return encodeSigningSessionHkdfTuple([
+		"seams/router-ab/signing-session-seal",
+		input.protocol.algorithm,
+		input.protocol.groupId,
+		input.keyVersion,
+		"server-lock/session/v1",
+		input.walletId,
+		input.thresholdSessionId
+	]);
+}
+function encodeEmailOtpEnrollmentServerLockContext(input) {
 	return encodeSigningSessionHkdfTuple([
 		"seams/router-ab/signing-session-seal",
 		input.protocol.algorithm,
@@ -89,14 +100,14 @@ function defaultRuntime() {
 		destroyLockKeyHandle: destroySigningSessionSealLockKeyHandle
 	};
 }
-async function deriveAcceptedKeyHandles(input) {
+async function deriveEmailOtpEnrollmentKeyHandles(input) {
 	const handles = /* @__PURE__ */ new Map();
 	try {
 		for (const keyVersion of input.config.acceptedWarmKeyVersions) {
 			const handle = await input.runtime.deriveLockKeyHandle({
 				groupId: input.config.protocol.groupId,
 				rootSecret32: input.config.rootSecret32,
-				context: encodeSigningSessionSealServerLockContext({
+				context: encodeEmailOtpEnrollmentServerLockContext({
 					protocol: input.config.protocol,
 					keyVersion
 				})
@@ -111,14 +122,14 @@ async function deriveAcceptedKeyHandles(input) {
 		input.config.rootSecret32.fill(0);
 	}
 }
-var SigningSessionSealKeyHandles = class {
+var EmailOtpEnrollmentKeyHandles = class {
 	initialization = null;
 	constructor(config, runtime) {
 		this.config = config;
 		this.runtime = runtime;
 	}
 	get() {
-		if (!this.initialization) this.initialization = deriveAcceptedKeyHandles({
+		if (!this.initialization) this.initialization = deriveEmailOtpEnrollmentKeyHandles({
 			config: this.config,
 			runtime: this.runtime
 		});
@@ -132,50 +143,159 @@ function mapCipherError(error, defaultMessage) {
 	if (lowered.includes("ciphertext") || lowered.includes("base64url") || lowered.includes("group")) return failure("invalid_ciphertext", message);
 	return failure("internal", message);
 }
-function createSigningSessionSealShamir3PassCipherAdapter(options) {
-	const config = normalizeConfig(options.config);
-	options.config.rootSecret32.fill(0);
-	const runtime = options.runtime ?? defaultRuntime();
-	const handles = new SigningSessionSealKeyHandles(config, runtime);
-	return createSigningSessionSealCipherAdapter({
-		applyServerSeal: async (input) => {
+function copyToArrayBuffer(bytes) {
+	const copy = new ArrayBuffer(bytes.length);
+	new Uint8Array(copy).set(bytes);
+	return copy;
+}
+async function importSigningSessionSealRootKey(rootSecret32) {
+	const rootCopy = copyToArrayBuffer(rootSecret32);
+	try {
+		return await crypto.subtle.importKey("raw", rootCopy, {
+			name: "HMAC",
+			hash: "SHA-256"
+		}, false, ["sign"]);
+	} finally {
+		rootSecret32.fill(0);
+		new Uint8Array(rootCopy).fill(0);
+	}
+}
+async function deriveScopedSigningSessionHandle(input) {
+	const context = encodeSigningSessionSealServerLockContext({
+		protocol: input.state.config.protocol,
+		keyVersion: input.keyVersion,
+		walletId: input.walletId,
+		thresholdSessionId: input.thresholdSessionId
+	});
+	let sessionRoot32 = null;
+	try {
+		const rootKey = await input.state.rootKey;
+		sessionRoot32 = new Uint8Array(await crypto.subtle.sign("HMAC", rootKey, copyToArrayBuffer(context)));
+		return await input.state.runtime.deriveLockKeyHandle({
+			groupId: input.state.config.protocol.groupId,
+			rootSecret32: sessionRoot32,
+			context
+		});
+	} finally {
+		sessionRoot32?.fill(0);
+		context.fill(0);
+	}
+}
+async function acquireLockHandle(state, input, keyVersion) {
+	switch (state.kind) {
+		case "email_otp_enrollment": {
+			const handle = (await state.handles.get()).get(keyVersion);
+			if (handle === void 0) throw new Error("Email OTP enrollment lock key handle is unavailable");
+			return {
+				kind: "borrowed",
+				handle
+			};
+		}
+		case "signing_session": return {
+			kind: "owned",
+			handle: await deriveScopedSigningSessionHandle({
+				state,
+				keyVersion,
+				walletId: input.auth.userId,
+				thresholdSessionId: input.thresholdSessionId
+			})
+		};
+		default: return assertNeverShamir3PassCipherState(state);
+	}
+}
+function assertNeverShamir3PassCipherState(value) {
+	throw new Error(`Unsupported Shamir 3-pass cipher state: ${String(value)}`);
+}
+function assertNeverSigningSessionSealOperation(value) {
+	throw new Error(`Unsupported signing-session seal operation: ${String(value)}`);
+}
+async function runShamir3PassCipher(state, operation, input) {
+	if (state.kind === "signing_session") {
+		if (!normalizeOptionalTrimmedString(input.auth.userId) || !normalizeOptionalTrimmedString(input.thresholdSessionId)) return failure("invalid_scope", "Authenticated wallet and threshold session are required");
+	}
+	let keyVersion;
+	switch (operation) {
+		case "apply-server-seal": {
 			const requestedKeyVersion = normalizeOptionalTrimmedString(input.keyVersion);
-			if (requestedKeyVersion && requestedKeyVersion !== config.currentKeyVersion) return failure("invalid_key_version", `Requested keyVersion "${requestedKeyVersion}" does not match active keyVersion "${config.currentKeyVersion}"`);
+			if (requestedKeyVersion && requestedKeyVersion !== state.config.currentKeyVersion) return failure("invalid_key_version", `Requested keyVersion "${requestedKeyVersion}" does not match active keyVersion "${state.config.currentKeyVersion}"`);
+			keyVersion = state.config.currentKeyVersion;
+			break;
+		}
+		case "remove-server-seal":
 			try {
-				const handle = (await handles.get()).get(config.currentKeyVersion);
-				if (handle === void 0) throw new Error("currentKeyVersion handle is unavailable");
-				return {
-					ok: true,
-					ciphertext: await runtime.addLock({
-						handle,
-						ciphertextB64u: input.ciphertext
-					}),
-					keyVersion: config.currentKeyVersion
-				};
-			} catch (error) {
-				return mapCipherError(error, "Failed to apply server seal");
+				keyVersion = normalizeKeyVersion(input.keyVersion, "keyVersion");
+			} catch {
+				return failure("invalid_key_version", "keyVersion is invalid");
 			}
-		},
-		removeServerSeal: async (input) => {
-			const keyVersion = normalizeKeyVersion(input.keyVersion, "keyVersion");
-			try {
-				const handle = (await handles.get()).get(keyVersion);
-				if (handle === void 0) return failure("invalid_key_version", `Unknown keyVersion "${keyVersion}"`);
-				return {
-					ok: true,
-					ciphertext: await runtime.removeLock({
-						handle,
+			if (!state.config.acceptedWarmKeyVersions.includes(keyVersion)) return failure("invalid_key_version", `Unknown keyVersion "${keyVersion}"`);
+			break;
+		default: return assertNeverSigningSessionSealOperation(operation);
+	}
+	try {
+		const lease = await acquireLockHandle(state, input, keyVersion);
+		try {
+			let ciphertext;
+			switch (operation) {
+				case "apply-server-seal":
+					ciphertext = await state.runtime.addLock({
+						handle: lease.handle,
 						ciphertextB64u: input.ciphertext
-					}),
-					keyVersion
-				};
-			} catch (error) {
-				return mapCipherError(error, "Failed to remove server seal");
+					});
+					break;
+				case "remove-server-seal":
+					ciphertext = await state.runtime.removeLock({
+						handle: lease.handle,
+						ciphertextB64u: input.ciphertext
+					});
+					break;
+				default: return assertNeverSigningSessionSealOperation(operation);
 			}
+			return {
+				ok: true,
+				ciphertext,
+				keyVersion
+			};
+		} finally {
+			if (lease.kind === "owned") state.runtime.destroyLockKeyHandle(lease.handle);
 		}
+	} catch (error) {
+		return mapCipherError(error, "Failed to process server seal");
+	}
+}
+function applyShamir3PassCipher(state, input) {
+	return runShamir3PassCipher(state, "apply-server-seal", input);
+}
+function removeShamir3PassCipher(state, input) {
+	return runShamir3PassCipher(state, "remove-server-seal", input);
+}
+function createShamir3PassCipherAdapter(state) {
+	return createSigningSessionSealCipherAdapter({
+		applyServerSeal: applyShamir3PassCipher.bind(null, state),
+		removeServerSeal: removeShamir3PassCipher.bind(null, state)
+	});
+}
+function createEmailOtpEnrollmentShamir3PassCipherAdapter(options) {
+	const config = normalizeConfig(options.config);
+	options.config.rootSecret32.fill(0);
+	const runtime = options.runtime ?? defaultRuntime();
+	return createShamir3PassCipherAdapter({
+		kind: "email_otp_enrollment",
+		config,
+		runtime,
+		handles: new EmailOtpEnrollmentKeyHandles(config, runtime)
+	});
+}
+function createSigningSessionSealShamir3PassCipherAdapter(options) {
+	const config = normalizeConfig(options.config);
+	options.config.rootSecret32.fill(0);
+	return createShamir3PassCipherAdapter({
+		kind: "signing_session",
+		config,
+		runtime: options.runtime ?? defaultRuntime(),
+		rootKey: importSigningSessionSealRootKey(config.rootSecret32)
 	});
 }
 //#endregion
-export { createPassthroughSigningSessionSealCipherAdapter, createSigningSessionSealCipherAdapter, createSigningSessionSealShamir3PassCipherAdapter, encodeSigningSessionSealServerLockContext };
+export { createEmailOtpEnrollmentShamir3PassCipherAdapter, createPassthroughSigningSessionSealCipherAdapter, createSigningSessionSealCipherAdapter, createSigningSessionSealShamir3PassCipherAdapter, encodeSigningSessionSealServerLockContext };
 
 //# sourceMappingURL=cipher.js.map

package/dist/types/shared-ts/src/authorization/walletCustodyOperation.d.ts

@@ -1,5 +1,5 @@
 import { type DigestB64u } from '../utils/canonicalPrimitives';
-export type WalletCustodyAdminOperation = 'credentials_list' | 'credential_label' | 'recovery_rotate' | 'recovery_read';
+export type WalletCustodyAdminOperation = 'credentials_list' | 'credential_label' | 'recovery_rotate' | 'recovery_read' | 'recovery_status' | 'recovery_backup_acknowledge';
 /** Public challenge digest for a single wallet-administration factor proof. */
 export declare function computeWalletCustodyAdminChallengeDigest(input: {
     readonly walletId: string;

package/dist/types/shared-ts/src/device-linking/contracts.d.ts

@@ -429,13 +429,7 @@ export type LinkedOwnerCredentialMetadataV1 = {
 } | {
     readonly kind: 'email_otp';
     readonly walletAuthMethodId: WalletAuthMethodId;
-    /**
-     * The verified address behind this factor. The management projection is
-     * served only to an authenticated owner session, and the owner already
-     * knows the address they enrolled — this exists so the settings surface
-     * can name the factor. Local persistence keeps only the email hash.
-     */
-    readonly email: VerifiedEmailAddress;
+    readonly email?: never;
     readonly device?: never;
     readonly credentialIdB64u?: never;
 };

package/dist/types/shared-ts/src/passkey-custody/ceremonyCommitPayload.d.ts

@@ -135,8 +135,10 @@ export type WalletCustodyRegistrationOutcome =
 /** No custody payload rode this leg. Registration is unaffected. */
 {
     readonly status: 'not_requested';
+    readonly issuedAtMs?: never;
 } | {
     readonly status: 'committed';
+    readonly issuedAtMs: number;
 }
 /**
  * A joining run: this key set's manifest digest, with no custody records
@@ -145,6 +147,7 @@ export type WalletCustodyRegistrationOutcome =
  | {
     readonly status: 'joined';
     readonly keyManifestDigestB64u: string;
+    readonly issuedAtMs?: never;
 }
 /**
  * Another ceremony established this wallet's custody first. The client must
@@ -152,11 +155,13 @@ export type WalletCustodyRegistrationOutcome =
  */
  | {
     readonly status: 'custody_already_established';
+    readonly issuedAtMs?: never;
 }
 /** The payload was refused. Nothing was written. */
  | {
     readonly status: 'rejected';
     readonly reason: string;
+    readonly issuedAtMs?: never;
 };
 /**
  * Reads a commit payload off the wire without judging it.

package/dist/types/shared-ts/src/utils/evmRpcResults.d.ts

@@ -1,8 +1,8 @@
 export type EvmTransactionReceipt = {
-    transactionHash?: string | null;
+    transactionHash: string;
     from?: string | null;
-    blockNumber?: string | null;
-    status?: string | null;
+    blockNumber: string;
+    status: string;
     gasUsed?: string | null;
     effectiveGasPrice?: string | null;
     gasPrice?: string | null;

package/dist/types/shared-ts/src/utils/routerAbEcdsaDerivation.d.ts

@@ -441,7 +441,7 @@ type RouterAbEcdsaOperationStepUpWebAuthnCredentialV1Wire = {
         readonly signature: string;
         readonly userHandle: string | null;
     };
-    readonly clientExtensionResults: unknown | null;
+    readonly clientExtensionResults: null;
 };
 export type RouterAbEcdsaOperationStepUpPreparationV1Wire = {
     readonly wallet_id: string;

package/dist/types/wallet-server/src/core/authService/emailOtpSeal.d.ts

@@ -8,9 +8,13 @@ export type EmailOtpShamirCipherResult = {
     readonly code: 'not_configured';
     readonly message: string;
 };
-export type EmailOtpServerSealRequest = {
+export type EmailOtpServerSealApplyRequest = {
     readonly wrappedCiphertext?: unknown;
 };
+export type EmailOtpServerSealRemoveRequest = {
+    readonly wrappedCiphertext?: unknown;
+    readonly enrollmentSealKeyVersion: string;
+};
 export type EmailOtpServerSealResult = {
     ok: true;
     ciphertext: string;

package/dist/types/wallet-server/src/core/deviceLinking/linkedDeviceManagement.d.ts

@@ -108,15 +108,6 @@ type LinkedDeviceManagementCredentialMetadataPortV1 = {
         readonly walletId: WalletId;
         readonly credentialIdB64u: string;
     }): Promise<WebAuthnAuthenticatorDeviceInfo | null>;
-    /**
-     * The wallet's verified Email OTP address, from its canonical enrollment.
-     * Served only inside the owner-scoped management projection, which is why the
-     * plaintext address (not the hash) is acceptable here: the reader is the
-     * wallet owner who enrolled it.
-     */
-    readEmailOtpAddressV1(input: {
-        readonly walletId: WalletId;
-    }): Promise<string | null>;
 };
 type LinkedDeviceManagementServiceOptionsV1 = {
     readonly tenantId: TenantId;
@@ -151,5 +142,6 @@ export declare class LinkedDeviceManagementServiceV1 {
     private buildLinkedDeviceSummaryV1;
     private buildOwnerDeviceSummaryV1;
 }
+export declare const MAX_FRESH_REVOCATION_PROOF_AGE_MS_V1: number;
 export {};
 //# sourceMappingURL=linkedDeviceManagement.d.ts.map

package/dist/types/wallet-server/src/core/emailOtpD1Statements.d.ts

@@ -11,7 +11,8 @@ export declare const emailOtpChallengeRows: {
 /** Statements on `email_otp_grants`. */
 export declare const emailOtpGrantRows: {
     insert: (prepare: ScopedD1Prepare, record: EmailOtpGrantRecord) => D1PreparedStatementLike;
-    consume: (prepare: ScopedD1Prepare, grantToken: string) => D1PreparedStatementLike;
+    read: (prepare: ScopedD1Prepare, grantToken: string) => D1PreparedStatementLike;
+    consumeMatching: (prepare: ScopedD1Prepare, record: EmailOtpGrantRecord, nowMs: number) => D1PreparedStatementLike;
 };
 /** Statements on `email_otp_wallet_enrollments`. */
 export declare const emailOtpWalletEnrollmentRows: {

package/dist/types/wallet-server/src/hosted-wallet-gateway.d.ts

@@ -52,6 +52,7 @@ export interface CloudflareD1GatewayBaseEnv extends Readonly<Record<string, unkn
     readonly SIGNING_SESSION_SEAL_ROOT_SECRET_B64U?: string;
     readonly SIGNING_SESSION_SEAL_CURRENT_KEY_VERSION?: string;
     readonly SIGNING_SESSION_SEAL_ACCEPTED_WARM_KEY_VERSIONS?: string;
+    readonly EMAIL_OTP_SERVER_SEAL_ACCEPTED_WARM_KEY_VERSIONS?: string;
     readonly EMAIL_OTP_DELIVERY_MODE?: string;
     readonly EMAIL_OTP_RUNTIME_PROFILE?: string;
     readonly EMAIL_OTP_PROVIDER?: string;

package/dist/types/wallet-server/src/router/auth/webAuthnCredentialCodecs.d.ts

@@ -12,6 +12,7 @@ type WebAuthnClientDataJson = {
     readonly origin: string;
     readonly type: string;
 };
+export declare function unredactedWebAuthnExtensionField(input: unknown): string | null;
 export declare function decodeWebAuthnBase64UrlOrBase64(input: string, fieldName: string): Uint8Array<ArrayBuffer>;
 export declare function parseWebAuthnClientDataJsonBase64url(clientDataJSONB64u: string): WebAuthnClientDataJson;
 export declare function webAuthnOriginHostnameOrEmpty(origin: string): string;

package/dist/types/wallet-server/src/router/cloudflare/d1/deviceLinking/d1LinkedDeviceManagementService.d.ts

@@ -6,7 +6,6 @@ import type { OrdinaryInactiveSignerMaterialDeactivationPortV1 } from '../../../
 import { D1WalletAuthorityStore, type D1WalletAuthorityStoreScope } from '../wallet/d1WalletAuthorityStore';
 import { CloudflareD1WebAuthnStore } from '../webauthn/d1WebAuthnStore';
 import type { CloudflareD1AuthorizationStore } from '../authorization/d1AuthorizationStore';
-import type { CloudflareD1EmailOtpEnrollmentStore } from '../emailOtp/d1EmailOtpEnrollmentStore';
 export declare function createD1LinkedDeviceManagementServiceV1(input: {
     readonly scope: D1WalletAuthorityStoreScope;
     readonly tenantId: TenantId;
@@ -15,8 +14,6 @@ export declare function createD1LinkedDeviceManagementServiceV1(input: {
     readonly authorizationService: AuthorizationService;
     readonly walletSessionAuthorizations: Pick<CloudflareD1AuthorizationStore, 'readActiveWalletSessionAuthorizationV2ByIdentity' | 'prepareRetireWalletSessionAuthorizationsV2ForAuthority'>;
     readonly webAuthnStore: CloudflareD1WebAuthnStore;
-    /** Absent when Email OTP is not deployed; an email_otp method then fails closed. */
-    readonly emailOtpEnrollments?: Pick<CloudflareD1EmailOtpEnrollmentStore, 'readEnrollment'>;
     readonly materialDeactivation?: OrdinaryInactiveSignerMaterialDeactivationPortV1;
 }): LinkedDeviceManagementServiceV1;
 //# sourceMappingURL=d1LinkedDeviceManagementService.d.ts.map

package/dist/types/wallet-server/src/router/cloudflare/d1/deviceLinking/d1LinkedDeviceRevocation.d.ts

@@ -1,7 +1,7 @@
 import type { LinkedDeviceRevokeRequestV1, LinkedDeviceRevokeResultV1 } from '../../../../../../shared-ts/src/device-linking/contracts';
 import type { DigestB64u } from '../../../../../../shared-ts/src/utils/canonicalPrimitives';
 import type { WalletAuthMethodId, WalletId } from '../../../../../../shared-ts/src/utils/domainIds';
-import type { LinkedDeviceManagementServiceV1, LinkedDeviceManagementSourceV1 } from '../../../../core/deviceLinking/linkedDeviceManagement';
+import { type LinkedDeviceManagementServiceV1, type LinkedDeviceManagementSourceV1 } from '../../../../core/deviceLinking/linkedDeviceManagement';
 import type { D1WalletAuthMethodStore } from '../../../../core/d1WalletAuthMethodStore';
 import type { DeviceLinkingAuthDeniedV1 } from '../../../transport/fetch/routes/deviceLinking';
 import type { D1LinkedDeviceFreshRevokeProofV1, verifyD1LinkedDeviceFreshRevokeProofV1 } from '../wallet/d1WalletAuthMethodBoundary';

package/dist/types/wallet-server/src/router/cloudflare/d1/emailOtp/d1EmailOtpGrantStore.d.ts

@@ -1,11 +1,13 @@
 import type { EmailOtpGrantRecord } from '../../../../core/EmailOtpStores';
 import { type ScopedD1Prepare } from '../../../../core/emailOtpD1Statements';
+import type { D1PreparedStatementLike } from '../../../../storage/tenantRoute';
 export declare class CloudflareD1EmailOtpGrantStore {
     private readonly prepare;
     constructor(input: {
         readonly prepare: ScopedD1Prepare;
     });
     put(record: EmailOtpGrantRecord): Promise<void>;
-    consume(grantToken: string): Promise<EmailOtpGrantRecord | null>;
+    read(grantToken: string): Promise<EmailOtpGrantRecord | null>;
+    prepareConsumeMatching(record: EmailOtpGrantRecord, nowMs: number): D1PreparedStatementLike;
 }
 //# sourceMappingURL=d1EmailOtpGrantStore.d.ts.map

package/dist/types/wallet-server/src/router/cloudflare/d1/emailOtp/d1EmailOtpRateLimitStore.d.ts

@@ -1,8 +1,8 @@
-import type { D1DatabaseLike } from '../../../../storage/tenantRoute';
+import type { D1DatabaseLike, D1PreparedStatementLike } from '../../../../storage/tenantRoute';
 import type { ScopedD1Prepare } from '../../../../core/emailOtpD1Statements';
 import type { RateLimitResult } from '../../../../core/authService/rateLimits';
 import type { EmailOtpRateLimitPolicy } from '../auth/d1RouterApiAuthConfig';
-import { type EmailOtpRateLimitScope, type EmailOtpRateLimitConsumeInput } from './d1EmailOtpRecords';
+import { emailOtpRateLimitExceeded, type EmailOtpRateLimitScope, type EmailOtpRateLimitConsumeInput } from './d1EmailOtpRecords';
 type EmailOtpRateLimitPolicies = {
     readonly [K in EmailOtpRateLimitScope]: EmailOtpRateLimitPolicy;
 };
@@ -10,11 +10,24 @@ type EmailOtpRateLimitConsumeResult = Readonly<RateLimitResult>;
 export declare class CloudflareD1EmailOtpRateLimitStore {
     private readonly input;
     constructor(input: {
+        readonly database: D1DatabaseLike;
         readonly prepare: ScopedD1Prepare;
         readonly batch: D1DatabaseLike['batch'];
         readonly rateLimits: EmailOtpRateLimitPolicies;
     });
     consume(input: EmailOtpRateLimitConsumeInput): Promise<EmailOtpRateLimitConsumeResult>;
+    consumeVerifiedGrant(input: {
+        readonly grantDelete: D1PreparedStatementLike;
+        readonly rateLimit: EmailOtpRateLimitConsumeInput & {
+            readonly kind: 'wallet';
+            readonly scope: 'grant';
+        };
+        readonly nowMs: number;
+    }): Promise<void>;
+    readExceededGrantRateLimit(input: EmailOtpRateLimitConsumeInput & {
+        readonly kind: 'wallet';
+        readonly scope: 'grant';
+    }, nowMs: number): Promise<ReturnType<typeof emailOtpRateLimitExceeded> | null>;
     private prepareConsume;
     private readCounter;
 }

package/dist/types/wallet-server/src/router/cloudflare/d1/emailOtp/d1EmailOtpServerSealRuntime.d.ts

@@ -1,12 +1,12 @@
 import type { EmailOtpServerSealRuntimeConfig } from '../auth/d1RouterApiAuthConfig';
-import type { EmailOtpServerSealRequest, EmailOtpServerSealResult as CoreEmailOtpServerSealResult } from '../../../../core/authService/emailOtpSeal';
+import type { EmailOtpServerSealApplyRequest, EmailOtpServerSealRemoveRequest, EmailOtpServerSealResult as CoreEmailOtpServerSealResult } from '../../../../core/authService/emailOtpSeal';
 type EmailOtpServerSealResult = Readonly<CoreEmailOtpServerSealResult>;
 export declare class CloudflareD1EmailOtpServerSealRuntime {
     private readonly config;
     private readonly cipherResult;
     constructor(config: EmailOtpServerSealRuntimeConfig);
-    removeEmailOtpServerSeal(input: EmailOtpServerSealRequest): Promise<EmailOtpServerSealResult>;
-    applyEmailOtpServerSeal(input: EmailOtpServerSealRequest): Promise<EmailOtpServerSealResult>;
+    removeEmailOtpServerSeal(input: EmailOtpServerSealRemoveRequest): Promise<EmailOtpServerSealResult>;
+    applyEmailOtpServerSeal(input: EmailOtpServerSealApplyRequest): Promise<EmailOtpServerSealResult>;
     private runServerSealOperation;
     private createCipher;
 }

package/dist/types/wallet-server/src/router/cloudflare/d1/passkeyCustody/d1PasskeyCustodyRouteService.d.ts

@@ -236,11 +236,14 @@ export interface RouterApiPasskeyCustodyService {
      */
     acknowledgeRecoveryBackup(request: {
         readonly walletId: string;
+        readonly expectedIssuedAtMs: number;
     }): Promise<{
         kind: 'acknowledged';
         issuedAtMs: number;
     } | {
         kind: 'no_recovery_set';
+    } | {
+        kind: 'conflict';
     }>;
     /**
      * Replaces the wallet's recovery codes with a freshly wrapped set.

package/dist/types/wallet-server/src/router/cloudflare/d1/passkeyCustody/d1WalletCustodyCommitStore.d.ts

@@ -43,9 +43,11 @@ export type WalletRecoveryCodeLocatorRecord = {
  */
 export type WalletCustodyRegistrationReservation = {
     readonly kind: 'reserved';
+    readonly issuedAtMs: number;
     readonly statements: readonly D1PreparedStatementLike[];
 } | {
     readonly kind: 'already_exists';
+    readonly issuedAtMs: number;
 } | {
     readonly kind: 'custody_already_established';
 } | {
@@ -148,12 +150,9 @@ export declare class CloudflareD1WalletCustodyCommitStore {
      */
     readBackupAcknowledgement(walletId: WalletId): Promise<WalletRecoveryBackupAcknowledgementV1 | null>;
     /**
-     * Records that the owner confirmed saving their codes.
-     *
-     * Written with no expected version, unlike the recovery set: this row is
-     * cosmetic, a repeat acknowledgement is not a conflict worth surfacing to
-     * someone pressing a button, and it shares no record with the wraps a spend
-     * updates — which is exactly why it is a separate key.
+     * Records the issuance that the owner confirmed saving. The caller selects
+     * that issuance before this write, so a concurrent rotation cannot make this
+     * acknowledgement apply to newer codes the owner did not see.
      */
     writeBackupAcknowledgement(record: WalletRecoveryBackupAcknowledgementV1): Promise<{
         kind: 'stored';

package/dist/types/wallet-server/src/router/domains/passkeyCustody/walletCustodyRegistrationCommit.d.ts

@@ -3,6 +3,7 @@ export type { WalletCustodyCeremonyCommitPayload };
 import type { CloudflareD1WalletCustodyCommitStore, WalletCustodyRegistrationReservation } from '../../cloudflare/d1/passkeyCustody/d1WalletCustodyCommitStore';
 export type WalletCustodyRegistrationCommitOutcome = {
     readonly kind: 'already_exists';
+    readonly issuedAtMs: number;
 } | {
     readonly kind: 'custody_already_established';
 } | {
@@ -10,12 +11,9 @@ export type WalletCustodyRegistrationCommitOutcome = {
     readonly reason: string;
 };
 /** The write that a reservation left for after the registration's wallet commit. */
-export type WalletCustodyRegistrationReserved = {
-    readonly kind: 'reserved';
-    readonly statements: Extract<WalletCustodyRegistrationReservation, {
-        kind: 'reserved';
-    }>['statements'];
-};
+export type WalletCustodyRegistrationReserved = Extract<WalletCustodyRegistrationReservation, {
+    kind: 'reserved';
+}>;
 /**
  * Builds the records and claims their recovery-code routes.
  *

package/dist/types/wallet-server/src/router/framework/authServicePort.d.ts

@@ -701,7 +701,13 @@ type RouterApiMethodTypes = {
             readonly expiresAtMs: number;
         } | RouterApiOkFailure;
     };
-    removeEmailOtpServerSeal: RouterApiMethodTypes['applyEmailOtpServerSeal'];
+    removeEmailOtpServerSeal: {
+        readonly input: {
+            readonly wrappedCiphertext?: unknown;
+            readonly enrollmentSealKeyVersion: string;
+        };
+        readonly result: RouterApiMethodTypes['applyEmailOtpServerSeal']['result'];
+    };
     respondWalletAddSignerEcdsaDerivation: {
         readonly input: WalletAddSignerEcdsaDerivationRespondRequest;
         readonly result: WalletAddSignerEcdsaDerivationRespondResponse;

package/dist/types/wallet-server/src/router/transport/fetch/routes/passkeyCustody.d.ts

@@ -52,15 +52,6 @@ export declare function handleWalletRecoveryBackupAcknowledge(ctx: FetchRouterAp
  */
 export declare function handleWalletRecoveryRotate(ctx: FetchRouterApiContext): Promise<Response | null>;
 export declare function handleWalletRecoveryRead(ctx: FetchRouterApiContext): Promise<Response | null>;
-/**
- * Reporting recovery status to the wallet's owner.
- *
- * The wallet comes from the path. Origin binding keeps this count endpoint
- * scoped to browser callers without exposing recovery identifiers.
- *
- * Counts only, never identifiers. Which codes remain is not something even
- * the owner's browser needs, and a list would be one leak away from being
- * useful to someone else.
- */
+/** Reports current recovery-code counts after fresh owner proof. */
 export declare function handleWalletRecoveryStatus(ctx: FetchRouterApiContext): Promise<Response | null>;
 //# sourceMappingURL=passkeyCustody.d.ts.map

package/dist/types/wallet-server/src/router/transport/fetch/routes/walletCustodyRequestBoundary.d.ts

@@ -0,0 +1,28 @@
+import type { WebAuthnAuthenticationCredential } from '../../../../core/types';
+export type WalletCustodyOwnerProofWire = {
+    readonly kind: 'passkey';
+    readonly walletId: string;
+    readonly rpId: string;
+    readonly credentialIdB64u: string;
+    readonly challenge_digest: string;
+    readonly webauthn_authentication: WebAuthnAuthenticationCredential;
+} | {
+    readonly kind: 'email_otp';
+    readonly provider_subject_id: string;
+    readonly challenge_id: string;
+    readonly otp_code: string;
+    readonly challenge_digest: string;
+};
+export declare function requireExactObjectFields(value: Record<string, unknown>, fields: readonly string[], label: string): void;
+export declare function parseCustodyOwnerProof(value: unknown): WalletCustodyOwnerProofWire;
+export declare function parseRecoveryBackupAcknowledgementRequest(body: unknown): {
+    readonly walletId: string;
+    readonly requestId: string;
+    readonly expectedIssuedAtMs: number;
+    readonly factorProof: unknown;
+};
+export declare function parseRecoveryStatusRequest(body: unknown): {
+    readonly requestId: string;
+    readonly factorProof: unknown;
+};
+//# sourceMappingURL=walletCustodyRequestBoundary.d.ts.map

package/dist/types/wallet-server/src/threshold/session/signingSessionSeal/crypto/cipher.d.ts

@@ -39,7 +39,10 @@ export declare function createPassthroughSigningSessionSealCipherAdapter(): Sign
 export declare function encodeSigningSessionSealServerLockContext(input: {
     readonly protocol: SigningSessionSealProtocol;
     readonly keyVersion: string;
+    readonly walletId: string;
+    readonly thresholdSessionId: string;
 }): Uint8Array;
+export declare function createEmailOtpEnrollmentShamir3PassCipherAdapter(options: CreateSigningSessionSealShamir3PassCipherAdapterOptions): SigningSessionSealCipherAdapter;
 export declare function createSigningSessionSealShamir3PassCipherAdapter(options: CreateSigningSessionSealShamir3PassCipherAdapterOptions): SigningSessionSealCipherAdapter;
 export {};
 //# sourceMappingURL=cipher.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seams/wallet-server",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "type": "module",
   "description": "Seams server TypeScript SDK for NEAR and EVM-family wallets",
   "main": "./dist/esm/index.js",