@prosopo/account 2.8.102 → 2.8.104

package/src/extension/ExtensionWeb2.ts

@@ -1,129 +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 Signer from "@polkadot/extension-base/page/Signer";
-import type { InjectedAccount } from "@polkadot/extension-inject/types";
-import type { InjectedExtension } from "@polkadot/extension-inject/types";
-import { stringToU8a } from "@polkadot/util";
-import { getFingerprint, prefetchFingerprint } from "@prosopo/fingerprint";
-import { Keyring } from "@prosopo/keyring";
-import type { KeyringPair } from "@prosopo/types";
-import type { Account, ProcaptchaClientConfigOutput } from "@prosopo/types";
-import { u8aToHex, version } from "@prosopo/util";
-import { hexHash } from "@prosopo/util-crypto";
-import type { KeypairType } from "@prosopo/util-crypto";
-import { getCryptoWorkerManager } from "../workers/CryptoWorkerManager.js";
-import { Extension } from "./Extension.js";
-
-prefetchFingerprint();
-getCryptoWorkerManager().prewarm();
-
-const EntropyToMnemonicLoader = async () =>
-	(await import("@prosopo/util-crypto")).entropyToMnemonic;
-
-type AccountWithKeyPair = InjectedAccount & { keypair: KeyringPair };
-
-/**
- * Class for interfacing with web3 accounts.
- */
-export class ExtensionWeb2 extends Extension {
-	public async getAccount(
-		config: ProcaptchaClientConfigOutput,
-	): Promise<Account> {
-		const account = await this.createAccount(config);
-		const extension: InjectedExtension = this.createExtension(account);
-
-		return {
-			account,
-			extension,
-		};
-	}
-
-	private createExtension(account: AccountWithKeyPair): InjectedExtension {
-		const signer = new Signer(async () => {
-			return;
-		});
-
-		// signing carried out by the keypair. Signs the data with the private key, creating a signature. Other people can verify this signature given the message and the public key, proving that the message was indeed signed by account and proving ownership of the account.
-		signer.signRaw = async (payload) => {
-			const signature = account.keypair.sign(payload.data);
-			return {
-				id: 1, // the id of the request to sign. This should be incremented each time and adjust the signature, but we're hacking around this. Hence the signature will always be the same given the same payload.
-				signature: u8aToHex(signature) as `0x${string}`,
-			};
-		};
-
-		return {
-			accounts: {
-				get: async () => {
-					// there is only ever 1 account
-					return [account];
-				},
-				subscribe: () => {
-					// do nothing, there will never be account changes
-					return () => {
-						return;
-					};
-				},
-			},
-			name: "procaptcha-web2",
-			version,
-			signer,
-		};
-	}
-
-	private async createAccount(
-		config: ProcaptchaClientConfigOutput,
-	): Promise<AccountWithKeyPair> {
-		const browserEntropy = await getFingerprint();
-
-		// hash the entropy and remove 0x
-		const entropy = hexHash(browserEntropy, 128).slice(2);
-
-		const u8Entropy = stringToU8a(entropy);
-
-		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 { 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();
-			const mnemonic = entropyToMnemonic(u8Entropy);
-			const keypair = keyring.addFromMnemonic(mnemonic);
-			const address = keypair.address;
-			return { address, name: address, keypair };
-		}
-	}
-}
-
-export default ExtensionWeb2;

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();
-		});
-	});
-});