@prosopo/account 2.8.62 → 2.8.64

package/dist/extension/ExtensionWeb2.js

@@ -1,73 +1,76 @@
+import { Extension } from "./Extension.js";
+import { getCryptoWorkerManager } from "../workers/CryptoWorkerManager.js";
 import Signer from "@polkadot/extension-base/page/Signer";
 import { stringToU8a } from "@polkadot/util";
-import { prefetchFingerprint, getFingerprint } from "@prosopo/fingerprint";
+import { getFingerprint, prefetchFingerprint } from "@prosopo/fingerprint";
 import { Keyring } from "@prosopo/keyring";
 import { u8aToHex, version } from "@prosopo/util";
 import { hexHash } from "@prosopo/util-crypto";
-import { getCryptoWorkerManager } from "../workers/CryptoWorkerManager.js";
-import { Extension } from "./Extension.js";
+//#region src/extension/ExtensionWeb2.ts
 prefetchFingerprint();
 getCryptoWorkerManager().prewarm();
-const EntropyToMnemonicLoader = async () => (await import("@prosopo/util-crypto")).entropyToMnemonic;
-class ExtensionWeb2 extends Extension {
-  async getAccount(config) {
-    const account = await this.createAccount(config);
-    const extension = this.createExtension(account);
-    return {
-      account,
-      extension
-    };
-  }
-  createExtension(account) {
-    const signer = new Signer(async () => {
-      return;
-    });
-    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)
-      };
-    };
-    return {
-      accounts: {
-        get: async () => {
-          return [account];
-        },
-        subscribe: () => {
-          return () => {
-            return;
-          };
-        }
-      },
-      name: "procaptcha-web2",
-      version,
-      signer
-    };
-  }
-  async createAccount(config) {
-    const browserEntropy = await getFingerprint();
-    const entropy = hexHash(browserEntropy, 128).slice(2);
-    const u8Entropy = stringToU8a(entropy);
-    const type = "sr25519";
-    const keyring = new Keyring({ type });
-    const workerManager = getCryptoWorkerManager();
-    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 {
-  ExtensionWeb2,
-  ExtensionWeb2 as default
+var EntropyToMnemonicLoader = async () => (await import("@prosopo/util-crypto")).entropyToMnemonic;
+/**
+* Class for interfacing with web3 accounts.
+*/
+var ExtensionWeb2 = class extends Extension {
+	async getAccount(config) {
+		const account = await this.createAccount(config);
+		return {
+			account,
+			extension: this.createExtension(account)
+		};
+	}
+	createExtension(account) {
+		const signer = new Signer(async () => {});
+		signer.signRaw = async (payload) => {
+			return {
+				id: 1,
+				signature: u8aToHex(account.keypair.sign(payload.data))
+			};
+		};
+		return {
+			accounts: {
+				get: async () => {
+					return [account];
+				},
+				subscribe: () => {
+					return () => {};
+				}
+			},
+			name: "procaptcha-web2",
+			version,
+			signer
+		};
+	}
+	async createAccount(config) {
+		const u8Entropy = stringToU8a(hexHash(await getFingerprint(), 128).slice(2));
+		const type = "sr25519";
+		const keyring = new Keyring({ type });
+		const workerManager = getCryptoWorkerManager();
+		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 mnemonic = (await EntropyToMnemonicLoader())(u8Entropy);
+			const keypair = keyring.addFromMnemonic(mnemonic);
+			const address = keypair.address;
+			return {
+				address,
+				name: address,
+				keypair
+			};
+		}
+	}
 };
+//#endregion
+export { ExtensionWeb2, ExtensionWeb2 as default };

package/dist/extension/ExtensionWeb3.js

@@ -1,33 +1,27 @@
+import { Extension } from "./Extension.js";
 import { web3Enable } from "@polkadot/extension-dapp";
 import { cryptoWaitReady } from "@polkadot/util-crypto";
 import { ProsopoError } from "@prosopo/common";
-import { Extension } from "./Extension.js";
-class ExtensionWeb3 extends Extension {
-  async getAccount(config) {
-    const { dappName, userAccountAddress: address } = config;
-    if (!address) {
-      throw new ProsopoError("WIDGET.NO_ACCOUNTS_FOUND", {
-        context: { error: "No account address provided" }
-      });
-    }
-    await cryptoWaitReady();
-    const extensions = await web3Enable(dappName);
-    if (extensions.length === 0) {
-      throw new ProsopoError("WIDGET.NO_EXTENSION_FOUND");
-    }
-    for (const extension of extensions) {
-      const accounts = await extension.accounts.get();
-      const account = accounts.find((account2) => account2.address === address);
-      if (account) {
-        return { account, extension };
-      }
-    }
-    throw new ProsopoError("WIDGET.ACCOUNT_NOT_FOUND", {
-      context: { error: `No account found matching ${address}` }
-    });
-  }
-}
-export {
-  ExtensionWeb3,
-  ExtensionWeb3 as default
+//#region src/extension/ExtensionWeb3.ts
+/**
+* Class for interfacing with web3 accounts.
+*/
+var ExtensionWeb3 = class extends Extension {
+	async getAccount(config) {
+		const { dappName, userAccountAddress: address } = config;
+		if (!address) throw new ProsopoError("WIDGET.NO_ACCOUNTS_FOUND", { context: { error: "No account address provided" } });
+		await cryptoWaitReady();
+		const extensions = await web3Enable(dappName);
+		if (extensions.length === 0) throw new ProsopoError("WIDGET.NO_EXTENSION_FOUND");
+		for (const extension of extensions) {
+			const account = (await extension.accounts.get()).find((account) => account.address === address);
+			if (account) return {
+				account,
+				extension
+			};
+		}
+		throw new ProsopoError("WIDGET.ACCOUNT_NOT_FOUND", { context: { error: `No account found matching ${address}` } });
+	}
 };
+//#endregion
+export { ExtensionWeb3, ExtensionWeb3 as default };

package/dist/index.js

@@ -1,8 +1,5 @@
+import "./_virtual/_rolldown/runtime.js";
 import { Extension } from "./extension/Extension.js";
 import { ExtensionWeb2 } from "./extension/ExtensionWeb2.js";
 import { ExtensionWeb3 } from "./extension/ExtensionWeb3.js";
-export {
-  Extension,
-  ExtensionWeb2,
-  ExtensionWeb3
-};
+export { Extension, ExtensionWeb2, ExtensionWeb3 };

package/dist/workers/CryptoWorkerManager.js

@@ -1,126 +1,122 @@
 import WorkerWrapper from "./cryptoWorker.js";
-class CryptoWorkerManager {
-  constructor() {
-    this.worker = null;
-    this.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.
-   */
-  initWorker() {
-    if (this.worker || this.isInitializing) {
-      return;
-    }
-    this.isInitializing = true;
-    try {
-      this.worker = new WorkerWrapper({ type: "module" });
-      this.worker.onerror = () => {
-        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() {
-    this.initWorker();
-  }
-  /**
-   * Run a task in the Web Worker
-   */
-  async runTask(task, data) {
-    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(() => {
-        worker.removeEventListener("message", handleMessage);
-        worker.removeEventListener("error", handleError);
-        reject(new Error(`Worker task ${task} timeout (Task ID: ${taskId})`));
-      }, 1e4);
-      const handleMessage = (event) => {
-        if (event.data.taskId === taskId) {
-          clearTimeout(timeoutId);
-          worker.removeEventListener("message", handleMessage);
-          worker.removeEventListener("error", handleError);
-          if (event.data.error) {
-            reject(new Error(`Worker task failed: ${event.data.error}`));
-          } else {
-            resolve(event.data.result);
-          }
-        }
-      };
-      const handleError = (error) => {
-        clearTimeout(timeoutId);
-        worker.removeEventListener("message", handleMessage);
-        worker.removeEventListener("error", handleError);
-        reject(new Error(`Worker error during task: ${error.message}`));
-      };
-      worker.addEventListener("message", handleMessage);
-      worker.addEventListener("error", handleError);
-      const message = { taskId, task, data };
-      worker.postMessage(message);
-    });
-  }
-  /**
-   * Convert entropy to mnemonic using Web Worker
-   */
-  async entropyToMnemonic(entropy) {
-    return this.runTask("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) {
-    return this.runTask("entropyToKeypair", {
-      entropy
-    });
-  }
-  /**
-   * Clean up worker resources
-   */
-  cleanup() {
-    if (this.worker) {
-      this.worker.terminate();
-    }
-    this.worker = null;
-    this.isInitializing = false;
-  }
-  /**
-   * Public dispose method
-   */
-  dispose() {
-    this.cleanup();
-  }
-}
-let workerManagerInstance = null;
+//#region src/workers/CryptoWorkerManager.ts
+/**
+* Manages Web Worker for cryptographic operations to prevent blocking the main thread
+*/
+var CryptoWorkerManager = class {
+	constructor() {
+		this.worker = null;
+		this.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.
+	*/
+	initWorker() {
+		if (this.worker || this.isInitializing) return;
+		this.isInitializing = true;
+		try {
+			this.worker = new WorkerWrapper({ type: "module" });
+			this.worker.onerror = () => {
+				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() {
+		this.initWorker();
+	}
+	/**
+	* Run a task in the Web Worker
+	*/
+	async runTask(task, data) {
+		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(() => {
+				worker.removeEventListener("message", handleMessage);
+				worker.removeEventListener("error", handleError);
+				reject(/* @__PURE__ */ new Error(`Worker task ${task} timeout (Task ID: ${taskId})`));
+			}, 1e4);
+			const handleMessage = (event) => {
+				if (event.data.taskId === taskId) {
+					clearTimeout(timeoutId);
+					worker.removeEventListener("message", handleMessage);
+					worker.removeEventListener("error", handleError);
+					if (event.data.error) reject(/* @__PURE__ */ new Error(`Worker task failed: ${event.data.error}`));
+					else resolve(event.data.result);
+				}
+			};
+			const handleError = (error) => {
+				clearTimeout(timeoutId);
+				worker.removeEventListener("message", handleMessage);
+				worker.removeEventListener("error", handleError);
+				reject(/* @__PURE__ */ new Error(`Worker error during task: ${error.message}`));
+			};
+			worker.addEventListener("message", handleMessage);
+			worker.addEventListener("error", handleError);
+			const message = {
+				taskId,
+				task,
+				data
+			};
+			worker.postMessage(message);
+		});
+	}
+	/**
+	* Convert entropy to mnemonic using Web Worker
+	*/
+	async entropyToMnemonic(entropy) {
+		return this.runTask("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) {
+		return this.runTask("entropyToKeypair", { entropy });
+	}
+	/**
+	* Clean up worker resources
+	*/
+	cleanup() {
+		if (this.worker) this.worker.terminate();
+		this.worker = null;
+		this.isInitializing = false;
+	}
+	/**
+	* Public dispose method
+	*/
+	dispose() {
+		this.cleanup();
+	}
+};
+var workerManagerInstance = null;
+/**
+* Get the singleton CryptoWorkerManager instance
+*/
 function getCryptoWorkerManager() {
-  if (!workerManagerInstance) {
-    workerManagerInstance = new CryptoWorkerManager();
-  }
-  return workerManagerInstance;
+	if (!workerManagerInstance) workerManagerInstance = new CryptoWorkerManager();
+	return workerManagerInstance;
 }
-export {
-  CryptoWorkerManager,
-  getCryptoWorkerManager
-};
+//#endregion
+export { CryptoWorkerManager, getCryptoWorkerManager };