@nostrify/nostrify 0.46.4

package/test/MockRelay.ts

@@ -0,0 +1,92 @@
+// deno-lint-ignore-file require-await
+
+import {
+  NostrEvent,
+  NostrFilter,
+  NostrRelayCLOSED,
+  NostrRelayCOUNT,
+  NostrRelayEOSE,
+  NostrRelayEVENT,
+  NRelay,
+} from '@nostrify/types';
+import { matchFilters } from 'nostr-tools';
+
+import { Machina } from '../utils/Machina';
+import { NSet } from '../NSet';
+
+/** Mock relay for testing. */
+export class MockRelay extends NSet implements NRelay {
+  readonly subs: Map<
+    string,
+    { filters: NostrFilter[]; machina: Machina<NostrEvent> }
+  > = new Map();
+
+  async *req(
+    filters: NostrFilter[],
+    opts?: { signal?: AbortSignal },
+  ): AsyncIterable<NostrRelayEVENT | NostrRelayEOSE | NostrRelayCLOSED> {
+    const uuid = crypto.randomUUID();
+    const machina = new Machina<NostrEvent>(opts?.signal);
+
+    this.subs.set(uuid, { filters, machina });
+
+    try {
+      for (const event of await this.query(filters)) {
+        yield ['EVENT', uuid, event];
+      }
+
+      yield ['EOSE', uuid];
+
+      for await (const event of machina) {
+        yield ['EVENT', uuid, event];
+      }
+    } finally {
+      this.subs.delete(uuid);
+    }
+  }
+
+  async event(event: NostrEvent): Promise<void> {
+    this.add(event);
+
+    for (const { filters, machina } of this.subs.values()) {
+      if (matchFilters(filters, event)) {
+        machina.push(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,
+    };
+  }
+
+  close(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  override [Symbol.toStringTag] = 'MockRelay';
+}

package/test/TestRelayServer.ts

@@ -0,0 +1,156 @@
+import { MockRelay } from './mod';
+import { NostrClientMsg, NostrEvent, NostrRelayMsg } from '@nostrify/types';
+import { NSchema as n } from '../NSchema';
+import { WebSocketServer, WebSocket } from 'ws';
+import { createServer, Server } from 'http';
+import { AddressInfo } from 'net';
+
+interface TestRelayServerOpts {
+  handleMessage?(socket: WebSocket, msg: NostrClientMsg): Promise<void> | void;
+}
+
+export class TestRelayServer {
+  private port = 0;
+  private httpServer: Server;
+  private wsServer: WebSocketServer;
+  private connections = new Set<WebSocket>();
+  private controllers = new Map<string, AbortController>();
+  private store = new MockRelay();
+
+  constructor(private opts?: TestRelayServerOpts) {
+    this.httpServer = createServer();
+    this.wsServer = new WebSocketServer({ server: this.httpServer });
+    this.setupWebSocketServer();
+    this.httpServer.listen(0, '127.0.0.1', () => {
+      this.port = (this.httpServer.address() as AddressInfo).port;
+    });
+  }
+
+  private setupWebSocketServer(): void {
+    this.wsServer.on('connection', (socket: WebSocket) => {
+      this.connections.add(socket);
+
+      socket.on('close', () => {
+        this.connections.delete(socket);
+        // Clean up any subscriptions for this socket
+        for (const [subId, controller] of this.controllers.entries()) {
+          controller.abort();
+          this.controllers.delete(subId);
+        }
+      });
+
+      socket.on('message', (data: Buffer) => {
+        try {
+          const result = n.json().pipe(n.clientMsg()).safeParse(data.toString());
+          if (result.success) {
+            const handleMessage = this.opts?.handleMessage ??
+              this.handleMessage.bind(this);
+            handleMessage(socket, result.data);
+          }
+        } catch (error) {
+          // Handle parsing errors silently
+        }
+      });
+
+      socket.on('error', (error) => {
+        console.error('WebSocket error:', error);
+        this.connections.delete(socket);
+      });
+    });
+  }
+
+  send(socket: WebSocket, msg: NostrRelayMsg): void {
+    if (socket.readyState === WebSocket.OPEN) {
+      socket.send(JSON.stringify(msg));
+    }
+  }
+
+  private async handleMessage(
+    socket: WebSocket,
+    msg: NostrClientMsg,
+  ): Promise<void> {
+    switch (msg[0]) {
+      case 'REQ': {
+        const [_, subId, ...filters] = msg;
+
+        const controller = new AbortController();
+        this.controllers.set(subId, controller);
+
+        try {
+          for await (
+            const msg of this.store.req(filters, { signal: controller.signal })
+          ) {
+            msg[1] = subId;
+            this.send(socket, msg);
+          }
+        } catch {
+          // do nothing
+        }
+
+        break;
+      }
+
+      case 'CLOSE': {
+        const subId = msg[1];
+        this.controllers.get(subId)?.abort();
+        this.controllers.delete(subId);
+        break;
+      }
+
+      case 'EVENT': {
+        const [_, event] = msg;
+        await this.store.event(event);
+        this.send(socket, ['OK', event.id, true, '']);
+        break;
+      }
+    }
+  }
+
+  get url(): string {
+    const addr = this.httpServer.address() as AddressInfo;
+    return `ws://${addr.address}:${addr.port}`;
+  }
+
+  async close(): Promise<void> {
+    return new Promise((resolve) => {
+      // Close all WebSocket connections
+      this.connections.forEach((conn) => {
+        if (conn.readyState === WebSocket.OPEN) {
+          conn.close();
+        }
+      });
+      this.connections.clear();
+
+      // Abort all controllers
+      this.controllers.forEach((controller) => controller.abort());
+      this.controllers.clear();
+
+      // Close WebSocket server
+      this.wsServer.close(() => {
+        // Close HTTP server
+        this.httpServer.close(() => {
+          resolve();
+        });
+      });
+    });
+  }
+
+  open(): void {
+    if (!this.httpServer.listening) {
+      this.httpServer = createServer();
+      this.wsServer = new WebSocketServer({ server: this.httpServer });
+      this.setupWebSocketServer();
+      this.httpServer.listen(0, '127.0.0.1', () => {
+        this.port = (this.httpServer.address() as AddressInfo).port;
+      });
+    }
+  }
+
+  event(event: NostrEvent): Promise<void> {
+    return this.store.event(event);
+  }
+
+  async [Symbol.asyncDispose](): Promise<void> {
+    await this.close();
+  }
+}

package/test/mod.ts

@@ -0,0 +1,28 @@
+import { NostrEvent } from '@nostrify/types';
+import { finalizeEvent, generateSecretKey } from 'nostr-tools';
+import { readFile } from 'node:fs/promises';
+
+export { ErrorRelay } from './ErrorRelay';
+export { MockRelay } from './MockRelay';
+
+/** Import a JSONL fixture by name in tests. */
+export async function jsonlEvents(path: string): Promise<NostrEvent[]> {
+  const data = await readFile(path, { encoding: 'utf8' });
+  return data.split('\n').map((line) => JSON.parse(line));
+}
+
+/** Generate an event for use in tests. */
+export function genEvent(
+  t: Partial<NostrEvent> = {},
+  sk: Uint8Array = generateSecretKey(),
+): NostrEvent {
+  const { id, kind, pubkey, tags, content, created_at, sig } = finalizeEvent({
+    kind: 255,
+    created_at: 0,
+    content: '',
+    tags: [],
+    ...t,
+  }, sk);
+
+  return { id, kind, pubkey, tags, content, created_at, sig };
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "include": [
+    "./**/*.ts"
+  ],
+  "exclude": [
+    "./dist",
+    "./**/*.bench.ts",
+    "./**/*.test.ts"
+  ],
+  "compilerOptions": {
+    "outDir": "./dist"
+  }
+}

package/uploaders/BlossomUploader.test.ts

@@ -0,0 +1,26 @@
+import { assertEquals } from '@std/assert';
+import { generateSecretKey } from 'nostr-tools';
+
+import { BlossomUploader } from './BlossomUploader.ts';
+import { NSecSigner } from '../NSecSigner.ts';
+
+Deno.test('BlossomUploader.upload', { ignore: Deno.env.get('CI') === 'true' }, async () => {
+  const fsFile = await Deno.open(new URL('../../../fixtures/voadi.png', import.meta.url));
+  const blob = await (new Response(fsFile.readable)).blob();
+  const file = new File([blob], 'voadi.png', { type: 'image/png' });
+
+  const uploader = new BlossomUploader({
+    servers: ['https://blossom.primal.net/'],
+    signer: new NSecSigner(generateSecretKey()),
+  });
+
+  const tags = await uploader.upload(file);
+
+  assertEquals(tags, [
+    ['url', 'https://blossom.primal.net/7508bd9d8b0ed6e0891a3b973adf6011b1e49f6174910d6a1eb722a4a2e30539.png'],
+    ['x', '7508bd9d8b0ed6e0891a3b973adf6011b1e49f6174910d6a1eb722a4a2e30539'],
+    ['ox', '7508bd9d8b0ed6e0891a3b973adf6011b1e49f6174910d6a1eb722a4a2e30539'],
+    ['size', '172'],
+    ['m', 'image/png'],
+  ]);
+});

package/uploaders/BlossomUploader.ts

@@ -0,0 +1,98 @@
+import { NostrSigner, NUploader } from '@nostrify/types';
+import { encodeHex } from '@std/encoding/hex';
+import { z } from 'zod';
+
+import { N64 } from '../utils/N64';
+
+/** BlossomUploader options. */
+export interface BlossomUploaderOpts {
+  /** Blossom servers to use. */
+  servers: Request['url'][];
+  /** Signer for Blossom authorizations. */
+  signer: NostrSigner;
+  /** Custom fetch implementation. */
+  fetch?: typeof fetch;
+  /** Number of milliseconds until each request should expire. (Default: `60_000`) */
+  expiresIn?: number;
+}
+
+/** Upload files to Blossom servers. */
+export class BlossomUploader implements NUploader {
+  private servers: Request['url'][];
+  private signer: NostrSigner;
+  private fetch: typeof fetch;
+  private expiresIn: number;
+
+  constructor(opts: BlossomUploaderOpts) {
+    this.servers = opts.servers;
+    this.signer = opts.signer;
+    this.fetch = opts.fetch ?? globalThis.fetch.bind(globalThis);
+    this.expiresIn = opts.expiresIn ?? 60_000;
+  }
+
+  async upload(
+    file: File,
+    opts?: { signal?: AbortSignal },
+  ): Promise<[['url', string], ...string[][]]> {
+    const x = encodeHex(
+      await crypto.subtle.digest('SHA-256', await file.arrayBuffer()),
+    );
+
+    const now = Date.now();
+    const expiration = now + this.expiresIn;
+
+    const event = await this.signer.signEvent({
+      kind: 24242,
+      content: `Upload ${file.name}`,
+      created_at: Math.floor(now / 1000),
+      tags: [
+        ['t', 'upload'],
+        ['x', x],
+        ['size', file.size.toString()],
+        ['expiration', Math.floor(expiration / 1000).toString()],
+      ],
+    });
+
+    const authorization = `Nostr ${N64.encodeEvent(event)}`;
+
+    return Promise.any(this.servers.map(async (server) => {
+      const url = new URL('/upload', server);
+
+      const response = await this.fetch(url, {
+        method: 'PUT',
+        body: file,
+        headers: {
+          authorization,
+          'content-type': file.type,
+        },
+        signal: opts?.signal,
+      });
+
+      const json = await response.json();
+      const data = BlossomUploader.schema().parse(json);
+
+      const tags: [['url', string], ...string[][]] = [
+        ['url', data.url],
+        ['x', data.sha256],
+        ['ox', data.sha256],
+        ['size', data.size.toString()],
+      ];
+
+      if (data.type) {
+        tags.push(['m', data.type]);
+      }
+
+      return tags;
+    }));
+  }
+
+  /** Blossom "BlobDescriptor" schema. */
+  private static schema() {
+    return z.object({
+      url: z.string(),
+      sha256: z.string(),
+      size: z.number(),
+      type: z.string().optional(),
+    });
+  }
+}

package/uploaders/NostrBuildUploader.test.ts

@@ -0,0 +1,22 @@
+import { assertEquals } from '@std/assert';
+
+import { NostrBuildUploader } from './NostrBuildUploader.ts';
+
+Deno.test('NostrBuildUploader.upload', { ignore: Deno.env.get('CI') === 'true' }, async () => {
+  const fsFile = await Deno.open(new URL('../../../fixtures/voadi.png', import.meta.url));
+  const blob = await (new Response(fsFile.readable)).blob();
+  const file = new File([blob], 'voadi.png', { type: 'image/png' });
+
+  const uploader = new NostrBuildUploader();
+  const tags = await uploader.upload(file);
+
+  assertEquals(tags, [
+    ['url', 'https://image.nostr.build/7508bd9d8b0ed6e0891a3b973adf6011b1e49f6174910d6a1eb722a4a2e30539.png'],
+    ['m', 'image/png'],
+    ['x', '21608eecb7df80ca3838deb428fd6568a0d0d3b1baac56491e2247a1c110649a'],
+    ['ox', '7508bd9d8b0ed6e0891a3b973adf6011b1e49f6174910d6a1eb722a4a2e30539'],
+    ['size', '171'],
+    ['dim', '16x16'],
+    ['blurhash', 'LCB20ssn0+NcbsfjRmaz12WW}osn'],
+  ]);
+});

package/uploaders/NostrBuildUploader.ts

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+
+import { N64 } from '../utils/N64';
+import { NIP98 } from '../NIP98';
+import { NostrSigner } from '@nostrify/types';
+import { NUploader } from '@nostrify/types';
+
+/** NostrBuildUploader options. */
+export interface NostrBuildUploaderOpts {
+  /** nostr.build endpoint to use. Default: `https://nostr.build/api/v2/upload/files` */
+  endpoint?: string;
+  /** Signer to authenticate with NIP-98 requests. */
+  signer?: NostrSigner;
+  /** Custom fetch implementation. */
+  fetch?: typeof fetch;
+}
+
+/** Upload files to nostr.build or another compatible server. */
+export class NostrBuildUploader implements NUploader {
+  private endpoint: string;
+  private signer?: NostrSigner;
+  private fetch: typeof fetch;
+
+  constructor(opts?: NostrBuildUploaderOpts) {
+    this.endpoint = opts?.endpoint ?? 'https://nostr.build/api/v2/upload/files';
+    this.signer = opts?.signer;
+    this.fetch = opts?.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+
+  async upload(
+    file: File,
+    opts?: { signal?: AbortSignal },
+  ): Promise<[['url', string], ...string[][]]> {
+    const formData = new FormData();
+    formData.append('fileToUpload', file);
+
+    const request = new Request(this.endpoint, {
+      method: 'POST',
+      body: formData,
+      signal: opts?.signal,
+    });
+
+    if (this.signer) {
+      const t = await NIP98.template(request);
+      const event = await this.signer.signEvent(t);
+      request.headers.set('authorization', `Nostr ${N64.encodeEvent(event)}`);
+    }
+
+    const response = await this.fetch(request);
+    const json = await response.json();
+    const [data] = NostrBuildUploader.schema().parse(json).data;
+
+    const tags: [['url', string], ...string[][]] = [
+      ['url', data.url],
+      ['m', data.mime],
+      ['x', data.sha256],
+      ['ox', data.original_sha256],
+      ['size', data.size.toString()],
+    ];
+
+    if (data.dimensions) {
+      tags.push(['dim', `${data.dimensions.width}x${data.dimensions.height}`]);
+    }
+
+    if (data.blurhash) {
+      tags.push(['blurhash', data.blurhash]);
+    }
+
+    return tags;
+  }
+
+  /** nostr.build API response schema. */
+  private static schema() {
+    return z.object({
+      data: z.object({
+        url: z.string().url(),
+        blurhash: z.string().optional().catch(undefined),
+        sha256: z.string(),
+        original_sha256: z.string(),
+        mime: z.string(),
+        size: z.number(),
+        dimensions: z.object({
+          width: z.number().positive(),
+          height: z.number().positive(),
+        }).optional().catch(undefined),
+      }).array().min(1),
+    });
+  }
+}

package/uploaders/mod.ts

@@ -0,0 +1,2 @@
+export { BlossomUploader } from './BlossomUploader';
+export { NostrBuildUploader } from './NostrBuildUploader';

package/utils/CircularSet.test.ts

@@ -0,0 +1,15 @@
+import { assertEquals } from '@std/assert';
+
+import { CircularSet } from './CircularSet.ts';
+
+Deno.test('CircularSet', () => {
+  const set = new CircularSet<number>(3);
+
+  set.add(1);
+  set.add(2);
+  set.add(3);
+  set.add(3);
+  set.add(4);
+
+  assertEquals([...set], [2, 3, 4]);
+});

package/utils/CircularSet.ts

@@ -0,0 +1,34 @@
+/**
+ * Like a Circular Buffer, but the values are deduplicated.
+ * Shares the properties of both a Circular Buffer and a Set.
+ */
+export class CircularSet<T> {
+  private set: Set<T>;
+
+  constructor(private capacity: number) {
+    this.set = new Set();
+  }
+
+  add(item: T): void {
+    if (this.set.has(item)) {
+      return;
+    }
+
+    if (this.set.size >= this.capacity) {
+      const oldest = this.set.values().next().value;
+      if (oldest) {
+        this.set.delete(oldest);
+      }
+    }
+
+    this.set.add(item);
+  }
+
+  has(item: T): boolean {
+    return this.set.has(item);
+  }
+
+  [Symbol.iterator](): Iterator<T> {
+    return this.set.values();
+  }
+}

package/utils/Machina.test.ts

@@ -0,0 +1,91 @@
+import { assertEquals, assertRejects } from '@std/assert';
+
+import { Machina } from './Machina.ts';
+
+Deno.test('push, iterate, & close', async () => {
+  const results = [];
+  const machina = new Machina<number>();
+
+  machina.push(1);
+  machina.push(2);
+  setTimeout(() => machina.push(3), 100);
+
+  for await (const msg of machina) {
+    results.push(msg);
+
+    if (results.length === 3) {
+      break;
+    }
+  }
+
+  assertEquals(results, [1, 2, 3]);
+});
+
+Deno.test('close & reopen', async () => {
+  const machina = new Machina<number>();
+
+  machina.push(777);
+  for await (const msg of machina) {
+    assertEquals(msg, 777);
+    break;
+  }
+
+  machina.push(888);
+  for await (const msg of machina) {
+    assertEquals(msg, 888);
+    break;
+  }
+});
+
+Deno.test('aborts with signal', async () => {
+  const machina = new Machina<number>(AbortSignal.timeout(100));
+
+  await assertRejects(async () => {
+    for await (const _msg of machina) {
+      // Should never reach here.
+    }
+  });
+});
+
+Deno.test('already aborted signal in constructor', async () => {
+  const machina = new Machina<number>(AbortSignal.abort()); // doesn't throw
+
+  await assertRejects(async () => {
+    for await (const _msg of machina) {
+      // Should never reach here.
+    }
+  });
+});
+
+Deno.test('push after abort', async () => {
+  const controller = new AbortController();
+  const machina = new Machina<number>(controller.signal);
+
+  controller.abort();
+  machina.push(999);
+
+  await assertRejects(async () => {
+    for await (const _msg of machina) {
+      // Should never reach here.
+    }
+  }, DOMException);
+});
+
+Deno.test('multiple messages in queue', async () => {
+  const results = [];
+  const machina = new Machina<number>();
+
+  machina.push(10);
+  machina.push(20);
+  machina.push(30);
+
+  for await (const msg of machina) {
+    results.push(msg);
+
+    if (results.length === 3) {
+      break;
+    }
+  }
+
+  assertEquals(results, [10, 20, 30]);
+});