@txnlab/use-wallet-passkey 0.0.0-stage → 5.2.0-next.3

package/dist/index.js

@@ -0,0 +1,730 @@
+import algosdk from "algosdk";
+import { canonify } from "canonify";
+import { BaseWallet, ScopeType, SignDataError, base64ToByteArray, byteArrayToBase64, encodeEmptySignature, flattenTxnGroup, isSignedTxn, isTransactionArray } from "@txnlab/use-wallet/adapter";
+import { sha512_256 } from "@noble/hashes/sha2";
+//#region src/derivation.ts
+/**
+* The derivation from a passkey's PRF output to a Falcon-1024 account.
+*
+* ```
+* entropy    = PRF(eval.first = PRF_LABEL_PREFIX + context)    // 32 bytes
+* keygenSeed = SHA-512/256("PQK" || "f1" || entropy)
+* {pk, sk}   = falcon-1024 generateKey(keygenSeed)             // falcon_det1024
+* address    = algosdk.addressFromPQKey(FALCON_1024_SCHEME, pk)
+* phrase     = algosdk.mnemonicFromSeed(entropy)               // 25 words
+* ```
+*
+* The keygen seed matches go-algorand's `algokey pq` (`derivePQKeySeed`),
+* algosdk's `pq25WordMnemonicToSeed`, Lute's Falcon25 accounts, Pera and
+* ARC-76, so the recovery phrase restores the same account in any of them.
+*
+* NEVER CHANGE `PRF_LABEL_PREFIX`: the label is the PRF input, so changing it
+* changes every account derived from it.
+*/
+/** The PRF input prefix. Frozen: changing it moves every account. */
+const PRF_LABEL_PREFIX = "@txnlab/use-wallet-passkey:falcon-1024:v1:";
+/**
+* A `context` may not contain `:`, so a future account slot can be encoded as
+* a `:<n>` suffix without colliding with any slot-0 label.
+*/
+const CONTEXT_PATTERN = /^[^:]{0,128}$/;
+function assertValidContext(context) {
+	if (!CONTEXT_PATTERN.test(context)) throw new Error("passkey: `context` must be at most 128 characters and must not contain \":\"");
+}
+/** The PRF input (`eval.first`) for an account context */
+function prfInput(context) {
+	assertValidContext(context);
+	return new TextEncoder().encode(PRF_LABEL_PREFIX + context);
+}
+const PQK_PREFIX = new Uint8Array([
+	80,
+	81,
+	75,
+	102,
+	49
+]);
+/** keygenSeed = SHA-512/256("PQK" || "f1" || entropy) */
+function keygenSeedFromEntropy(entropy) {
+	if (entropy.length !== 32) throw new Error("entropy must be 32 bytes");
+	const input = new Uint8Array(PQK_PREFIX.length + entropy.length);
+	input.set(PQK_PREFIX);
+	input.set(entropy, PQK_PREFIX.length);
+	try {
+		return sha512_256(input);
+	} finally {
+		input.fill(0);
+	}
+}
+//#endregion
+//#region src/errors.ts
+var PasskeyError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = "PasskeyError";
+		this.code = code;
+	}
+};
+/**
+* Classifies a WebAuthn failure after the fact. Never gate on user-agent
+* sniffing up front: these errors are the only reliable signal.
+*/
+function toPasskeyError(error) {
+	if (error instanceof PasskeyError) return error;
+	const name = error instanceof Error ? error.name : void 0;
+	const message = error instanceof Error ? error.message : String(error);
+	switch (name) {
+		case "NotAllowedError":
+		case "AbortError": return new PasskeyError("cancelled", "The passkey request was cancelled or timed out. In an in-app browser, open the page in Safari or Chrome.", { cause: error });
+		case "NotSupportedError": return new PasskeyError("unsupported", "This browser does not support passkeys here. Open the page in a full browser.", { cause: error });
+		case "SecurityError": return new PasskeyError("invalid-rp-id", `The passkey relying party ID is not valid for this origin: ${message}`, { cause: error });
+		default: return new PasskeyError("failed", message, { cause: error });
+	}
+}
+//#endregion
+//#region src/icon.ts
+const icon = `
+<svg viewBox="0 0 40 40" xmlns="http://www.w3.org/2000/svg">
+  <rect fill="#1F2A44" width="40" height="40" rx="8"/>
+  <circle cx="16" cy="13.5" r="5" fill="none" stroke="#FFFFFF" stroke-width="2.5"/>
+  <path d="M7.5 30c0-4.7 3.8-8.5 8.5-8.5 1.6 0 3.1.4 4.3 1.2" fill="none" stroke="#FFFFFF" stroke-width="2.5" stroke-linecap="round"/>
+  <circle cx="27" cy="23" r="3.6" fill="none" stroke="#7DD3FC" stroke-width="2.4"/>
+  <path d="M27 26.6V33m0-3h2.6M27 32.4h2" fill="none" stroke="#7DD3FC" stroke-width="2.4" stroke-linecap="round"/>
+</svg>
+`;
+//#endregion
+//#region src/key-store.ts
+/**
+* The built-in key store: a dedicated module worker started from a Blob URL.
+* The worker module is inlined into this package, so a consumer's bundler has
+* no worker entry to resolve; the page's CSP must allow `worker-src blob:` and
+* `'wasm-unsafe-eval'`. `lock` terminates the worker, which drops its WASM
+* heap.
+*/
+var WorkerKeyStore = class {
+	options;
+	worker = null;
+	isUnlocked = false;
+	nextId = 1;
+	pending = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this.options = options;
+	}
+	get unlocked() {
+		return this.isUnlocked;
+	}
+	async unlock(entropy) {
+		const buffer = new Uint8Array(entropy).buffer;
+		entropy.fill(0);
+		this.lock();
+		try {
+			this.worker = await this.start();
+			const publicKey = await this.call({
+				op: "unlock",
+				entropy: buffer,
+				idleTimeoutMs: this.options.idleTimeoutMs
+			}, [buffer]);
+			this.isUnlocked = true;
+			return publicKey;
+		} catch (error) {
+			new Uint8Array(buffer).fill(0);
+			this.lock();
+			throw error;
+		}
+	}
+	sign(bytes) {
+		if (!this.isUnlocked) return Promise.reject(new PasskeyError("key-store-failed", "The passkey key store is locked."));
+		return this.call({
+			op: "sign",
+			bytes
+		});
+	}
+	lock() {
+		this.isUnlocked = false;
+		if (!this.worker) return;
+		this.worker.terminate();
+		this.worker = null;
+		const error = new PasskeyError("key-store-failed", "The passkey key store was locked.");
+		for (const { reject } of this.pending.values()) reject(error);
+		this.pending.clear();
+	}
+	async start() {
+		const { WORKER_SOURCE } = await import("./source.generated-CISa6YOa.js");
+		const { startTimeoutMs = 1e4 } = this.options;
+		const url = URL.createObjectURL(new Blob([WORKER_SOURCE], { type: "text/javascript" }));
+		return new Promise((resolve, reject) => {
+			let worker;
+			try {
+				worker = new Worker(url, {
+					type: "module",
+					name: "use-wallet-passkey"
+				});
+			} catch (error) {
+				URL.revokeObjectURL(url);
+				reject(this.startError(error));
+				return;
+			}
+			const done = () => {
+				clearTimeout(timer);
+				URL.revokeObjectURL(url);
+			};
+			const timer = setTimeout(() => {
+				done();
+				worker.terminate();
+				reject(new PasskeyError("key-store-failed", `The passkey key worker did not start within ${startTimeoutMs} ms.`));
+			}, startTimeoutMs);
+			worker.onmessage = (event) => {
+				if (event.data.type !== "ready") return;
+				done();
+				worker.onmessage = (event) => this.handle(event.data);
+				worker.onerror = (event) => {
+					event.preventDefault();
+					this.lock();
+				};
+				resolve(worker);
+			};
+			worker.onerror = (event) => {
+				event.preventDefault();
+				done();
+				worker.terminate();
+				reject(this.startError(event.message));
+			};
+		});
+	}
+	startError(cause) {
+		const detail = cause instanceof Error ? cause.message : cause ? String(cause) : "";
+		return new PasskeyError("key-store-failed", "The passkey key worker failed to start. If the page has a Content Security Policy, it must allow worker-src blob: and script-src 'wasm-unsafe-eval'." + (detail ? ` (${detail})` : ""), { cause });
+	}
+	call(request, transfer = []) {
+		const worker = this.worker;
+		if (!worker) return Promise.reject(new PasskeyError("key-store-failed", "The passkey key store is locked."));
+		const id = this.nextId++;
+		return new Promise((resolve, reject) => {
+			this.pending.set(id, {
+				resolve,
+				reject
+			});
+			worker.postMessage({
+				...request,
+				id
+			}, transfer);
+		});
+	}
+	handle(message) {
+		if (message.type === "locked") {
+			this.lock();
+			this.options.onIdleLock?.();
+			return;
+		}
+		if (message.type !== "result") return;
+		const entry = this.pending.get(message.id);
+		if (!entry) return;
+		this.pending.delete(message.id);
+		if (message.ok) entry.resolve(message.value);
+		else entry.reject(new PasskeyError("key-store-failed", message.error));
+	}
+};
+//#endregion
+//#region src/record.ts
+const LOCAL_STORAGE_PASSKEY_KEY = "@txnlab/use-wallet:v5:passkey";
+function loadRecord() {
+	if (typeof localStorage === "undefined") return null;
+	try {
+		const raw = localStorage.getItem(LOCAL_STORAGE_PASSKEY_KEY);
+		if (!raw) return null;
+		const stored = JSON.parse(raw);
+		if (stored.version !== 1 || typeof stored.rpId !== "string" || typeof stored.context !== "string" || typeof stored.credentialId !== "string" || typeof stored.publicKey !== "string" || typeof stored.salt !== "number" || typeof stored.address !== "string") return null;
+		return {
+			version: 1,
+			rpId: stored.rpId,
+			context: stored.context,
+			credentialId: base64ToByteArray(stored.credentialId),
+			publicKey: base64ToByteArray(stored.publicKey),
+			salt: stored.salt,
+			address: stored.address
+		};
+	} catch {
+		return null;
+	}
+}
+function saveRecord(record) {
+	if (typeof localStorage === "undefined") return;
+	const stored = {
+		...record,
+		credentialId: byteArrayToBase64(record.credentialId),
+		publicKey: byteArrayToBase64(record.publicKey)
+	};
+	localStorage.setItem(LOCAL_STORAGE_PASSKEY_KEY, JSON.stringify(stored));
+}
+function removeRecord() {
+	if (typeof localStorage === "undefined") return;
+	localStorage.removeItem(LOCAL_STORAGE_PASSKEY_KEY);
+}
+//#endregion
+//#region src/webauthn.ts
+/**
+* WebAuthn ceremonies.
+*
+* Each function calls `navigator.credentials.*` synchronously, before its
+* first `await`. WebKit (every iOS browser) drops the user gesture across an
+* await, so callers must also start the ceremony before awaiting anything.
+*
+* PRF output depends on whether the user was verified (CTAP2 `hmac-secret`
+* keeps separate secrets for verified and presence-only ceremonies), so every
+* ceremony that evaluates the PRF uses `userVerification: 'required'`. Only
+* `assertUser`, which evaluates nothing, may use `'preferred'`.
+*/
+function randomBytes(length) {
+	return crypto.getRandomValues(new Uint8Array(length));
+}
+function bytesEqual$1(a, b) {
+	return a.length === b.length && a.every((byte, i) => byte === b[i]);
+}
+function getCredentials() {
+	if (typeof navigator === "undefined" || !navigator.credentials || !globalThis.PublicKeyCredential) throw new PasskeyError("unsupported", "This browser does not support passkeys.");
+	return navigator.credentials;
+}
+/** Copy a WebAuthn buffer so the result doesn't alias the credential object */
+function copy(buffer) {
+	return ArrayBuffer.isView(buffer) ? new Uint8Array(new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)) : new Uint8Array(new Uint8Array(buffer));
+}
+/**
+* Create a discoverable passkey with the PRF extension enabled. Returns its
+* credential ID. The create-time `prf.enabled` flag is unreliable (1Password
+* on iOS returns `{}`, Windows Hello reports `false` but works), so callers
+* confirm PRF support with a scoped `evaluatePrf` right after.
+*/
+function createPasskey({ rpId, rpName, userName }) {
+	let pending;
+	try {
+		pending = getCredentials().create({ publicKey: {
+			rp: {
+				id: rpId,
+				name: rpName
+			},
+			user: {
+				id: randomBytes(16),
+				name: userName,
+				displayName: userName
+			},
+			challenge: randomBytes(32),
+			pubKeyCredParams: [
+				{
+					type: "public-key",
+					alg: -8
+				},
+				{
+					type: "public-key",
+					alg: -7
+				},
+				{
+					type: "public-key",
+					alg: -257
+				}
+			],
+			authenticatorSelection: {
+				residentKey: "required",
+				requireResidentKey: true,
+				userVerification: "required"
+			},
+			extensions: { prf: {} }
+		} });
+	} catch (error) {
+		return Promise.reject(toPasskeyError(error));
+	}
+	return pending.then((credential) => {
+		if (!(credential instanceof PublicKeyCredential)) throw new PasskeyError("cancelled", "No passkey was created.");
+		return copy(credential.rawId);
+	}, (error) => {
+		throw toPasskeyError(error);
+	});
+}
+/** Run a PRF assertion with `userVerification: 'required'` */
+function evaluatePrf({ rpId, prfInput, credentialId }) {
+	let pending;
+	try {
+		pending = getCredentials().get({ publicKey: {
+			challenge: randomBytes(32),
+			rpId,
+			userVerification: "required",
+			allowCredentials: credentialId ? [{
+				type: "public-key",
+				id: copy(credentialId)
+			}] : void 0,
+			extensions: { prf: { eval: { first: copy(prfInput) } } }
+		} });
+	} catch (error) {
+		return Promise.reject(toPasskeyError(error));
+	}
+	return pending.then((credential) => {
+		if (!(credential instanceof PublicKeyCredential)) throw new PasskeyError("cancelled", "No passkey was selected.");
+		const rawId = copy(credential.rawId);
+		if (credentialId && !bytesEqual$1(rawId, credentialId)) throw new PasskeyError("key-mismatch", "A different passkey answered the request.");
+		const first = credential.getClientExtensionResults().prf?.results?.first;
+		if (!first) throw new PasskeyError("prf-unsupported", "This passkey's provider doesn't support the PRF extension. Use a passkey from a provider that does, such as iCloud Keychain, Google Password Manager, 1Password, Windows Hello or a FIDO2 security key.");
+		const prf = copy(first);
+		if (prf.length !== 32) {
+			prf.fill(0);
+			throw new PasskeyError("prf-unsupported", `Unexpected PRF output length: ${prf.length}`);
+		}
+		return {
+			credentialId: rawId,
+			prf
+		};
+	}, (error) => {
+		throw toPasskeyError(error);
+	});
+}
+/**
+* Run a bare assertion as a consent prompt: no PRF, so it derives nothing and
+* may use `'preferred'`. There is no server to check its signature; it only
+* proves the user approved the prompt on this page.
+*/
+function assertUser({ rpId, credentialId, userVerification }) {
+	let pending;
+	try {
+		pending = getCredentials().get({ publicKey: {
+			challenge: randomBytes(32),
+			rpId,
+			userVerification,
+			allowCredentials: [{
+				type: "public-key",
+				id: copy(credentialId)
+			}]
+		} });
+	} catch (error) {
+		return Promise.reject(toPasskeyError(error));
+	}
+	return pending.then((credential) => {
+		if (!(credential instanceof PublicKeyCredential)) throw new PasskeyError("cancelled", "The passkey prompt was dismissed.");
+	}, (error) => {
+		throw toPasskeyError(error);
+	});
+}
+//#endregion
+//#region src/adapter.ts
+/**
+* Passkey Wallet Adapter for Algorand
+*
+* Derives a Falcon-1024 (post-quantum) account from a passkey's WebAuthn PRF
+* output. There is no extension, app or seed phrase to set up; the passkey
+* provider (iCloud Keychain, Google Password Manager, 1Password, Windows
+* Hello, a security key) syncs and protects the credential.
+*
+* SECURITY CONSIDERATIONS:
+* - The account is bound to the relying party ID (by default the page's
+*   hostname). Whoever controls that domain can run a PRF ceremony and recover
+*   the key with one tap, and the account is stranded if the domain is lost,
+*   so offer `exportRecoveryPhrase`.
+* - Only public data is persisted: the credential ID, public key, address
+*   salt and address. Never the PRF output, the entropy or the private key.
+* - The private key lives in a dedicated worker, never on the main thread.
+*   Without `session`, the worker is terminated after every request.
+*/
+const ICON = `data:image/svg+xml;base64,${btoa(icon)}`;
+const DEFAULT_IDLE_TIMEOUT_MS = 9e5;
+function bytesEqual(a, b) {
+	return a.length === b.length && a.every((byte, i) => byte === b[i]);
+}
+function emptySignatureFor(record) {
+	return encodeEmptySignature({ pqsig: {
+		sch: algosdk.FALCON_1024_SCHEME,
+		slt: record.salt,
+		pk: record.publicKey,
+		sig: /* @__PURE__ */ new Uint8Array()
+	} });
+}
+async function sha256(data) {
+	return new Uint8Array(await crypto.subtle.digest("SHA-256", new Uint8Array(data)));
+}
+var PasskeyAdapter = class extends BaseWallet {
+	keyStore = null;
+	constructor(params) {
+		super(params);
+		assertValidContext(this.context);
+	}
+	static defaultMetadata = {
+		name: "Passkey",
+		icon: ICON
+	};
+	get rpId() {
+		return this.options.rpId ?? location.hostname;
+	}
+	get rpName() {
+		return this.options.rpName ?? this.rpId;
+	}
+	get context() {
+		return this.options.context ?? "";
+	}
+	/** True when the key stays unlocked between requests */
+	get isSession() {
+		return !!this.options.session || !!this.options.keyStore;
+	}
+	createKeyStore() {
+		if (this.options.keyStore) return this.options.keyStore();
+		const { session } = this.options;
+		return new WorkerKeyStore({
+			idleTimeoutMs: session ? (typeof session === "object" ? session.idleTimeoutMs : void 0) ?? DEFAULT_IDLE_TIMEOUT_MS : 0,
+			onIdleLock: () => this.logger.info("Session locked after inactivity")
+		});
+	}
+	getKeyStore() {
+		this.keyStore ??= this.createKeyStore();
+		return this.keyStore;
+	}
+	/** Drop the key after a request, unless a session keeps it */
+	release() {
+		if (!this.isSession) this.keyStore?.lock();
+	}
+	/**
+	* Sign in with an existing passkey, or create one with `{ create: true }`.
+	* Show both choices: a missing passkey and a cancelled prompt raise the same
+	* error, so the adapter can't tell which one happened.
+	*/
+	connect = async (args) => {
+		const rpId = this.rpId;
+		const context = this.context;
+		const input = prfInput(context);
+		this.logger.info(args?.create ? "Creating passkey..." : "Connecting...");
+		let result;
+		try {
+			if (args?.create) result = await evaluatePrf({
+				rpId,
+				prfInput: input,
+				credentialId: await createPasskey({
+					rpId,
+					rpName: this.rpName,
+					userName: args.userName ?? this.options.userName ?? `${this.rpName} account`
+				})
+			});
+			else result = await evaluatePrf({
+				rpId,
+				prfInput: input
+			});
+			this.keyStore?.lock();
+			const publicKey = await this.getKeyStore().unlock(result.prf);
+			this.release();
+			const { address, salt } = algosdk.addressFromPQKey(algosdk.FALCON_1024_SCHEME, publicKey);
+			const record = {
+				version: 1,
+				rpId,
+				context,
+				credentialId: result.credentialId,
+				publicKey,
+				salt,
+				address: address.toString()
+			};
+			saveRecord(record);
+			const walletAccount = {
+				name: `${this.metadata.name} Account`,
+				address: record.address,
+				emptySignature: emptySignatureFor(record)
+			};
+			const walletState = {
+				accounts: [walletAccount],
+				activeAccount: walletAccount
+			};
+			this.store.addWallet(walletState);
+			this.logger.info("Connected successfully", walletState);
+			return [walletAccount];
+		} catch (error) {
+			result?.prf.fill(0);
+			this.keyStore?.lock();
+			this.logger.error("Error connecting:", error.message);
+			throw error;
+		}
+	};
+	disconnect = async () => {
+		this.logger.info("Disconnecting...");
+		this.keyStore?.lock();
+		this.keyStore = null;
+		removeRecord();
+		this.onDisconnect();
+		this.logger.info("Disconnected");
+	};
+	/** Restores the account without a ceremony; the key unlocks on the first signature */
+	resumeSession = async () => {
+		const walletState = this.store.getWalletState();
+		if (!walletState) {
+			this.logger.info("No session to resume");
+			return;
+		}
+		const record = loadRecord();
+		if (!record || !this.matchesRecord(record, walletState)) {
+			this.logger.info("No passkey record for this session, disconnecting...");
+			await this.disconnect();
+			return;
+		}
+		this.logger.info("Session resumed");
+	};
+	matchesRecord(record, walletState) {
+		return record.rpId === this.rpId && record.context === this.context && walletState.accounts.length === 1 && walletState.accounts[0].address === record.address;
+	}
+	requireRecord() {
+		const walletState = this.store.getWalletState();
+		const record = loadRecord();
+		if (!walletState || !record || !this.matchesRecord(record, walletState)) throw new PasskeyError("not-connected", "No passkey account is connected.");
+		return record;
+	}
+	/**
+	* Make sure the key is unlocked and the user approved this request. When the
+	* key is locked, the PRF ceremony that unlocks it is the approval. Starts its
+	* prompt before any await.
+	*/
+	async authorize(request, record) {
+		const keyStore = this.getKeyStore();
+		if (!keyStore.unlocked) {
+			const { prf } = await evaluatePrf({
+				rpId: record.rpId,
+				prfInput: prfInput(record.context),
+				credentialId: record.credentialId
+			});
+			if (!bytesEqual(await keyStore.unlock(prf), record.publicKey)) {
+				keyStore.lock();
+				throw new PasskeyError("key-mismatch", "This passkey derived a different key than the connected account. Disconnect and connect again.");
+			}
+			return;
+		}
+		const confirmation = this.options.confirm?.(request) ?? "presence";
+		if (confirmation === "silent") return;
+		await assertUser({
+			rpId: record.rpId,
+			credentialId: record.credentialId,
+			userVerification: confirmation === "presence" ? "preferred" : "required"
+		});
+	}
+	processTxns(txnGroup, indexesToSign, address) {
+		return txnGroup.filter((txn, index) => (!indexesToSign || indexesToSign.includes(index)) && txn.sender.toString() === address);
+	}
+	processEncodedTxns(txnGroup, indexesToSign, address) {
+		const txnsToSign = [];
+		txnGroup.forEach((txnBuffer, index) => {
+			const isSigned = isSignedTxn(algosdk.msgpackRawDecode(txnBuffer));
+			const txn = isSigned ? algosdk.decodeSignedTransaction(txnBuffer).txn : algosdk.decodeUnsignedTransaction(txnBuffer);
+			if ((!indexesToSign || indexesToSign.includes(index)) && !isSigned && txn.sender.toString() === address) txnsToSign.push(txn);
+		});
+		return txnsToSign;
+	}
+	/**
+	* Signs the transactions sent from the connected account. Each one carries a
+	* Falcon-1024 `pqsig` (about 3.2 KB) and pays an extra 2× the minimum fee;
+	* get fees by simulating with `emptyTransactionSigner`.
+	*/
+	signTransactions = async (txnGroup, indexesToSign) => {
+		const record = this.requireRecord();
+		const txnsToSign = isTransactionArray(txnGroup) ? this.processTxns(flattenTxnGroup(txnGroup), indexesToSign, record.address) : this.processEncodedTxns(flattenTxnGroup(txnGroup), indexesToSign, record.address);
+		if (txnsToSign.length === 0) return [];
+		try {
+			this.logger.debug("Signing transactions...", { txnsToSign });
+			await this.authorize({
+				type: "transactions",
+				transactions: txnsToSign
+			}, record);
+			const keyStore = this.getKeyStore();
+			const { txnSigner } = algosdk.addressWithSignersFromRawFalcon1024Signer({
+				falcon1024PublicKey: record.publicKey,
+				falcon1024Signer: (bytes) => keyStore.sign(bytes)
+			});
+			const signedTxns = await txnSigner(txnsToSign, txnsToSign.map((_, index) => index));
+			this.logger.debug("Transactions signed successfully");
+			return signedTxns;
+		} catch (error) {
+			this.logger.error("Error signing transactions:", error.message);
+			throw error;
+		} finally {
+			this.release();
+		}
+	};
+	canSignData = true;
+	/**
+	* Signs an ARC-60 authentication request (SIWA) with the account's Falcon
+	* key, scheme `falcon-1024-det`. The signature covers
+	* `SHA-256(data) || SHA-256(authenticatorData)`.
+	*/
+	signData = async (data, metadata) => {
+		const record = this.requireRecord();
+		if (metadata.encoding !== "base64") throw new SignDataError("Failed decoding", 4602);
+		if (metadata.scope !== ScopeType.AUTH) throw new SignDataError("Invalid Scope", 4600);
+		let bytes;
+		let json;
+		let siwa;
+		try {
+			bytes = algosdk.base64ToBytes(data);
+			json = new TextDecoder("utf-8", {
+				fatal: true,
+				ignoreBOM: true
+			}).decode(bytes);
+			siwa = JSON.parse(json);
+		} catch {
+			throw new SignDataError("Bad JSON", 4609);
+		}
+		if (!siwa || typeof siwa !== "object" || canonify(siwa) !== json) throw new SignDataError("Bad JSON", 4609);
+		if (siwa.domain !== location.host) throw new SignDataError("Failed Domain Auth", 4610);
+		if (siwa.type !== "falcon-1024-det" || siwa.account_address !== record.address) throw new SignDataError("Invalid Signer", 4603);
+		try {
+			await this.authorize({
+				type: "data",
+				siwa
+			}, record);
+			const stdSignData = await this.createStdSignData(data);
+			if (!bytesEqual(stdSignData.signer, record.publicKey)) throw new SignDataError("Invalid Signer", 4603);
+			const toSign = new Uint8Array([...await sha256(bytes), ...await sha256(stdSignData.authenticatorData)]);
+			const signature = await this.getKeyStore().sign(toSign);
+			return {
+				...stdSignData,
+				signature
+			};
+		} catch (error) {
+			this.logger.error("Error signing data:", error.message);
+			throw error;
+		} finally {
+			this.release();
+		}
+	};
+	/**
+	* Returns the account's 25-word recovery phrase after a fresh passkey
+	* ceremony with full user verification. Show it with a warning that it must
+	* be imported as a Falcon / quantum account (Lute: "Falcon25 account";
+	* Pera: quantum import; `algokey pq import --scheme falcon-1024`): the same
+	* words in a regular 25-word import restore a different, empty account.
+	*/
+	exportRecoveryPhrase = async () => {
+		const record = this.requireRecord();
+		const { prf } = await evaluatePrf({
+			rpId: record.rpId,
+			prfInput: prfInput(record.context),
+			credentialId: record.credentialId
+		});
+		const check = this.createKeyStore();
+		try {
+			if (!bytesEqual(await check.unlock(new Uint8Array(prf)), record.publicKey)) throw new PasskeyError("key-mismatch", "This passkey derived a different key than the connected account.");
+			return {
+				scheme: "falcon-1024",
+				phrase: algosdk.mnemonicFromSeed(prf)
+			};
+		} finally {
+			check.lock();
+			prf.fill(0);
+		}
+	};
+};
+//#endregion
+//#region src/index.ts
+const WALLET_ID = "passkey";
+function passkey(options) {
+	const { metadata, ...adapterOptions } = options ?? {};
+	assertValidContext(adapterOptions.context ?? "");
+	return {
+		id: WALLET_ID,
+		metadata: {
+			...PasskeyAdapter.defaultMetadata,
+			...metadata
+		},
+		Adapter: PasskeyAdapter,
+		options: Object.keys(adapterOptions).length > 0 ? adapterOptions : void 0
+	};
+}
+//#endregion
+export { LOCAL_STORAGE_PASSKEY_KEY, PRF_LABEL_PREFIX, PasskeyAdapter, PasskeyError, WALLET_ID, WorkerKeyStore, keygenSeedFromEntropy, passkey, prfInput };
+
+//# sourceMappingURL=index.js.map