@peerbit/canonical-client 0.0.0-e209d2e

package/src/peerbit.ts

@@ -0,0 +1,354 @@
+import { deserialize } from "@dao-xyz/borsh";
+import type { PeerId } from "@libp2p/interface";
+import { peerIdFromString } from "@libp2p/peer-id";
+import {
+	type Multiaddr,
+	isMultiaddr,
+	multiaddr,
+} from "@multiformats/multiaddr";
+import type {
+	Identity,
+	PreHash,
+	PublicSignKey,
+	SignatureWithKey,
+} from "@peerbit/crypto";
+import { Program } from "@peerbit/program";
+import type { Address, OpenOptions, ProgramClient } from "@peerbit/program";
+import {
+	type CanonicalOpenAdapter,
+	type CanonicalOpenMode,
+	createManagedProxy,
+} from "./auto.js";
+import type { CanonicalChannel } from "./client.js";
+import type { CanonicalClient } from "./index.js";
+
+type IdentityProxy = Identity<PublicSignKey> & {
+	signer: (
+		prehash?: PreHash,
+	) => (data: Uint8Array) => Promise<SignatureWithKey>;
+};
+
+export type PeerbitCanonicalPeerInfo = {
+	peerId: PeerId;
+	identity: IdentityProxy;
+	multiaddrs: Multiaddr[];
+};
+
+const asMultiaddrs = (value: unknown): Multiaddr[] | undefined => {
+	if (Array.isArray(value) && value.every((x) => isMultiaddr(x))) {
+		return value as Multiaddr[];
+	}
+	return undefined;
+};
+
+export class PeerbitCanonicalClient {
+	private _peerId: PeerId;
+	private _identity: IdentityProxy;
+	private _multiaddrs: Multiaddr[];
+	private openState?: {
+		adapters: CanonicalOpenAdapter[];
+		mode: CanonicalOpenMode;
+		adapterCaches: Map<CanonicalOpenAdapter, Map<string, Promise<any>>>;
+		proxies: Set<any>;
+	};
+
+	private constructor(
+		readonly canonical: CanonicalClient,
+		info: PeerbitCanonicalPeerInfo,
+	) {
+		this._peerId = info.peerId;
+		this._identity = info.identity;
+		this._multiaddrs = info.multiaddrs;
+	}
+
+	static async create(
+		canonical: CanonicalClient,
+		options?: { adapters?: CanonicalOpenAdapter[]; mode?: CanonicalOpenMode },
+	): Promise<PeerbitCanonicalClient> {
+		await canonical.init();
+		const peer = new PeerbitCanonicalClient(canonical, {
+			peerId: peerIdFromString(await canonical.peerId()),
+			identity: canonical.identity,
+			multiaddrs: (await canonical.multiaddrs()).map((a) => multiaddr(a)),
+		});
+		if (options?.adapters?.length) {
+			peer.enableOpen({ adapters: options.adapters, mode: options.mode });
+		}
+		return peer;
+	}
+
+	get peerId(): PeerId {
+		return this._peerId;
+	}
+
+	get identity(): IdentityProxy {
+		return this._identity;
+	}
+
+	getMultiaddrs(): Multiaddr[] {
+		return this._multiaddrs.slice();
+	}
+
+	private static attachParent(
+		child: { parents?: any[]; children?: any[] },
+		parent?: any,
+	) {
+		if (child.parents && child.parents.includes(parent) && parent == null) {
+			return;
+		}
+		(child.parents || (child.parents = [])).push(parent);
+		if (parent) {
+			(parent.children || (parent.children = [])).push(child);
+		}
+	}
+
+	private async closeOpenProxies(): Promise<void> {
+		const state = this.openState;
+		if (!state || state.proxies.size === 0) return;
+		const targets = [...state.proxies];
+		await Promise.allSettled(
+			targets.map((proxy) =>
+				typeof proxy?.close === "function" ? proxy.close() : undefined,
+			),
+		);
+		state.proxies.clear();
+		for (const cache of state.adapterCaches.values()) {
+			cache.clear();
+		}
+	}
+
+	enableOpen(options: {
+		adapters: CanonicalOpenAdapter[];
+		mode?: CanonicalOpenMode;
+	}): void {
+		if (!this.openState) {
+			this.openState = {
+				adapters: [...options.adapters],
+				mode: options.mode ?? "canonical",
+				adapterCaches: new Map(),
+				proxies: new Set(),
+			};
+			return;
+		}
+		this.openState.adapters.push(...options.adapters);
+		this.openState.mode = options.mode ?? this.openState.mode;
+	}
+
+	/**
+	 * Refreshes peerId/publicKey/multiaddrs from the canonical host.
+	 */
+	async refreshPeerInfo(): Promise<PeerbitCanonicalPeerInfo> {
+		const info = await this.canonical.peerInfo();
+		this._peerId = peerIdFromString(info.peerId);
+		this._identity = this.canonical.identity;
+		this._multiaddrs = (info.multiaddrs ?? []).map((a) => multiaddr(a));
+		return {
+			peerId: this._peerId,
+			identity: this._identity,
+			multiaddrs: this._multiaddrs.slice(),
+		};
+	}
+
+	async dial(
+		address: string | Multiaddr | Multiaddr[] | ProgramClient,
+	): Promise<boolean> {
+		if (typeof address === "string") {
+			return this.canonical.dial(address);
+		}
+		if (isMultiaddr(address)) {
+			return this.canonical.dial(address.toString());
+		}
+		const many = asMultiaddrs(address);
+		if (many) {
+			if (many.length === 0) {
+				throw new Error("Canonical dial requires at least one multiaddr");
+			}
+			let lastError: unknown;
+			for (const addr of many) {
+				try {
+					await this.canonical.dial(addr.toString());
+					return true;
+				} catch (e) {
+					lastError = e;
+				}
+			}
+			throw lastError ?? new Error("Canonical dial failed");
+		}
+
+		const candidate = address as any;
+		if (candidate && typeof candidate.getMultiaddrs === "function") {
+			const addrs = await Promise.resolve(candidate.getMultiaddrs());
+			return this.dial(addrs as any);
+		}
+
+		if (candidate && typeof candidate.toString === "function") {
+			return this.canonical.dial(candidate.toString());
+		}
+
+		throw new Error("Unsupported dial address");
+	}
+
+	async hangUp(
+		address: PeerId | PublicSignKey | string | Multiaddr,
+	): Promise<void> {
+		if (typeof address === "string") {
+			await this.canonical.hangUp(address);
+			return;
+		}
+		if (isMultiaddr(address)) {
+			await this.canonical.hangUp(address.toString());
+			return;
+		}
+
+		const candidate = address as any;
+		if (candidate && typeof candidate.toPeerId === "function") {
+			const peerId = await Promise.resolve(candidate.toPeerId());
+			await this.canonical.hangUp(peerId.toString());
+			return;
+		}
+
+		if (candidate && typeof candidate.toString === "function") {
+			await this.canonical.hangUp(candidate.toString());
+			return;
+		}
+
+		throw new Error("Unsupported hangUp address");
+	}
+
+	async start(): Promise<void> {
+		await this.canonical.start();
+		await this.refreshPeerInfo();
+	}
+
+	async stop(): Promise<void> {
+		await this.closeOpenProxies();
+		await this.canonical.stop();
+	}
+
+	async bootstrap(addresses?: string[] | Multiaddr[]): Promise<void> {
+		if (!addresses) {
+			await this.canonical.bootstrap();
+			return;
+		}
+		const normalized = addresses.map((addr) =>
+			typeof addr === "string" ? addr : addr.toString(),
+		);
+		await this.canonical.bootstrap(normalized);
+	}
+
+	openPort(name: string, payload: Uint8Array): Promise<CanonicalChannel> {
+		return this.canonical.openPort(name, payload);
+	}
+
+	async open<S extends Program<any>>(
+		storeOrAddress: S | Address,
+		openOptions: OpenOptions<S> = {},
+	): Promise<S> {
+		const state = this.openState;
+		if (!state || state.adapters.length === 0) {
+			throw new Error(
+				"Canonical open is not enabled. Pass adapters to PeerbitCanonicalClient.create(..., { adapters }) or call peer.enableOpen({ adapters }).",
+			);
+		}
+
+		const mode = openOptions?.mode ?? state.mode;
+		if (mode === "local") {
+			throw new Error(
+				"PeerbitCanonicalClient has no local Peerbit; use mode:'canonical' or omit mode.",
+			);
+		}
+
+		if (typeof storeOrAddress === "string") {
+			const address = storeOrAddress;
+			const bytes = await this.canonical.loadProgram(address, {
+				timeoutMs: openOptions.timeout,
+			});
+			const loaded = deserialize(bytes, Program) as Program<any>;
+			loaded.address = address;
+			return this.open(loaded as any, openOptions as any) as Promise<S>;
+		}
+
+		const program = storeOrAddress as Program<any>;
+		const adapter = state.adapters.find((candidate) =>
+			candidate.canOpen(program),
+		);
+		if (!adapter) {
+			throw new Error(
+				`No canonical adapter registered for ${program.constructor?.name ?? "program"}`,
+			);
+		}
+
+		const key = adapter.getKey?.(program as any, openOptions);
+		if (adapter.getKey && key === undefined) {
+			throw new Error(
+				`Canonical adapter '${adapter.name}' requires a cache key (adapter.getKey returned undefined)`,
+			);
+		}
+		const existingMode = openOptions?.existing ?? "reject";
+		let cache = key ? state.adapterCaches.get(adapter) : undefined;
+		if (key && !cache) {
+			cache = new Map();
+			state.adapterCaches.set(adapter, cache);
+		}
+
+		if (key && cache?.has(key)) {
+			if (existingMode === "reject") {
+				throw new Error(`Program already open for adapter '${adapter.name}'`);
+			}
+			if (existingMode === "replace") {
+				const prev = await cache.get(key);
+				if (prev && typeof (prev as any).close === "function") {
+					await (prev as any).close();
+				}
+				cache.delete(key);
+			} else {
+				const existingProxy = await cache.get(key);
+				if (openOptions?.parent) {
+					PeerbitCanonicalClient.attachParent(
+						existingProxy as any,
+						openOptions.parent,
+					);
+				}
+				return existingProxy as S;
+			}
+		}
+
+		const peer = this as any as ProgramClient;
+		const openPromise = (async () => {
+			const result = await adapter.open({
+				program: program as any,
+				options: openOptions,
+				peer,
+				client: this.canonical,
+			});
+
+			let managed: any;
+			managed = createManagedProxy(result.proxy as any, {
+				address: result.address,
+				node: peer,
+				onClose: () => {
+					if (key && cache?.get(key) === openPromise) {
+						cache.delete(key);
+					}
+					this.openState?.proxies.delete(managed);
+				},
+			});
+
+			this.openState?.proxies.add(managed);
+			if (openOptions?.parent) {
+				PeerbitCanonicalClient.attachParent(managed, openOptions.parent);
+			}
+			return managed as S;
+		})();
+
+		if (key && cache) {
+			cache.set(key, openPromise);
+		}
+		return openPromise as Promise<S>;
+	}
+
+	close(): void {
+		void this.closeOpenProxies();
+		this.canonical.close();
+	}
+}

package/src/service-worker.ts

@@ -0,0 +1,118 @@
+import type { CanonicalOpenAdapter, CanonicalOpenMode } from "./auto.js";
+import { CanonicalClient } from "./client.js";
+import { PeerbitCanonicalClient } from "./peerbit.js";
+
+export const CANONICAL_SERVICE_WORKER_CONNECT_OP =
+	"__peerbit_canonical_connect__";
+export const CANONICAL_SERVICE_WORKER_READY_KEY = "__peerbit_canonical_ready__";
+
+export type ConnectServiceWorkerOptions = {
+	serviceWorker?: ServiceWorker;
+	registration?: ServiceWorkerRegistration;
+	url?: string | URL;
+	scope?: string;
+	type?: RegistrationOptions["type"];
+	timeoutMs?: number;
+};
+
+const waitForActivated = async (
+	registration: ServiceWorkerRegistration,
+	timeoutMs: number,
+): Promise<ServiceWorker> => {
+	const candidate =
+		registration.active ?? registration.installing ?? registration.waiting;
+	if (!candidate) {
+		throw new Error("Service worker not installing");
+	}
+	if (candidate.state === "activated") {
+		return candidate;
+	}
+
+	return new Promise<ServiceWorker>((resolve, reject) => {
+		let timeout: ReturnType<typeof setTimeout> | undefined;
+		const onState = () => {
+			if (candidate.state !== "activated") return;
+			if (timeout) clearTimeout(timeout);
+			candidate.removeEventListener("statechange", onState);
+			resolve(candidate);
+		};
+		timeout = setTimeout(() => {
+			candidate.removeEventListener("statechange", onState);
+			reject(new Error("Service worker activation timeout"));
+		}, timeoutMs);
+		candidate.addEventListener("statechange", onState);
+	});
+};
+
+const waitForReady = async (
+	port: MessagePort,
+	timeoutMs: number,
+): Promise<void> => {
+	port.start();
+	return new Promise<void>((resolve, reject) => {
+		let timeout: ReturnType<typeof setTimeout> | undefined;
+		const cleanup = () => {
+			if (timeout) clearTimeout(timeout);
+			port.removeEventListener("message", onMessage);
+		};
+		const onMessage = (event: MessageEvent) => {
+			const data = event.data as any;
+			if (data?.[CANONICAL_SERVICE_WORKER_READY_KEY] == null) return;
+			cleanup();
+			if (data[CANONICAL_SERVICE_WORKER_READY_KEY] === false) {
+				reject(new Error(data.error ?? "Service worker canonical host failed"));
+			} else {
+				resolve();
+			}
+		};
+		timeout = setTimeout(() => {
+			cleanup();
+			reject(new Error("Service worker canonical connect timeout"));
+		}, timeoutMs);
+		port.addEventListener("message", onMessage);
+	});
+};
+
+export const connectServiceWorker = async (
+	options: ConnectServiceWorkerOptions,
+): Promise<CanonicalClient> => {
+	if (!("serviceWorker" in navigator)) {
+		throw new Error("Service workers not supported");
+	}
+
+	const timeoutMs = options.timeoutMs ?? 10_000;
+	let target = options.serviceWorker;
+
+	if (!target) {
+		const registration =
+			options.registration ??
+			(options.url
+				? await navigator.serviceWorker.register(options.url, {
+						scope: options.scope,
+						type: options.type ?? "module",
+					})
+				: undefined);
+		if (!registration) {
+			throw new Error(
+				"connectServiceWorker requires url, registration, or serviceWorker",
+			);
+		}
+		target = await waitForActivated(registration, timeoutMs);
+	}
+
+	const channel = new MessageChannel();
+	const ready = waitForReady(channel.port1, timeoutMs);
+	target.postMessage({ op: CANONICAL_SERVICE_WORKER_CONNECT_OP }, [
+		channel.port2,
+	]);
+	await ready;
+	return CanonicalClient.create(channel.port1);
+};
+
+export const connectServiceWorkerPeerbit = async (
+	options: ConnectServiceWorkerOptions,
+	peerOptions?: { adapters?: CanonicalOpenAdapter[]; mode?: CanonicalOpenMode },
+): Promise<PeerbitCanonicalClient> => {
+	const canonical = await connectServiceWorker(options);
+	return PeerbitCanonicalClient.create(canonical, peerOptions);
+};

package/src/window.ts

@@ -0,0 +1,112 @@
+import { createWindowTransport } from "@peerbit/canonical-transport";
+import type { CanonicalOpenAdapter, CanonicalOpenMode } from "./auto.js";
+import { CanonicalClient } from "./client.js";
+import { PeerbitCanonicalClient } from "./peerbit.js";
+
+export const CANONICAL_WINDOW_CONNECT_OP =
+	"__peerbit_canonical_window_connect__";
+export const CANONICAL_WINDOW_READY_KEY = "__peerbit_canonical_window_ready__";
+
+export type ConnectWindowOptions = {
+	target?: Window;
+	channel?: string;
+	targetOrigin?: string;
+	timeoutMs?: number;
+};
+
+const randomId = (): string => {
+	if (
+		typeof crypto !== "undefined" &&
+		typeof crypto.randomUUID === "function"
+	) {
+		return crypto.randomUUID();
+	}
+	return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+};
+
+const waitForReady = async (options: {
+	target: Window;
+	channel: string;
+	requestId: string;
+	timeoutMs: number;
+	expectedOrigin?: string;
+}): Promise<void> => {
+	return new Promise<void>((resolve, reject) => {
+		let timeout: ReturnType<typeof setTimeout> | undefined;
+		const cleanup = () => {
+			if (timeout) clearTimeout(timeout);
+			globalThis.removeEventListener("message", onMessage);
+		};
+		const onMessage = (event: MessageEvent) => {
+			if (event.source !== options.target) return;
+			if (options.expectedOrigin && event.origin !== options.expectedOrigin)
+				return;
+			const data = event.data as any;
+			if (data?.[CANONICAL_WINDOW_READY_KEY] == null) return;
+			if (data.channel && String(data.channel) !== options.channel) return;
+			if (data.requestId && String(data.requestId) !== options.requestId)
+				return;
+			cleanup();
+			if (data[CANONICAL_WINDOW_READY_KEY] === false) {
+				reject(new Error(data.error ?? "Window canonical host failed"));
+				return;
+			}
+			resolve();
+		};
+		timeout = setTimeout(() => {
+			cleanup();
+			reject(new Error("Window canonical connect timeout"));
+		}, options.timeoutMs);
+		globalThis.addEventListener("message", onMessage);
+	});
+};
+
+export const connectWindow = async (
+	options: ConnectWindowOptions = {},
+): Promise<CanonicalClient> => {
+	const parent = window.parent;
+	const opener = window.opener;
+	const inferredTarget = parent && parent !== window ? parent : opener;
+	const target = options.target ?? inferredTarget;
+	if (!target || target === window) {
+		throw new Error(
+			"connectWindow requires a parent/opener window or options.target",
+		);
+	}
+
+	const channel = options.channel ?? "peerbit-canonical";
+	const targetOrigin = options.targetOrigin ?? "*";
+	const timeoutMs = options.timeoutMs ?? 10_000;
+	const requestId = randomId();
+
+	const expectedOrigin = targetOrigin !== "*" ? targetOrigin : undefined;
+	const ready = waitForReady({
+		target,
+		channel,
+		requestId,
+		timeoutMs,
+		expectedOrigin,
+	});
+
+	target.postMessage(
+		{ op: CANONICAL_WINDOW_CONNECT_OP, channel, requestId },
+		targetOrigin,
+	);
+
+	await ready;
+
+	const transport = createWindowTransport(target, {
+		channel,
+		source: target,
+		targetOrigin,
+	});
+	return CanonicalClient.create(transport);
+};
+
+export const connectWindowPeerbit = async (
+	options: ConnectWindowOptions = {},
+	peerOptions?: { adapters?: CanonicalOpenAdapter[]; mode?: CanonicalOpenMode },
+): Promise<PeerbitCanonicalClient> => {
+	const canonical = await connectWindow(options);
+	return PeerbitCanonicalClient.create(canonical, peerOptions);
+};