@peerbit/react 1.1.30 → 1.1.32

package/src/usePeer.tsx

@@ -20,8 +20,10 @@ import { v4 as uuid } from "uuid";
 import { FastMutex } from "./lockstorage.ts";
 import {
 	cookiesWhereClearedJustNow,
+	createWebLockClientId,
 	getClientId,
 	getFreeKeypair,
+	getFreeKeypairWithWebLock,
 	inIframe,
 } from "./utils.ts";
 
@@ -245,8 +247,16 @@ export const PeerProvider = ({ config, children }: PeerProviderProps) => {
 	React.useEffect(() => {
 		let unmounted = false;
 		let unloadUnsubscribe: (() => void) | undefined;
+		let identityUnloadUnsubscribe: (() => void) | undefined;
 		let stopKeepAlive: (() => void) | undefined;
 		let closePeer: (() => void) | undefined;
+		let releaseIdentityLock: (() => void) | undefined;
+		const startupAbortController = new AbortController();
+		const releaseIdentity = () => {
+			const release = releaseIdentityLock;
+			releaseIdentityLock = undefined;
+			release?.();
+		};
 
 		const selected = resolveConfig(config);
 		setRuntime(selected.runtime);
@@ -344,32 +354,44 @@ export const PeerProvider = ({ config, children }: PeerProviderProps) => {
 			const keepAliveRef = { current: true } as { current: boolean };
 
 			const releaseFirstLock = cookiesWhereClearedJustNow();
+			const webLockManager =
+				typeof navigator.locks?.request === "function"
+					? navigator.locks
+					: undefined;
 			const sessionId = getClientId("session");
-			const mutex = new FastMutex({ clientId: sessionId, timeout: 1e3 });
+			const mutex = new FastMutex({
+				clientId: webLockManager
+					? createWebLockClientId()
+					: sessionId,
+				timeout: 1e3,
+			});
 
 			if (nodeOptions.singleton) {
+				const singletonMutex = webLockManager
+					? new FastMutex({ clientId: sessionId, timeout: 1e3 })
+					: mutex;
 				singletonLog("acquiring lock");
 				const localId = getClientId("local");
 				try {
 					const lockKey = localId + "-singleton";
 					const unsubscribeUnload = subscribeToUnload(() => {
 						keepAliveRef.current = false;
-						mutex.release(lockKey);
+						singletonMutex.release(lockKey);
 					});
 					const onVisibility = () => {
 						if (document.visibilityState === "hidden") {
 							keepAliveRef.current = false;
 							try {
-								mutex.release(lockKey);
+								singletonMutex.release(lockKey);
 							} catch {}
 						}
 					};
 					document.addEventListener("visibilitychange", onVisibility);
 					if (isInStandaloneMode()) {
 						keepAliveRef.current = false;
-						mutex.release(lockKey);
+						singletonMutex.release(lockKey);
 					}
-					await mutex.lock(lockKey, () => keepAliveRef.current, {
+					await singletonMutex.lock(lockKey, () => keepAliveRef.current, {
 						replaceIfSameClient: true,
 					});
 					singletonLog("lock acquired");
@@ -385,14 +407,44 @@ export const PeerProvider = ({ config, children }: PeerProviderProps) => {
 				nodeId = nodeOptions.keypair;
 			} else {
 				keypairLog("acquiring lock");
-				const kp = await getFreeKeypair("", mutex, () => keepAliveRef.current, {
-					releaseFirstLock,
-					releaseLockIfSameId: true,
-				});
+				const kp = webLockManager
+					? await getFreeKeypairWithWebLock(
+							"",
+							mutex,
+							webLockManager,
+							() => keepAliveRef.current,
+							startupAbortController.signal,
+						)
+					: await getFreeKeypair(
+							"",
+							mutex,
+							() => keepAliveRef.current,
+							{
+								releaseFirstLock,
+								releaseLockIfSameId: true,
+							},
+						);
 				keypairLog("lock acquired", { index: kp.index });
-				subscribeToUnload(() => {
+				const webLockRelease = (kp as { release?: () => void }).release;
+				releaseIdentityLock = webLockRelease
+					? webLockRelease
+					: () => mutex.release(kp.path);
+				if (unmounted) {
+					releaseIdentity();
+					return;
+				}
+				identityUnloadUnsubscribe = subscribeToUnload(() => {
 					keepAliveRef.current = false;
-					mutex.release(kp.path);
+					if (!webLockManager) {
+						releaseIdentity();
+					}
+					if (closePeer) {
+						closePeer();
+					} else {
+						startupAbortController.abort(
+							new DOMException("Page unloaded", "AbortError"),
+						);
+					}
 				});
 				nodeId = kp.key;
 				setTabIndex(kp.index);
@@ -403,16 +455,42 @@ export const PeerProvider = ({ config, children }: PeerProviderProps) => {
 
 			let directory: string | undefined;
 			if (!nodeOptions.inMemory && !(await detectIncognito()).isPrivate) {
-				storageLog("requesting persist");
-				const persistedValue = await navigator.storage.persist();
+				const storage = navigator.storage as StorageManager & {
+					getDirectory?: () => Promise<FileSystemDirectoryHandle>;
+				};
+				let persistedValue = false;
+				if (typeof storage?.persist === "function") {
+					storageLog("requesting persist");
+					try {
+						persistedValue = await storage.persist();
+					} catch (error) {
+						console.warn(
+							"Failed to request protection from browser storage eviction.",
+							error,
+						);
+					}
+				}
 				setPersisted(persistedValue);
 				persistedResolved = persistedValue;
-				if (!persistedValue) {
+				if (typeof storage?.getDirectory === "function") {
+					try {
+						await storage.getDirectory();
+						directory = `./repo/${peerId.toString()}/`;
+						if (!persistedValue) {
+							console.warn(
+								"Browser storage is not protected from eviction; continuing with OPFS-backed storage.",
+							);
+						}
+					} catch (error) {
+						console.error(
+							"Origin-private file system storage could not be opened; falling back to in-memory storage.",
+							error,
+						);
+					}
+				} else {
 					console.error(
-						"Request persistence but permission was not granted by browser.",
+						"Origin-private file system storage is unavailable; falling back to in-memory storage.",
 					);
-				} else {
-					directory = `./repo/${peerId.toString()}/`;
 				}
 			}
 
@@ -449,9 +527,18 @@ export const PeerProvider = ({ config, children }: PeerProviderProps) => {
 			});
 
 			newPeer = created as unknown as PeerbitLike;
+			let stopping: Promise<void> | undefined;
 			closePeer = () => {
-				keepAliveRef.current = false;
-				void (created as any)?.stop?.().catch(() => {});
+				stopping ??= Promise.resolve()
+					.then(() => (created as any)?.stop?.())
+					.then(() => {
+						keepAliveRef.current = false;
+						releaseIdentity();
+					})
+					.catch((error) => {
+						stopping = undefined;
+						clientLog("stop failed; retaining identity lock", error);
+					});
 			};
 
 			(window as any).__peerInfo = {
@@ -584,9 +671,7 @@ export const PeerProvider = ({ config, children }: PeerProviderProps) => {
 			}
 
 			if (unmounted) {
-				try {
-					await (created as any)?.stop?.();
-				} catch {}
+				closePeer();
 				return;
 			}
 			setPeer(newPeer);
@@ -597,6 +682,14 @@ export const PeerProvider = ({ config, children }: PeerProviderProps) => {
 			try {
 				await fn();
 			} catch (error: any) {
+				if (closePeer) {
+					closePeer();
+				} else {
+					releaseIdentity();
+				}
+				if (unmounted) {
+					return;
+				}
 				setError(error);
 				setConnectionState("failed");
 				setLoading(false);
@@ -607,7 +700,11 @@ export const PeerProvider = ({ config, children }: PeerProviderProps) => {
 		setPromise(p);
 		return () => {
 			unmounted = true;
+			startupAbortController.abort(
+				new DOMException("PeerProvider unmounted", "AbortError"),
+			);
 			unloadUnsubscribe?.();
+			identityUnloadUnsubscribe?.();
 			closePeer?.();
 		};
 	}, [config]);

package/src/utils.ts

@@ -2,10 +2,12 @@ import { deserialize, serialize } from "@dao-xyz/borsh";
 import { Ed25519Keypair, fromBase64, toBase64 } from "@peerbit/crypto";
 import sodium from "libsodium-wrappers";
 import { v4 as uuid } from "uuid";
-import { FastMutex } from "./lockstorage.ts";
+import { acquireWebLock, FastMutex, type WebLockLease } from "./lockstorage.ts";
 
 const CLIENT_ID_STORAGE_KEY = "CLIENT_ID";
 const ID_COUNTER_KEY = "idc/";
+export const WEB_LOCK_CLIENT_ID_PREFIX = "@peerbit/react:web-lock/v1:";
+const WEB_LOCK_NAME_PREFIX = "@peerbit/react:";
 
 const getKeyId = (prefix: string, id: number) => `${prefix}/${id}`;
 
@@ -33,6 +35,121 @@ export const releaseKey = (path: string, lock: FastMutex) => {
 	lock.release(path);
 };
 
+export const createWebLockClientId = () =>
+	`${WEB_LOCK_CLIENT_ID_PREFIX}${uuid()}`;
+
+const isWebLockClientId = (clientId: string) =>
+	clientId.startsWith(WEB_LOCK_CLIENT_ID_PREFIX);
+
+const getSelectionLockName = (id: string) =>
+	`${WEB_LOCK_NAME_PREFIX}keypair-selection:${JSON.stringify(id)}`;
+
+const getKeypairLockName = (id: string, index: number) =>
+	`${WEB_LOCK_NAME_PREFIX}keypair:${JSON.stringify([id, index])}`;
+
+const getAbortReason = (signal: AbortSignal) =>
+	signal.reason ?? new DOMException("Aborted", "AbortError");
+
+const throwIfAborted = (signal?: AbortSignal) => {
+	if (signal?.aborted) {
+		throw getAbortReason(signal);
+	}
+};
+
+const waitForLegacyCounter = async (
+	key: string,
+	lock: FastMutex,
+	signal?: AbortSignal,
+) => {
+	const startedAt = Date.now();
+	while (true) {
+		throwIfAborted(signal);
+		const owners = lock.getLockedOwners(key);
+		if (owners.length === 0) {
+			return;
+		}
+		if (owners.every(isWebLockClientId)) {
+			lock.releaseIfOwnedBy(key, isWebLockClientId);
+			return;
+		}
+		if (Date.now() - startedAt >= lock.timeout * 2 + 50) {
+			throw new Error("Timed out waiting for the legacy key counter lock");
+		}
+		await new Promise((resolve) => setTimeout(resolve, 10));
+	}
+};
+
+const acquirePinnedKeypairLock = async ({
+	id,
+	index,
+	lock,
+	lockManager,
+	lockCondition,
+	signal,
+}: {
+	id: string;
+	index: number;
+	lock: FastMutex;
+	lockManager: LockManager;
+	lockCondition: () => boolean;
+	signal?: AbortSignal;
+}): Promise<WebLockLease | undefined> => {
+	const webLock = await acquireWebLock(
+		lockManager,
+		getKeypairLockName(id, index),
+		{ ifAvailable: true, signal },
+	);
+	if (!webLock) {
+		return;
+	}
+
+	const key = getKeyId(id, index);
+	const owners = lock.getLockedOwners(key);
+	if (owners.some((owner) => !isWebLockClientId(owner))) {
+		webLock.release();
+		return;
+	}
+	lock.releaseIfOwnedBy(key, isWebLockClientId);
+
+	try {
+		await lock.lock(key, lockCondition);
+		throwIfAborted(signal);
+		lock.pin(key);
+	} catch (error) {
+		try {
+			lock.release(key);
+		} finally {
+			webLock.release();
+		}
+		throw error;
+	}
+
+	let released = false;
+	const release = () => {
+		if (released) return;
+		released = true;
+		signal?.removeEventListener("abort", release);
+		try {
+			lock.release(key);
+		} finally {
+			webLock.release();
+		}
+	};
+	signal?.addEventListener("abort", release, { once: true });
+	if (signal?.aborted) {
+		release();
+		throw getAbortReason(signal);
+	}
+
+	return {
+		release,
+		detachAbort: () => {
+			signal?.removeEventListener("abort", release);
+			webLock.detachAbort();
+		},
+	};
+};
+
 export const getFreeKeypair = async (
 	id = "",
 	lock: FastMutex,
@@ -45,34 +162,112 @@ export const getFreeKeypair = async (
 	await sodium.ready;
 	const idCounterKey = ID_COUNTER_KEY + id;
 	await lock.lock(idCounterKey, () => true);
-	let idCounter = JSON.parse(localStorage.getItem(idCounterKey) || "0");
-	for (let i = 0; i < 10000; i++) {
-		const key = getKeyId(id, i);
-		const lockedInfo = lock.getLockedInfo(key);
-		if (lockedInfo) {
-			if (
-				(lockedInfo === lock.clientId && options?.releaseLockIfSameId) ||
-				options?.releaseFirstLock
-			) {
-				await lock.release(key);
-			} else {
-				continue;
+	try {
+		const idCounter = JSON.parse(localStorage.getItem(idCounterKey) || "0");
+		for (let i = 0; i < 10000; i++) {
+			const key = getKeyId(id, i);
+			const lockedInfo = lock.getLockedInfo(key);
+			if (lockedInfo) {
+				if (
+					lockedInfo === lock.clientId &&
+					options?.releaseLockIfSameId
+				) {
+					lock.release(key);
+				} else if (options?.releaseFirstLock) {
+					lock.releaseIfOwnedBy(key, () => true);
+				} else {
+					continue;
+				}
 			}
+
+			await lock.lock(key, lockCondition);
+			localStorage.setItem(
+				idCounterKey,
+				JSON.stringify(Math.max(idCounter, i + 1)),
+			);
+			return {
+				index: i,
+				path: key,
+				key: await getKeypair(key),
+			};
 		}
+		throw new Error("Failed to resolve key");
+	} finally {
+		lock.release(idCounterKey);
+	}
+};
 
-		await lock.lock(key, lockCondition);
-		localStorage.setItem(
-			idCounterKey,
-			JSON.stringify(Math.max(idCounter, i + 1)),
+export const getFreeKeypairWithWebLock = async (
+	id: string,
+	lock: FastMutex,
+	lockManager: LockManager,
+	lockCondition: () => boolean = () => true,
+	signal?: AbortSignal,
+) => {
+	if (!isWebLockClientId(lock.clientId)) {
+		throw new Error(
+			"Web Lock key allocation requires a tagged mutex client ID",
 		);
-		await lock.release(idCounterKey);
-		return {
-			index: i,
-			path: key,
-			key: await getKeypair(key),
-		};
 	}
-	throw new Error("Failed to resolve key");
+	await sodium.ready;
+	throwIfAborted(signal);
+
+	const selectionLock = await acquireWebLock(
+		lockManager,
+		getSelectionLockName(id),
+		{ signal },
+	);
+	if (!selectionLock) {
+		throw new Error("Failed to acquire the keypair selection lock");
+	}
+
+	const idCounterKey = ID_COUNTER_KEY + id;
+	let counterLocked = false;
+	try {
+		await waitForLegacyCounter(idCounterKey, lock, signal);
+		await lock.lock(idCounterKey, () => true);
+		counterLocked = true;
+		const idCounter = JSON.parse(localStorage.getItem(idCounterKey) || "0");
+
+		for (let i = 0; i < 10000; i++) {
+			throwIfAborted(signal);
+			const selected = await acquirePinnedKeypairLock({
+				id,
+				index: i,
+				lock,
+				lockManager,
+				lockCondition,
+				signal,
+			});
+			if (!selected) {
+				continue;
+			}
+
+			const path = getKeyId(id, i);
+			try {
+				const key = await getKeypair(path);
+				throwIfAborted(signal);
+				localStorage.setItem(
+					idCounterKey,
+					JSON.stringify(Math.max(idCounter, i + 1)),
+				);
+				selected.detachAbort();
+				return { index: i, path, key, release: selected.release };
+			} catch (error) {
+				selected.release();
+				throw error;
+			}
+		}
+		throw new Error("Failed to resolve key");
+	} finally {
+		try {
+			if (counterLocked) {
+				lock.release(idCounterKey);
+			}
+		} finally {
+			selectionLock.release();
+		}
+	}
 };
 
 export const getAllKeyPairs = async (id = "") => {