@prosopo/account 2.8.103 → 2.8.104

package/src/extension/ExtensionWeb3.ts

@@ -1,60 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import { web3Enable } from "@polkadot/extension-dapp";
-import type { InjectedExtension } from "@polkadot/extension-inject/types";
-import { cryptoWaitReady } from "@polkadot/util-crypto";
-import { ProsopoError } from "@prosopo/common";
-import type { Account, ProcaptchaClientConfigOutput } from "@prosopo/types";
-import { Extension } from "./Extension.js";
-
-/**
- * Class for interfacing with web3 accounts.
- */
-export class ExtensionWeb3 extends Extension {
-	public async getAccount(
-		config: ProcaptchaClientConfigOutput,
-	): Promise<Account> {
-		const { dappName, userAccountAddress: address } = config;
-
-		if (!address) {
-			throw new ProsopoError("WIDGET.NO_ACCOUNTS_FOUND", {
-				context: { error: "No account address provided" },
-			});
-		}
-
-		await cryptoWaitReady();
-
-		// enable access to all extensions
-		const extensions: InjectedExtension[] = await web3Enable(dappName);
-		if (extensions.length === 0) {
-			throw new ProsopoError("WIDGET.NO_EXTENSION_FOUND");
-		}
-
-		// search through all extensions for the one that has the account
-		for (const extension of extensions) {
-			const accounts = await extension.accounts.get();
-			const account = accounts.find((account) => account.address === address);
-			if (account) {
-				return { account, extension };
-			}
-		}
-
-		throw new ProsopoError("WIDGET.ACCOUNT_NOT_FOUND", {
-			context: { error: `No account found matching ${address}` },
-		});
-	}
-}
-
-export default ExtensionWeb3;

package/src/index.ts

@@ -1,16 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-export * from "./extension/Extension.js";
-export * from "./extension/ExtensionWeb2.js";
-export * from "./extension/ExtensionWeb3.js";

package/src/tests/ExtensionWeb2.unit.test.ts

@@ -1,172 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Tests for ExtensionWeb2.createAccount. The interesting behaviour to lock
-// down is the two-branch account-derivation path:
-//
-//   1. Worker branch (preferred): `workerManager.entropyToKeypair(...)` →
-//      `keyring.addFromPair({publicKey, secretKey})` — the sr25519 scalar-
-//      mul runs off the main thread, main thread just packages the bytes.
-//   2. Fallback branch: worker throws (CSP block, task timeout, etc.) →
-//      dynamic-import `entropyToMnemonic` → `keyring.addFromMnemonic(...)`
-//      on the main thread.
-//
-// Both branches must produce the same account address for a given fingerprint
-// or session identity breaks between the two paths — a repeat visitor whose
-// worker fails would look like a different user to the provider.
-
-import { stringToU8a } from "@polkadot/util";
-import { getFingerprint } from "@prosopo/fingerprint";
-import { Keyring } from "@prosopo/keyring";
-import { entropyToMnemonic, hexHash } from "@prosopo/util-crypto";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-// vi.hoisted() makes these accessible from within vi.mock factories, which
-// run before the module's own imports at collection time.
-const mocks = vi.hoisted(() => {
-	const entropyToKeypair = vi.fn();
-	return {
-		entropyToKeypair,
-		getCryptoWorkerManager: vi.fn(() => ({
-			prewarm: vi.fn(),
-			entropyToKeypair,
-			entropyToMnemonic: vi.fn(),
-		})),
-	};
-});
-
-vi.mock("@prosopo/fingerprint", async (importOriginal) => {
-	const actual =
-		(await importOriginal()) as typeof import("@prosopo/fingerprint");
-	return {
-		...actual,
-		getFingerprint: vi.fn(),
-		prefetchFingerprint: vi.fn(),
-	};
-});
-
-vi.mock("../workers/CryptoWorkerManager.js", () => ({
-	getCryptoWorkerManager: mocks.getCryptoWorkerManager,
-	// Types re-exported at runtime aren't needed for the tests but keep the
-	// mock shape aligned with the module's actual named exports.
-	CryptoWorkerManager: class {},
-}));
-
-// Imported after mocks so the module picks up the mocked getFingerprint and
-// worker manager during its top-level side effects (prefetchFingerprint,
-// getCryptoWorkerManager().prewarm()).
-const { default: ExtensionWeb2 } = await import(
-	"../extension/ExtensionWeb2.js"
-);
-
-// Fixed browser-fingerprint hex the mocked getFingerprint always returns.
-// The real code hashes this to 128 bits, hex-encodes it, and passes the ASCII
-// hex bytes as entropy to the mnemonic derivation — so both branches under
-// test see the same input regardless of the underlying fingerprint.
-const FIXED_FINGERPRINT_HEX = "0x1234567890abcdef1234567890abcdef";
-
-// Config placeholder — ExtensionWeb2.createAccount ignores fields other than
-// what the fingerprint hash + keyring type need.
-const config = {
-	account: { address: "" },
-	web2: true,
-	defaultEnvironment: "test",
-} as unknown as Parameters<InstanceType<typeof ExtensionWeb2>["getAccount"]>[0];
-
-describe("ExtensionWeb2.createAccount", () => {
-	beforeEach(() => {
-		vi.mocked(getFingerprint).mockReset();
-		mocks.entropyToKeypair.mockReset();
-		vi.mocked(getFingerprint).mockResolvedValue(FIXED_FINGERPRINT_HEX);
-	});
-
-	it("worker branch: derives account from worker-returned keypair bytes", async () => {
-		// Compute the expected keypair the same way ExtensionWeb2 would — we
-		// need to feed the mock the exact bytes the worker would produce for
-		// this fingerprint, otherwise the reconstructed address won't match.
-		const entropyHex = hexHash(FIXED_FINGERPRINT_HEX, 128).slice(2);
-		const u8Entropy = stringToU8a(entropyHex);
-		const mnemonic = entropyToMnemonic(u8Entropy);
-		const keyring = new Keyring({ type: "sr25519" });
-		const expectedPair = keyring.addFromMnemonic(mnemonic);
-
-		mocks.entropyToKeypair.mockResolvedValue({
-			publicKey: expectedPair.publicKey,
-			secretKey:
-				// Fish the secret out of the reference pair — this is what the
-				// real CryptoWorker returns from sr25519FromSeed(seed).
-				(expectedPair as unknown as { secretKey: Uint8Array }).secretKey ??
-				new Uint8Array(64),
-			mnemonic,
-		});
-
-		const ext = new ExtensionWeb2();
-		const { account } = await ext.getAccount(config);
-
-		expect(mocks.entropyToKeypair).toHaveBeenCalledTimes(1);
-		// The worker got called with the entropy ExtensionWeb2 hashed from the
-		// fingerprint — verifies the argument-shaping code isn't broken.
-		const [entropyArg] = mocks.entropyToKeypair.mock.calls[0] ?? [];
-		expect(entropyArg).toBeInstanceOf(Uint8Array);
-		expect(entropyArg).toEqual(u8Entropy);
-		// Account address matches the addFromMnemonic-derived one — proves the
-		// addFromPair wrapping preserves account identity.
-		expect(account.address).toBe(expectedPair.address);
-	});
-
-	it("fallback branch: derives account on main thread when worker throws", async () => {
-		// Simulate a worker failure — CSP block, worker script parse failure,
-		// task timeout — anything that surfaces as a rejection from
-		// entropyToKeypair. Fallback path must reach the same account address.
-		mocks.entropyToKeypair.mockRejectedValue(new Error("Worker unavailable"));
-
-		const entropyHex = hexHash(FIXED_FINGERPRINT_HEX, 128).slice(2);
-		const u8Entropy = stringToU8a(entropyHex);
-		const mnemonic = entropyToMnemonic(u8Entropy);
-		const keyring = new Keyring({ type: "sr25519" });
-		const expectedPair = keyring.addFromMnemonic(mnemonic);
-
-		const ext = new ExtensionWeb2();
-		const { account } = await ext.getAccount(config);
-
-		expect(mocks.entropyToKeypair).toHaveBeenCalledTimes(1);
-		// Fallback still gives us a working keypair with the same address —
-		// this is the invariant that lets us safely swap in the worker path.
-		expect(account.address).toBe(expectedPair.address);
-	});
-
-	it("worker and fallback branches derive the same account address", async () => {
-		// Direct A/B: one call goes through the worker mock, the next through
-		// the fallback. Assert the addresses match.
-		const entropyHex = hexHash(FIXED_FINGERPRINT_HEX, 128).slice(2);
-		const u8Entropy = stringToU8a(entropyHex);
-		const mnemonic = entropyToMnemonic(u8Entropy);
-		const refKeyring = new Keyring({ type: "sr25519" });
-		const refPair = refKeyring.addFromMnemonic(mnemonic);
-
-		mocks.entropyToKeypair.mockResolvedValueOnce({
-			publicKey: refPair.publicKey,
-			secretKey:
-				(refPair as unknown as { secretKey: Uint8Array }).secretKey ??
-				new Uint8Array(64),
-			mnemonic,
-		});
-		const workerAccount = await new ExtensionWeb2().getAccount(config);
-
-		mocks.entropyToKeypair.mockRejectedValueOnce(new Error("worker down"));
-		const fallbackAccount = await new ExtensionWeb2().getAccount(config);
-
-		expect(workerAccount.account.address).toBe(fallbackAccount.account.address);
-	});
-});

package/src/tests/cryptoWorker.unit.test.ts

@@ -1,146 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Unit tests for the CryptoWorker task implementations. The worker itself
-// bootstraps under `?worker&inline` in the browser build and can't easily be
-// spun up in a Node vitest env, so these tests exercise the same primitives
-// the worker's message handler dispatches to (entropyToMnemonic,
-// mnemonicToMiniSecret, sr25519FromSeed) and prove they produce a keypair
-// equivalent to `keyring.addFromMnemonic` — the shipped-blob invariant that
-// `ExtensionWeb2.createAccount`'s worker path relies on.
-
-import { stringToU8a } from "@polkadot/util";
-import { Keyring } from "@prosopo/keyring";
-import {
-	entropyToMnemonic,
-	mnemonicToMiniSecret,
-	sr25519FromSeed,
-} from "@prosopo/util-crypto";
-import { describe, expect, it } from "vitest";
-
-// Mirrors ExtensionWeb2.createAccount: browserEntropy → hexHash(., 128) →
-// slice(2) → 32 ASCII-hex characters → stringToU8a → 32 bytes. Fixed value
-// so tests are deterministic (real code path uses the browser fingerprint).
-const FIXED_ENTROPY_HEX = "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6";
-
-const entropyBytes = (hex: string): Uint8Array => stringToU8a(hex);
-
-describe("CryptoWorker task primitives", () => {
-	describe("entropyToKeypair pipeline", () => {
-		it("derives an sr25519 keypair from entropy deterministically", () => {
-			const entropy = entropyBytes(FIXED_ENTROPY_HEX);
-
-			const mnemonic = entropyToMnemonic(entropy);
-			const seed = mnemonicToMiniSecret(mnemonic);
-			const { publicKey, secretKey } = sr25519FromSeed(seed);
-
-			expect(publicKey).toBeInstanceOf(Uint8Array);
-			expect(secretKey).toBeInstanceOf(Uint8Array);
-			expect(publicKey.length).toBe(32);
-			expect(secretKey.length).toBe(64);
-
-			// Re-running with the same entropy must yield the same keys —
-			// otherwise the CryptoWorker cache would be poisoned by a
-			// non-deterministic derivation.
-			const again = sr25519FromSeed(
-				mnemonicToMiniSecret(entropyToMnemonic(entropy)),
-			);
-			expect(again.publicKey).toEqual(publicKey);
-			expect(again.secretKey).toEqual(secretKey);
-		});
-
-		it("produces the same address as keyring.addFromMnemonic (worker/main-thread parity)", () => {
-			const entropy = entropyBytes(FIXED_ENTROPY_HEX);
-			const mnemonic = entropyToMnemonic(entropy);
-
-			// Worker path: entropy → mnemonic → miniSecret → sr25519 → addFromPair
-			const seed = mnemonicToMiniSecret(mnemonic);
-			const { publicKey, secretKey } = sr25519FromSeed(seed);
-			const workerKeyring = new Keyring({ type: "sr25519" });
-			const workerPair = workerKeyring.addFromPair(
-				{ publicKey, secretKey },
-				{},
-				"sr25519",
-			);
-
-			// Legacy main-thread path: keyring.addFromMnemonic
-			const mainKeyring = new Keyring({ type: "sr25519" });
-			const mainPair = mainKeyring.addFromMnemonic(mnemonic);
-
-			// Addresses must match exactly — this is the invariant that guarantees
-			// swapping addFromMnemonic → addFromPair(entropyToKeypair(...)) is a
-			// behavioural no-op for account identity.
-			expect(workerPair.address).toBe(mainPair.address);
-			expect(workerPair.publicKey).toEqual(mainPair.publicKey);
-			expect(workerPair.type).toBe(mainPair.type);
-		});
-
-		it("signatures produced by addFromPair verify against the addFromMnemonic public key", () => {
-			const entropy = entropyBytes(FIXED_ENTROPY_HEX);
-			const mnemonic = entropyToMnemonic(entropy);
-			const seed = mnemonicToMiniSecret(mnemonic);
-			const { publicKey, secretKey } = sr25519FromSeed(seed);
-
-			const workerKeyring = new Keyring({ type: "sr25519" });
-			const workerPair = workerKeyring.addFromPair(
-				{ publicKey, secretKey },
-				{},
-				"sr25519",
-			);
-			const mainKeyring = new Keyring({ type: "sr25519" });
-			const mainPair = mainKeyring.addFromMnemonic(mnemonic);
-
-			const message = stringToU8a("prosopo-test-message");
-			const workerSig = workerPair.sign(message);
-			const mainSig = mainPair.sign(message);
-
-			expect(workerSig.length).toBe(64);
-			expect(mainSig.length).toBe(64);
-			// sr25519 signatures are non-deterministic, so we can't byte-compare;
-			// but each signature must verify against BOTH pairs' public keys.
-			expect(mainPair.verify(message, workerSig, mainPair.publicKey)).toBe(
-				true,
-			);
-			expect(workerPair.verify(message, mainSig, workerPair.publicKey)).toBe(
-				true,
-			);
-		});
-	});
-
-	describe("entropyToMnemonic (existing worker task, unchanged)", () => {
-		it("produces a 24-word BIP39 mnemonic from 32 bytes of entropy", () => {
-			const entropy = entropyBytes(FIXED_ENTROPY_HEX);
-			const mnemonic = entropyToMnemonic(entropy);
-			const words = mnemonic.split(" ");
-			// 32 bytes of entropy = 256 bits → 24 BIP39 words.
-			expect(words.length).toBe(24);
-			for (const w of words) {
-				expect(w).toMatch(/^[a-z]+$/);
-			}
-		});
-
-		it("is deterministic for a given entropy", () => {
-			const entropy = entropyBytes(FIXED_ENTROPY_HEX);
-			expect(entropyToMnemonic(entropy)).toBe(entropyToMnemonic(entropy));
-		});
-
-		it("rejects entropy that isn't 16/20/24/28/32 bytes", () => {
-			// bip39 accepts only these sizes — CryptoWorker relies on the caller
-			// passing valid entropy (already-hashed to 32 bytes in ExtensionWeb2).
-			expect(() => entropyToMnemonic(new Uint8Array(15))).toThrow();
-			expect(() => entropyToMnemonic(new Uint8Array(17))).toThrow();
-			expect(() => entropyToMnemonic(new Uint8Array(33))).toThrow();
-		});
-	});
-});

package/src/workers/CryptoWorkerManager.ts

@@ -1,192 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import CryptoWorkerConstructor from "./cryptoWorker.js?worker&inline";
-
-interface CryptoWorkerMessage {
-	taskId: string;
-	task: string;
-	data: Record<string, string | Uint8Array>;
-}
-
-export interface KeypairBytes {
-	publicKey: Uint8Array;
-	secretKey: Uint8Array;
-}
-
-export interface EntropyToKeypairResult extends KeypairBytes {
-	mnemonic: string;
-}
-
-type CryptoWorkerResult = string | KeypairBytes | EntropyToKeypairResult;
-
-interface CryptoWorkerResponse {
-	taskId: string;
-	result?: CryptoWorkerResult;
-	error?: string;
-}
-
-/**
- * Manages Web Worker for cryptographic operations to prevent blocking the main thread
- */
-export class CryptoWorkerManager {
-	private worker: Worker | null = null;
-	private isInitializing = false;
-
-	/**
-	 * Initialize the worker. No test round-trip — construction failure throws
-	 * synchronously (caught below); post-construction failures surface via
-	 * `worker.onerror` (cleans up so the next call retries); anything that
-	 * gets past both surfaces via `runTask`'s timeout + reject path, which
-	 * already falls back to main-thread crypto. The prior `testWorker()` ping
-	 * was a Blob-URL-era defensive check that no longer earns its ~30–80ms
-	 * critical-path cost under Vite's `?worker&inline` constructor.
-	 */
-	private initWorker(): void {
-		if (this.worker || this.isInitializing) {
-			return;
-		}
-
-		this.isInitializing = true;
-
-		try {
-			this.worker = new CryptoWorkerConstructor({ type: "module" });
-
-			this.worker.onerror = () => {
-				// Terminate the failed worker; the next runTask will re-init.
-				this.cleanup();
-			};
-		} catch {
-			this.cleanup();
-		} finally {
-			this.isInitializing = false;
-		}
-	}
-
-	/**
-	 * Eagerly spawn the worker so the first runTask() doesn't pay the
-	 * worker-spawn + module-parse cost. Synchronous now — construction is
-	 * fire-and-forget with cleanup via `worker.onerror`.
-	 */
-	prewarm(): void {
-		this.initWorker();
-	}
-
-	/**
-	 * Run a task in the Web Worker
-	 */
-	async runTask<T>(
-		task: string,
-		data: Record<string, string | Uint8Array>,
-	): Promise<T> {
-		this.initWorker();
-
-		if (!this.worker) {
-			throw new Error("Failed to initialize worker");
-		}
-
-		const worker = this.worker;
-
-		return new Promise((resolve, reject) => {
-			const taskId = Math.random().toString(36).substr(2, 9);
-			const timeoutId = setTimeout(() => {
-				// Clean up listeners on timeout
-				worker.removeEventListener("message", handleMessage);
-				worker.removeEventListener("error", handleError);
-				reject(new Error(`Worker task ${task} timeout (Task ID: ${taskId})`));
-			}, 10000);
-
-			const handleMessage = (event: MessageEvent<CryptoWorkerResponse>) => {
-				if (event.data.taskId === taskId) {
-					clearTimeout(timeoutId);
-					worker.removeEventListener("message", handleMessage);
-					worker.removeEventListener("error", handleError);
-
-					if (event.data.error) {
-						// Reject with the error message sent back by the worker
-						reject(new Error(`Worker task failed: ${event.data.error}`));
-					} else {
-						resolve(event.data.result as T); // Type assertion for clean resolution
-					}
-				}
-			};
-
-			const handleError = (error: ErrorEvent) => {
-				clearTimeout(timeoutId);
-				worker.removeEventListener("message", handleMessage);
-				worker.removeEventListener("error", handleError);
-				// Reject on global worker error while task is pending
-				reject(new Error(`Worker error during task: ${error.message}`));
-			};
-
-			worker.addEventListener("message", handleMessage);
-			worker.addEventListener("error", handleError);
-
-			const message: CryptoWorkerMessage = { taskId, task, data };
-			worker.postMessage(message);
-		});
-	}
-
-	/**
-	 * Convert entropy to mnemonic using Web Worker
-	 */
-	async entropyToMnemonic(entropy: Uint8Array): Promise<string> {
-		return this.runTask<string>("entropyToMnemonic", { entropy });
-	}
-
-	/**
-	 * Fused: entropy → mnemonic → sr25519 keypair in a single worker
-	 * round-trip. Callers that don't need the mnemonic separately should
-	 * prefer this over two `entropyToMnemonic + keypairFromMnemonic` hops —
-	 * saves one postMessage transit (~30–80ms on constrained hardware / under
-	 * throttle) on the frictionless critical path. sr25519 derivation is a
-	 * ~500ms main-thread cost otherwise.
-	 */
-	async entropyToKeypair(entropy: Uint8Array): Promise<EntropyToKeypairResult> {
-		return this.runTask<EntropyToKeypairResult>("entropyToKeypair", {
-			entropy,
-		});
-	}
-
-	/**
-	 * Clean up worker resources
-	 */
-	private cleanup(): void {
-		if (this.worker) {
-			this.worker.terminate();
-		}
-		this.worker = null;
-		this.isInitializing = false;
-	}
-
-	/**
-	 * Public dispose method
-	 */
-	public dispose(): void {
-		this.cleanup();
-	}
-}
-
-// Create a singleton instance for reuse
-let workerManagerInstance: CryptoWorkerManager | null = null;
-
-/**
- * Get the singleton CryptoWorkerManager instance
- */
-export function getCryptoWorkerManager(): CryptoWorkerManager {
-	if (!workerManagerInstance) {
-		workerManagerInstance = new CryptoWorkerManager();
-	}
-	return workerManagerInstance;
-}

package/src/workers/cryptoWorker.ts

@@ -1,98 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// cryptoWorker.ts
-
-import {
-	entropyToMnemonic,
-	mnemonicToMiniSecret,
-	sr25519FromSeed,
-} from "@prosopo/util-crypto";
-
-interface CryptoWorkerMessage {
-	taskId: string;
-	task: "entropyToMnemonic" | "entropyToKeypair" | "test";
-	data: {
-		entropy?: Uint8Array;
-	};
-}
-
-interface EntropyToKeypairResult {
-	mnemonic: string;
-	publicKey: Uint8Array;
-	secretKey: Uint8Array;
-}
-
-interface CryptoWorkerResponse {
-	taskId: string;
-	result?: string | EntropyToKeypairResult;
-	error?: string;
-}
-
-// The main message listener runs in the worker's global scope
-self.addEventListener(
-	"message",
-	async (event: MessageEvent<CryptoWorkerMessage>) => {
-		const { taskId, task, data } = event.data;
-
-		try {
-			let result: string | EntropyToKeypairResult;
-
-			switch (task) {
-				case "test":
-					// Respond to test message to confirm worker is ready
-					result = "ready";
-					break;
-				case "entropyToMnemonic":
-					if (!data.entropy) {
-						throw new Error("Entropy data is required");
-					}
-					result = entropyToMnemonic(data.entropy);
-					break;
-				case "entropyToKeypair":
-					// Fused: entropy → mnemonic → sr25519 keypair in one worker
-					// round-trip. Saves the postMessage transit on the frictionless
-					// critical path (~30–80ms per hop on constrained hardware).
-					// Called by ExtensionWeb2.createAccount when the caller doesn't
-					// need the mnemonic string for any other purpose than deriving
-					// the pair. sr25519 derivation is a scalar multiplication on
-					// Ristretto25519 — ~500ms mid-tier, ~800ms mobile — and was the
-					// single biggest main-thread cost pre-worker.
-					if (!data.entropy) {
-						throw new Error("Entropy data is required");
-					}
-					result = processEntropyToKeypair(data.entropy);
-					break;
-				default:
-					throw new Error(`Unknown task: ${task}`);
-			}
-
-			const response: CryptoWorkerResponse = { taskId, result };
-			self.postMessage(response);
-		} catch (error) {
-			const response: CryptoWorkerResponse = {
-				taskId,
-				error: error instanceof Error ? error.message : "Unknown error",
-			};
-			self.postMessage(response);
-		}
-	},
-);
-
-function processEntropyToKeypair(entropy: Uint8Array): EntropyToKeypairResult {
-	const mnemonic = entropyToMnemonic(entropy);
-	const seed = mnemonicToMiniSecret(mnemonic);
-	const { publicKey, secretKey } = sr25519FromSeed(seed);
-	return { mnemonic, publicKey, secretKey };
-}