@qntx/wallet-worker 0.1.0 → 0.3.0

package/dist/node.d.mts

@@ -2,7 +2,9 @@ import { AutoLockPolicy, PasskeyConfig, Wallet } from "@qntx/wallet";
 import { PasskeyCeremony } from "@qntx/wallet/host";
 import { Worker } from "node:worker_threads";
 //#region src/node/software-passkey.d.ts
-export declare function createSoftwarePasskey(seed: Uint8Array): PasskeyCeremony;
+export declare function createSoftwarePasskey(seed: Uint8Array, options?: {
+  readonly synced?: boolean;
+}): PasskeyCeremony;
 //#endregion
 //#region src/node/index.d.ts
 export type NodeWalletOptions = {

package/dist/node.mjs

@@ -1,5 +1,5 @@
 import { WalletError } from "@qntx/wallet";
-import { connectKernel } from "@qntx/wallet/host";
+import { PASSKEY_PURPOSE_VAULT, PASSKEY_PURPOSE_WALLET, connectKernel } from "@qntx/wallet/host";
 import { MessageChannel, Worker } from "node:worker_threads";
 //#region ../wallet-kernel/src/errors.ts
 /**
@@ -806,10 +806,19 @@ function cloneImage(image) {
 		factors: image.factors.map(cloneFactor)
 	};
 }
+function conflict(message) {
+	return new KernelError("conflict", `vault store: ${message}`);
+}
+function requireMeta(meta) {
+	if (meta === void 0) throw conflict("vault is not initialized");
+	return meta;
+}
 /**
 * In-memory RecordStore for the Node host and kernel tests. Loads and commits deep-copy every
 * Uint8Array, so callers can never mutate stored state. `commit` applies ops to a clone and swaps
-* atomically: a failing `expect-uninitialized` leaves the store untouched.
+* atomically: a failing precondition (`init`, `expect-revision`, a counter op on an empty store)
+* leaves the store untouched. Content ops bump `meta.revision` once per commit; an `init` commit
+* writes its meta verbatim (revision stays as the initializer set it).
 */
 function createMemoryStore() {
 	let image = {
@@ -822,30 +831,65 @@ function createMemoryStore() {
 		let { meta } = image;
 		let { records } = image;
 		let { factors } = image;
+		let bump = false;
+		let initialized = false;
 		for (const op of ops) switch (op.op) {
-			case "expect-uninitialized":
-				if (meta !== void 0 || records.length > 0 || factors.length > 0) throw new KernelError("integrity", "vault already initialized");
-				break;
-			case "put-meta":
+			case "init":
+				if (meta !== void 0 || records.length > 0 || factors.length > 0) throw conflict("vault already initialized");
 				meta = cloneMeta(op.meta);
+				initialized = true;
+				break;
+			case "expect-revision":
+				if (meta === void 0 || meta.revision !== op.revision) throw conflict("vault changed underneath");
+				break;
+			case "set-key-id":
+				meta = {
+					...requireMeta(meta),
+					keyId: op.keyId
+				};
+				bump = true;
+				break;
+			case "record-failure": {
+				const current = requireMeta(meta);
+				meta = {
+					...current,
+					failedAttempts: current.failedAttempts + 1,
+					lastFailureAt: op.at
+				};
+				break;
+			}
+			case "reset-failures":
+				meta = {
+					...requireMeta(meta),
+					failedAttempts: 0,
+					lastFailureAt: 0
+				};
 				break;
 			case "put-record":
 				records = [...records.filter((record) => !(record.kind === op.record.kind && record.id === op.record.id)), cloneRecord(op.record)];
+				bump = true;
 				break;
 			case "delete-record":
 				records = records.filter((record) => !(record.kind === op.kind && record.id === op.id));
+				bump = true;
 				break;
 			case "put-factor":
 				factors = [...factors.filter((factor) => factor.id !== op.factor.id), cloneFactor(op.factor)];
+				bump = true;
 				break;
 			case "delete-factor":
 				factors = factors.filter((factor) => factor.id !== op.id);
+				bump = true;
 				break;
 			case "clear":
 				meta = void 0;
 				records = [];
 				factors = [];
 		}
+		if (bump && !initialized && meta !== void 0) meta = {
+			...meta,
+			revision: meta.revision + 1
+		};
 		return {
 			meta,
 			records,
@@ -890,13 +934,25 @@ function serveStore(store, port) {
 	const post = (reply) => {
 		port.postMessage(reply);
 	};
+	const failed = (id, error) => {
+		const code = error instanceof KernelError ? error.code : "unavailable";
+		post({
+			t: "failed",
+			id,
+			code
+		});
+	};
 	const answer = async (request) => {
 		if (request.t === "load") {
-			post({
-				t: "loaded",
-				id: request.id,
-				image: encodeImage(await store.load())
-			});
+			try {
+				post({
+					t: "loaded",
+					id: request.id,
+					image: encodeImage(await store.load())
+				});
+			} catch (error) {
+				failed(request.id, error);
+			}
 			return;
 		}
 		ownCommits++;
@@ -904,7 +960,8 @@ function serveStore(store, port) {
 			await store.commit(request.ops);
 		} catch (error) {
 			ownCommits--;
-			throw error;
+			failed(request.id, error);
+			return;
 		}
 		post({
 			t: "committed",
@@ -943,8 +1000,11 @@ function serveStore(store, port) {
 *
 * CredentialId = SHA-256(seed ‖ "credential" ‖ u32be(n)) (n increments per create) PRF(salt) =
 * HMAC-SHA256(HMAC-SHA256(seed, credentialId), SHA-256(UTF-8("WebAuthn PRF") ‖ 0x00 ‖ salt))
+* UserHandle = purpose byte ‖ SHA-256(seed ‖ "user-handle" ‖ credentialId)[0:15] — the same
+* 16-byte, purpose-prefixed shape the browser create path puts in `user.id`.
 */
-function createSoftwarePasskey(seed) {
+function createSoftwarePasskey(seed, options) {
+	const synced = options?.synced ?? true;
 	let counter = 0;
 	let lastCreated;
 	const known = /* @__PURE__ */ new Map();
@@ -953,25 +1013,35 @@ function createSoftwarePasskey(seed) {
 		const message = sha256(concatBytes(utf8ToBytes("WebAuthn PRF"), new Uint8Array([0]), salt));
 		return hmac(sha256, key, message);
 	};
-	const result = (credentialId, salts) => ({
+	const result = (credentialId, salts, userHandle) => ({
 		credentialId: new Uint8Array(credentialId),
 		first: prf(credentialId, salts.first),
-		...salts.second === void 0 ? {} : { second: prf(credentialId, salts.second) }
+		...salts.second === void 0 ? {} : { second: prf(credentialId, salts.second) },
+		...userHandle === void 0 ? {} : { userHandle: new Uint8Array(userHandle) },
+		synced
 	});
 	return {
-		create: async ({ salts }) => {
+		create: async ({ purpose, salts }) => {
 			const counterBytes = /* @__PURE__ */ new Uint8Array(4);
 			new DataView(counterBytes.buffer).setUint32(0, counter);
 			counter++;
 			const credentialId = sha256(concatBytes(seed, utf8ToBytes("credential"), counterBytes));
-			known.set(bytesToHex(credentialId), credentialId);
+			const purposeByte = purpose === "wallet" ? PASSKEY_PURPOSE_WALLET : PASSKEY_PURPOSE_VAULT;
+			const userHandle = /* @__PURE__ */ new Uint8Array(16);
+			userHandle[0] = purposeByte;
+			userHandle.set(sha256(concatBytes(seed, utf8ToBytes("user-handle"), credentialId)).subarray(0, 15), 1);
+			known.set(bytesToHex(credentialId), {
+				credentialId,
+				userHandle
+			});
 			lastCreated = credentialId;
 			return result(credentialId, salts);
 		},
 		assert: async ({ credentialIds, salts }) => {
 			const credentialId = credentialIds === void 0 ? lastCreated : credentialIds.find((id) => known.has(bytesToHex(id)));
 			if (credentialId === void 0) throw new WalletError("factor-unavailable", credentialIds === void 0 ? "no software credential exists yet" : "unknown software credential");
-			return result(credentialId, salts);
+			const entry = known.get(bytesToHex(credentialId));
+			return result(credentialId, salts, entry?.userHandle);
 		}
 	};
 }
@@ -983,14 +1053,10 @@ function createSoftwarePasskey(seed) {
 * in-memory store, served to each worker over a MessageChannel. That is what lets a lock destroy
 * the whole worker without losing the vault.
 */
-const MAX_SESSION_MS = 432e5;
 async function createNodeWallet(options) {
 	const { autoLock } = options;
 	if (autoLock.platform !== "web") throw new WalletError("invalid-input", "createNodeWallet accepts only the web autoLock policy");
-	const workerData = {
-		idleMs: autoLock.idleMinutes * 6e4,
-		maxSessionMs: MAX_SESSION_MS
-	};
+	const workerData = { idleMinutes: autoLock.idleMinutes };
 	const store = createMemoryStore();
 	const kernelUrl = options.kernelUrl ?? new URL("kernel.node.js", import.meta.url);
 	const spawn = () => {
@@ -1035,7 +1101,13 @@ async function createNodeWallet(options) {
 	return connectKernel({
 		spawn,
 		passkey: options.passkey,
-		ceremony: options.authenticator
+		ceremony: options.authenticator,
+		setTimer: (delayMs, fn) => {
+			const timer = setTimeout(fn, delayMs);
+			return () => {
+				clearTimeout(timer);
+			};
+		}
 	});
 }
 //#endregion