@nostrify/nostrify 0.48.1 → 0.48.3

package/dist/NIP98.ts

@@ -1,111 +0,0 @@
-import type { NostrEvent } from "@nostrify/types";
-import { toHex } from "@smithy/util-hex-encoding";
-import { verifyEvent as _verifyEvent } from "nostr-tools";
-
-import { N64 } from "./utils/N64.ts";
-
-/** [NIP-98](https://github.com/nostr-protocol/nips/blob/master/98.md) HTTP auth. */
-export class NIP98 {
-  /** Generate an auth event template from a Request. */
-  static async template(
-    request: Request,
-    opts?: { validatePayload?: boolean },
-  ): Promise<Omit<NostrEvent, "id" | "pubkey" | "sig">> {
-    const {
-      validatePayload = ["POST", "PUT", "PATCH"].includes(request.method),
-    } = opts ?? {};
-    const { method, url } = request;
-
-    const tags = [
-      ["method", method],
-      ["u", url],
-    ];
-
-    if (validatePayload) {
-      const buffer = await request.clone().arrayBuffer();
-      const digest = await crypto.subtle.digest("SHA-256", buffer);
-
-      tags.push(["payload", toHex(new Uint8Array(digest))]);
-    }
-
-    return {
-      kind: 27235,
-      content: "",
-      tags,
-      created_at: Math.floor(Date.now() / 1000),
-    };
-  }
-
-  /** Compare the auth event with the request, throwing a human-readable error if validation fails. */
-  static async verify(
-    request: Request,
-    opts?: {
-      maxAge?: number;
-      validatePayload?: boolean;
-      verifyEvent?: (event: NostrEvent) => boolean;
-    },
-  ): Promise<NostrEvent> {
-    const {
-      maxAge = 60_000,
-      validatePayload = ["POST", "PUT", "PATCH"].includes(request.method),
-      verifyEvent = _verifyEvent,
-    } = opts ?? {};
-
-    const header = request.headers.get("authorization");
-    if (!header) {
-      throw new Error("Missing Nostr authorization header");
-    }
-
-    const token = header.match(/^Nostr (.+)$/)?.[1];
-    if (!token) {
-      throw new Error("Missing Nostr authorization token");
-    }
-
-    let event: NostrEvent;
-    try {
-      event = N64.decodeEvent(token);
-    } catch (e) {
-      if (
-        e instanceof TypeError &&
-        e.message.includes("Incorrect padding on base64")
-      ) {
-        throw new Error("Invalid token");
-      } else {
-        throw e;
-      }
-    }
-
-    if (!verifyEvent(event)) {
-      throw new Error("Event signature is invalid");
-    }
-
-    const age = Date.now() - (event.created_at * 1_000);
-    const u = event.tags.find(([name]) => name === "u")?.[1];
-    const method = event.tags.find(([name]) => name === "method")?.[1];
-    const payload = event.tags.find(([name]) => name === "payload")?.[1];
-
-    if (event.kind !== 27235) {
-      throw new Error("Event must be kind 27235");
-    }
-    if (u !== request.url) {
-      throw new Error("Event URL does not match request URL");
-    }
-    if (method !== request.method) {
-      throw new Error("Event method does not match HTTP request method");
-    }
-    if (age >= maxAge) {
-      throw new Error("Event expired");
-    }
-    if (validatePayload && payload !== undefined) {
-      const buffer = await request.clone().arrayBuffer();
-      const digest = await crypto.subtle.digest("SHA-256", buffer);
-      const hexed = toHex(new Uint8Array(digest));
-
-      if (hexed !== payload) {
-        throw new Error("Event payload does not match request body");
-      }
-    }
-
-    return event;
-  }
-}

package/dist/NIP98Client.ts

@@ -1,36 +0,0 @@
-import { type NostrSigner } from '@nostrify/types';
-import { NIP98 } from './NIP98.ts';
-import { N64 } from './utils/N64.ts';
-
-export interface NIP98ClientOpts {
-  signer: NostrSigner;
-  fetch?: typeof globalThis.fetch;
-}
-
-/** Wraps a fetch request with NIP98 authentication */
-export class NIP98Client {
-  private signer: NostrSigner;
-  private customFetch: typeof globalThis.fetch;
-
-  constructor(opts: NIP98ClientOpts) {
-    this.signer = opts.signer;
-    this.customFetch = opts.fetch ?? globalThis.fetch.bind(globalThis);
-  }
-
-  /** Performs a fetch request with NIP98 authentication */
-  async fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> {
-    // Normalize to a Request object
-    const request = new Request(input, init);
-
-    // Create the NIP98 token
-    const template = await NIP98.template(request);
-    const event = await this.signer.signEvent(template);
-    const token = N64.encodeEvent(event);
-
-    // Add the Authorization header
-    request.headers.set('Authorization', `Nostr ${token}`);
-
-    // Call the custom fetch function
-    return this.customFetch(request);
-  }
-}

package/dist/NKinds.ts

@@ -1,26 +0,0 @@
-export class NKinds {
-  /** Events are **regular**, which means they're all expected to be stored by relays. */
-  static regular(kind: number): boolean {
-    return (1000 <= kind && kind < 10000) || [1, 2, 4, 5, 6, 7, 8, 16, 40, 41, 42, 43, 44].includes(kind);
-  }
-
-  /** Events are **replaceable**, which means that, for each combination of `pubkey` and `kind`, only the latest event is expected to (SHOULD) be stored by relays, older versions are expected to be discarded. */
-  static replaceable(kind: number): boolean {
-    return (10000 <= kind && kind < 20000) || [0, 3].includes(kind);
-  }
-
-  /** Events are **ephemeral**, which means they are not expected to be stored by relays. */
-  static ephemeral(kind: number): boolean {
-    return 20000 <= kind && kind < 30000;
-  }
-
-  /** Events are **addressable**, which means that, for each combination of `pubkey`, `kind` and the `d` tag, only the latest event is expected to be stored by relays, older versions are expected to be discarded. */
-  static addressable(kind: number): boolean {
-    return 30000 <= kind && kind < 40000;
-  }
-
-  /** @deprecated Use `NKinds.addressable()` instead. */
-  static parameterizedReplaceable(kind: number): boolean {
-    return NKinds.addressable(kind);
-  }
-}

package/dist/NPool.ts

@@ -1,243 +0,0 @@
-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();
-  }
-}