@qntx/nostr 0.6.0 → 0.8.0

package/dist/pool-vlw74C4t.mjs

@@ -0,0 +1,606 @@
+import { S as toError, _ as MessageError, u as normalizeURL } from "./util-DMF9AIO0.mjs";
+import { n as canonicalizeFilters } from "./filter-BQl3GlHt.mjs";
+import { t as assertSubscriptionId } from "./message-oNr7t0SJ.mjs";
+import { t as invokeSafely } from "./report-CHld4uWj.mjs";
+import { c as RelayConnectionError, d as RelaySuspendedError, n as Relay, r as RelayStatus, s as RelayClosedError, u as RelayPublishError } from "./relay-quCs7MHD.mjs";
+import { i as throwIfAborted, n as onAbort, t as abortReason } from "./abort-DBq2STPj.mjs";
+import { t as Emitter } from "./emitter-DkCY6NkU.mjs";
+//#region src/relay/url.ts
+/**
+* {@link normalizeURL}, or the raw string when it is not a valid relay URL (ensureRelay then fails
+* it like a dead relay).
+*/
+function relayUrlKey(url) {
+	try {
+		return normalizeURL(url);
+	} catch {
+		return url;
+	}
+}
+/** Unique relay keys in first-seen order. */
+function uniqueRelayUrls(urls) {
+	const seen = /* @__PURE__ */ new Set();
+	const unique = [];
+	for (const url of urls) {
+		const key = relayUrlKey(url);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		unique.push(key);
+	}
+	return unique;
+}
+/**
+* True for `ws:` / `http:` URLs that are not `.onion`. Local-network `ws://` is still insecure;
+* allow those via a trusted set.
+*/
+function isInsecureRelayUrl(url) {
+	try {
+		const parsed = new URL(url);
+		if (parsed.hostname.endsWith(".onion")) return false;
+		return parsed.protocol === "ws:" || parsed.protocol === "http:";
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/relay/fan-in.ts
+/**
+* Aggregate EOSE/close across routed jobs. One `seen` set. `pending` counts URL list entries
+* (duplicates included). `pendingEose` counts unique `jobIndex:url` keys.
+*/
+function fanIn(pool, jobs, opts = {}) {
+	const seen = /* @__PURE__ */ new Set();
+	const closers = [];
+	let closed = false;
+	let eoseFired = false;
+	let sawEose = false;
+	let eoseTimer;
+	const eoseDone = /* @__PURE__ */ new Set();
+	const eoseAttempted = /* @__PURE__ */ new Set();
+	let pendingEose = 0;
+	let pending = 0;
+	const fireEose = () => {
+		if (closed || eoseFired) return;
+		eoseFired = true;
+		if (eoseTimer !== void 0) {
+			clearTimeout(eoseTimer);
+			eoseTimer = void 0;
+		}
+		invokeSafely(() => opts.oneose?.());
+	};
+	/**
+	* Remove one relay from the pending-EOSE set. `eosed` credits a real EOSE; a CLOSED or a connect
+	* failure only drops the wait — the aggregate `oneose` fires once every remaining relay ended AND
+	* at least one actually EOSE'd.
+	*/
+	const settleEose = (jobIndex, url, eosed) => {
+		const key = `${jobIndex}:${url}`;
+		if (eoseDone.has(key)) return;
+		eoseDone.add(key);
+		if (eosed) sawEose = true;
+		pendingEose -= 1;
+		if (pendingEose === 0 && sawEose) fireEose();
+	};
+	const settleClose = () => {
+		closed = true;
+		disposeAbort();
+		if (eoseTimer !== void 0) {
+			clearTimeout(eoseTimer);
+			eoseTimer = void 0;
+		}
+	};
+	const closeAll = (reason) => {
+		if (closed) return;
+		settleClose();
+		for (const c of closers) c.close(reason);
+		invokeSafely(() => opts.onclose?.(reason ?? "closed by client"));
+	};
+	if (opts.signal?.aborted === true) {
+		closed = true;
+		invokeSafely(() => opts.onclose?.("aborted"));
+		return { close: closeAll };
+	}
+	const disposeAbort = onAbort(opts.signal, () => closeAll("aborted"));
+	const failUrl = (jobIndex, key) => {
+		settleEose(jobIndex, key, false);
+		pending -= 1;
+		if (pending <= 0 && closers.length === 0 && !closed) {
+			settleClose();
+			invokeSafely(() => opts.onclose?.("all relays failed"));
+		}
+	};
+	const attach = (relay, job, jobIndex) => {
+		if (closed) return;
+		const received = opts.receivedEvent;
+		const sub = relay.subscribe([...job.filters], {
+			id: jobs.length === 1 ? job.id : void 0,
+			closeOnEose: opts.closeOnEose,
+			alreadyHaveEvent: (id) => {
+				let have = seen.has(id);
+				invokeSafely(() => {
+					have = have || Boolean(opts.alreadyHaveEvent?.(id));
+				});
+				return have;
+			},
+			receivedEvent: received === void 0 ? void 0 : (id) => invokeSafely(() => received(id, relay.url)),
+			onevent: (event) => {
+				seen.add(event.id);
+				invokeSafely(() => opts.onevent?.(event, relay.url));
+			},
+			oneose: () => settleEose(jobIndex, relay.url, true),
+			onclose: (reason) => {
+				settleEose(jobIndex, relay.url, false);
+				pending -= 1;
+				if (pending <= 0 && !closed) {
+					settleClose();
+					invokeSafely(() => opts.onclose?.(reason));
+				}
+			}
+		});
+		closers.push(sub);
+	};
+	for (const [jobIndex, job] of jobs.entries()) for (const key of uniqueRelayUrls(job.urls)) {
+		pending += 1;
+		const eoseKey = `${jobIndex}:${key}`;
+		if (!eoseAttempted.has(eoseKey)) {
+			eoseAttempted.add(eoseKey);
+			pendingEose += 1;
+		}
+		const tryAttach = (relay) => {
+			try {
+				attach(relay, job, jobIndex);
+			} catch (error) {
+				if (error instanceof RelayClosedError) {
+					failUrl(jobIndex, key);
+					return;
+				}
+				throw error;
+			}
+		};
+		(async () => {
+			let relay;
+			try {
+				relay = await pool.ensureRelay(key, {
+					signal: opts.signal,
+					timeoutMs: opts.connectTimeoutMs
+				});
+			} catch {
+				const existing = pool.getRelay(key);
+				if (existing !== void 0) {
+					tryAttach(existing);
+					return;
+				}
+				failUrl(jobIndex, key);
+				return;
+			}
+			tryAttach(relay);
+		})();
+	}
+	if (opts.eoseTimeoutMs !== void 0 && pending > 0) eoseTimer = setTimeout(() => {
+		eoseTimer = void 0;
+		fireEose();
+	}, opts.eoseTimeoutMs);
+	if (pending === 0) queueMicrotask(() => {
+		if (closed) return;
+		settleClose();
+		invokeSafely(() => opts.onclose?.("no relays"));
+	});
+	return { close: closeAll };
+}
+async function fetchRouted(pool, jobs, opts = {}) {
+	throwIfAborted(opts.signal);
+	const byId = /* @__PURE__ */ new Map();
+	await Promise.all(jobs.flatMap((job) => {
+		return uniqueRelayUrls(job.urls).map(async (url) => {
+			let batch;
+			let relayUrl;
+			try {
+				const relay = await pool.ensureRelay(url, {
+					signal: opts.signal,
+					timeoutMs: opts.connectTimeoutMs
+				});
+				relayUrl = relay.url;
+				batch = (await relay.fetch([...job.filters], {
+					timeoutMs: opts.timeoutMs,
+					signal: opts.signal
+				})).events;
+			} catch {
+				if (opts.signal?.aborted === true) throw abortReason(opts.signal);
+				return;
+			}
+			for (const event of batch) if (!byId.has(event.id)) byId.set(event.id, event);
+			for (const event of batch) invokeSafely(() => opts.onevent?.(event, relayUrl));
+		});
+	}));
+	return [...byId.values()];
+}
+//#endregion
+//#region src/relay/pool.ts
+const countOk = (url, payload) => ({
+	url,
+	status: "ok",
+	...payload
+});
+function isIdle(relay) {
+	return relay.status !== RelayStatus.Connecting && relay.subscriptionCount === 0 && relay.inFlightCount === 0;
+}
+/** Multi-relay coordinator: connection reuse, cross-relay event dedup, fan-out publish. */
+var Pool = class {
+	#relays = /* @__PURE__ */ new Map();
+	#relayOptions;
+	#automaticallyAuth;
+	#maxRelays;
+	#invalidEventPolicy;
+	#events = new Emitter();
+	#lastActivity = /* @__PURE__ */ new Map();
+	#idleTimeoutMs;
+	#idleTimer;
+	#allowInsecure;
+	#trustedInsecure;
+	#pinned;
+	/** Per-relay timestamps of verification failures inside the sliding window. */
+	#invalidEvents = /* @__PURE__ */ new Map();
+	/** Normalized URL → epoch ms when its suspension lifts. */
+	#suspendedUntil = /* @__PURE__ */ new Map();
+	#resumeTimers = /* @__PURE__ */ new Map();
+	constructor(opts = {}) {
+		const { automaticallyAuth, allowInsecure, trustedInsecureUrls, idleTimeoutMs, idleCleanupIntervalMs, maxRelays, pinnedUrls, invalidEventPolicy, ...relayOptions } = opts;
+		this.#relayOptions = relayOptions;
+		this.#automaticallyAuth = automaticallyAuth;
+		this.#maxRelays = maxRelays;
+		this.#invalidEventPolicy = invalidEventPolicy;
+		this.#allowInsecure = allowInsecure ?? false;
+		this.#trustedInsecure = new Set((trustedInsecureUrls ?? []).map(normalizeURL));
+		this.#pinned = new Set((pinnedUrls ?? []).map(normalizeURL));
+		this.#idleTimeoutMs = idleTimeoutMs ?? 0;
+		if (this.#idleTimeoutMs > 0) this.#idleTimer = setInterval(() => this.cleanIdleRelays(), idleCleanupIntervalMs ?? 3e4);
+	}
+	/**
+	* Listen for a pool event. Multiple listeners per type are allowed and fire in registration
+	* order; a throwing listener is reported and does not break the dispatch. Returns an unsubscribe
+	* function.
+	*/
+	on(type, listener) {
+		return this.#events.on(type, listener);
+	}
+	setAllowInsecure(allow) {
+		this.#allowInsecure = allow;
+	}
+	setTrustedInsecureUrls(urls) {
+		this.#trustedInsecure = new Set(urls.map(normalizeURL));
+	}
+	setPinnedUrls(urls) {
+		this.#pinned = new Set(urls.map(normalizeURL));
+	}
+	/**
+	* Drop cached AUTH rejections and re-fire pending challenges on every pooled relay, so a later
+	* `setSigner` takes effect without reconnect.
+	*/
+	resetAuth() {
+		for (const relay of this.#relays.values()) relay.resetAuth();
+	}
+	cleanIdleRelays() {
+		if (this.#idleTimeoutMs <= 0) return;
+		const now = Date.now();
+		const idle = [];
+		for (const [url, relay] of this.#relays) {
+			if (this.#pinned.has(url) || !isIdle(relay)) continue;
+			const last = this.#lastActivity.get(url) ?? 0;
+			if (!relay.connected || now - last >= this.#idleTimeoutMs) idle.push(url);
+		}
+		for (const url of this.#lastActivity.keys()) if (!this.#relays.has(url)) this.#lastActivity.delete(url);
+		if (idle.length === 0) return;
+		this.closeRelays(idle);
+		this.#events.emit("idle", idle);
+	}
+	#touch(url) {
+		this.#lastActivity.set(url, Date.now());
+	}
+	/**
+	* Count one verification failure for `norm`; on the `limit + 1`-th inside `windowMs` suspend the
+	* relay: drop its connection (subscriptions kept), record `until`, and emit `suspend`.
+	*/
+	#noteInvalidEvent(norm) {
+		const policy = this.#invalidEventPolicy;
+		if (policy === void 0) return;
+		const now = Date.now();
+		const window = (this.#invalidEvents.get(norm) ?? []).filter((at) => now - at < policy.windowMs);
+		window.push(now);
+		if (window.length <= policy.limit) {
+			this.#invalidEvents.set(norm, window);
+			return;
+		}
+		this.#invalidEvents.delete(norm);
+		if (this.#suspendedUntil.has(norm)) return;
+		const until = now + policy.cooldownMs;
+		this.#suspendedUntil.set(norm, until);
+		this.#relays.get(norm)?.disconnect();
+		const resume = setTimeout(() => {
+			this.#resumeTimers.delete(norm);
+			this.#suspendedUntil.delete(norm);
+			const relay = this.#relays.get(norm);
+			if (relay === void 0 || relay.connected || relay.subscriptionCount === 0) return;
+			(async () => {
+				try {
+					await relay.connect();
+				} catch {}
+			})();
+		}, policy.cooldownMs);
+		this.#resumeTimers.set(norm, resume);
+		this.#events.emit("suspend", {
+			url: norm,
+			until
+		});
+	}
+	#rejectInsecure(url, norm) {
+		if (this.#allowInsecure) return;
+		if (!isInsecureRelayUrl(url)) return;
+		if (this.#trustedInsecure.has(norm)) return;
+		throw new RelayConnectionError("insecure relay connection blocked", norm);
+	}
+	#stopIdleCleanup() {
+		if (this.#idleTimer === void 0) return;
+		clearInterval(this.#idleTimer);
+		this.#idleTimer = void 0;
+	}
+	/**
+	* Soft cap: closing the least-recently-used idle non-pinned relay when a new non-pinned relay
+	* would push the count past `maxRelays`. Busy relays are never evicted; with none idle the cap is
+	* exceeded rather than failing.
+	*/
+	#enforceMaxRelays(incoming) {
+		const cap = this.#maxRelays;
+		if (cap === void 0 || this.#pinned.has(incoming)) return;
+		let count = 0;
+		let oldestUrl;
+		let oldestAt = Number.POSITIVE_INFINITY;
+		for (const [url, relay] of this.#relays) {
+			if (this.#pinned.has(url)) continue;
+			count += 1;
+			if (!isIdle(relay)) continue;
+			const at = this.#lastActivity.get(url) ?? 0;
+			if (at < oldestAt) {
+				oldestAt = at;
+				oldestUrl = url;
+			}
+		}
+		if (count >= cap && oldestUrl !== void 0) this.closeRelays([oldestUrl]);
+	}
+	async ensureRelay(url, opts) {
+		const norm = normalizeURL(url);
+		this.#rejectInsecure(url, norm);
+		const suspendedUntil = this.#suspendedUntil.get(norm);
+		if (suspendedUntil !== void 0) {
+			if (Date.now() < suspendedUntil) throw new RelaySuspendedError(norm, suspendedUntil);
+			this.#suspendedUntil.delete(norm);
+		}
+		let relay = this.#relays.get(norm);
+		if (!relay) {
+			this.#enforceMaxRelays(norm);
+			const signFn = this.#automaticallyAuth?.(norm) ?? void 0;
+			const created = new Relay(norm, {
+				...this.#relayOptions,
+				authSigner: signFn
+			});
+			created.on("close", () => {
+				this.#relays.delete(norm);
+				this.#lastActivity.delete(norm);
+			});
+			created.on("invalidevent", () => {
+				this.#noteInvalidEvent(norm);
+			});
+			if (signFn) created.on("auth", () => {
+				(async () => {
+					try {
+						await created.auth(signFn);
+					} catch {}
+				})();
+			});
+			this.#relays.set(norm, created);
+			relay = created;
+		}
+		this.#touch(norm);
+		if (!relay.connected) try {
+			await relay.connect({
+				signal: opts?.signal,
+				timeoutMs: opts?.timeoutMs ?? this.#relayOptions.connectTimeoutMs
+			});
+		} catch (error) {
+			if (this.#relayOptions.enableReconnect !== true) {
+				this.#relays.delete(norm);
+				this.#lastActivity.delete(norm);
+			}
+			throw error;
+		}
+		return relay;
+	}
+	/** Close every pooled relay and clear all pool state. */
+	close() {
+		this.#stopIdleCleanup();
+		for (const timer of this.#resumeTimers.values()) clearTimeout(timer);
+		this.#resumeTimers.clear();
+		this.#suspendedUntil.clear();
+		this.#invalidEvents.clear();
+		for (const relay of this.#relays.values()) relay.close();
+		this.#relays.clear();
+		this.#lastActivity.clear();
+	}
+	/** Close and forget the listed relays; other pooled relays are untouched. */
+	closeRelays(urls) {
+		for (const url of urls) {
+			const norm = normalizeURL(url);
+			const timer = this.#resumeTimers.get(norm);
+			if (timer !== void 0) {
+				clearTimeout(timer);
+				this.#resumeTimers.delete(norm);
+			}
+			this.#relays.get(norm)?.close();
+			this.#relays.delete(norm);
+			this.#lastActivity.delete(norm);
+		}
+	}
+	/**
+	* Subscribe across relays. Deduplicates by event id. Returns a closer; callbacks receive every
+	* new event once.
+	*/
+	subscribe(relays, filters, opts = {}) {
+		if (filters.length === 0) throw new MessageError("REQ requires at least one filter");
+		if (opts.id !== void 0) assertSubscriptionId(opts.id);
+		const canonical = canonicalizeFilters(filters);
+		return fanIn(this, [{
+			urls: relays,
+			filters: canonical,
+			id: opts.id
+		}], {
+			onevent: opts.onevent,
+			oneose: opts.oneose,
+			onclose: opts.onclose,
+			signal: opts.signal,
+			eoseTimeoutMs: opts.eoseTimeoutMs,
+			alreadyHaveEvent: opts.alreadyHaveEvent,
+			receivedEvent: opts.receivedEvent,
+			closeOnEose: opts.closeOnEose,
+			connectTimeoutMs: this.#relayOptions.connectTimeoutMs
+		});
+	}
+	/**
+	* One-shot fetch per relay: each entry reports its own events and end reason (`eose`, `closed`,
+	* `timeout`), or `failed` when the connect or REQ itself errored. An abort rejects the whole
+	* call. Events are not deduped across relays — use {@link fetch} for that.
+	*/
+	async fetchEach(relays, filters, opts) {
+		if (filters.length === 0) throw new MessageError("REQ requires at least one filter");
+		throwIfAborted(opts?.signal);
+		const canonical = canonicalizeFilters(filters);
+		return Promise.all(uniqueRelayUrls(relays).map(async (url) => {
+			try {
+				const relay = await this.ensureRelay(url, {
+					signal: opts?.signal,
+					timeoutMs: this.#relayOptions.connectTimeoutMs
+				});
+				this.#touch(relay.url);
+				const result = await relay.fetch([...canonical], {
+					timeoutMs: opts?.timeoutMs,
+					signal: opts?.signal
+				});
+				return {
+					url,
+					events: result.events,
+					end: result.end
+				};
+			} catch (error) {
+				if (opts?.signal?.aborted === true) throw abortReason(opts.signal);
+				return {
+					url,
+					events: [],
+					end: {
+						type: "failed",
+						error: toError(error)
+					}
+				};
+			}
+		}));
+	}
+	/** Fetch events until each connected relay EOSE or timeout; dedupe by id. */
+	async fetch(relays, filters, opts) {
+		if (filters.length === 0) throw new MessageError("REQ requires at least one filter");
+		return fetchRouted(this, [{
+			urls: relays,
+			filters: canonicalizeFilters(filters)
+		}], {
+			timeoutMs: opts?.timeoutMs,
+			signal: opts?.signal,
+			connectTimeoutMs: this.#relayOptions.connectTimeoutMs,
+			onevent: opts?.onevent
+		});
+	}
+	/** Publish to all listed relays; returns per-relay outcomes. */
+	async publish(relays, event, opts) {
+		return Promise.all(uniqueRelayUrls(relays).map(async (url) => {
+			try {
+				const relay = await this.ensureRelay(url, { timeoutMs: this.#relayOptions.connectTimeoutMs });
+				this.#touch(relay.url);
+				const result = await relay.publish(event, { timeoutMs: opts?.timeoutMs });
+				return result.ok ? {
+					url,
+					status: "ok",
+					message: result.message
+				} : {
+					url,
+					status: "rejected",
+					message: result.message
+				};
+			} catch (error) {
+				return {
+					url,
+					status: "failed",
+					error: toError(error)
+				};
+			}
+		}));
+	}
+	/** First successful publish (Promise.any semantics). */
+	async publishAny(relays, event, opts) {
+		return Promise.any(uniqueRelayUrls(relays).map(async (url) => {
+			const relay = await this.ensureRelay(url, { timeoutMs: this.#relayOptions.connectTimeoutMs });
+			this.#touch(relay.url);
+			const result = await relay.publish(event, { timeoutMs: opts?.timeoutMs });
+			if (!result.ok) throw new RelayPublishError(result.message || "rejected", relay.url);
+			return {
+				url,
+				status: "ok",
+				message: result.message
+			};
+		}));
+	}
+	/**
+	* NIP-45 COUNT across relays. Per-relay outcomes; failures do not throw. Counts are not summed —
+	* each relay reports independently (may overlap).
+	*/
+	async count(relays, filters, opts) {
+		throwIfAborted(opts?.signal);
+		const canonical = canonicalizeFilters(filters);
+		return Promise.all(uniqueRelayUrls(relays).map(async (url) => {
+			try {
+				const relay = await this.ensureRelay(url, {
+					signal: opts?.signal,
+					timeoutMs: this.#relayOptions.connectTimeoutMs
+				});
+				this.#touch(relay.url);
+				const payload = await relay.count(canonical, {
+					timeoutMs: opts?.timeoutMs,
+					signal: opts?.signal
+				});
+				return countOk(url, payload);
+			} catch (error) {
+				if (opts?.signal?.aborted === true) throw abortReason(opts.signal);
+				return {
+					url,
+					status: "failed",
+					error: toError(error)
+				};
+			}
+		}));
+	}
+	listRelays() {
+		return [...this.#relays.keys()];
+	}
+	/** Lookup a pooled relay, including disconnected reconnecting entries. */
+	getRelay(url) {
+		try {
+			return this.#relays.get(normalizeURL(url));
+		} catch {
+			return this.#relays.get(url);
+		}
+	}
+	/** Currently connected URLs. Unlike listRelays(), excludes reconnecting/disconnected entries. */
+	connectedUrls() {
+		const urls = [];
+		for (const [url, relay] of this.#relays) if (relay.connected) urls.push(url);
+		return urls;
+	}
+};
+//#endregion
+export { isInsecureRelayUrl as i, fanIn as n, fetchRouted as r, Pool as t };
+
+//# sourceMappingURL=pool-vlw74C4t.mjs.map