@nostrify/nostrify 0.48.2 → 0.48.3

package/dist/NBrowserSigner.ts

@@ -1,100 +0,0 @@
-import type { NostrEvent, NostrSigner } from '@nostrify/types';
-
-/**
- * NIP-07-compatible signer that proxies to browser extension, normalizing behavior across different implementations.
- *
- * This signer delegates all operations to the browser's `window.nostr` object,
- * which is typically provided by browser extensions like Alby, nos2x, etc.
- *
- * Usage:
- *
- * ```ts
- * const signer = new NBrowserSigner();
- * const pubkey = await signer.getPublicKey();
- * const event = await signer.signEvent({ kind: 1, content: 'Hello, world!', tags: [], created_at: 0 });
- * ```
- */
-export class NBrowserSigner implements NostrSigner {
-  private get nostr(): NostrSigner {
-    const nostr = (globalThis as { nostr?: NostrSigner }).nostr;
-    if (!nostr) {
-      throw new Error('Browser extension not available');
-    }
-    return nostr;
-  }
-
-  async getPublicKey(): Promise<string> {
-    const pubkey = await this.nostr.getPublicKey();
-    if (typeof pubkey !== 'string') {
-      throw new Error(`Nostr public key retrieval failed: expected string, got ${JSON.stringify(pubkey)}`);
-    }
-    return pubkey;
-  }
-
-  async signEvent(event: Omit<NostrEvent, 'id' | 'pubkey' | 'sig'>): Promise<NostrEvent> {
-    const signed = await this.nostr.signEvent(event);
-    if (typeof signed !== 'object' || !signed.id || !signed.pubkey || !signed.sig) {
-      throw new Error(
-        `Nostr event signing failed: expected object with id, pubkey, and sig, got ${JSON.stringify(signed)}`,
-      );
-    }
-    return signed;
-  }
-
-  async getRelays(): Promise<Record<string, { read: boolean; write: boolean }>> {
-    if (!this.nostr.getRelays) {
-      return {};
-    }
-    const relays = await this.nostr.getRelays();
-    if (typeof relays !== 'object' || relays === null) {
-      throw new Error(`Nostr getRelays failed: expected object, got ${JSON.stringify(relays)}`);
-    }
-    return this.nostr.getRelays();
-  }
-
-  get nip04(): NostrSigner['nip04'] {
-    const nostr = this.nostr;
-    if (!nostr.nip04) {
-      return undefined;
-    }
-    return {
-      encrypt: async (pubkey: string, plaintext: string): Promise<string> => {
-        const encrypted = await nostr.nip04!.encrypt(pubkey, plaintext);
-        if (typeof encrypted !== 'string') {
-          throw new Error(`NIP-04 encryption failed: expected string result, got ${JSON.stringify(encrypted)}`);
-        }
-        return encrypted;
-      },
-      decrypt: async (pubkey: string, ciphertext: string): Promise<string> => {
-        const decrypted = await nostr.nip04!.decrypt(pubkey, ciphertext);
-        if (typeof decrypted !== 'string') {
-          throw new Error(`NIP-04 decryption failed: expected string result, got ${JSON.stringify(decrypted)}`);
-        }
-        return decrypted;
-      },
-    };
-  }
-
-  get nip44(): NostrSigner['nip44'] {
-    const nostr = this.nostr;
-    if (!nostr.nip44) {
-      return undefined;
-    }
-    return {
-      encrypt: async (pubkey: string, plaintext: string): Promise<string> => {
-        const encrypted = await nostr.nip44!.encrypt(pubkey, plaintext);
-        if (typeof encrypted !== 'string') {
-          throw new Error(`NIP-44 encryption failed: expected string result, got ${JSON.stringify(encrypted)}`);
-        }
-        return encrypted;
-      },
-      decrypt: async (pubkey: string, ciphertext: string): Promise<string> => {
-        const decrypted = await nostr.nip44!.decrypt(pubkey, ciphertext);
-        if (typeof decrypted !== 'string') {
-          throw new Error(`NIP-44 decryption failed: expected string result, got ${JSON.stringify(decrypted)}`);
-        }
-        return decrypted;
-      },
-    };
-  }
-}

package/dist/NCache.ts

@@ -1,73 +0,0 @@
-// deno-lint-ignore-file require-await
-
-import type { NostrEvent, NostrFilter, NostrRelayCOUNT, NStore } from '@nostrify/types';
-import { LRUCache } from 'lru-cache';
-import { matchFilters } from 'nostr-tools';
-
-import { NSet } from './NSet.ts';
-
-/**
- * Nostr LRU cache based on [`npm:lru-cache`](https://www.npmjs.com/package/lru-cache).
- * It implements both `NStore` and `NSet` interfaces.
- *
- * ```ts
- * // Accepts the options of `npm:lru-cache`:
- * const cache = new NCache({ max: 1000 });
- *
- * // Events can be added like a regular `Set`:
- * cache.add(event1);
- * cache.add(event2);
- *
- * // Can be queried like `NStore`:
- * const events = await cache.query([{ kinds: [1] }]);
- *
- * // Can be iterated like `NSet`:
- * for (const event of cache) {
- *  console.log(event);
- * }
- * ```
- */
-class NCache extends NSet implements NStore {
-  constructor(
-    ...args: ConstructorParameters<typeof LRUCache<string, NostrEvent>>
-  ) {
-    super(new LRUCache<string, NostrEvent>(...args) as Map<string, NostrEvent>);
-  }
-
-  async event(event: NostrEvent): Promise<void> {
-    this.add(event);
-  }
-
-  async query(filters: NostrFilter[]): Promise<NostrEvent[]> {
-    const events: NostrEvent[] = [];
-
-    for (const event of this) {
-      if (matchFilters(filters, event)) {
-        this.cache.get(event.id);
-        events.push(event);
-      }
-    }
-
-    return events;
-  }
-
-  async remove(filters: NostrFilter[]): Promise<void> {
-    for (const event of this) {
-      if (matchFilters(filters, event)) {
-        this.delete(event);
-      }
-    }
-  }
-
-  async count(filters: NostrFilter[]): Promise<NostrRelayCOUNT[2]> {
-    const events = await this.query(filters);
-    return {
-      count: events.length,
-      approximate: false,
-    };
-  }
-
-  override [Symbol.toStringTag] = 'NCache';
-}
-
-export { NCache };

package/dist/NConnectSigner.ts

@@ -1,188 +0,0 @@
-// deno-lint-ignore-file require-await
-
-import { z } from 'zod';
-
-import type { NostrConnectRequest, NostrConnectResponse, NostrEvent, NostrSigner, NRelay } from '@nostrify/types';
-
-import { NSchema as n } from './NSchema.ts';
-
-/** Options for `NConnectSigner`. */
-export interface NConnectSignerOpts {
-  /** Relay to facilitate connection. */
-  relay: NRelay;
-  /** Remote pubkey to sign as. */
-  pubkey: string;
-  /** Local signer to sign the request events. */
-  signer: NostrSigner;
-  /** Timeout for requests. */
-  timeout?: number;
-  /** Encryption to use when encrypting local messages. Decryption is automatic. */
-  encryption?: 'nip04' | 'nip44';
-}
-
-/** [NIP-46](https://github.com/nostr-protocol/nips/blob/master/46.md) remote signer through a relay. */
-export class NConnectSigner implements NostrSigner {
-  private relay: NRelay;
-  private pubkey: string;
-  private signer: NostrSigner;
-  private timeout?: number;
-  private encryption: 'nip04' | 'nip44';
-
-  constructor(
-    { relay, pubkey, signer, timeout, encryption = 'nip44' }: NConnectSignerOpts,
-  ) {
-    this.relay = relay;
-    this.pubkey = pubkey;
-    this.signer = signer;
-    this.timeout = timeout;
-    this.encryption = encryption;
-  }
-
-  async getPublicKey(): Promise<string> {
-    return this.cmd('get_public_key', []);
-  }
-
-  async signEvent(
-    event: Omit<NostrEvent, 'id' | 'pubkey' | 'sig'>,
-  ): Promise<NostrEvent> {
-    const result = await this.cmd('sign_event', [JSON.stringify(event)]);
-    return n.json().pipe(n.event()).parse(result);
-  }
-
-  async getRelays(): Promise<
-    Record<string, { read: boolean; write: boolean }>
-  > {
-    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) as Record<string, { read: boolean; write: boolean }>; // FIXME: hack!
-  }
-
-  readonly nip04 = {
-    encrypt: async (pubkey: string, plaintext: string): Promise<string> => {
-      return this.cmd('nip04_encrypt', [pubkey, plaintext]);
-    },
-
-    decrypt: async (pubkey: string, ciphertext: string): Promise<string> => {
-      return this.cmd('nip04_decrypt', [pubkey, ciphertext]);
-    },
-  };
-
-  readonly nip44 = {
-    encrypt: async (pubkey: string, plaintext: string): Promise<string> => {
-      return this.cmd('nip44_encrypt', [pubkey, plaintext]);
-    },
-
-    decrypt: async (pubkey: string, ciphertext: string): Promise<string> => {
-      return this.cmd('nip44_decrypt', [pubkey, ciphertext]);
-    },
-  };
-
-  /** Send a `connect` command to the relay. It should respond with `ack`. */
-  async connect(secret?: string): Promise<string> {
-    const params: string[] = [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(): Promise<string> {
-    return this.cmd('ping', []);
-  }
-
-  /** High-level RPC method. Returns the string result, or throws on error. */
-  private async cmd(method: string, params: string[]): Promise<string> {
-    const signal = typeof this.timeout === 'number' ? AbortSignal.timeout(this.timeout) : undefined;
-
-    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. */
-  private async send(
-    request: NostrConnectRequest,
-    opts: { signal?: AbortSignal } = {},
-  ): Promise<NostrConnectResponse> {
-    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() / 1000),
-      tags: [['p', this.pubkey]],
-    });
-
-    const local = await this.signer.getPublicKey();
-
-    const req = this.relay.req(
-      [{ kinds: [24133], authors: [this.pubkey], '#p': [local] }],
-      { signal },
-    );
-
-    // Ensure the REQ is opened before sending the EVENT
-    const promise = new Promise<NostrConnectResponse>((resolve, reject) => {
-      (async () => {
-        try {
-          for await (const msg of req) {
-            if (msg[0] === 'CLOSED') throw new Error('Subscription closed');
-            if (msg[0] === 'EVENT') {
-              const event = msg[2];
-              const decrypted = await this.decrypt(this.pubkey, event.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. */
-  private async encrypt(pubkey: string, plaintext: string): Promise<string> {
-    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. */
-  private async decrypt(pubkey: string, ciphertext: string): Promise<string> {
-    switch (this.encryption) {
-      case 'nip04':
-        return this.signer.nip04!.decrypt(pubkey, ciphertext);
-      case 'nip44':
-        return this.signer.nip44!.decrypt(pubkey, ciphertext);
-    }
-  }
-}

package/dist/NIP05.ts

@@ -1,51 +0,0 @@
-import type { NProfilePointer } from "@nostrify/types";
-
-import { NSchema as n, z } from "./NSchema.ts";
-
-interface LookupOpts {
-  fetch?: typeof fetch;
-  signal?: AbortSignal;
-}
-
-export class NIP05 {
-  /** NIP-05 value regex. */
-  static regex(): RegExp {
-    return /^(?:([\w.+-]+)@)?([\w.-]+)$/;
-  }
-
-  /** Nostr pubkey with relays object. */
-  private static profilePointerSchema(): z.ZodType<NProfilePointer> {
-    return z.object({
-      pubkey: n.id(),
-      relays: n.relayUrl().array().optional(),
-    }) as z.ZodType<NProfilePointer>;
-  }
-
-  /** Resolve NIP-05 name to a profile pointer. */
-  static async lookup(
-    nip05: string,
-    opts?: LookupOpts,
-  ): Promise<NProfilePointer> {
-    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}`);
-    }
-  }
-}

package/dist/NIP50.ts

@@ -1,24 +0,0 @@
-type SearchToken = string | { key: string; value: string };
-
-/** [NIP-50](https://github.com/nostr-protocol/nips/blob/master/50.md) search functionality. */
-export class NIP50 {
-  static parseInput(input: string): SearchToken[] {
-    const regex = /(\B-\w+:[^\s"]+)|(\b\w+:[^\s"]+)|(".*?")|(\S+)/g;
-
-    const tokens: SearchToken[] = [];
-    let match: RegExpExecArray | null;
-
-    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;
-  }
-}

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);
-  }
-}