@nostrify/nostrify 0.46.7 → 0.46.9

package/NIP98.test.ts

@@ -1,181 +1,194 @@
-import { assertEquals, assertRejects } from '@std/assert';
-import { generateSecretKey } from 'nostr-tools';
-import { ZodError } from 'zod';
+import { test } from "node:test";
+import { deepStrictEqual, rejects } from "node:assert";
+import { generateSecretKey } from "nostr-tools";
+import { ZodError } from "zod";
 
-import { NIP98 } from './NIP98.ts';
-import { NSecSigner } from './NSecSigner.ts';
-import { N64 } from './utils/mod.ts';
+import { NIP98 } from "./NIP98.ts";
+import { NSecSigner } from "./NSecSigner.ts";
+import { N64 } from "./utils/mod.ts";
 
-Deno.test('NIP98.template', async () => {
-  const request = new Request('https://example.com');
+await test("NIP98.template", async () => {
+  const request = new Request("https://example.com");
   const event = await NIP98.template(request);
 
-  assertEquals(event.kind, 27235);
-  assertEquals(event.tags, [
-    ['method', 'GET'],
-    ['u', 'https://example.com/'],
+  deepStrictEqual(event.kind, 27235);
+  deepStrictEqual(event.tags, [
+    ["method", "GET"],
+    ["u", "https://example.com/"],
   ]);
 });
 
-Deno.test('NIP98.template with payload', async () => {
-  const request = new Request('https://example.com', {
-    method: 'POST',
-    body: 'Hello, world!',
+await test("NIP98.template with payload", async () => {
+  const request = new Request("https://example.com", {
+    method: "POST",
+    body: "Hello, world!",
   });
   const event = await NIP98.template(request);
 
-  assertEquals(event.kind, 27235);
-  assertEquals(event.tags, [
-    ['method', 'POST'],
-    ['u', 'https://example.com/'],
-    ['payload', '315f5bdb76d078c43b8ac0064e4a0164612b1fce77c869345bfc94c75894edd3'],
+  deepStrictEqual(event.kind, 27235);
+  deepStrictEqual(event.tags, [
+    ["method", "POST"],
+    ["u", "https://example.com/"],
+    [
+      "payload",
+      "315f5bdb76d078c43b8ac0064e4a0164612b1fce77c869345bfc94c75894edd3",
+    ],
   ]);
 });
 
-Deno.test('NIP98.verify', async () => {
+await test("NIP98.verify", async () => {
   const signer = new NSecSigner(generateSecretKey());
-  const request = new Request('https://example.com');
+  const request = new Request("https://example.com");
 
   const t = await NIP98.template(request);
   const event = await signer.signEvent(t);
 
-  request.headers.set('authorization', `Nostr ${N64.encodeEvent(event)}`);
+  request.headers.set("authorization", `Nostr ${N64.encodeEvent(event)}`);
 
   const proof = await NIP98.verify(request);
 
-  assertEquals(proof, event);
-  assertEquals(proof.pubkey, await signer.getPublicKey());
+  deepStrictEqual(proof, event);
+  deepStrictEqual(proof.pubkey, await signer.getPublicKey());
 });
 
-Deno.test('NIP98.verify fails with missing header', async () => {
-  const request = new Request('https://example.com');
+await test("NIP98.verify fails with missing header", async () => {
+  const request = new Request("https://example.com");
 
-  await assertRejects(
+  await rejects(
     () => NIP98.verify(request),
     Error,
-    'Missing Nostr authorization header',
+    "Missing Nostr authorization header",
   );
 });
 
-Deno.test('NIP98.verify fails with missing token', async () => {
-  const request = new Request('https://example.com');
-  request.headers.set('authorization', 'Nostr');
+await test("NIP98.verify fails with missing token", async () => {
+  const request = new Request("https://example.com");
+  request.headers.set("authorization", "Nostr");
 
-  await assertRejects(
+  await rejects(
     () => NIP98.verify(request),
     Error,
-    'Missing Nostr authorization token',
+    "Missing Nostr authorization token",
   );
 });
 
-Deno.test('NIP98.verify fails with invalid token', async () => {
-  const request = new Request('https://example.com');
-  request.headers.set('authorization', 'Nostr invalid');
+await test("NIP98.verify fails with invalid token", async () => {
+  const request = new Request("https://example.com");
+  request.headers.set("authorization", "Nostr invalid");
 
-  await assertRejects(
+  await rejects(
     () => NIP98.verify(request),
     ZodError,
   );
 });
 
-Deno.test('NIP98.verify fails with invalid event', async () => {
+await test("NIP98.verify fails with invalid event", async () => {
   const signer = new NSecSigner(generateSecretKey());
-  const request = new Request('https://example.com');
+  const request = new Request("https://example.com");
 
   const t = await NIP98.template(request);
   const event = await signer.signEvent(t);
 
-  event.sig = 'invalid';
+  event.sig = "invalid";
 
-  request.headers.set('authorization', `Nostr ${N64.encodeEvent(event)}`);
+  request.headers.set("authorization", `Nostr ${N64.encodeEvent(event)}`);
 
-  await assertRejects(
+  await rejects(
     () => NIP98.verify(request),
     Error,
-    'Event signature is invalid',
+    "Event signature is invalid",
   );
 });
 
-Deno.test('NIP98.verify fails with wrong event kind', async () => {
+await test("NIP98.verify fails with wrong event kind", async () => {
   const signer = new NSecSigner(generateSecretKey());
-  const request = new Request('https://example.com');
+  const request = new Request("https://example.com");
 
   const t = await NIP98.template(request);
   const event = await signer.signEvent({ ...t, kind: 1 });
 
-  request.headers.set('authorization', `Nostr ${N64.encodeEvent(event)}`);
+  request.headers.set("authorization", `Nostr ${N64.encodeEvent(event)}`);
 
-  await assertRejects(
+  await rejects(
     () => NIP98.verify(request),
     Error,
-    'Event must be kind 27235',
+    "Event must be kind 27235",
   );
 });
 
-Deno.test('NIP98.verify fails with wrong request URL', async () => {
+await test("NIP98.verify fails with wrong request URL", async () => {
   const signer = new NSecSigner(generateSecretKey());
-  const request = new Request('https://example.com');
+  const request = new Request("https://example.com");
 
   const t = await NIP98.template(request);
-  const event = await signer.signEvent({ ...t, tags: [['u', 'https://example.org/']] });
+  const event = await signer.signEvent({
+    ...t,
+    tags: [["u", "https://example.org/"]],
+  });
 
-  request.headers.set('authorization', `Nostr ${N64.encodeEvent(event)}`);
+  request.headers.set("authorization", `Nostr ${N64.encodeEvent(event)}`);
 
-  await assertRejects(
+  await rejects(
     () => NIP98.verify(request),
     Error,
-    'Event URL does not match request URL',
+    "Event URL does not match request URL",
   );
 });
 
-Deno.test('NIP98.verify fails with wrong request method', async () => {
+await test("NIP98.verify fails with wrong request method", async () => {
   const signer = new NSecSigner(generateSecretKey());
-  const request = new Request('https://example.com');
+  const request = new Request("https://example.com");
 
   const t = await NIP98.template(request);
-  const event = await signer.signEvent({ ...t, tags: [['u', 'https://example.com/'], ['method', 'POST']] });
+  const event = await signer.signEvent({
+    ...t,
+    tags: [["u", "https://example.com/"], ["method", "POST"]],
+  });
 
-  request.headers.set('authorization', `Nostr ${N64.encodeEvent(event)}`);
+  request.headers.set("authorization", `Nostr ${N64.encodeEvent(event)}`);
 
-  await assertRejects(
+  await rejects(
     () => NIP98.verify(request),
     Error,
-    'Event method does not match HTTP request method',
+    "Event method does not match HTTP request method",
   );
 });
 
-Deno.test('NIP98.verify fails with expired event', async () => {
+await test("NIP98.verify fails with expired event", async () => {
   const signer = new NSecSigner(generateSecretKey());
-  const request = new Request('https://example.com');
+  const request = new Request("https://example.com");
 
   const t = await NIP98.template(request);
   const event = await signer.signEvent({ ...t, created_at: 0 });
 
-  request.headers.set('authorization', `Nostr ${N64.encodeEvent(event)}`);
+  request.headers.set("authorization", `Nostr ${N64.encodeEvent(event)}`);
 
-  await assertRejects(
+  await rejects(
     () => NIP98.verify(request),
     Error,
-    'Event expired',
+    "Event expired",
   );
 });
 
-Deno.test('NIP98.verify fails with invalid payload', async () => {
+await test("NIP98.verify fails with invalid payload", async () => {
   const signer = new NSecSigner(generateSecretKey());
-  const request = new Request('https://example.com', {
-    method: 'POST',
-    body: 'Hello, world!',
+  const request = new Request("https://example.com", {
+    method: "POST",
+    body: "Hello, world!",
   });
 
   const t = await NIP98.template(request);
-  const tags = t.tags.filter(([name]) => name !== 'payload');
-  const event = await signer.signEvent({ ...t, tags: [...tags, ['payload', 'invalid']] });
+  const tags = t.tags.filter(([name]) => name !== "payload");
+  const event = await signer.signEvent({
+    ...t,
+    tags: [...tags, ["payload", "invalid"]],
+  });
 
-  request.headers.set('authorization', `Nostr ${N64.encodeEvent(event)}`);
+  request.headers.set("authorization", `Nostr ${N64.encodeEvent(event)}`);
 
-  await assertRejects(
+  await rejects(
     () => NIP98.verify(request),
     Error,
-    'Event payload does not match request body',
+    "Event payload does not match request body",
   );
 });

package/NIP98.ts

@@ -1,8 +1,8 @@
-import { NostrEvent } from '@nostrify/types';
+import type { NostrEvent } from '@nostrify/types';
 import { encodeHex } from '@std/encoding/hex';
 import { verifyEvent as _verifyEvent } from 'nostr-tools';
 
-import { N64 } from './utils/N64.js';
+import { N64 } from './utils/N64.ts';
 
 /** [NIP-98](https://github.com/nostr-protocol/nips/blob/master/98.md) HTTP auth. */
 export class NIP98 {

package/NKinds.test.ts

@@ -1,42 +1,43 @@
-import { assertEquals } from '@std/assert';
+import { test } from "node:test";
+import { deepStrictEqual } from "node:assert";
 
-import { NKinds } from './NKinds.ts';
+import { NKinds } from "./NKinds.ts";
 
-Deno.test('NKinds', () => {
-  assertEquals(NKinds.regular(1000), true);
-  assertEquals(NKinds.regular(10000), false);
-  assertEquals(NKinds.regular(0), false);
-  assertEquals(NKinds.regular(44), true);
-  assertEquals(NKinds.regular(45), false);
-  assertEquals(NKinds.regular(100000), false);
+await test("NKinds", () => {
+  deepStrictEqual(NKinds.regular(1000), true);
+  deepStrictEqual(NKinds.regular(10000), false);
+  deepStrictEqual(NKinds.regular(0), false);
+  deepStrictEqual(NKinds.regular(44), true);
+  deepStrictEqual(NKinds.regular(45), false);
+  deepStrictEqual(NKinds.regular(100000), false);
 
-  assertEquals(NKinds.replaceable(1000), false);
-  assertEquals(NKinds.replaceable(10000), true);
-  assertEquals(NKinds.replaceable(0), true);
-  assertEquals(NKinds.replaceable(3), true);
-  assertEquals(NKinds.replaceable(44), false);
-  assertEquals(NKinds.replaceable(45), false);
-  assertEquals(NKinds.replaceable(100000), false);
+  deepStrictEqual(NKinds.replaceable(1000), false);
+  deepStrictEqual(NKinds.replaceable(10000), true);
+  deepStrictEqual(NKinds.replaceable(0), true);
+  deepStrictEqual(NKinds.replaceable(3), true);
+  deepStrictEqual(NKinds.replaceable(44), false);
+  deepStrictEqual(NKinds.replaceable(45), false);
+  deepStrictEqual(NKinds.replaceable(100000), false);
 
-  assertEquals(NKinds.ephemeral(1000), false);
-  assertEquals(NKinds.ephemeral(10000), false);
-  assertEquals(NKinds.ephemeral(0), false);
-  assertEquals(NKinds.ephemeral(3), false);
-  assertEquals(NKinds.ephemeral(44), false);
-  assertEquals(NKinds.ephemeral(45), false);
-  assertEquals(NKinds.ephemeral(20000), true);
-  assertEquals(NKinds.ephemeral(30000), false);
-  assertEquals(NKinds.ephemeral(40000), false);
-  assertEquals(NKinds.ephemeral(100000), false);
+  deepStrictEqual(NKinds.ephemeral(1000), false);
+  deepStrictEqual(NKinds.ephemeral(10000), false);
+  deepStrictEqual(NKinds.ephemeral(0), false);
+  deepStrictEqual(NKinds.ephemeral(3), false);
+  deepStrictEqual(NKinds.ephemeral(44), false);
+  deepStrictEqual(NKinds.ephemeral(45), false);
+  deepStrictEqual(NKinds.ephemeral(20000), true);
+  deepStrictEqual(NKinds.ephemeral(30000), false);
+  deepStrictEqual(NKinds.ephemeral(40000), false);
+  deepStrictEqual(NKinds.ephemeral(100000), false);
 
-  assertEquals(NKinds.addressable(1000), false);
-  assertEquals(NKinds.addressable(10000), false);
-  assertEquals(NKinds.addressable(0), false);
-  assertEquals(NKinds.addressable(3), false);
-  assertEquals(NKinds.addressable(44), false);
-  assertEquals(NKinds.addressable(45), false);
-  assertEquals(NKinds.addressable(20000), false);
-  assertEquals(NKinds.addressable(30000), true);
-  assertEquals(NKinds.addressable(40000), false);
-  assertEquals(NKinds.addressable(100000), false);
+  deepStrictEqual(NKinds.addressable(1000), false);
+  deepStrictEqual(NKinds.addressable(10000), false);
+  deepStrictEqual(NKinds.addressable(0), false);
+  deepStrictEqual(NKinds.addressable(3), false);
+  deepStrictEqual(NKinds.addressable(44), false);
+  deepStrictEqual(NKinds.addressable(45), false);
+  deepStrictEqual(NKinds.addressable(20000), false);
+  deepStrictEqual(NKinds.addressable(30000), true);
+  deepStrictEqual(NKinds.addressable(40000), false);
+  deepStrictEqual(NKinds.addressable(100000), false);
 });

package/NPool.test.ts

@@ -1,24 +1,25 @@
-import { NostrEvent } from '@nostrify/types';
-import { assert, assertEquals } from '@std/assert';
-import { finalizeEvent, generateSecretKey } from 'nostr-tools';
+import { test } from "node:test";
+import type { NostrEvent } from "@nostrify/types";
+import { deepStrictEqual, ok } from "node:assert";
+import { finalizeEvent, generateSecretKey } from "nostr-tools";
 
-import { NPool } from './NPool.ts';
-import { NRelay1 } from './NRelay1.ts';
+import { NPool } from "./NPool.ts";
+import { NRelay1 } from "./NRelay1.ts";
 
-import events from '../../fixtures/events.json' with { type: 'json' };
-import { TestRelayServer } from './test/TestRelayServer.ts';
+import events from "../../fixtures/events.json" with { type: "json" };
+import { TestRelayServer } from "./test/TestRelayServer.ts";
 
 const event1s = events
   .filter((e) => e.kind === 1)
   .toSorted((_) => 0.5 - Math.random())
   .slice(0, 10);
 
-Deno.test('NPool.query', async () => {
+await test("NPool.query", async () => {
   const controller = new AbortController();
   const tid = setTimeout(() => controller.abort(), 5000);
 
-  await using server1 = new TestRelayServer();
-  await using server2 = new TestRelayServer();
+  await using server1 = await TestRelayServer.create();
+  await using server2 = await TestRelayServer.create();
 
   for (const event of event1s) {
     await server1.event(event);
@@ -37,18 +38,18 @@ Deno.test('NPool.query', async () => {
 
   const events = await pool.query([{ kinds: [1], limit: 15 }]);
 
-  assertEquals(events.length, 10);
-  assert(events[0].created_at >= events[1].created_at);
+  deepStrictEqual(events.length, 10);
+  ok(events[0].created_at >= events[1].created_at);
 
   clearTimeout(tid);
 });
 
-Deno.test('NPool.req', async () => {
+await test("NPool.req", async () => {
   const controller = new AbortController();
   const tid = setTimeout(() => controller.abort(), 3000);
 
-  await using server1 = new TestRelayServer();
-  await using server2 = new TestRelayServer();
+  await using server1 = await TestRelayServer.create();
+  await using server2 = await TestRelayServer.create();
 
   for (const event of event1s) {
     await server1.event(event);
@@ -67,25 +68,29 @@ Deno.test('NPool.req', async () => {
     eventRouter: () => [server1.url],
   });
 
-  for await (const msg of pool.req([{ kinds: [1], limit: 3 }], { signal: controller.signal })) {
-    if (msg[0] === 'EVENT') {
+  for await (
+    const msg of pool.req([{ kinds: [1], limit: 3 }], {
+      signal: controller.signal,
+    })
+  ) {
+    if (msg[0] === "EVENT") {
       events.push(msg[2]);
     }
 
     if (events.length === 3) break;
   }
 
-  assertEquals(events.length, 3);
+  deepStrictEqual(events.length, 3);
 
   clearTimeout(tid);
 });
 
-Deno.test('NPool.event', async () => {
+await test("NPool.event", async () => {
   const controller = new AbortController();
   const tid = setTimeout(() => controller.abort(), 5000);
 
-  await using server1 = new TestRelayServer();
-  await using server2 = new TestRelayServer();
+  await using server1 = await TestRelayServer.create();
+  await using server2 = await TestRelayServer.create();
 
   for (const event of event1s) {
     await server1.event(event);
@@ -94,8 +99,9 @@ Deno.test('NPool.event', async () => {
 
   const event: NostrEvent = finalizeEvent({
     kind: 1,
-    content: 'This is an automated test from Nostrify: https://gitlab.com/soapbox-pub/nostrify',
-    tags: [['unique', 'uniqueTag']],
+    content:
+      "This is an automated test from Nostrify: https://gitlab.com/soapbox-pub/nostrify",
+    tags: [["unique", "uniqueTag"]],
     created_at: Math.floor(Date.now() / 1000),
   }, generateSecretKey());
 
@@ -111,7 +117,12 @@ Deno.test('NPool.event', async () => {
 
   await pool.event(event, { signal: controller.signal });
 
-  assertEquals((await pool.query([{ kinds: [1], '#unique': ['uniqueTag'] }], { signal: controller.signal })).length, 1);
+  deepStrictEqual(
+    (await pool.query([{ kinds: [1], "#unique": ["uniqueTag"] }], {
+      signal: controller.signal,
+    })).length,
+    1,
+  );
 
   clearTimeout(tid);
 });

package/NPool.ts

@@ -1,9 +1,16 @@
-import { NostrEvent, NostrFilter, NostrRelayCLOSED, NostrRelayEOSE, NostrRelayEVENT, NRelay } from '@nostrify/types';
+import type {
+  NostrEvent,
+  NostrFilter,
+  NostrRelayCLOSED,
+  NostrRelayEOSE,
+  NostrRelayEVENT,
+  NRelay,
+} from '@nostrify/types';
 import { getFilterLimit } from 'nostr-tools';
 
-import { CircularSet } from './utils/CircularSet.js';
-import { Machina } from './utils/Machina.js';
-import { NSet } from './NSet.js';
+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. */
@@ -49,8 +56,11 @@ export interface NPoolOpts<T extends NRelay> {
  */
 export class NPool<T extends NRelay = NRelay> implements NRelay {
   private _relays = new Map<string, T>();
+  private opts: NPoolOpts<T>;
 
-  constructor(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 {
@@ -111,31 +121,38 @@ export class NPool<T extends NRelay = NRelay> implements NRelay {
     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);
-      (async () => {
-        for await (const msg of relay.req(filters, { signal })) {
-          if (msg[0] === 'EOSE') {
-            eoses.add(url);
-            if (eoses.size === routes.size) {
-              machina.push(msg);
+      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] === '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);
+            if (msg[0] === 'EVENT') {
+              const [, , event] = msg;
+              if (!events.has(event.id)) {
+                events.add(event.id);
+                machina.push(msg);
+              }
             }
           }
+        } catch {
+          // Handle errors silently
         }
-      })().catch(() => {});
+      })();
+      relayPromises.push(relayPromise);
     }
 
     try {
@@ -144,6 +161,8 @@ export class NPool<T extends NRelay = NRelay> implements NRelay {
       }
     } finally {
       controller.abort();
+      // Wait for all relay promises to complete to prevent hanging promises
+      await Promise.allSettled(relayPromises);
     }
   }