@nostrify/nostrify 0.48.2 → 0.48.3

package/dist/NSchema.ts

@@ -1,291 +0,0 @@
-import { z } from "zod";
-
-import type {
-  NostrClientAUTH,
-  NostrClientCLOSE,
-  NostrClientCOUNT,
-  NostrClientEVENT,
-  NostrClientMsg,
-  NostrClientREQ,
-  NostrConnectRequest,
-  NostrConnectResponse,
-  NostrEvent,
-  NostrFilter,
-  NostrMetadata,
-  NostrRelayAUTH,
-  NostrRelayCLOSED,
-  NostrRelayCOUNT,
-  NostrRelayEOSE,
-  NostrRelayEVENT,
-  NostrRelayMsg,
-  NostrRelayNOTICE,
-  NostrRelayOK,
-} from "@nostrify/types";
-
-/**
- * A suite of [zod](https://github.com/colinhacks/zod) schemas for Nostr.
- *
- * ```ts
- * import { NSchema as n } from '@nostrify/nostrify';
- *
- * const event: NostrEvent = n.event().parse(eventData);
- * const metadata: NostrMetadata = n.json().pipe(n.metadata()).parse(event.content);
- * const msg: NostrRelayMsg = n.relayMsg().parse(e.data);
- * const nsec: `nsec1${string}` = n.bech32('nsec').parse(token);
- * ```
- */
-class NSchema {
-  /** Schema to validate Nostr hex IDs such as event IDs and pubkeys. */
-  static id(): z.ZodString {
-    return z.string().regex(/^[0-9a-f]{64}$/);
-  }
-
-  /** Nostr event schema. */
-  static event(): z.ZodType<NostrEvent> {
-    return z.object({
-      id: NSchema.id(),
-      kind: z.number().int().nonnegative(),
-      pubkey: NSchema.id(),
-      tags: z.string().array().array(),
-      content: z.string(),
-      created_at: z.number().int().nonnegative(),
-      sig: z.string(),
-    }).required({
-      id: true,
-      kind: true,
-      pubkey: true,
-      tags: true,
-      content: true,
-      created_at: true,
-      sig: true,
-    }) as z.ZodType<NostrEvent>;
-  }
-
-  /** Nostr filter schema. */
-  static filter(): z.ZodType<NostrFilter> {
-    return z.object({
-      kinds: z.number().int().nonnegative().array().optional(),
-      ids: NSchema.id().array().optional(),
-      authors: NSchema.id().array().optional(),
-      since: z.number().int().nonnegative().optional(),
-      until: z.number().int().nonnegative().optional(),
-      limit: z.number().int().nonnegative().optional(),
-      search: z.string().optional(),
-    })
-      .passthrough()
-      .transform((value) => {
-        const keys = [
-          "kinds",
-          "ids",
-          "authors",
-          "since",
-          "until",
-          "limit",
-          "search",
-        ];
-        return Object.entries(value).reduce((acc, [key, val]) => {
-          if (keys.includes(key) || key.startsWith("#")) {
-            acc[key] = val;
-          }
-          return acc;
-        }, {} as Record<string, unknown>) as NostrFilter;
-      }) as z.ZodType<NostrFilter>;
-  }
-
-  /**
-   * Bech32 string.
-   * @see https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki#bech32
-   */
-  static bech32<P extends string>(prefix?: P): z.ZodType<`${P}1${string}`> {
-    return z
-      .string()
-      .regex(/^[\x21-\x7E]{1,83}1[023456789acdefghjklmnpqrstuvwxyz]{6,}$/)
-      .refine((value) =>
-        prefix ? value.startsWith(`${prefix}1`) : true
-      ) as z.ZodType<`${P}1${string}`>;
-  }
-
-  /** WebSocket URL starting with `ws://` or `wss://`. */
-  static relayUrl(): z.ZodType<`ws://${string}` | `wss://${string}`> {
-    return z
-      .string()
-      .url()
-      .regex(/^wss?:\/\//) as z.ZodType<`ws://${string}` | `wss://${string}`>;
-  }
-
-  /** NIP-01 `EVENT` message from client to relay. */
-  static clientEVENT(): z.ZodType<NostrClientEVENT> {
-    return z.tuple([
-      z.literal("EVENT"),
-      NSchema.event(),
-    ]) as unknown as z.ZodType<
-      NostrClientEVENT
-    >;
-  }
-
-  /** NIP-01 `REQ` message from client to relay. */
-  static clientREQ(): z.ZodType<NostrClientREQ> {
-    return z.tuple([z.literal("REQ"), z.string()]).rest(NSchema.filter());
-  }
-
-  /** NIP-45 `COUNT` message from client to relay. */
-  static clientCOUNT(): z.ZodType<NostrClientCOUNT> {
-    return z.tuple([z.literal("COUNT"), z.string()]).rest(NSchema.filter());
-  }
-
-  /** NIP-01 `CLOSE` message from client to relay. */
-  static clientCLOSE(): z.ZodType<NostrClientCLOSE> {
-    return z.tuple([z.literal("CLOSE"), z.string()]) as unknown as z.ZodType<
-      NostrClientCLOSE
-    >;
-  }
-
-  /** NIP-42 `AUTH` message from client to relay. */
-  static clientAUTH(): z.ZodType<NostrClientAUTH> {
-    return z.tuple([
-      z.literal("AUTH"),
-      NSchema.event(),
-    ]) as unknown as z.ZodType<
-      NostrClientAUTH
-    >;
-  }
-
-  /** NIP-01 message from client to relay. */
-  static clientMsg(): z.ZodType<NostrClientMsg> {
-    return z.union([
-      NSchema.clientEVENT(),
-      NSchema.clientREQ(),
-      NSchema.clientCOUNT(),
-      NSchema.clientCLOSE(),
-      NSchema.clientAUTH(),
-    ]) as z.ZodType<NostrClientMsg>;
-  }
-
-  /** NIP-01 `EVENT` message from relay to client. */
-  static relayEVENT(): z.ZodType<NostrRelayEVENT> {
-    return z.tuple([
-      z.literal("EVENT"),
-      z.string(),
-      NSchema.event(),
-    ]) as unknown as z.ZodType<NostrRelayEVENT>;
-  }
-
-  /** NIP-01 `OK` message from relay to client. */
-  static relayOK(): z.ZodType<NostrRelayOK> {
-    return z.tuple([
-      z.literal("OK"),
-      NSchema.id(),
-      z.boolean(),
-      z.string(),
-    ]) as unknown as z.ZodType<NostrRelayOK>;
-  }
-
-  /** NIP-01 `EOSE` message from relay to client. */
-  static relayEOSE(): z.ZodType<NostrRelayEOSE> {
-    return z.tuple([z.literal("EOSE"), z.string()]) as unknown as z.ZodType<
-      NostrRelayEOSE
-    >;
-  }
-
-  /** NIP-01 `NOTICE` message from relay to client. */
-  static relayNOTICE(): z.ZodType<NostrRelayNOTICE> {
-    return z.tuple([z.literal("NOTICE"), z.string()]) as unknown as z.ZodType<
-      NostrRelayNOTICE
-    >;
-  }
-
-  /** NIP-01 `CLOSED` message from relay to client. */
-  static relayCLOSED(): z.ZodType<NostrRelayCLOSED> {
-    return z.tuple([
-      z.literal("CLOSED"),
-      z.string(),
-      z.string(),
-    ]) as unknown as z.ZodType<NostrRelayCLOSED>;
-  }
-
-  /** NIP-42 `AUTH` message from relay to client. */
-  static relayAUTH(): z.ZodType<NostrRelayAUTH> {
-    return z.tuple([z.literal("AUTH"), z.string()]) as unknown as z.ZodType<
-      NostrRelayAUTH
-    >;
-  }
-
-  /** NIP-45 `COUNT` message from relay to client. */
-  static relayCOUNT(): z.ZodType<NostrRelayCOUNT> {
-    return z.tuple([
-      z.literal("COUNT"),
-      z.string(),
-      z.object({
-        count: z.number().int().nonnegative(),
-        approximate: z.boolean().optional(),
-      }),
-    ]) as unknown as z.ZodType<NostrRelayCOUNT>;
-  }
-
-  /** NIP-01 message from relay to client. */
-  static relayMsg(): z.ZodType<NostrRelayMsg> {
-    return z.union([
-      NSchema.relayEVENT(),
-      NSchema.relayOK(),
-      NSchema.relayEOSE(),
-      NSchema.relayNOTICE(),
-      NSchema.relayCLOSED(),
-      NSchema.relayAUTH(),
-      NSchema.relayCOUNT(),
-    ]);
-  }
-
-  /** Kind 0 content schema. */
-  static metadata(): z.ZodType<NostrMetadata> {
-    return z.object({
-      about: z.string().optional().catch(undefined),
-      banner: z.string().url().optional().catch(undefined),
-      bot: z.boolean().optional().catch(undefined),
-      display_name: z.string().optional().catch(undefined),
-      lud06: NSchema.bech32("lnurl").optional().catch(undefined),
-      lud16: z.string().email().optional().catch(undefined),
-      name: z.string().optional().catch(undefined),
-      nip05: z.string().email().optional().catch(undefined),
-      picture: z.string().url().optional().catch(undefined),
-      website: z.string().url().optional().catch(undefined),
-    }).passthrough() as z.ZodType<NostrMetadata>;
-  }
-
-  /** NIP-46 request content schema. */
-  static connectRequest(): z.ZodType<NostrConnectRequest> {
-    return z.object({
-      id: z.string(),
-      method: z.string(),
-      params: z.string().array(),
-    }) as z.ZodType<NostrConnectRequest>;
-  }
-
-  /** NIP-46 response content schema. */
-  static connectResponse(): z.ZodType<NostrConnectResponse> {
-    return z.object({
-      id: z.string(),
-      result: z.string(),
-      error: z.string().optional(),
-    }) as z.ZodType<NostrConnectResponse>;
-  }
-
-  /**
-   * Helper schema to parse a JSON string. It should then be piped into another schema. For example:
-   *
-   * ```ts
-   * const event = NSchema.json().pipe(NSchema.event()).parse(data);
-   * ```
-   */
-  static json(): z.ZodType<unknown> {
-    return z.string().transform((value, ctx) => {
-      try {
-        return JSON.parse(value) as unknown;
-      } catch (_e) {
-        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "Invalid JSON" });
-        return z.NEVER;
-      }
-    });
-  }
-}
-
-export { NSchema, z };

package/dist/NSecSigner.ts

@@ -1,62 +0,0 @@
-// deno-lint-ignore-file require-await
-
-import { finalizeEvent, getPublicKey, nip04, nip44 } from 'nostr-tools';
-
-import type { NostrEvent, NostrSigner } from '@nostrify/types';
-
-/**
- * NIP-07-compatible signer with secret key. It is a drop-in replacement for `window.nostr`.
- *
- * Usage:
- *
- * ```ts
- * const signer = new NSecSigner(secretKey);
- * const pubkey = await signer.getPublicKey();
- * const event = await signer.signEvent({ kind: 1, content: 'Hello, world!', tags: [], created_at: 0 });
- * ```
- */
-export class NSecSigner implements NostrSigner {
-  #secretKey: Uint8Array;
-  private pubkey?: string;
-
-  constructor(secretKey: Uint8Array) {
-    this.#secretKey = secretKey;
-  }
-
-  async getPublicKey(): Promise<string> {
-    return this.pubkey ??= getPublicKey(this.#secretKey);
-  }
-
-  async signEvent(
-    event: Omit<NostrEvent, 'id' | 'pubkey' | 'sig'>,
-  ): Promise<NostrEvent> {
-    // @ts-ignore this is fine
-    return finalizeEvent(event, this.#secretKey);
-  }
-
-  readonly nip04 = {
-    encrypt: async (pubkey: string, plaintext: string): Promise<string> => {
-      return nip04.encrypt(this.#secretKey, pubkey, plaintext);
-    },
-
-    decrypt: async (pubkey: string, ciphertext: string): Promise<string> => {
-      return nip04.decrypt(this.#secretKey, pubkey, ciphertext);
-    },
-  };
-
-  #getConversationKey(pubkey: string): Uint8Array {
-    return nip44.v2.utils.getConversationKey(this.#secretKey, pubkey);
-  }
-
-  readonly nip44 = {
-    encrypt: async (pubkey: string, plaintext: string): Promise<string> => {
-      const conversationKey = this.#getConversationKey(pubkey);
-      return nip44.v2.encrypt(plaintext, conversationKey);
-    },
-
-    decrypt: async (pubkey: string, ciphertext: string): Promise<string> => {
-      const conversationKey = this.#getConversationKey(pubkey);
-      return nip44.v2.decrypt(ciphertext, conversationKey);
-    },
-  };
-}

package/dist/NSet.ts

@@ -1,210 +0,0 @@
-import type { NostrEvent } from '@nostrify/types';
-
-/**
- * Nostr event implementation of the `Set` interface.
- *
- * NSet is an implementation of the theory that a Nostr Storage is actually just a Set.
- * Events are Nostr's only data type, and they are immutable, making the Set interface ideal.
- *
- * ```ts
- * const events = new NSet();
- *
- * // Events can be added like a regular `Set`:
- * events.add(event1);
- * events.add(event2);
- *
- * // Can be iterated:
- * for (const event of events) {
- *   if (matchFilters(filters, event)) {
- *     console.log(event);
- *   }
- * }
- * ```
- *
- * `NSet` will handle kind `5` deletions, removing events from the set.
- * Replaceable (and parameterized) events will keep only the newest version.
- * However, verification of `id` and `sig` is NOT performed.
- *
- * Any `Map` instance can be passed into `new NSet()`, making it compatible with
- * [lru-cache](https://www.npmjs.com/package/lru-cache), among others.
- */
-class NSet {
-  protected cache: Map<string, NostrEvent>;
-
-  constructor(map?: Map<string, NostrEvent>) {
-    this.cache = map ?? new Map();
-  }
-
-  get size(): number {
-    return this.cache.size;
-  }
-
-  add(event: NostrEvent): this {
-    this.#processDeletions(event);
-
-    for (const e of this) {
-      if (NSet.deletes(e, event) || NSet.replaces(e, event)) {
-        return this;
-      } else if (NSet.replaces(event, e)) {
-        this.delete(e);
-      }
-    }
-
-    this.cache.set(event.id, event);
-    return this;
-  }
-
-  #processDeletions(event: NostrEvent): void {
-    if (event.kind === 5) {
-      for (const tag of event.tags) {
-        if (tag[0] === 'e') {
-          const e = this.cache.get(tag[1]);
-          if (e && e.pubkey === event.pubkey) {
-            this.delete(e);
-          }
-        }
-      }
-    }
-  }
-
-  clear(): void {
-    this.cache.clear();
-  }
-
-  delete(event: NostrEvent): boolean {
-    return this.cache.delete(event.id);
-  }
-
-  forEach(
-    callbackfn: (event: NostrEvent, key: NostrEvent, set: typeof this) => void,
-    thisArg?: any,
-  ): void {
-    return this.cache.forEach(
-      (event, _id) => callbackfn(event, event, this),
-      thisArg,
-    );
-  }
-
-  has(event: NostrEvent): boolean {
-    return this.cache.has(event.id);
-  }
-
-  *entries(): IterableIterator<[NostrEvent, NostrEvent]> {
-    for (const event of this.values()) {
-      yield [event, event];
-    }
-  }
-
-  keys(): IterableIterator<NostrEvent> {
-    return this.values();
-  }
-
-  *values(): IterableIterator<NostrEvent> {
-    for (const event of NSet.sortEvents([...this.cache.values()])) {
-      yield event;
-    }
-  }
-
-  [Symbol.iterator](): IterableIterator<NostrEvent> {
-    return this.values();
-  }
-
-  [Symbol.toStringTag]: string = 'NSet';
-
-  /** Event kind is **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. */
-  protected static isReplaceable(kind: number): boolean {
-    return [0, 3].includes(kind) || (10000 <= kind && kind < 20000);
-  }
-
-  /** Event kind is **parameterized replaceable**, 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. */
-  protected static isAddressable(kind: number): boolean {
-    return 30000 <= kind && kind < 40000;
-  }
-
-  /**
-   * Returns true if `event` replaces `target`.
-   *
-   * Both events must be replaceable, belong to the same kind and pubkey (and `d` tag, for parameterized events), and the `event` must be newer than the `target`.
-   */
-  protected static replaces(event: NostrEvent, target: NostrEvent): boolean {
-    const { kind, pubkey } = event;
-
-    if (NSet.isReplaceable(kind)) {
-      return kind === target.kind && pubkey === target.pubkey &&
-        NSet.sortEvents([event, target])[0] === event;
-    }
-
-    if (NSet.isAddressable(kind)) {
-      const d1 = event.tags.find(([name]: string[]) => name === 'd')?.[1] || '';
-      const d2 = target.tags.find(([name]: string[]) => name === 'd')?.[1] || '';
-
-      return kind === target.kind &&
-        pubkey === target.pubkey &&
-        NSet.sortEvents([event, target])[0] === event &&
-        d1 === d2;
-    }
-
-    return false;
-  }
-
-  /**
-   * Returns true if the `event` deletes`target`.
-   *
-   * `event` must be a kind `5` event, and both events must share the same `pubkey`.
-   */
-  protected static deletes(event: NostrEvent, target: NostrEvent): boolean {
-    const { kind, pubkey, tags } = event;
-    if (kind === 5 && pubkey === target.pubkey) {
-      for (const [name, value] of tags) {
-        if (name === 'e' && value === target.id) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Sort events in reverse-chronological order by the `created_at` timestamp,
-   * and then by the event `id` (lexicographically) in case of ties.
-   * This mutates the array.
-   */
-  protected static sortEvents(events: NostrEvent[]): NostrEvent[] {
-    return events.sort((a: NostrEvent, b: NostrEvent): number => {
-      if (a.created_at !== b.created_at) {
-        return b.created_at - a.created_at;
-      }
-      return a.id.localeCompare(b.id);
-    });
-  }
-
-  union<U>(_other: Set<U>): Set<NostrEvent | U> {
-    throw new Error('Method not implemented.');
-  }
-
-  intersection<U>(_other: Set<U>): Set<NostrEvent & U> {
-    throw new Error('Method not implemented.');
-  }
-
-  difference<U>(_other: Set<U>): Set<NostrEvent> {
-    throw new Error('Method not implemented.');
-  }
-
-  symmetricDifference<U>(_other: Set<U>): Set<NostrEvent | U> {
-    throw new Error('Method not implemented.');
-  }
-
-  isSubsetOf(_other: Set<unknown>): boolean {
-    throw new Error('Method not implemented.');
-  }
-
-  isSupersetOf(_other: Set<unknown>): boolean {
-    throw new Error('Method not implemented.');
-  }
-
-  isDisjointFrom(_other: Set<unknown>): boolean {
-    throw new Error('Method not implemented.');
-  }
-}
-
-export { NSet };

package/dist/RelayError.ts

@@ -1,22 +0,0 @@
-import type { NostrRelayOK } from '@nostrify/types';
-
-/** NIP-01 command line result. */
-export class RelayError extends Error {
-  constructor(prefix: string, message: string) {
-    super(`${prefix}: ${message}`);
-  }
-
-  /** Construct a RelayError from the reason message. */
-  static fromReason(reason: string): RelayError {
-    const [prefix, ...rest] = reason.split(': ');
-    return new RelayError(prefix, rest.join(': '));
-  }
-
-  /** Throw a new RelayError if the OK message is false. */
-  static assert(msg: NostrRelayOK): void {
-    const [, , ok, reason] = msg;
-    if (!ok) {
-      throw RelayError.fromReason(reason);
-    }
-  }
-}