@prosopo/account 2.8.57 → 2.8.59

package/src/extension/ExtensionWeb2.ts

@@ -93,28 +93,36 @@ export class ExtensionWeb2 extends Extension {
 
 		const u8Entropy = stringToU8a(entropy);
 
-		let mnemonic: string;
-
-		// Try to use Web Worker for entropy-to-mnemonic conversion to avoid blocking
+		const type: KeypairType = "sr25519";
+		const keyring = new Keyring({ type });
+		const workerManager = getCryptoWorkerManager();
+
+		// Two paths, in order of preference:
+		//
+		// 1. Worker path: entropy → mnemonic → sr25519 keypair in ONE fused
+		//    worker round-trip. sr25519 derivation is a ~500ms scalar-mul
+		//    on mid-tier hardware and was the biggest main-thread cost in
+		//    the frictionless critical path pre-worker. Doing it in the
+		//    worker lets it overlap with BotScoreWorker and main-thread
+		//    detectors. We wrap the raw keypair bytes on main via
+		//    `addFromPair` (cheap packaging — no ECC work).
+		//
+		// 2. Fallback path (worker refused to boot / CSP): synchronous
+		//    derivation on main thread. Preserves behaviour for browsers
+		//    that block workers.
 		try {
-			const workerManager = getCryptoWorkerManager();
-			mnemonic = await workerManager.entropyToMnemonic(u8Entropy);
+			const { publicKey, secretKey } =
+				await workerManager.entropyToKeypair(u8Entropy);
+			const keypair = keyring.addFromPair({ publicKey, secretKey }, {}, type);
+			const address = keypair.address;
+			return { address, name: address, keypair };
 		} catch (workerError) {
 			const entropyToMnemonic = await EntropyToMnemonicLoader();
-			mnemonic = entropyToMnemonic(u8Entropy);
+			const mnemonic = entropyToMnemonic(u8Entropy);
+			const keypair = keyring.addFromMnemonic(mnemonic);
+			const address = keypair.address;
+			return { address, name: address, keypair };
 		}
-
-		const type: KeypairType = "sr25519";
-		const keyring = new Keyring({
-			type,
-		});
-		const keypair = keyring.addFromMnemonic(mnemonic);
-		const address = keypair.address;
-		return {
-			address,
-			name: address,
-			keypair,
-		};
 	}
 }
 

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

@@ -0,0 +1,172 @@
+// 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

@@ -0,0 +1,146 @@
+// 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

@@ -20,9 +20,20 @@ interface CryptoWorkerMessage {
 	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?: Record<string, string>;
+	result?: CryptoWorkerResult;
 	error?: string;
 }
 
@@ -34,9 +45,15 @@ export class CryptoWorkerManager {
 	private isInitializing = false;
 
 	/**
-	 * Initialize the worker
+	 * 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 async initWorker(): Promise<void> {
+	private initWorker(): void {
 		if (this.worker || this.isInitializing) {
 			return;
 		}
@@ -46,88 +63,24 @@ export class CryptoWorkerManager {
 		try {
 			this.worker = new CryptoWorkerConstructor({ type: "module" });
 
-			// Add an IMMEDIATE global error handler for initialization failures (e.g., failed parsing)
-			this.worker.onerror = (errorEvent: ErrorEvent) => {
-				// Terminate the failed worker and mark for re-initialization
+			this.worker.onerror = () => {
+				// Terminate the failed worker; the next runTask will re-init.
 				this.cleanup();
-				// The specific runTask/testWorker promise will reject via their local handleError
 			};
-
-			// Test if worker is working
-			await this.testWorker();
-		} catch (error) {
-			this.cleanup(); // Clean up if instantiation itself fails
-			throw error; // Re-throw to propagate failure
+		} catch {
+			this.cleanup();
 		} finally {
-			// We don't want to set isInitializing to false here if the worker started,
-			// but we can if the test fails or construction fails.
-			if (!this.worker) {
-				this.isInitializing = false;
-			}
+			this.isInitializing = false;
 		}
 	}
 
-	/**
-	 * Test if the worker is functioning properly
-	 */
-	private async testWorker(): Promise<void> {
-		if (!this.worker) {
-			throw new Error("Worker not initialized");
-		}
-
-		const worker = this.worker;
-
-		return new Promise((resolve, reject) => {
-			const testTimeout = setTimeout(() => {
-				// Clean up event listeners on timeout
-				worker.removeEventListener("message", handleMessage);
-				worker.removeEventListener("error", handleError);
-				reject(new Error("Worker test timeout"));
-			}, 5000);
-
-			const handleMessage = (event: MessageEvent) => {
-				const { taskId, error, result } = event.data;
-				if (taskId === "test") {
-					clearTimeout(testTimeout);
-					worker.removeEventListener("message", handleMessage);
-					worker.removeEventListener("error", handleError); // Also remove error listener
-
-					if (error || result !== "ready") {
-						reject(
-							new Error(
-								`Worker test failed: ${error || 'Did not return "ready"'}`,
-							),
-						);
-					} else {
-						resolve();
-					}
-				}
-			};
-
-			const handleError = (error: ErrorEvent) => {
-				clearTimeout(testTimeout);
-				worker.removeEventListener("message", handleMessage);
-				worker.removeEventListener("error", handleError);
-				reject(
-					new Error(`Worker test failed with error event: ${error.message}`),
-				);
-			};
-
-			worker.addEventListener("message", handleMessage);
-			worker.addEventListener("error", handleError); // Catch errors during test
-
-			// Send a test message
-			worker.postMessage({ taskId: "test", task: "test", data: {} });
-		});
-	}
-
 	/**
 	 * Eagerly spawn the worker so the first runTask() doesn't pay the
-	 * worker-spawn + module-parse cost. Failures are swallowed because
-	 * runTask() will reattempt initWorker() on demand.
+	 * worker-spawn + module-parse cost. Synchronous now — construction is
+	 * fire-and-forget with cleanup via `worker.onerror`.
 	 */
 	prewarm(): void {
-		this.initWorker().catch(() => {});
+		this.initWorker();
 	}
 
 	/**
@@ -137,7 +90,7 @@ export class CryptoWorkerManager {
 		task: string,
 		data: Record<string, string | Uint8Array>,
 	): Promise<T> {
-		await this.initWorker();
+		this.initWorker();
 
 		if (!this.worker) {
 			throw new Error("Failed to initialize worker");
@@ -192,6 +145,20 @@ export class CryptoWorkerManager {
 		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
 	 */

package/src/workers/cryptoWorker.ts

@@ -14,19 +14,29 @@
 
 // cryptoWorker.ts
 
-import { entropyToMnemonic } from "@prosopo/util-crypto";
+import {
+	entropyToMnemonic,
+	mnemonicToMiniSecret,
+	sr25519FromSeed,
+} from "@prosopo/util-crypto";
 
 interface CryptoWorkerMessage {
 	taskId: string;
-	task: "entropyToMnemonic" | "test";
+	task: "entropyToMnemonic" | "entropyToKeypair" | "test";
 	data: {
 		entropy?: Uint8Array;
 	};
 }
 
+interface EntropyToKeypairResult {
+	mnemonic: string;
+	publicKey: Uint8Array;
+	secretKey: Uint8Array;
+}
+
 interface CryptoWorkerResponse {
 	taskId: string;
-	result?: string;
+	result?: string | EntropyToKeypairResult;
 	error?: string;
 }
 
@@ -37,7 +47,7 @@ self.addEventListener(
 		const { taskId, task, data } = event.data;
 
 		try {
-			let result: string;
+			let result: string | EntropyToKeypairResult;
 
 			switch (task) {
 				case "test":
@@ -48,7 +58,21 @@ self.addEventListener(
 					if (!data.entropy) {
 						throw new Error("Entropy data is required");
 					}
-					result = await processEntropyToMnemonic(data.entropy);
+					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}`);
@@ -66,14 +90,9 @@ self.addEventListener(
 	},
 );
 
-// Helper function remains async for consistency, even if entropyToMnemonic is sync
-async function processEntropyToMnemonic(entropy: Uint8Array): Promise<string> {
-	try {
-		// Convert entropy to mnemonic (Vite/Rollup ensures this import is resolved and bundled)
-		return entropyToMnemonic(entropy);
-	} catch (error) {
-		throw new Error(
-			`Failed to process entropy: ${error instanceof Error ? error.message : "Unknown error"}`,
-		);
-	}
+function processEntropyToKeypair(entropy: Uint8Array): EntropyToKeypairResult {
+	const mnemonic = entropyToMnemonic(entropy);
+	const seed = mnemonicToMiniSecret(mnemonic);
+	const { publicKey, secretKey } = sr25519FromSeed(seed);
+	return { mnemonic, publicKey, secretKey };
 }