@nostrify/nostrify 0.46.9 → 0.46.10

package/dist/NPool.js

@@ -0,0 +1,154 @@
+import { getFilterLimit } from "nostr-tools";
+import { CircularSet } from "./utils/CircularSet.js";
+import { Machina } from "./utils/Machina.js";
+import { NSet } from "./NSet.js";
+class NPool {
+  _relays = /* @__PURE__ */ new Map();
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /** Get or create a relay instance for the given URL. */
+  relay(url) {
+    const relay = this._relays.get(url);
+    if (relay) {
+      return relay;
+    } else {
+      const relay2 = this.opts.open(url);
+      this._relays.set(url, relay2);
+      return relay2;
+    }
+  }
+  /** Returns a new pool instance that uses the given relays. Connections are shared with the original pool. */
+  group(urls) {
+    return new NPool({
+      open: (url) => this.relay(url),
+      reqRouter: (filters) => new Map(urls.map((url) => [url, filters])),
+      eventRouter: () => urls
+    });
+  }
+  get relays() {
+    return this._relays;
+  }
+  /**
+   * Sends a `REQ` to relays based on the configured `reqRouter`.
+   *
+   * `EVENT` messages from the selected relays are yielded.
+   * `EOSE` and `CLOSE` messages are only yielded when all relays have emitted them.
+   *
+   * Deduplication of `EVENT` messages is attempted, so that each event is only yielded once.
+   * A circular set of 1000 is used to track seen event IDs, so it's possible that very
+   * long-running subscriptions (with over 1000 results) may yield duplicate events.
+   */
+  async *req(filters, opts) {
+    const controller = new AbortController();
+    const signal = opts?.signal ? AbortSignal.any([opts.signal, controller.signal]) : controller.signal;
+    const routes = opts?.relays ? new Map(opts.relays.map((url) => [url, filters])) : await this.opts.reqRouter(filters);
+    if (routes.size < 1) {
+      return;
+    }
+    const machina = new Machina(signal);
+    const eoses = /* @__PURE__ */ new Set();
+    const closes = /* @__PURE__ */ new Set();
+    const events = new CircularSet(1e3);
+    const relayPromises = [];
+    for (const [url, filters2] of routes.entries()) {
+      const relay = this.relay(url);
+      const relayPromise = (async () => {
+        try {
+          for await (const msg of relay.req(filters2, { signal })) {
+            if (msg[0] === "EOSE") {
+              eoses.add(url);
+              if (eoses.size === routes.size) {
+                machina.push(msg);
+              }
+            }
+            if (msg[0] === "CLOSED") {
+              closes.add(url);
+              if (closes.size === routes.size) {
+                machina.push(msg);
+              }
+            }
+            if (msg[0] === "EVENT") {
+              const [, , event] = msg;
+              if (!events.has(event.id)) {
+                events.add(event.id);
+                machina.push(msg);
+              }
+            }
+          }
+        } catch {
+        }
+      })();
+      relayPromises.push(relayPromise);
+    }
+    try {
+      for await (const msg of machina) {
+        yield msg;
+      }
+    } finally {
+      controller.abort();
+      await Promise.allSettled(relayPromises);
+    }
+  }
+  /**
+   * Events are sent to relays according to the `eventRouter`.
+   * Returns a fulfilled promise if ANY relay accepted the event,
+   * or a rejected promise if ALL relays rejected or failed to publish the event.
+   */
+  async event(event, opts) {
+    const relayUrls = opts?.relays ?? await this.opts.eventRouter(event);
+    if (!relayUrls.length) {
+      return;
+    }
+    await Promise.any(
+      relayUrls.map((url) => this.relay(url).event(event, opts))
+    );
+  }
+  /**
+   * This method calls `.req` internally and then post-processes the results.
+   * Please read the definition of `.req`.
+   *
+   * - The strategy is to seek regular events quickly, and to wait to find the latest versions of replaceable events.
+   * - Filters for replaceable events will wait for all relays to `EOSE` (or `CLOSE`, or for the signal to be aborted) to ensure the latest event versions are retrieved.
+   * - Filters for regular events will stop as soon as the filters are fulfilled.
+   * - Events are deduplicated, sorted, and only the latest version of replaceable events is kept.
+   * - If the signal is aborted, this method will return partial results instead of throwing.
+   *
+   * To implement a custom strategy, call `.req` directly.
+   */
+  async query(filters, opts) {
+    const map = /* @__PURE__ */ new Map();
+    const events = new NSet(map);
+    const limit = filters.reduce(
+      (result, filter) => result + getFilterLimit(filter),
+      0
+    );
+    if (limit === 0) return [];
+    try {
+      for await (const msg of this.req(filters, opts)) {
+        if (msg[0] === "EOSE") break;
+        if (msg[0] === "EVENT") events.add(msg[2]);
+        if (msg[0] === "CLOSED") break;
+      }
+    } catch {
+    }
+    if (filters.some((filter) => typeof filter.search === "string")) {
+      return [...map.values()];
+    } else {
+      return [...events];
+    }
+  }
+  /** Close all the relays in the pool. */
+  async close() {
+    await Promise.all(
+      [...this._relays.values()].map((relay) => relay.close())
+    );
+  }
+  async [Symbol.asyncDispose]() {
+    await this.close();
+  }
+}
+export {
+  NPool
+};

package/dist/NPool.ts

@@ -0,0 +1,243 @@
+import type {
+  NostrEvent,
+  NostrFilter,
+  NostrRelayCLOSED,
+  NostrRelayEOSE,
+  NostrRelayEVENT,
+  NRelay,
+} from '@nostrify/types';
+import { getFilterLimit } from 'nostr-tools';
+
+import { CircularSet } from './utils/CircularSet.ts';
+import { Machina } from './utils/Machina.ts';
+import { NSet } from './NSet.ts';
+
+export interface NPoolOpts<T extends NRelay> {
+  /** Creates an `NRelay` instance for the given URL. */
+  open(url: string): T;
+  /** Determines the relays to use for making `REQ`s to the given filters. To support the Outbox model, it should analyze the `authors` field of the filters. */
+  reqRouter(
+    filters: NostrFilter[],
+  ):
+    | ReadonlyMap<string, NostrFilter[]>
+    | Promise<ReadonlyMap<string, NostrFilter[]>>;
+  /** Determines the relays to use for publishing the given event. To support the Outbox model, it should analyze the `pubkey` field of the event. */
+  eventRouter(event: NostrEvent): string[] | Promise<string[]>;
+}
+
+/**
+ * The `NPool` class is a `NRelay` implementation for connecting to multiple relays.
+ *
+ * ```ts
+ * const pool = new NPool({
+ *   open: (url) => new NRelay1(url),
+ *   reqRouter: async (filters) => new Map([
+ *     ['wss://relay1.mostr.pub', filters],
+ *     ['wss://relay2.mostr.pub', filters],
+ *   ]),
+ *   eventRouter: async (event) => ['wss://relay1.mostr.pub', 'wss://relay2.mostr.pub'],
+ * });
+ *
+ * // Now you can use the pool like a regular relay.
+ * for await (const msg of pool.req([{ kinds: [1] }])) {
+ *   if (msg[0] === 'EVENT') console.log(msg[2]);
+ *   if (msg[0] === 'EOSE') break;
+ * }
+ * ```
+ *
+ * This class is designed with the Outbox model in mind.
+ * Instead of passing relay URLs into each method, you pass functions into the contructor that statically-analyze filters and events to determine which relays to use for requesting and publishing events.
+ * If a relay wasn't already connected, it will be opened automatically.
+ * Defining `open` will also let you use any relay implementation, such as `NRelay1`.
+ *
+ * Note that `pool.req` may stream duplicate events, while `pool.query` will correctly process replaceable events and deletions within the event set before returning them.
+ *
+ * `pool.req` will only emit an `EOSE` when all relays in its set have emitted an `EOSE`, and likewise for `CLOSED`.
+ */
+export class NPool<T extends NRelay = NRelay> implements NRelay {
+  private _relays = new Map<string, T>();
+  private opts: NPoolOpts<T>;
+
+  constructor(opts: NPoolOpts<T>) {
+    this.opts = opts;
+  }
+
+  /** Get or create a relay instance for the given URL. */
+  public relay(url: string): T {
+    const relay = this._relays.get(url);
+
+    if (relay) {
+      return relay;
+    } else {
+      const relay = this.opts.open(url);
+      this._relays.set(url, relay);
+      return relay;
+    }
+  }
+
+  /** Returns a new pool instance that uses the given relays. Connections are shared with the original pool. */
+  public group(urls: string[]): NPool<T> {
+    return new NPool({
+      open: (url) => this.relay(url),
+      reqRouter: (filters) => new Map(urls.map((url) => [url, filters])),
+      eventRouter: () => urls,
+    });
+  }
+
+  public get relays(): ReadonlyMap<string, T> {
+    return this._relays;
+  }
+
+  /**
+   * Sends a `REQ` to relays based on the configured `reqRouter`.
+   *
+   * `EVENT` messages from the selected relays are yielded.
+   * `EOSE` and `CLOSE` messages are only yielded when all relays have emitted them.
+   *
+   * Deduplication of `EVENT` messages is attempted, so that each event is only yielded once.
+   * A circular set of 1000 is used to track seen event IDs, so it's possible that very
+   * long-running subscriptions (with over 1000 results) may yield duplicate events.
+   */
+  async *req(
+    filters: NostrFilter[],
+    opts?: { signal?: AbortSignal; relays?: string[] },
+  ): AsyncIterable<NostrRelayEVENT | NostrRelayEOSE | NostrRelayCLOSED> {
+    const controller = new AbortController();
+    const signal = opts?.signal ? AbortSignal.any([opts.signal, controller.signal]) : controller.signal;
+
+    const routes = opts?.relays
+      ? new Map(opts.relays.map((url) => [url, filters]))
+      : await this.opts.reqRouter(filters);
+
+    if (routes.size < 1) {
+      return;
+    }
+
+    const machina = new Machina<
+      NostrRelayEVENT | NostrRelayEOSE | NostrRelayCLOSED
+    >(signal);
+
+    const eoses = new Set<string>();
+    const closes = new Set<string>();
+    const events = new CircularSet<string>(1000);
+
+    const relayPromises: Promise<void>[] = [];
+
+    for (const [url, filters] of routes.entries()) {
+      const relay = this.relay(url);
+      const relayPromise = (async () => {
+        try {
+          for await (const msg of relay.req(filters, { signal })) {
+            if (msg[0] === 'EOSE') {
+              eoses.add(url);
+              if (eoses.size === routes.size) {
+                machina.push(msg);
+              }
+            }
+            if (msg[0] === 'CLOSED') {
+              closes.add(url);
+              if (closes.size === routes.size) {
+                machina.push(msg);
+              }
+            }
+            if (msg[0] === 'EVENT') {
+              const [, , event] = msg;
+              if (!events.has(event.id)) {
+                events.add(event.id);
+                machina.push(msg);
+              }
+            }
+          }
+        } catch {
+          // Handle errors silently
+        }
+      })();
+      relayPromises.push(relayPromise);
+    }
+
+    try {
+      for await (const msg of machina) {
+        yield msg;
+      }
+    } finally {
+      controller.abort();
+      // Wait for all relay promises to complete to prevent hanging promises
+      await Promise.allSettled(relayPromises);
+    }
+  }
+
+  /**
+   * Events are sent to relays according to the `eventRouter`.
+   * Returns a fulfilled promise if ANY relay accepted the event,
+   * or a rejected promise if ALL relays rejected or failed to publish the event.
+   */
+  async event(
+    event: NostrEvent,
+    opts?: { signal?: AbortSignal; relays?: string[] },
+  ): Promise<void> {
+    const relayUrls = opts?.relays ?? await this.opts.eventRouter(event);
+
+    if (!relayUrls.length) {
+      return;
+    }
+
+    // @ts-ignore Promise.any exists for sure
+    await Promise.any(
+      relayUrls.map((url) => this.relay(url).event(event, opts)),
+    );
+  }
+
+  /**
+   * This method calls `.req` internally and then post-processes the results.
+   * Please read the definition of `.req`.
+   *
+   * - The strategy is to seek regular events quickly, and to wait to find the latest versions of replaceable events.
+   * - Filters for replaceable events will wait for all relays to `EOSE` (or `CLOSE`, or for the signal to be aborted) to ensure the latest event versions are retrieved.
+   * - Filters for regular events will stop as soon as the filters are fulfilled.
+   * - Events are deduplicated, sorted, and only the latest version of replaceable events is kept.
+   * - If the signal is aborted, this method will return partial results instead of throwing.
+   *
+   * To implement a custom strategy, call `.req` directly.
+   */
+  async query(
+    filters: NostrFilter[],
+    opts?: { signal?: AbortSignal; relays?: string[] },
+  ): Promise<NostrEvent[]> {
+    const map = new Map<string, NostrEvent>();
+    const events = new NSet(map);
+
+    const limit = filters.reduce(
+      (result, filter) => result + getFilterLimit(filter),
+      0,
+    );
+    if (limit === 0) return [];
+
+    try {
+      for await (const msg of this.req(filters, opts)) {
+        if (msg[0] === 'EOSE') break;
+        if (msg[0] === 'EVENT') events.add(msg[2]);
+        if (msg[0] === 'CLOSED') break;
+      }
+    } catch {
+      // Skip errors, return partial results.
+    }
+
+    // Don't sort results of search filters.
+    if (filters.some((filter) => typeof filter.search === 'string')) {
+      return [...map.values()];
+    } else {
+      return [...events];
+    }
+  }
+
+  /** Close all the relays in the pool. */
+  async close(): Promise<void> {
+    await Promise.all(
+      [...this._relays.values()].map((relay) => relay.close()),
+    );
+  }
+
+  async [Symbol.asyncDispose](): Promise<void> {
+    await this.close();
+  }
+}

package/dist/NRelay1.js

@@ -0,0 +1,318 @@
+import { getFilterLimit, matchFilters, verifyEvent as _verifyEvent } from "nostr-tools";
+import { ArrayQueue, ExponentialBackoff, WebsocketBuilder, WebsocketEvent } from "websocket-ts";
+import { Machina } from "./utils/Machina.js";
+import { NSchema as n } from "./NSchema.js";
+import { NSet } from "./NSet.js";
+class NRelay1 {
+  socket;
+  subs = /* @__PURE__ */ new Map();
+  closedByUser = false;
+  idleTimer;
+  controller = new AbortController();
+  url;
+  opts;
+  ee = new EventTarget();
+  get subscriptions() {
+    return [...this.subs.values()];
+  }
+  log(log) {
+    this.opts.log?.({ ...log, url: this.url });
+  }
+  constructor(url, opts = {}) {
+    this.url = url;
+    this.opts = opts;
+    this.socket = this.createSocket();
+    this.maybeStartIdleTimer();
+  }
+  /** Create (and open) a WebSocket connection with automatic reconnect. */
+  createSocket() {
+    const { backoff = new ExponentialBackoff(1e3) } = this.opts;
+    return new WebsocketBuilder(this.url).withBuffer(new ArrayQueue()).withBackoff(backoff === false ? void 0 : backoff).onOpen((socket) => {
+      this.log({
+        level: "debug",
+        ns: "relay.ws.state",
+        state: "open",
+        readyState: socket.readyState
+      });
+      for (const req of this.subs.values()) {
+        this.send(req);
+      }
+    }).onClose((socket) => {
+      this.log({
+        level: "debug",
+        ns: "relay.ws.state",
+        state: "close",
+        readyState: socket.readyState
+      });
+      if (!this.subs.size) {
+        this.socket.close();
+      }
+    }).onReconnect((socket) => {
+      this.log({
+        level: "debug",
+        ns: "relay.ws.state",
+        state: "reconnect",
+        readyState: socket.readyState
+      });
+    }).onRetry((socket, e) => {
+      this.log({
+        level: "warn",
+        ns: "relay.ws.retry",
+        readyState: socket.readyState,
+        backoff: e.detail.backoff
+      });
+    }).onError((socket) => {
+      this.log({
+        level: "error",
+        ns: "relay.ws.error",
+        readyState: socket.readyState
+      });
+    }).onMessage((_socket, e) => {
+      if (typeof e.data !== "string") {
+        this.close();
+        return;
+      }
+      const result = n.json().pipe(n.relayMsg()).safeParse(e.data);
+      if (result.success) {
+        this.log({
+          level: "trace",
+          ns: "relay.ws.message",
+          data: result.data
+        });
+        this.receive(result.data);
+      } else {
+        this.log({
+          level: "warn",
+          ns: "relay.ws.message",
+          error: result.error
+        });
+      }
+    }).build();
+  }
+  /** Handle a NIP-01 relay message. */
+  receive(msg) {
+    const { auth, verifyEvent = _verifyEvent } = this.opts;
+    switch (msg[0]) {
+      case "EVENT":
+        if (!verifyEvent(msg[2])) break;
+        this.ee.dispatchEvent(
+          new CustomEvent(`sub:${msg[1]}`, { detail: msg })
+        );
+        break;
+      case "EOSE":
+        this.ee.dispatchEvent(
+          new CustomEvent(`sub:${msg[1]}`, { detail: msg })
+        );
+        break;
+      case "CLOSED":
+        this.subs.delete(msg[1]);
+        this.maybeStartIdleTimer();
+        this.ee.dispatchEvent(
+          new CustomEvent(`sub:${msg[1]}`, { detail: msg })
+        );
+        this.ee.dispatchEvent(
+          new CustomEvent(`count:${msg[1]}`, { detail: msg })
+        );
+        break;
+      case "OK":
+        this.ee.dispatchEvent(new CustomEvent(`ok:${msg[1]}`, { detail: msg }));
+        break;
+      case "NOTICE":
+        this.ee.dispatchEvent(new CustomEvent("notice", { detail: msg }));
+        break;
+      case "COUNT":
+        this.ee.dispatchEvent(
+          new CustomEvent(`count:${msg[1]}`, { detail: msg })
+        );
+        break;
+      case "AUTH":
+        auth?.(msg[1]).then((event) => this.send(["AUTH", event])).catch(
+          () => {
+          }
+        );
+    }
+  }
+  /** Send a NIP-01 client message to the relay. */
+  send(msg) {
+    this.log({ level: "trace", ns: "relay.ws.send", data: msg });
+    this.wake();
+    switch (msg[0]) {
+      case "REQ":
+        this.subs.set(msg[1], msg);
+        break;
+      case "CLOSE":
+        this.subs.delete(msg[1]);
+        this.maybeStartIdleTimer();
+        break;
+      case "EVENT":
+      case "COUNT":
+        return this.socket.send(JSON.stringify(msg));
+    }
+    if (this.socket.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify(msg));
+    }
+  }
+  async *req(filters, opts = {}) {
+    const { signal } = opts;
+    const subscriptionId = crypto.randomUUID();
+    const msgs = this.on(`sub:${subscriptionId}`, signal);
+    const req = ["REQ", subscriptionId, ...filters];
+    this.send(req);
+    try {
+      for await (const msg of msgs) {
+        if (msg[0] === "EOSE") yield msg;
+        if (msg[0] === "CLOSED") break;
+        if (msg[0] === "EVENT") {
+          if (matchFilters(filters, msg[2])) {
+            yield msg;
+          } else {
+            continue;
+          }
+        }
+      }
+    } finally {
+      this.send(["CLOSE", subscriptionId]);
+    }
+  }
+  async query(filters, opts) {
+    const events = new NSet();
+    const limit = filters.reduce(
+      (result, filter) => result + getFilterLimit(filter),
+      0
+    );
+    if (limit === 0) return [];
+    for await (const msg of this.req(filters, opts)) {
+      if (msg[0] === "EOSE") break;
+      if (msg[0] === "EVENT") events.add(msg[2]);
+      if (msg[0] === "CLOSED") throw new Error("Subscription closed");
+      if (events.size >= limit) {
+        break;
+      }
+    }
+    return [...events];
+  }
+  async event(event, opts) {
+    const result = this.once(`ok:${event.id}`, opts?.signal);
+    try {
+      this.send(["EVENT", event]);
+    } catch (e) {
+      result.catch(() => {
+      });
+      throw e;
+    }
+    const [, , ok, reason] = await result;
+    if (!ok) {
+      throw new Error(reason);
+    }
+  }
+  async count(filters, opts) {
+    const subscriptionId = crypto.randomUUID();
+    const result = this.once(`count:${subscriptionId}`, opts?.signal);
+    try {
+      this.send(["COUNT", subscriptionId, ...filters]);
+    } catch (e) {
+      result.catch(() => {
+      });
+      throw e;
+    }
+    const msg = await result;
+    switch (msg[0]) {
+      case "CLOSED":
+        throw new Error("Subscription closed");
+      case "COUNT": {
+        const [, , count] = msg;
+        return count;
+      }
+    }
+    throw new Error("Count ended -- this should never happen");
+  }
+  /** Get a stream of EE events. */
+  async *on(key, signal) {
+    const _signal = signal ? AbortSignal.any([this.controller.signal, signal]) : this.controller.signal;
+    if (_signal.aborted) throw this.abortError();
+    const machina = new Machina(_signal);
+    const onMsg = (e) => machina.push(e.detail);
+    this.ee.addEventListener(key, onMsg);
+    try {
+      for await (const msg of machina) {
+        yield msg;
+      }
+    } finally {
+      this.ee.removeEventListener(key, onMsg);
+    }
+  }
+  /** Wait for a single EE event. */
+  async once(key, signal) {
+    for await (const msg of this.on(key, signal)) {
+      return msg;
+    }
+    throw new Error("Unreachable");
+  }
+  abortError() {
+    return new DOMException("The signal has been aborted", "AbortError");
+  }
+  /** Start the idle time if applicable. */
+  maybeStartIdleTimer() {
+    const { idleTimeout = 3e4 } = this.opts;
+    if (idleTimeout === false) return;
+    if (this.idleTimer) return;
+    if (this.subs.size) return;
+    if (this.closedByUser) return;
+    this.log({
+      level: "debug",
+      ns: "relay.idletimer",
+      state: "running",
+      timeout: idleTimeout
+    });
+    this.idleTimer = setTimeout(() => {
+      this.log({
+        level: "debug",
+        ns: "relay.idletimer",
+        state: "aborted",
+        timeout: idleTimeout
+      });
+      this.socket.close();
+    }, idleTimeout);
+  }
+  /** Stop the idle timer. */
+  stopIdleTimer() {
+    this.log({ level: "debug", ns: "relay.idletimer", state: "stopped" });
+    clearTimeout(this.idleTimer);
+    this.idleTimer = void 0;
+  }
+  /** Make a new WebSocket, but only if it was closed by an idle timeout. */
+  wake() {
+    this.stopIdleTimer();
+    if (!this.closedByUser && this.socket.closedByUser) {
+      this.log({ level: "debug", ns: "relay.wake", state: "awoken" });
+      this.socket = this.createSocket();
+    } else if (this.closedByUser || this.socket.closedByUser) {
+      this.log({ level: "debug", ns: "relay.wake", state: "closed" });
+    } else {
+      this.log({ level: "debug", ns: "relay.wake", state: "awake" });
+    }
+  }
+  /**
+   * Close the relay connection and prevent it from reconnecting.
+   * After this you should dispose of the `NRelay1` instance and create a new one to connect again.
+   */
+  async close() {
+    this.closedByUser = true;
+    this.socket.close();
+    this.stopIdleTimer();
+    this.controller.abort();
+    if (this.socket.readyState !== WebSocket.CLOSED) {
+      await new Promise((resolve) => {
+        this.socket.addEventListener(WebsocketEvent.close, resolve, {
+          once: true
+        });
+      });
+    }
+  }
+  async [Symbol.asyncDispose]() {
+    await this.close();
+  }
+}
+export {
+  NRelay1
+};