@nostrify/nostrify 0.46.8 → 0.46.9

package/dist/NCache.js

@@ -1,39 +0,0 @@
-import { LRUCache } from "lru-cache";
-import { matchFilters } from "nostr-tools";
-import { NSet } from "./NSet.js";
-class NCache extends NSet {
-  constructor(...args) {
-    super(new LRUCache(...args));
-  }
-  async event(event) {
-    this.add(event);
-  }
-  async query(filters) {
-    const events = [];
-    for (const event of this) {
-      if (matchFilters(filters, event)) {
-        this.cache.get(event.id);
-        events.push(event);
-      }
-    }
-    return events;
-  }
-  async remove(filters) {
-    for (const event of this) {
-      if (matchFilters(filters, event)) {
-        this.delete(event);
-      }
-    }
-  }
-  async count(filters) {
-    const events = await this.query(filters);
-    return {
-      count: events.length,
-      approximate: false
-    };
-  }
-  [Symbol.toStringTag] = "NCache";
-}
-export {
-  NCache
-};

package/dist/NConnectSigner.js

@@ -1,132 +0,0 @@
-import { z } from "zod";
-import { NSchema as n } from "./NSchema.js";
-class NConnectSigner {
-  relay;
-  pubkey;
-  signer;
-  timeout;
-  encryption;
-  constructor({ relay, pubkey, signer, timeout, encryption = "nip44" }) {
-    this.relay = relay;
-    this.pubkey = pubkey;
-    this.signer = signer;
-    this.timeout = timeout;
-    this.encryption = encryption;
-  }
-  async getPublicKey() {
-    return this.cmd("get_public_key", []);
-  }
-  async signEvent(event) {
-    const result = await this.cmd("sign_event", [JSON.stringify(event)]);
-    return n.json().pipe(n.event()).parse(result);
-  }
-  async getRelays() {
-    const result = await this.cmd("get_relays", []);
-    return n.json().pipe(
-      z.record(
-        z.string(),
-        z.object({ read: z.boolean(), write: z.boolean() })
-      )
-    ).parse(result);
-  }
-  nip04 = {
-    encrypt: async (pubkey, plaintext) => {
-      return this.cmd("nip04_encrypt", [pubkey, plaintext]);
-    },
-    decrypt: async (pubkey, ciphertext) => {
-      return this.cmd("nip04_decrypt", [pubkey, ciphertext]);
-    }
-  };
-  nip44 = {
-    encrypt: async (pubkey, plaintext) => {
-      return this.cmd("nip44_encrypt", [pubkey, plaintext]);
-    },
-    decrypt: async (pubkey, ciphertext) => {
-      return this.cmd("nip44_decrypt", [pubkey, ciphertext]);
-    }
-  };
-  /** Send a `connect` command to the relay. It should respond with `ack`. */
-  async connect(secret) {
-    const params = [this.pubkey];
-    if (secret) {
-      params.push(secret);
-    }
-    return this.cmd("connect", params);
-  }
-  /** Send a `ping` command to the signer. It should respond with `pong`. */
-  async ping() {
-    return this.cmd("ping", []);
-  }
-  /** High-level RPC method. Returns the string result, or throws on error. */
-  async cmd(method, params) {
-    const signal = typeof this.timeout === "number" ? AbortSignal.timeout(this.timeout) : void 0;
-    const { result, error } = await this.send(
-      { id: crypto.randomUUID(), method, params },
-      { signal }
-    );
-    if (error) {
-      throw new Error(error);
-    }
-    return result;
-  }
-  /** Low-level send method. Deals directly with connect request/response. */
-  async send(request, opts = {}) {
-    const { signal } = opts;
-    const event = await this.signer.signEvent({
-      kind: 24133,
-      content: await this.encrypt(this.pubkey, JSON.stringify(request)),
-      created_at: Math.floor(Date.now() / 1e3),
-      tags: [["p", this.pubkey]]
-    });
-    const local = await this.signer.getPublicKey();
-    const req = this.relay.req(
-      [{ kinds: [24133], authors: [this.pubkey], "#p": [local] }],
-      { signal }
-    );
-    const promise = new Promise((resolve, reject) => {
-      (async () => {
-        try {
-          for await (const msg of req) {
-            if (msg[0] === "CLOSED") throw new Error("Subscription closed");
-            if (msg[0] === "EVENT") {
-              const event2 = msg[2];
-              const decrypted = await this.decrypt(this.pubkey, event2.content);
-              const response = n.json().pipe(n.connectResponse()).parse(
-                decrypted
-              );
-              if (response.id === request.id) {
-                resolve(response);
-                return;
-              }
-            }
-          }
-        } catch (error) {
-          reject(error);
-        }
-      })();
-    });
-    await this.relay.event(event, { signal });
-    return promise;
-  }
-  /** Local encrypt depending on settings. */
-  async encrypt(pubkey, plaintext) {
-    switch (this.encryption) {
-      case "nip04":
-        return this.signer.nip04.encrypt(pubkey, plaintext);
-      case "nip44":
-        return this.signer.nip44.encrypt(pubkey, plaintext);
-    }
-  }
-  /** Local decrypt depending on settings. */
-  async decrypt(pubkey, ciphertext) {
-    switch (this.encryption) {
-      case "nip04":
-        return this.signer.nip04.decrypt(pubkey, ciphertext);
-      case "nip44":
-        return this.signer.nip44.decrypt(pubkey, ciphertext);
-    }
-  }
-}
-export {
-  NConnectSigner
-};

package/dist/NIP05.js

@@ -1,35 +0,0 @@
-import { NSchema as n, z } from "./NSchema.js";
-class NIP05 {
-  /** NIP-05 value regex. */
-  static regex() {
-    return /^(?:([\w.+-]+)@)?([\w.-]+)$/;
-  }
-  /** Nostr pubkey with relays object. */
-  static profilePointerSchema() {
-    return z.object({
-      pubkey: n.id(),
-      relays: n.relayUrl().array().optional()
-    });
-  }
-  /** Resolve NIP-05 name to a profile pointer. */
-  static async lookup(nip05, opts) {
-    const { fetch = globalThis.fetch.bind(globalThis), signal } = opts ?? {};
-    const match = nip05.match(NIP05.regex());
-    if (!match) throw new Error(`NIP-05: invalid name ${nip05}`);
-    const [_, name = "_", domain] = match;
-    const url = new URL("/.well-known/nostr.json", `https://${domain}/`);
-    url.searchParams.set("name", name);
-    const response = await fetch(url, { signal });
-    const json = await response.json();
-    try {
-      const pubkey = json.names[name];
-      const relays = json.relays?.[pubkey];
-      return NIP05.profilePointerSchema().parse({ pubkey, relays });
-    } catch {
-      throw new Error(`NIP-05: no match for ${nip05}`);
-    }
-  }
-}
-export {
-  NIP05
-};

package/dist/NIP50.js

@@ -1,21 +0,0 @@
-class NIP50 {
-  static parseInput(input) {
-    const regex = /(\B-\w+:[^\s"]+)|(\b\w+:[^\s"]+)|(".*?")|(\S+)/g;
-    const tokens = [];
-    let match;
-    while ((match = regex.exec(input)) !== null) {
-      if (match[1] || match[2]) {
-        const [key, ...values] = (match[1] || match[2]).split(":");
-        tokens.push({ key, value: values.join(":") });
-      } else if (match[3]) {
-        tokens.push(match[3].replace(/"/g, ""));
-      } else if (match[4]) {
-        tokens.push(match[4]);
-      }
-    }
-    return tokens;
-  }
-}
-export {
-  NIP50
-};

package/dist/NIP98.js

@@ -1,74 +0,0 @@
-import { encodeHex } from "@std/encoding/hex";
-import { verifyEvent as _verifyEvent } from "nostr-tools";
-import { N64 } from "./utils/N64.js";
-class NIP98 {
-  /** Generate an auth event template from a Request. */
-  static async template(request, opts) {
-    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", encodeHex(digest)]);
-    }
-    return {
-      kind: 27235,
-      content: "",
-      tags,
-      created_at: Math.floor(Date.now() / 1e3)
-    };
-  }
-  /** Compare the auth event with the request, throwing a human-readable error if validation fails. */
-  static async verify(request, opts) {
-    const {
-      maxAge = 6e4,
-      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");
-    }
-    const event = N64.decodeEvent(token);
-    if (!verifyEvent(event)) {
-      throw new Error("Event signature is invalid");
-    }
-    const age = Date.now() - event.created_at * 1e3;
-    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 !== void 0) {
-      const buffer = await request.clone().arrayBuffer();
-      const digest = await crypto.subtle.digest("SHA-256", buffer);
-      if (encodeHex(digest) !== payload) {
-        throw new Error("Event payload does not match request body");
-      }
-    }
-    return event;
-  }
-}
-export {
-  NIP98
-};

package/dist/NKinds.js

@@ -1,25 +0,0 @@
-class NKinds {
-  /** Events are **regular**, which means they're all expected to be stored by relays. */
-  static regular(kind) {
-    return 1e3 <= kind && kind < 1e4 || [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) {
-    return 1e4 <= kind && kind < 2e4 || [0, 3].includes(kind);
-  }
-  /** Events are **ephemeral**, which means they are not expected to be stored by relays. */
-  static ephemeral(kind) {
-    return 2e4 <= kind && kind < 3e4;
-  }
-  /** 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) {
-    return 3e4 <= kind && kind < 4e4;
-  }
-  /** @deprecated Use `NKinds.addressable()` instead. */
-  static parameterizedReplaceable(kind) {
-    return NKinds.addressable(kind);
-  }
-}
-export {
-  NKinds
-};

package/dist/NPool.js

@@ -1,154 +0,0 @@
-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
-};