@nostrify/nostrify 0.46.7 → 0.46.8

package/NIP05.test.ts

@@ -1,67 +1,59 @@
-import { assertEquals, assertRejects } from '@std/assert';
-import { returnsNext, stub } from '@std/testing/mock';
+import { test } from "node:test";
+import { deepStrictEqual, rejects } from "node:assert";
+import sinon from "sinon";
 
-import { NIP05 } from './NIP05.ts';
+import { NIP05 } from "./NIP05.ts";
 
-Deno.test('NIP05.lookup', async () => {
-  const { default: nostrJson } = await import('../../fixtures/nostr.json', { with: { type: 'json' } });
+await test("NIP05.lookup", async () => {
+  const { default: nostrJson } = await import("../../fixtures/nostr.json", {
+    with: { type: "json" },
+  });
 
-  const fetch = stub(
-    globalThis,
-    'fetch',
-    returnsNext([
-      Promise.resolve(new Response(JSON.stringify(nostrJson))),
-    ]),
-  );
+  const fetchStub = sinon.stub(globalThis, "fetch");
+  fetchStub.resolves(new Response(JSON.stringify(nostrJson)));
 
-  const result = await NIP05.lookup('alex_at_gleasonator.com@mostr.pub', { fetch });
+  const result = await NIP05.lookup("alex_at_gleasonator.com@mostr.pub", {
+    fetch: fetchStub,
+  });
 
   const expected = {
-    pubkey: '79c2cae114ea28a981e7559b4fe7854a473521a8d22a66bbab9fa248eb820ff6',
-    relays: ['wss://relay.mostr.pub'],
+    pubkey: "79c2cae114ea28a981e7559b4fe7854a473521a8d22a66bbab9fa248eb820ff6",
+    relays: ["wss://relay.mostr.pub"],
   };
 
-  assertEquals(result, expected);
-  fetch.restore();
+  deepStrictEqual(result, expected);
+  fetchStub.restore();
 });
 
 // https://github.com/nostrability/nostrability/issues/143#issuecomment-2565772246
-Deno.test('NIP05.lookup with invalid values but valid profile pointer', async () => {
-  const { default: nostrJson } = await import('../../fixtures/lncal.json', { with: { type: 'json' } });
+await test("NIP05.lookup with invalid values but valid profile pointer", async () => {
+  const { default: nostrJson } = await import("../../fixtures/lncal.json", {
+    with: { type: "json" },
+  });
 
-  const fetch = stub(
-    globalThis,
-    'fetch',
-    returnsNext([
-      Promise.resolve(new Response(JSON.stringify(nostrJson))),
-    ]),
-  );
+  const fetchStub = sinon.stub(globalThis, "fetch");
+  fetchStub.resolves(new Response(JSON.stringify(nostrJson)));
 
-  const result = await NIP05.lookup('elsat@lncal.com', { fetch });
+  const result = await NIP05.lookup("elsat@lncal.com", { fetch: fetchStub });
 
   const expected = {
-    pubkey: '17538dc2a62769d09443f18c37cbe358fab5bbf981173542aa7c5ff171ed77c4',
+    pubkey: "17538dc2a62769d09443f18c37cbe358fab5bbf981173542aa7c5ff171ed77c4",
     relays: undefined,
   };
 
-  assertEquals(result, expected);
-  fetch.restore();
+  deepStrictEqual(result, expected);
+  fetchStub.restore();
 });
 
-Deno.test('NIP05.lookup with invalid document', () => {
-  const fetch = stub(
-    globalThis,
-    'fetch',
-    returnsNext([
-      Promise.resolve(new Response(JSON.stringify({ names: 'yolo' }))),
-      Promise.resolve(new Response(JSON.stringify({}))),
-      Promise.resolve(new Response(JSON.stringify([]))),
-    ]),
-  );
+await test("NIP05.lookup with invalid document", () => {
+  const fetchStub = sinon.stub(globalThis, "fetch");
+  fetchStub.onCall(0).resolves(new Response(JSON.stringify({ names: "yolo" })));
+  fetchStub.onCall(1).resolves(new Response(JSON.stringify({})));
+  fetchStub.onCall(2).resolves(new Response(JSON.stringify([])));
 
-  assertRejects(() => NIP05.lookup('alex@gleasonator.dev', { fetch }));
-  assertRejects(() => NIP05.lookup('alex@gleasonator.dev', { fetch }));
-  assertRejects(() => NIP05.lookup('alex@gleasonator.dev', { fetch }));
+  rejects(() => NIP05.lookup("alex@gleasonator.dev", { fetch: fetchStub }));
+  rejects(() => NIP05.lookup("alex@gleasonator.dev", { fetch: fetchStub }));
+  rejects(() => NIP05.lookup("alex@gleasonator.dev", { fetch: fetchStub }));
 
-  fetch.restore();
+  fetchStub.restore();
 });

package/NIP05.ts

@@ -1,6 +1,6 @@
-import { NProfilePointer } from '@nostrify/types';
+import type { NProfilePointer } from '@nostrify/types';
 
-import { NSchema as n, z } from './NSchema.js';
+import { NSchema as n, z } from './NSchema.ts';
 
 interface LookupOpts {
   fetch?: typeof fetch;

package/NIP50.test.ts

@@ -1,58 +1,59 @@
-import { assertEquals } from '@std/assert';
+import { test } from "node:test";
+import { deepStrictEqual } from "node:assert";
 
-import { NIP50 } from './NIP50.ts';
+import { NIP50 } from "./NIP50.ts";
 
-Deno.test('NIP50.parseInput', () => {
-  assertEquals(NIP50.parseInput(''), []);
-  assertEquals(NIP50.parseInput(' '), []);
-  assertEquals(NIP50.parseInput('hello'), ['hello']);
-  assertEquals(NIP50.parseInput('hello world'), ['hello', 'world']);
-  assertEquals(NIP50.parseInput('hello  "world"'), ['hello', 'world']);
+await test("NIP50.parseInput", () => {
+  deepStrictEqual(NIP50.parseInput(""), []);
+  deepStrictEqual(NIP50.parseInput(" "), []);
+  deepStrictEqual(NIP50.parseInput("hello"), ["hello"]);
+  deepStrictEqual(NIP50.parseInput("hello world"), ["hello", "world"]);
+  deepStrictEqual(NIP50.parseInput('hello  "world"'), ["hello", "world"]);
 
-  assertEquals(
+  deepStrictEqual(
     NIP50.parseInput('hello "world" "hello world"'),
-    ['hello', 'world', 'hello world'],
+    ["hello", "world", "hello world"],
   );
 
-  assertEquals(
-    NIP50.parseInput('domain:gleasonator.dev'),
-    [{ key: 'domain', value: 'gleasonator.dev' }],
+  deepStrictEqual(
+    NIP50.parseInput("domain:gleasonator.dev"),
+    [{ key: "domain", value: "gleasonator.dev" }],
   );
 
-  assertEquals(
-    NIP50.parseInput('domain: yolo'),
-    ['domain:', 'yolo'],
+  deepStrictEqual(
+    NIP50.parseInput("domain: yolo"),
+    ["domain:", "yolo"],
   );
 
-  assertEquals(
-    NIP50.parseInput('domain:localhost:8000'),
-    [{ key: 'domain', value: 'localhost:8000' }],
+  deepStrictEqual(
+    NIP50.parseInput("domain:localhost:8000"),
+    [{ key: "domain", value: "localhost:8000" }],
   );
 
-  assertEquals(
+  deepStrictEqual(
     NIP50.parseInput('name:John "New York" age:30 hobbies:programming'),
     [
-      { key: 'name', value: 'John' },
-      'New York',
-      { key: 'age', value: '30' },
-      { key: 'hobbies', value: 'programming' },
+      { key: "name", value: "John" },
+      "New York",
+      { key: "age", value: "30" },
+      { key: "hobbies", value: "programming" },
     ],
   );
 });
 
-Deno.test('NIP50.parseInput with negated token', () => {
-  assertEquals(
-    NIP50.parseInput('-reply:true'),
-    [{ key: '-reply', value: 'true' }],
+await test("NIP50.parseInput with negated token", () => {
+  deepStrictEqual(
+    NIP50.parseInput("-reply:true"),
+    [{ key: "-reply", value: "true" }],
   );
 
-  assertEquals(
-    NIP50.parseInput('hello -reply:true'),
-    ['hello', { key: '-reply', value: 'true' }],
+  deepStrictEqual(
+    NIP50.parseInput("hello -reply:true"),
+    ["hello", { key: "-reply", value: "true" }],
   );
 
-  assertEquals(
-    NIP50.parseInput('-media:true -reply:true'),
-    [{ key: '-media', value: 'true' }, { key: '-reply', value: 'true' }],
+  deepStrictEqual(
+    NIP50.parseInput("-media:true -reply:true"),
+    [{ key: "-media", value: "true" }, { key: "-reply", value: "true" }],
   );
 });

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