@nostrify/nostrify 0.46.4

package/NBrowserSigner.test.ts

@@ -0,0 +1,170 @@
+import { NSecSigner } from '@nostrify/nostrify';
+import { assertEquals, assertRejects } from '@std/assert';
+import { finalizeEvent, generateSecretKey, getPublicKey } from 'nostr-tools';
+
+import { NBrowserSigner } from './NBrowserSigner.ts';
+
+import type { NostrEvent, NostrSigner } from '@nostrify/types';
+
+Deno.test('NBrowserSigner - without extension', async () => {
+  // Ensure no extension is available
+  (globalThis as { nostr?: NostrSigner }).nostr = undefined;
+
+  const signer = new NBrowserSigner();
+
+  await assertRejects(
+    () => signer.getPublicKey(),
+    Error,
+    'Browser extension not available',
+  );
+
+  await assertRejects(
+    () => signer.signEvent({ kind: 1, content: 'Hello, world!', tags: [], created_at: 0 }),
+    Error,
+    'Browser extension not available',
+  );
+});
+
+Deno.test('NBrowserSigner - with extension polyfill', async () => {
+  const secretKey = generateSecretKey();
+  const mockExtension = new NSecSigner(secretKey);
+
+  // Set up the polyfill
+  (globalThis as { nostr?: NostrSigner }).nostr = mockExtension;
+
+  const signer = new NBrowserSigner();
+
+  // Test getPublicKey
+  assertEquals(await signer.getPublicKey(), getPublicKey(secretKey));
+
+  // Test signEvent
+  const template = { kind: 1, content: 'Hello, world!', tags: [], created_at: 0 };
+  assertEquals(await signer.signEvent(template), finalizeEvent(template, secretKey));
+
+  // Clean up
+  (globalThis as { nostr?: NostrSigner }).nostr = undefined;
+});
+
+Deno.test('NBrowserSigner.nip44 - with extension polyfill', async () => {
+  const secretKey = generateSecretKey();
+  const mockExtension = new NSecSigner(secretKey);
+
+  // Set up the polyfill
+  (globalThis as { nostr?: NostrSigner }).nostr = mockExtension;
+
+  const signer = new NBrowserSigner();
+
+  const pubkey = await signer.getPublicKey();
+  const plaintext = 'Hello, world!';
+
+  const ciphertext = await signer.nip44!.encrypt(pubkey, plaintext);
+  assertEquals(await signer.nip44!.decrypt(pubkey, ciphertext), plaintext);
+
+  // Clean up
+  (globalThis as { nostr?: NostrSigner }).nostr = undefined;
+});
+
+Deno.test('NBrowserSigner.nip04 - with extension polyfill', async () => {
+  const secretKey = generateSecretKey();
+  const mockExtension = new NSecSigner(secretKey);
+
+  // Set up the polyfill
+  (globalThis as { nostr?: NostrSigner }).nostr = mockExtension;
+
+  const signer = new NBrowserSigner();
+
+  const pubkey = await signer.getPublicKey();
+  const plaintext = 'Hello, world!';
+
+  const ciphertext = await signer.nip04!.encrypt(pubkey, plaintext);
+  assertEquals(await signer.nip04!.decrypt(pubkey, ciphertext), plaintext);
+
+  // Clean up
+  (globalThis as { nostr?: NostrSigner }).nostr = undefined;
+});
+
+Deno.test('NBrowserSigner.getRelays - with extension polyfill', async () => {
+  const secretKey = generateSecretKey();
+  const mockExtension = new NSecSigner(secretKey);
+
+  // Set up the polyfill
+  (globalThis as { nostr?: NostrSigner }).nostr = mockExtension;
+
+  const signer = new NBrowserSigner();
+
+  // Since NSecSigner doesn't implement getRelays, this should return empty object
+  const relays = await signer.getRelays();
+  assertEquals(relays, {});
+
+  // Clean up
+  (globalThis as { nostr?: NostrSigner }).nostr = undefined;
+});
+
+Deno.test('NBrowserSigner - missing nip44 support', () => {
+  // Create a mock extension without nip44 support
+  const mockExtension = {
+    // deno-lint-ignore require-await
+    getPublicKey: async () => 'pubkey',
+    // deno-lint-ignore require-await
+    signEvent: async (event: NostrEvent) => event,
+    // No nip44 property
+  };
+
+  (globalThis as { nostr?: NostrSigner }).nostr = mockExtension;
+
+  const signer = new NBrowserSigner();
+
+  // Should return undefined when nip44 is not supported
+  assertEquals(signer.nip44, undefined);
+
+  // Clean up
+  (globalThis as { nostr?: NostrSigner }).nostr = undefined;
+});
+
+Deno.test('NBrowserSigner - missing nip04 support', () => {
+  // Create a mock extension without nip04 support
+  const mockExtension = {
+    // deno-lint-ignore require-await
+    getPublicKey: async () => 'pubkey',
+    // deno-lint-ignore require-await
+    signEvent: async (event: NostrEvent) => event,
+    // No nip04 property
+  };
+
+  (globalThis as { nostr?: NostrSigner }).nostr = mockExtension;
+
+  const signer = new NBrowserSigner();
+
+  // Should return undefined when nip04 is not supported
+  assertEquals(signer.nip04, undefined);
+
+  // Clean up
+  (globalThis as { nostr?: NostrSigner }).nostr = undefined;
+});
+
+Deno.test('NBrowserSigner - feature detection', () => {
+  const secretKey = generateSecretKey();
+  const mockExtension = new NSecSigner(secretKey);
+
+  // Set up the polyfill
+  (globalThis as { nostr?: NostrSigner }).nostr = mockExtension;
+
+  const signer = new NBrowserSigner();
+
+  // Should be able to detect nip44 support
+  if (signer.nip44) {
+    // This should work since NSecSigner supports nip44
+    assertEquals(typeof signer.nip44.encrypt, 'function');
+    assertEquals(typeof signer.nip44.decrypt, 'function');
+  }
+
+  // Should be able to detect nip04 support
+  if (signer.nip04) {
+    // This should work since NSecSigner supports nip04
+    assertEquals(typeof signer.nip04.encrypt, 'function');
+    assertEquals(typeof signer.nip04.decrypt, 'function');
+  }
+
+  // Clean up
+  (globalThis as { nostr?: NostrSigner }).nostr = undefined;
+});

package/NBrowserSigner.ts

@@ -0,0 +1,100 @@
+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/NCache.bench.ts

@@ -0,0 +1,81 @@
+import { finalizeEvent, generateSecretKey } from 'nostr-tools';
+
+import { NCache } from './NCache.ts';
+
+import events from '../../fixtures/events.json' with { type: 'json' };
+
+const cache = new NCache({ max: 5000 });
+
+// Seed cache with 1000 events.
+for (const event of events) {
+  await cache.event(event);
+}
+
+Deno.bench('NCache.event', async (b) => {
+  const secretKey = generateSecretKey();
+  const event = finalizeEvent({
+    kind: 1,
+    content: 'hello world!',
+    created_at: Math.floor(Date.now() / 1000),
+    tags: [['t', 'test']],
+  }, secretKey);
+
+  b.start();
+
+  await cache.event(event);
+});
+
+Deno.bench('NCache.event with many tags', async (b) => {
+  const secretKey = generateSecretKey();
+
+  const tags: string[][] = new Array(300)
+    .fill('')
+    .map(() => ['p', '570a9c85c7dd56eca0d8c7f258d7fc178f1b2bb3aab4136ba674dc4879eee88a']);
+
+  const event = finalizeEvent({
+    kind: 1,
+    content: 'hello world!',
+    created_at: Math.floor(Date.now() / 1000),
+    tags,
+  }, secretKey);
+
+  b.start();
+
+  await cache.event(event);
+});
+
+Deno.bench('NCache.query by id', async () => {
+  await cache.query([{ ids: ['119abcfcebf253a6b1af1a03e2ff1c05798c2f46cadfa2efc98eaef686095292'], limit: 1 }]);
+});
+
+Deno.bench('NCache.query by multiple ids', async () => {
+  await cache.query([{
+    ids: [
+      '119abcfcebf253a6b1af1a03e2ff1c05798c2f46cadfa2efc98eaef686095292',
+      'a9d877196e64eec8645c9c28a1051f3cdde94b6272c0769517f47cfae518ea0c',
+    ],
+    limit: 20,
+  }]);
+});
+
+Deno.bench('NCache.query by kind', async () => {
+  await cache.query([{ kinds: [1], limit: 20 }]);
+});
+
+Deno.bench('NCache.query by multiple kinds', async () => {
+  await cache.query([{ kinds: [6, 7], limit: 20 }]);
+});
+
+Deno.bench('NCache.query by author', async () => {
+  await cache.query([{ authors: ['753d025936c8c3238b1b2b2f748be6df92743c2201e5198946e9d6a29156793f'], limit: 20 }]);
+});
+
+Deno.bench('NCache.query by multiple authors', async () => {
+  await cache.query([{
+    authors: [
+      '753d025936c8c3238b1b2b2f748be6df92743c2201e5198946e9d6a29156793f',
+      '79c2cae114ea28a981e7559b4fe7854a473521a8d22a66bbab9fa248eb820ff6',
+    ],
+    limit: 20,
+  }]);
+});

package/NCache.test.ts

@@ -0,0 +1,22 @@
+import { assertEquals } from '@std/assert';
+
+import { NCache } from './NCache.ts';
+
+import event1 from '../../fixtures/event-1.json' with { type: 'json' };
+
+Deno.test('NCache', async () => {
+  const cache = new NCache({
+    max: 3000,
+    maxEntrySize: 5000,
+    sizeCalculation: (event) => JSON.stringify(event).length,
+  });
+
+  assertEquals(await cache.count([{ ids: [event1.id] }]), { count: 0, approximate: false });
+
+  await cache.event(event1);
+
+  assertEquals(await cache.count([{ ids: [event1.id] }]), { count: 1, approximate: false });
+
+  const result = await cache.query([{ ids: [event1.id] }]);
+  assertEquals(result[0], event1);
+});

package/NCache.ts

@@ -0,0 +1,73 @@
+// deno-lint-ignore-file require-await
+
+import { NostrEvent, NostrFilter, NostrRelayCOUNT, NStore } from '@nostrify/types';
+import { LRUCache } from 'lru-cache';
+import { matchFilters } from 'nostr-tools';
+
+import { NSet } from './NSet';
+
+/**
+ * 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/NConnectSigner.test.ts

@@ -0,0 +1,102 @@
+import { NostrConnectResponse } from '@nostrify/types';
+import { assert, assertEquals } from '@std/assert';
+import { generateSecretKey, verifyEvent } from 'nostr-tools';
+
+import { MockRelay } from './test/MockRelay.ts';
+import { NConnectSigner } from './NConnectSigner.ts';
+import { NSchema as n } from './NSchema.ts';
+import { NSecSigner } from './NSecSigner.ts';
+
+Deno.test('NConnectSigner.signEvent with nip04 encryption', async () => {
+  const relay = new MockRelay();
+  const remote = new NSecSigner(generateSecretKey());
+  const pubkey = await remote.getPublicKey();
+
+  const connect = new NConnectSigner({
+    relay,
+    pubkey,
+    signer: new NSecSigner(generateSecretKey()),
+    encryption: 'nip04',
+  });
+
+  const req = relay.req([{ kinds: [24133], '#p': [pubkey] }]);
+
+  const promise = connect.signEvent({
+    kind: 1,
+    content: 'hello world',
+    tags: [],
+    created_at: Math.floor(Date.now() / 1000),
+  });
+
+  for await (const msg of req) {
+    if (msg[0] === 'EVENT') {
+      const event = msg[2];
+      const decrypted = await remote.nip04!.decrypt(event.pubkey, event.content);
+      const request = n.json().pipe(n.connectRequest()).parse(decrypted);
+      assertEquals(request.method, 'sign_event');
+      const response: NostrConnectResponse = {
+        id: request.id,
+        result: JSON.stringify(await remote.signEvent(JSON.parse(request.params[0]))),
+      };
+      await relay.event(
+        await remote.signEvent({
+          kind: 24133,
+          content: await remote.nip04!.encrypt(event.pubkey, JSON.stringify(response)),
+          tags: [['p', event.pubkey]],
+          created_at: Math.floor(Date.now() / 1000),
+        }),
+      );
+      break;
+    }
+  }
+
+  assert(verifyEvent(await promise));
+  assertEquals(relay.subs.size, 0); // cleanup
+});
+
+Deno.test('NConnectSigner.signEvent with nip44 encryption', async () => {
+  const relay = new MockRelay();
+  const remote = new NSecSigner(generateSecretKey());
+  const pubkey = await remote.getPublicKey();
+
+  const connect = new NConnectSigner({
+    relay,
+    pubkey,
+    signer: new NSecSigner(generateSecretKey()),
+    encryption: 'nip44',
+  });
+
+  const req = relay.req([{ kinds: [24133], '#p': [pubkey] }]);
+
+  const promise = connect.signEvent({
+    kind: 1,
+    content: 'hello world',
+    tags: [],
+    created_at: Math.floor(Date.now() / 1000),
+  });
+
+  for await (const msg of req) {
+    if (msg[0] === 'EVENT') {
+      const event = msg[2];
+      const decrypted = await remote.nip44!.decrypt(event.pubkey, event.content);
+      const request = n.json().pipe(n.connectRequest()).parse(decrypted);
+      assertEquals(request.method, 'sign_event');
+      const response: NostrConnectResponse = {
+        id: request.id,
+        result: JSON.stringify(await remote.signEvent(JSON.parse(request.params[0]))),
+      };
+      await relay.event(
+        await remote.signEvent({
+          kind: 24133,
+          content: await remote.nip44!.encrypt(event.pubkey, JSON.stringify(response)),
+          tags: [['p', event.pubkey]],
+          created_at: Math.floor(Date.now() / 1000),
+        }),
+      );
+      break;
+    }
+  }
+
+  assert(verifyEvent(await promise));
+  assertEquals(relay.subs.size, 0); // cleanup
+});