nip46: fix legacyDecrypt argument.

- Fix "TypeError: Invalid redirect value, must be one of "follow" or "manual" ("error" won't be implemented since it does not make sense at the edge; use "manual" and check the response status code)." that is thrown when trying to use fetch in the edge environment  (e.g., workers)
- Cleanup types and variable definitions.

.devcontainer/Dockerfile

@@ -0,0 +1,19 @@
+FROM node:20
+
+RUN npm install typescript eslint prettier -g
+
+# Install bun
+RUN curl -fsSL https://bun.sh/install | bash
+
+# Install just
+WORKDIR /usr/bin
+RUN wget https://github.com/casey/just/releases/download/1.26.0/just-1.26.0-x86_64-unknown-linux-musl.tar.gz
+RUN tar -xzf just-1.26.0-x86_64-unknown-linux-musl.tar.gz
+RUN chmod +x ./just
+RUN rm just-1.26.0-x86_64-unknown-linux-musl.tar.gz
+
+WORKDIR /nostr-tools
+ENV LANG C.UTF-8
+
+# The run the start script
+CMD [ "/bin/bash" ]

.devcontainer/devcontainer.json

@@ -0,0 +1,19 @@
+{
+  "name": "Nostr Tools",
+  "dockerComposeFile": [
+    "docker-compose.yml"
+  ],
+  "service": "nostr-tools-dev",
+  "workspaceFolder": "/nostr-tools",
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "ms-vscode.vscode-typescript-next",
+        "eamodio.gitlens",
+        "dbaeumer.vscode-eslint",
+        "manishsencha.readme-preview",
+        "wix.vscode-import-cost"
+      ]
+    }
+  }
+}

.devcontainer/docker-compose.yml

@@ -0,0 +1,13 @@
+version: '3.9'
+
+services:
+  nostr-tools-dev:
+    image: nostr-tools-dev
+    container_name: nostr-tools-dev
+    build:
+      context: ../.
+      dockerfile: ./.devcontainer/Dockerfile
+    working_dir: /nostr-tools
+    volumes:
+      - ..:/nostr-tools:cached
+    tty: true

.eslintrc.json

@@ -116,7 +116,8 @@
     "no-unexpected-multiline": 2,
     "no-unneeded-ternary": [2, { "defaultAssignment": false }],
     "no-unreachable": 2,
-    "no-unused-vars": [2, { "vars": "local", "args": "none", "varsIgnorePattern": "^_" }],
+    "no-unused-vars": "off",
+    "@typescript-eslint/no-unused-vars": [2, { "vars": "local", "args": "none", "varsIgnorePattern": "^_" }],
     "no-useless-call": 2,
     "no-useless-constructor": 2,
     "no-with": 2,

.github/workflows/publish.yml

@@ -1,18 +0,0 @@
-name: Publish
-
-on:
-  push:
-    branches:
-      - master
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write # The OIDC ID token is used for authentication with JSR.    
-    steps:
-      - uses: actions/checkout@v4
-      - uses: oven-sh/setup-bun@v1
-      - run: bun i
-      - run: npx jsr publish

README.md

@@ -1,19 +1,27 @@
-# ![](https://img.shields.io/github/actions/workflow/status/nbd-wtf/nostr-tools/test.yml) nostr-tools
+# ![](https://img.shields.io/github/actions/workflow/status/nbd-wtf/nostr-tools/test.yml) [![JSR](https://jsr.io/badges/@nostr/tools)](https://jsr.io/@nostr/tools) nostr-tools
 
 Tools for developing [Nostr](https://github.com/fiatjaf/nostr) clients.
 
 Only depends on _@scure_ and _@noble_ packages.
 
-This package is only providing lower-level functionality. If you want an easy-to-use fully-fledged solution that abstracts the hard parts of Nostr and makes decisions on your behalf, take a look at [NDK](https://github.com/nostr-dev-kit/ndk) and [@snort/system](https://www.npmjs.com/package/@snort/system).
+This package is only providing lower-level functionality. If you want more higher-level features, take a look at [Nostrify](https://nostrify.dev), or if you want an easy-to-use fully-fledged solution that abstracts the hard parts of Nostr and makes decisions on your behalf, take a look at [NDK](https://github.com/nostr-dev-kit/ndk) and [@snort/system](https://www.npmjs.com/package/@snort/system).
 
 ## Installation
 
 ```bash
- npm install nostr-tools # or yarn add nostr-tools
+# npm
+npm install --save nostr-tools
+
+# jsr
+npx jsr add @nostr/tools
 ```
 
 If using TypeScript, this package requires TypeScript >= 5.0.
 
+## Documentation
+
+https://jsr.io/@nostr/tools/doc
+
 ## Usage
 
 ### Generating a private key and a public key
@@ -25,6 +33,15 @@ let sk = generateSecretKey() // `sk` is a Uint8Array
 let pk = getPublicKey(sk) // `pk` is a hex string
 ```
 
+To get the secret key in hex format, use
+
+```js
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils' // already an installed dependency
+
+let skHex = bytesToHex(sk)
+let backToBytes = hexToBytes(skHex)
+```
+
 ### Creating, signing and verifying events
 
 ```js
@@ -67,7 +84,7 @@ const sub = relay.subscribe([
 let sk = generateSecretKey()
 let pk = getPublicKey(sk)
 
-relay.sub([
+relay.subscribe([
   {
     kinds: [1],
     authors: [pk],
@@ -95,8 +112,11 @@ relay.close()
 To use this on Node.js you first must install `ws` and call something like this:
 
 ```js
-import { useWebSocketImplementation } from 'nostr-tools/relay'
-useWebSocketImplementation(require('ws'))
+import { useWebSocketImplementation } from 'nostr-tools/pool'
+// or import { useWebSocketImplementation } from 'nostr-tools/relay' if you're using the Relay directly
+
+import WebSocket from 'ws'
+useWebSocketImplementation(WebSocket)
 ```
 
 ### Interacting with multiple relays
@@ -129,7 +149,7 @@ let h = pool.subscribeMany(
 await Promise.any(pool.publish(relays, newEvent))
 console.log('published to at least one relay!')
 
-let events = await pool.querySync(relays, [{ kinds: [0, 1] }])
+let events = await pool.querySync(relays, { kinds: [0, 1] })
 let event = await pool.get(relays, {
   ids: ['44e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245'],
 })
@@ -174,6 +194,43 @@ import { useFetchImplementation } from 'nostr-tools/nip05'
 useFetchImplementation(require('node-fetch'))
 ```
 
+### Including NIP-07 types
+```js
+import type { WindowNostr } from 'nostr-tools/nip07'
+
+declare global {
+  interface Window {
+    nostr?: WindowNostr;
+  }
+}
+```
+
+
+### Generating NIP-06 keys
+```js
+import {
+  privateKeyFromSeedWords,
+  accountFromSeedWords,
+  extendedKeysFromSeedWords,
+  accountFromExtendedKey
+} from 'nostr-tools/nip06'
+
+const mnemonic = 'zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong'
+const passphrase = '123' // optional
+const accountIndex = 0
+const sk0 = privateKeyFromSeedWords(mnemonic, passphrase, accountIndex)
+
+const { privateKey: sk1, publicKey: pk1 } = accountFromSeedWords(mnemonic, passphrase, accountIndex)
+
+const extendedAccountIndex = 0
+
+const { privateExtendedKey, publicExtendedKey } = extendedKeysFromSeedWords(mnemonic, passphrase, extendedAccountIndex)
+
+const { privateKey: sk2, publicKey: pk2 } = accountFromExtendedKey(privateExtendedKey)
+
+const { publicKey: pk3 } = accountFromExtendedKey(publicExtendedKey)
+```
+
 ### Encoding and decoding NIP-19 codes
 
 ```js

abstract-pool.ts

@@ -1,4 +1,11 @@
-import { AbstractRelay as AbstractRelay, SubscriptionParams, Subscription } from './abstract-relay.ts'
+/* global WebSocket */
+
+import {
+  AbstractRelay as AbstractRelay,
+  SubscriptionParams,
+  Subscription,
+  type AbstractRelayConstructorOptions,
+} from './abstract-relay.ts'
 import { normalizeURL } from './utils.ts'
 
 import type { Event, Nostr } from './core.ts'
@@ -7,6 +14,8 @@ import { alwaysTrue } from './helpers.ts'
 
 export type SubCloser = { close: () => void }
 
+export type AbstractPoolConstructorOptions = AbstractRelayConstructorOptions & {}
+
 export type SubscribeManyParams = Omit<SubscriptionParams, 'onclose' | 'id'> & {
   maxWait?: number
   onclose?: (reasons: string[]) => void
@@ -14,15 +23,18 @@ export type SubscribeManyParams = Omit<SubscriptionParams, 'onclose' | 'id'> & {
 }
 
 export class AbstractSimplePool {
-  private relays = new Map<string, AbstractRelay>()
+  protected relays: Map<string, AbstractRelay> = new Map()
   public seenOn: Map<string, Set<AbstractRelay>> = new Map()
   public trackRelays: boolean = false
 
   public verifyEvent: Nostr['verifyEvent']
   public trustedRelayURLs: Set<string> = new Set()
 
-  constructor(opts: { verifyEvent: Nostr['verifyEvent'] }) {
+  private _WebSocket?: typeof WebSocket
+
+  constructor(opts: AbstractPoolConstructorOptions) {
     this.verifyEvent = opts.verifyEvent
+    this._WebSocket = opts.websocketImplementation
   }
 
   async ensureRelay(url: string, params?: { connectionTimeout?: number }): Promise<AbstractRelay> {
@@ -32,6 +44,7 @@ export class AbstractSimplePool {
     if (!relay) {
       relay = new AbstractRelay(url, {
         verifyEvent: this.trustedRelayURLs.has(url) ? alwaysTrue : this.verifyEvent,
+        websocketImplementation: this._WebSocket,
       })
       if (params?.connectionTimeout) relay.connectionTimeout = params.connectionTimeout
       this.relays.set(url, relay)
@@ -48,6 +61,10 @@ export class AbstractSimplePool {
   }
 
   subscribeMany(relays: string[], filters: Filter[], params: SubscribeManyParams): SubCloser {
+    return this.subscribeManyMap(Object.fromEntries(relays.map(url => [url, filters])), params)
+  }
+
+  subscribeManyMap(requests: { [relay: string]: Filter[] }, params: SubscribeManyParams): SubCloser {
     if (this.trackRelays) {
       params.receivedEvent = (relay: AbstractRelay, id: string) => {
         let set = this.seenOn.get(id)
@@ -61,12 +78,13 @@ export class AbstractSimplePool {
 
     const _knownIds = new Set<string>()
     const subs: Subscription[] = []
+    const relaysLength = Object.keys(requests).length
 
     // batch all EOSEs into a single
     const eosesReceived: boolean[] = []
     let handleEose = (i: number) => {
       eosesReceived[i] = true
-      if (eosesReceived.filter(a => a).length === relays.length) {
+      if (eosesReceived.filter(a => a).length === relaysLength) {
         params.oneose?.()
         handleEose = () => {}
       }
@@ -76,7 +94,7 @@ export class AbstractSimplePool {
     let handleClose = (i: number, reason: string) => {
       handleEose(i)
       closesReceived[i] = reason
-      if (closesReceived.filter(a => a).length === relays.length) {
+      if (closesReceived.filter(a => a).length === relaysLength) {
         params.onclose?.(closesReceived)
         handleClose = () => {}
       }
@@ -93,13 +111,16 @@ export class AbstractSimplePool {
 
     // open a subscription in all given relays
     const allOpened = Promise.all(
-      relays.map(normalizeURL).map(async (url, i, arr) => {
-        if (arr.indexOf(url) !== i) {
+      Object.entries(requests).map(async (req, i, arr) => {
+        if (arr.indexOf(req) !== i) {
           // duplicate
           handleClose(i, 'duplicate url')
           return
         }
 
+        let [url, filters] = req
+        url = normalizeURL(url)
+
         let relay: AbstractRelay
         try {
           relay = await this.ensureRelay(url, {
@@ -184,7 +205,29 @@ export class AbstractSimplePool {
       }
 
       let r = await this.ensureRelay(url)
-      return r.publish(event)
+      return r.publish(event).then(reason => {
+        if (this.trackRelays) {
+          let set = this.seenOn.get(event.id)
+          if (!set) {
+            set = new Set()
+            this.seenOn.set(event.id, set)
+          }
+          set.add(r)
+        }
+        return reason
+      })
     })
   }
+
+  listConnectionStatus(): Map<string, boolean> {
+    const map = new Map<string, boolean>()
+    this.relays.forEach((relay, url) => map.set(url, relay.connected))
+
+    return map
+  }
+
+  destroy(): void {
+    this.relays.forEach(conn => conn.close())
+    this.relays = new Map()
+  }
 }

abstract-relay.ts

@@ -7,14 +7,9 @@ import { Queue, normalizeURL } from './utils.ts'
 import { makeAuthEvent } from './nip42.ts'
 import { yieldThread } from './helpers.ts'
 
-var _WebSocket: typeof WebSocket
-
-try {
-  _WebSocket = WebSocket
-} catch {}
-
-export function useWebSocketImplementation(websocketImplementation: any) {
-  _WebSocket = websocketImplementation
+export type AbstractRelayConstructorOptions = {
+  verifyEvent: Nostr['verifyEvent']
+  websocketImplementation?: typeof WebSocket
 }
 
 export class AbstractRelay {
@@ -24,8 +19,12 @@ export class AbstractRelay {
   public onclose: (() => void) | null = null
   public onnotice: (msg: string) => void = msg => console.debug(`NOTICE from ${this.url}: ${msg}`)
 
+  // this is exposed just to help in ndk migration, shouldn't be relied upon
+  public _onauth: ((challenge: string) => void) | null = null
+
   public baseEoseTimeout: number = 4400
   public connectionTimeout: number = 4400
+  public publishTimeout: number = 4400
   public openSubs: Map<string, Subscription> = new Map()
   private connectionTimeoutHandle: ReturnType<typeof setTimeout> | undefined
 
@@ -39,12 +38,15 @@ export class AbstractRelay {
   private serial: number = 0
   private verifyEvent: Nostr['verifyEvent']
 
-  constructor(url: string, opts: { verifyEvent: Nostr['verifyEvent'] }) {
+  private _WebSocket: typeof WebSocket
+
+  constructor(url: string, opts: AbstractRelayConstructorOptions) {
     this.url = normalizeURL(url)
     this.verifyEvent = opts.verifyEvent
+    this._WebSocket = opts.websocketImplementation || WebSocket
   }
 
-  static async connect(url: string, opts: { verifyEvent: Nostr['verifyEvent'] }): Promise<AbstractRelay> {
+  static async connect(url: string, opts: AbstractRelayConstructorOptions): Promise<AbstractRelay> {
     const relay = new AbstractRelay(url, opts)
     await relay.connect()
     return relay
@@ -84,7 +86,7 @@ export class AbstractRelay {
       }, this.connectionTimeout)
 
       try {
-        this.ws = new _WebSocket(this.url)
+        this.ws = new this._WebSocket(this.url)
       } catch (err) {
         reject(err)
         return
@@ -97,19 +99,22 @@ export class AbstractRelay {
       }
 
       this.ws.onerror = ev => {
-        reject((ev as any).message)
+        reject((ev as any).message || 'websocket error')
         if (this._connected) {
+          this._connected = false
+          this.connectionPromise = undefined
           this.onclose?.()
           this.closeAllSubscriptions('relay connection errored')
-          this._connected = false
         }
       }
 
       this.ws.onclose = async () => {
-        this.connectionPromise = undefined
-        this.onclose?.()
-        this.closeAllSubscriptions('relay connection closed')
-        this._connected = false
+        if (this._connected) {
+          this._connected = false
+          this.connectionPromise = undefined
+          this.onclose?.()
+          this.closeAllSubscriptions('relay connection closed')
+        }
       }
 
       this.ws.onmessage = this._onmessage.bind(this)
@@ -194,9 +199,11 @@ export class AbstractRelay {
           const ok: boolean = data[2]
           const reason: string = data[3]
           const ep = this.openEventPublishes.get(id) as EventPublishResolver
-          if (ok) ep.resolve(reason)
-          else ep.reject(new Error(reason))
-          this.openEventPublishes.delete(id)
+          if (ep) {
+            if (ok) ep.resolve(reason)
+            else ep.reject(new Error(reason))
+            this.openEventPublishes.delete(id)
+          }
           return
         }
         case 'CLOSED': {
@@ -212,6 +219,7 @@ export class AbstractRelay {
           return
         case 'AUTH': {
           this.challenge = data[1] as string
+          this._onauth?.(data[1] as string)
           return
         }
       }
@@ -243,6 +251,13 @@ export class AbstractRelay {
       this.openEventPublishes.set(event.id, { resolve, reject })
     })
     this.send('["EVENT",' + JSON.stringify(event) + ']')
+    setTimeout(() => {
+      const ep = this.openEventPublishes.get(event.id) as EventPublishResolver
+      if (ep) {
+        ep.reject(new Error('publish timed out'))
+        this.openEventPublishes.delete(event.id)
+      }
+    }, this.publishTimeout)
     return ret
   }
 
@@ -252,11 +267,11 @@ export class AbstractRelay {
     const ret = new Promise<number>((resolve, reject) => {
       this.openCountRequests.set(id, { resolve, reject })
     })
-    this.send('["COUNT","' + id + '",' + JSON.stringify(filters) + ']')
+    this.send('["COUNT","' + id + '",' + JSON.stringify(filters).substring(1))
     return ret
   }
 
-  public subscribe(filters: Filter[], params: Partial<SubscriptionParams>): Subscription {
+  public subscribe(filters: Filter[], params: Partial<SubscriptionParams> & { id?: string }): Subscription {
     const subscription = this.prepareSubscription(filters, params)
     subscription.fire()
     return subscription
@@ -338,7 +353,7 @@ export class Subscription {
   }
 
   public close(reason: string = 'closed by caller') {
-    if (!this.closed) {
+    if (!this.closed && this.relay.connected) {
       // if the connection was closed by the user calling .close() we will send a CLOSE message
       // otherwise this._open will be already set to false so we will skip this
       this.relay.send('["CLOSE",' + JSON.stringify(this.id) + ']')

benchmarks.ts

@@ -1,8 +1,8 @@
 import { run, bench, group, baseline } from 'mitata'
 import { initNostrWasm } from 'nostr-wasm'
-import { NostrEvent } from './core'
-import { finalizeEvent, generateSecretKey } from './pure'
-import { setNostrWasm, verifyEvent } from './wasm'
+import { NostrEvent } from './core.ts'
+import { finalizeEvent, generateSecretKey } from './pure.ts'
+import { setNostrWasm, verifyEvent } from './wasm.ts'
 import { AbstractRelay } from './abstract-relay.ts'
 import { Relay as PureRelay } from './relay.ts'
 import { alwaysTrue } from './helpers.ts'

core.test.ts

@@ -1,293 +1,18 @@
-import { describe, test, expect } from 'bun:test'
+import { test, expect } from 'bun:test'
+import { sortEvents } from './core.ts'
 
-import {
-  finalizeEvent,
-  serializeEvent,
-  getEventHash,
-  validateEvent,
-  verifyEvent,
-  verifiedSymbol,
-  getPublicKey,
-  generateSecretKey,
-} from './pure.ts'
-import { ShortTextNote } from './kinds.ts'
-import { bytesToHex, hexToBytes } from '@noble/hashes/utils'
+test('sortEvents', () => {
+  const events = [
+    { id: 'abc123', pubkey: 'key1', created_at: 1610000000, kind: 1, tags: [], content: 'Hello', sig: 'sig1' },
+    { id: 'abc124', pubkey: 'key2', created_at: 1620000000, kind: 1, tags: [], content: 'World', sig: 'sig2' },
+    { id: 'abc125', pubkey: 'key3', created_at: 1620000000, kind: 1, tags: [], content: '!', sig: 'sig3' },
+  ]
 
-test('private key generation', () => {
-  expect(bytesToHex(generateSecretKey())).toMatch(/[a-f0-9]{64}/)
-})
-
-test('public key generation', () => {
-  expect(getPublicKey(generateSecretKey())).toMatch(/[a-f0-9]{64}/)
-})
-
-test('public key from private key deterministic', () => {
-  let sk = generateSecretKey()
-  let pk = getPublicKey(sk)
-
-  for (let i = 0; i < 5; i++) {
-    expect(getPublicKey(sk)).toEqual(pk)
-  }
-})
-
-describe('finalizeEvent', () => {
-  test('should create a signed event from a template', () => {
-    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
-    const publicKey = getPublicKey(privateKey)
-
-    const template = {
-      kind: ShortTextNote,
-      tags: [],
-      content: 'Hello, world!',
-      created_at: 1617932115,
-    }
-
-    const event = finalizeEvent(template, privateKey)
-
-    expect(event.kind).toEqual(template.kind)
-    expect(event.tags).toEqual(template.tags)
-    expect(event.content).toEqual(template.content)
-    expect(event.created_at).toEqual(template.created_at)
-    expect(event.pubkey).toEqual(publicKey)
-    expect(typeof event.id).toEqual('string')
-    expect(typeof event.sig).toEqual('string')
-  })
-})
-
-describe('serializeEvent', () => {
-  test('should serialize a valid event object', () => {
-    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
-    const publicKey = getPublicKey(privateKey)
-
-    const unsignedEvent = {
-      pubkey: publicKey,
-      created_at: 1617932115,
-      kind: ShortTextNote,
-      tags: [],
-      content: 'Hello, world!',
-    }
-
-    const serializedEvent = serializeEvent(unsignedEvent)
-
-    expect(serializedEvent).toEqual(
-      JSON.stringify([
-        0,
-        publicKey,
-        unsignedEvent.created_at,
-        unsignedEvent.kind,
-        unsignedEvent.tags,
-        unsignedEvent.content,
-      ]),
-    )
-  })
-
-  test('should throw an error for an invalid event object', () => {
-    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
-    const publicKey = getPublicKey(privateKey)
-
-    const invalidEvent = {
-      kind: ShortTextNote,
-      tags: [],
-      created_at: 1617932115,
-      pubkey: publicKey, // missing content
-    }
-
-    expect(() => {
-      // @ts-expect-error
-      serializeEvent(invalidEvent)
-    }).toThrow("can't serialize event with wrong or missing properties")
-  })
-})
-
-describe('getEventHash', () => {
-  test('should return the correct event hash', () => {
-    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
-    const publicKey = getPublicKey(privateKey)
-
-    const unsignedEvent = {
-      kind: ShortTextNote,
-      tags: [],
-      content: 'Hello, world!',
-      created_at: 1617932115,
-      pubkey: publicKey,
-    }
-
-    const eventHash = getEventHash(unsignedEvent)
-
-    expect(typeof eventHash).toEqual('string')
-    expect(eventHash.length).toEqual(64)
-  })
-})
-
-describe('validateEvent', () => {
-  test('should return true for a valid event object', () => {
-    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
-    const publicKey = getPublicKey(privateKey)
-
-    const unsignedEvent = {
-      kind: ShortTextNote,
-      tags: [],
-      content: 'Hello, world!',
-      created_at: 1617932115,
-      pubkey: publicKey,
-    }
-
-    const isValid = validateEvent(unsignedEvent)
-
-    expect(isValid).toEqual(true)
-  })
-
-  test('should return false for a non object event', () => {
-    const nonObjectEvent = ''
-    const isValid = validateEvent(nonObjectEvent)
-    expect(isValid).toEqual(false)
-  })
-
-  test('should return false for an event object with missing properties', () => {
-    const invalidEvent = {
-      kind: ShortTextNote,
-      tags: [],
-      created_at: 1617932115, // missing content and pubkey
-    }
-
-    const isValid = validateEvent(invalidEvent)
-
-    expect(isValid).toEqual(false)
-  })
-
-  test('should return false for an empty object', () => {
-    const emptyObj = {}
-
-    const isValid = validateEvent(emptyObj)
-
-    expect(isValid).toEqual(false)
-  })
-
-  test('should return false for an object with invalid properties', () => {
-    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
-    const publicKey = getPublicKey(privateKey)
-
-    const invalidEvent = {
-      kind: 1,
-      tags: [],
-      created_at: '1617932115', // should be a number
-      pubkey: publicKey,
-    }
-
-    const isValid = validateEvent(invalidEvent)
-
-    expect(isValid).toEqual(false)
-  })
-
-  test('should return false for an object with an invalid public key', () => {
-    const invalidEvent = {
-      kind: 1,
-      tags: [],
-      content: 'Hello, world!',
-      created_at: 1617932115,
-      pubkey: 'invalid_pubkey',
-    }
-
-    const isValid = validateEvent(invalidEvent)
-
-    expect(isValid).toEqual(false)
-  })
-
-  test('should return false for an object with invalid tags', () => {
-    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
-    const publicKey = getPublicKey(privateKey)
-
-    const invalidEvent = {
-      kind: 1,
-      tags: {}, // should be an array
-      content: 'Hello, world!',
-      created_at: 1617932115,
-      pubkey: publicKey,
-    }
-
-    const isValid = validateEvent(invalidEvent)
-
-    expect(isValid).toEqual(false)
-  })
-})
-
-describe('verifyEvent', () => {
-  test('should return true for a valid event signature', () => {
-    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
-    const event = finalizeEvent(
-      {
-        kind: ShortTextNote,
-        tags: [],
-        content: 'Hello, world!',
-        created_at: 1617932115,
-      },
-      privateKey,
-    )
-
-    const isValid = verifyEvent(event)
-    expect(isValid).toEqual(true)
-  })
-
-  test('should return false for an invalid event signature', () => {
-    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
-    const { [verifiedSymbol]: _, ...event } = finalizeEvent(
-      {
-        kind: ShortTextNote,
-        tags: [],
-        content: 'Hello, world!',
-        created_at: 1617932115,
-      },
-      privateKey,
-    )
-
-    // tamper with the signature
-    event.sig = event.sig.replace(/^.{3}/g, '666')
-
-    const isValid = verifyEvent(event)
-    expect(isValid).toEqual(false)
-  })
-
-  test('should return false when verifying an event with a different private key', () => {
-    const privateKey1 = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
-
-    const privateKey2 = hexToBytes('5b4a34f4e4b23c63ad55a35e3f84a3b53d96dbf266edf521a8358f71d19cbf67')
-    const publicKey2 = getPublicKey(privateKey2)
-
-    const { [verifiedSymbol]: _, ...event } = finalizeEvent(
-      {
-        kind: ShortTextNote,
-        tags: [],
-        content: 'Hello, world!',
-        created_at: 1617932115,
-      },
-      privateKey1,
-    )
-
-    // verify with different private key
-    const isValid = verifyEvent({
-      ...event,
-      pubkey: publicKey2,
-    })
-    expect(isValid).toEqual(false)
-  })
-
-  test('should return false for an invalid event id', () => {
-    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
-
-    const { [verifiedSymbol]: _, ...event } = finalizeEvent(
-      {
-        kind: 1,
-        tags: [],
-        content: 'Hello, world!',
-        created_at: 1617932115,
-      },
-      privateKey,
-    )
-
-    // tamper with the id
-    event.id = event.id.replace(/^.{3}/g, '666')
-
-    const isValid = verifyEvent(event)
-    expect(isValid).toEqual(false)
-  })
+  const sortedEvents = sortEvents(events)
+
+  expect(sortedEvents).toEqual([
+    { id: 'abc124', pubkey: 'key2', created_at: 1620000000, kind: 1, tags: [], content: 'World', sig: 'sig2' },
+    { id: 'abc125', pubkey: 'key3', created_at: 1620000000, kind: 1, tags: [], content: '!', sig: 'sig3' },
+    { id: 'abc123', pubkey: 'key1', created_at: 1610000000, kind: 1, tags: [], content: 'Hello', sig: 'sig1' },
+  ])
 })

core.ts

@@ -49,3 +49,17 @@ export function validateEvent<T>(event: T): event is T & UnsignedEvent {
 
   return true
 }
+
+/**
+ * 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.
+ */
+export function sortEvents(events: Event[]): Event[] {
+  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)
+  })
+}

filter.test.ts

@@ -13,7 +13,6 @@ describe('Filter', () => {
         until: 200,
         '#tag': ['value'],
       }
-
       const event = buildEvent({
         id: '123',
         kind: 1,
@@ -21,39 +20,21 @@ describe('Filter', () => {
         created_at: 150,
         tags: [['tag', 'value']],
       })
-
       const result = matchFilter(filter, event)
-
       expect(result).toEqual(true)
     })
 
     test('should return false when the event id is not in the filter', () => {
       const filter = { ids: ['123', '456'] }
-
       const event = buildEvent({ id: '789' })
-
       const result = matchFilter(filter, event)
-
       expect(result).toEqual(false)
     })
 
-    test('should return true when the event id starts with a prefix', () => {
-      const filter = { ids: ['22', '00'] }
-
-      const event = buildEvent({ id: '001' })
-
-      const result = matchFilter(filter, event)
-
-      expect(result).toEqual(true)
-    })
-
     test('should return false when the event kind is not in the filter', () => {
       const filter = { kinds: [1, 2, 3] }
-
       const event = buildEvent({ kind: 4 })
-
       const result = matchFilter(filter, event)
-
       expect(result).toEqual(false)
     })
 
@@ -154,25 +135,8 @@ describe('Filter', () => {
         { ids: ['456'], kinds: [2], authors: ['def'] },
         { ids: ['789'], kinds: [3], authors: ['ghi'] },
       ]
-
       const event = buildEvent({ id: '789', kind: 3, pubkey: 'ghi' })
-
       const result = matchFilters(filters, event)
-
-      expect(result).toEqual(true)
-    })
-
-    test('should return true when at least one prefix matches the event', () => {
-      const filters = [
-        { ids: ['1'], kinds: [1], authors: ['a'] },
-        { ids: ['4'], kinds: [2], authors: ['d'] },
-        { ids: ['9'], kinds: [3], authors: ['g'] },
-      ]
-
-      const event = buildEvent({ id: '987', kind: 3, pubkey: 'ghi' })
-
-      const result = matchFilters(filters, event)
-
       expect(result).toEqual(true)
     })
 
@@ -201,11 +165,8 @@ describe('Filter', () => {
         { ids: ['456'], kinds: [2], authors: ['def'] },
         { ids: ['789'], kinds: [3], authors: ['ghi'] },
       ]
-
       const event = buildEvent({ id: '100', kind: 4, pubkey: 'jkl' })
-
       const result = matchFilters(filters, event)
-
       expect(result).toEqual(false)
     })
 
@@ -221,9 +182,7 @@ describe('Filter', () => {
         pubkey: 'def',
         created_at: 200,
       })
-
       const result = matchFilters(filters, event)
-
       expect(result).toEqual(false)
     })
   })
@@ -256,6 +215,16 @@ describe('Filter', () => {
       expect(getFilterLimit({ kinds: [0, 3], authors: ['alex', 'fiatjaf'] })).toEqual(4)
     })
 
+    test('should handle parameterized replaceable events', () => {
+      expect(getFilterLimit({ kinds: [30078], authors: ['alex'] })).toEqual(Infinity)
+      expect(getFilterLimit({ kinds: [30078], authors: ['alex'], '#d': ['ditto'] })).toEqual(1)
+      expect(getFilterLimit({ kinds: [30078], authors: ['alex'], '#d': ['ditto', 'soapbox'] })).toEqual(2)
+      expect(getFilterLimit({ kinds: [30078], authors: ['alex', 'fiatjaf'], '#d': ['ditto', 'soapbox'] })).toEqual(4)
+      expect(
+        getFilterLimit({ kinds: [30000, 30078], authors: ['alex', 'fiatjaf'], '#d': ['ditto', 'soapbox'] }),
+      ).toEqual(8)
+    })
+
     test('should return Infinity for authors with regular kinds', () => {
       expect(getFilterLimit({ kinds: [1], authors: ['alex'] })).toEqual(Infinity)
     })
@@ -263,5 +232,9 @@ describe('Filter', () => {
     test('should return Infinity for empty filters', () => {
       expect(getFilterLimit({})).toEqual(Infinity)
     })
+
+    test('empty tags return 0', () => {
+      expect(getFilterLimit({ '#p': [] })).toEqual(0)
+    })
   })
 })

filter.ts

@@ -1,5 +1,5 @@
 import { Event } from './core.ts'
-import { isReplaceableKind } from './kinds.ts'
+import { isParameterizedReplaceableKind, isReplaceableKind } from './kinds.ts'
 
 export type Filter = {
   ids?: string[]
@@ -14,15 +14,13 @@ export type Filter = {
 
 export function matchFilter(filter: Filter, event: Event): boolean {
   if (filter.ids && filter.ids.indexOf(event.id) === -1) {
-    if (!filter.ids.some(prefix => event.id.startsWith(prefix))) {
-      return false
-    }
+    return false
+  }
+  if (filter.kinds && filter.kinds.indexOf(event.kind) === -1) {
+    return false
   }
-  if (filter.kinds && filter.kinds.indexOf(event.kind) === -1) return false
   if (filter.authors && filter.authors.indexOf(event.pubkey) === -1) {
-    if (!filter.authors.some(prefix => event.pubkey.startsWith(prefix))) {
-      return false
-    }
+    return false
   }
 
   for (let f in filter) {
@@ -41,7 +39,9 @@ export function matchFilter(filter: Filter, event: Event): boolean {
 
 export function matchFilters(filters: Filter[], event: Event): boolean {
   for (let i = 0; i < filters.length; i++) {
-    if (matchFilter(filters[i], event)) return true
+    if (matchFilter(filters[i], event)) {
+      return true
+    }
   }
   return false
 }
@@ -72,17 +72,34 @@ export function mergeFilters(...filters: Filter[]): Filter {
   return result
 }
 
-/** Calculate the intrinsic limit of a filter. This function may return `Infinity`. */
+/**
+ * Calculate the intrinsic limit of a filter.
+ * This function returns a positive integer, or `Infinity` if there is no intrinsic limit.
+ */
 export function getFilterLimit(filter: Filter): number {
   if (filter.ids && !filter.ids.length) return 0
   if (filter.kinds && !filter.kinds.length) return 0
   if (filter.authors && !filter.authors.length) return 0
 
+  for (const [key, value] of Object.entries(filter)) {
+    if (key[0] === '#' && Array.isArray(value) && !value.length) return 0
+  }
+
   return Math.min(
+    // The `limit` property creates an artificial limit.
     Math.max(0, filter.limit ?? Infinity),
+
+    // There can only be one event per `id`.
     filter.ids?.length ?? Infinity,
+
+    // Replaceable events are limited by the number of authors and kinds.
     filter.authors?.length && filter.kinds?.every(kind => isReplaceableKind(kind))
       ? filter.authors.length * filter.kinds.length
       : Infinity,
+
+    // Parameterized replaceable events are limited by the number of authors, kinds, and "d" tags.
+    filter.authors?.length && filter.kinds?.every(kind => isParameterizedReplaceableKind(kind)) && filter['#d']?.length
+      ? filter.authors.length * filter.kinds.length * filter['#d'].length
+      : Infinity,
   )
 }

index.ts

@@ -1,7 +1,7 @@
 export * from './pure.ts'
-export * from './relay.ts'
+export { Relay } from './relay.ts'
 export * from './filter.ts'
-export * from './pool.ts'
+export { SimplePool } from './pool.ts'
 export * from './references.ts'
 
 export * as nip04 from './nip04.ts'
@@ -21,6 +21,7 @@ export * as nip42 from './nip42.ts'
 export * as nip44 from './nip44.ts'
 export * as nip47 from './nip47.ts'
 export * as nip57 from './nip57.ts'
+export * as nip59 from './nip59.ts'
 export * as nip98 from './nip98.ts'
 
 export * as kinds from './kinds.ts'

jsr.json

@@ -1,5 +1,48 @@
 {
   "name": "@nostr/tools",
-  "version": "2.3.1",
-  "exports": "./index.ts"
-}
+  "version": "2.10.1",
+  "exports": {
+    ".": "./index.ts",
+    "./core": "./core.ts",
+    "./pure": "./pure.ts",
+    "./wasm": "./wasm.ts",
+    "./kinds": "./kinds.ts",
+    "./filter": "./filter.ts",
+    "./abstract-relay": "./abstract-relay.ts",
+    "./relay": "./relay.ts",
+    "./abstract-pool": "./abstract-pool.ts",
+    "./pool": "./pool.ts",
+    "./references": "./references.ts",
+    "./nip04": "./nip04.ts",
+    "./nip05": "./nip05.ts",
+    "./nip06": "./nip06.ts",
+    "./nip07": "./nip07.ts",
+    "./nip10": "./nip10.ts",
+    "./nip11": "./nip11.ts",
+    "./nip13": "./nip13.ts",
+    "./nip17": "./nip17.ts",
+    "./nip18": "./nip18.ts",
+    "./nip19": "./nip19.ts",
+    "./nip21": "./nip21.ts",
+    "./nip25": "./nip25.ts",
+    "./nip27": "./nip27.ts",
+    "./nip28": "./nip28.ts",
+    "./nip29": "./nip29.ts",
+    "./nip30": "./nip30.ts",
+    "./nip39": "./nip39.ts",
+    "./nip42": "./nip42.ts",
+    "./nip44": "./nip44.ts",
+    "./nip46": "./nip46.ts",
+    "./nip49": "./nip49.ts",
+    "./nip57": "./nip57.ts",
+    "./nip58": "./nip58.ts",
+    "./nip59": "./nip59.ts",
+    "./nip75": "./nip75.ts",
+    "./nip94": "./nip94.ts",
+    "./nip96": "./nip96.ts",
+    "./nip98": "./nip98.ts",
+    "./nip99": "./nip99.ts",
+    "./fakejson": "./fakejson.ts",
+    "./utils": "./utils.ts"
+  }
+}

kinds.test.ts

@@ -1,5 +1,6 @@
-import { test, expect } from 'bun:test'
-import { classifyKind } from './kinds.ts'
+import { expect, test } from 'bun:test'
+import { classifyKind, isKind, Repost, ShortTextNote } from './kinds.ts'
+import { finalizeEvent, generateSecretKey } from './pure.ts'
 
 test('kind classification', () => {
   expect(classifyKind(1)).toBe('regular')
@@ -19,3 +20,22 @@ test('kind classification', () => {
   expect(classifyKind(40000)).toBe('unknown')
   expect(classifyKind(255)).toBe('unknown')
 })
+
+test('kind type guard', () => {
+  const privateKey = generateSecretKey()
+  const repostedEvent = finalizeEvent(
+    {
+      kind: ShortTextNote,
+      tags: [
+        ['e', 'replied event id'],
+        ['p', 'replied event pubkey'],
+      ],
+      content: 'Replied to a post',
+      created_at: 1617932115,
+    },
+    privateKey,
+  )
+
+  expect(isKind(repostedEvent, ShortTextNote)).toBeTrue()
+  expect(isKind(repostedEvent, Repost)).toBeFalse()
+})

kinds.ts

@@ -1,3 +1,5 @@
+import { NostrEvent, validateEvent } from './pure.ts'
+
 /** Events are **regular**, which means they're all expected to be stored by relays. */
 export function isRegularKind(kind: number): boolean {
   return (1000 <= kind && kind < 10000) || [1, 2, 4, 5, 6, 7, 8, 16, 40, 41, 42, 43, 44].includes(kind)
@@ -30,77 +32,162 @@ export function classifyKind(kind: number): KindClassification {
   return 'unknown'
 }
 
+export function isKind<T extends number>(event: unknown, kind: T | Array<T>): event is NostrEvent & { kind: T } {
+  const kindAsArray: number[] = kind instanceof Array ? kind : [kind]
+  return (validateEvent(event) && kindAsArray.includes(event.kind)) || false
+}
+
 export const Metadata = 0
+export type Metadata = typeof Metadata
 export const ShortTextNote = 1
+export type ShortTextNote = typeof ShortTextNote
 export const RecommendRelay = 2
+export type RecommendRelay = typeof RecommendRelay
 export const Contacts = 3
+export type Contacts = typeof Contacts
 export const EncryptedDirectMessage = 4
-export const EncryptedDirectMessages = 4
+export type EncryptedDirectMessage = typeof EncryptedDirectMessage
 export const EventDeletion = 5
+export type EventDeletion = typeof EventDeletion
 export const Repost = 6
+export type Repost = typeof Repost
 export const Reaction = 7
+export type Reaction = typeof Reaction
 export const BadgeAward = 8
+export type BadgeAward = typeof BadgeAward
+export const Seal = 13
+export type Seal = typeof Seal
+export const PrivateDirectMessage = 14
+export type PrivateDirectMessage = typeof PrivateDirectMessage
 export const GenericRepost = 16
+export type GenericRepost = typeof GenericRepost
 export const ChannelCreation = 40
+export type ChannelCreation = typeof ChannelCreation
 export const ChannelMetadata = 41
+export type ChannelMetadata = typeof ChannelMetadata
 export const ChannelMessage = 42
+export type ChannelMessage = typeof ChannelMessage
 export const ChannelHideMessage = 43
+export type ChannelHideMessage = typeof ChannelHideMessage
 export const ChannelMuteUser = 44
+export type ChannelMuteUser = typeof ChannelMuteUser
 export const OpenTimestamps = 1040
+export type OpenTimestamps = typeof OpenTimestamps
+export const GiftWrap = 1059
+export type GiftWrap = typeof GiftWrap
 export const FileMetadata = 1063
+export type FileMetadata = typeof FileMetadata
 export const LiveChatMessage = 1311
+export type LiveChatMessage = typeof LiveChatMessage
 export const ProblemTracker = 1971
+export type ProblemTracker = typeof ProblemTracker
 export const Report = 1984
+export type Report = typeof Report
 export const Reporting = 1984
+export type Reporting = typeof Reporting
 export const Label = 1985
+export type Label = typeof Label
 export const CommunityPostApproval = 4550
+export type CommunityPostApproval = typeof CommunityPostApproval
 export const JobRequest = 5999
+export type JobRequest = typeof JobRequest
 export const JobResult = 6999
+export type JobResult = typeof JobResult
 export const JobFeedback = 7000
+export type JobFeedback = typeof JobFeedback
 export const ZapGoal = 9041
+export type ZapGoal = typeof ZapGoal
 export const ZapRequest = 9734
+export type ZapRequest = typeof ZapRequest
 export const Zap = 9735
+export type Zap = typeof Zap
 export const Highlights = 9802
+export type Highlights = typeof Highlights
 export const Mutelist = 10000
+export type Mutelist = typeof Mutelist
 export const Pinlist = 10001
+export type Pinlist = typeof Pinlist
 export const RelayList = 10002
+export type RelayList = typeof RelayList
 export const BookmarkList = 10003
+export type BookmarkList = typeof BookmarkList
 export const CommunitiesList = 10004
+export type CommunitiesList = typeof CommunitiesList
 export const PublicChatsList = 10005
+export type PublicChatsList = typeof PublicChatsList
 export const BlockedRelaysList = 10006
+export type BlockedRelaysList = typeof BlockedRelaysList
 export const SearchRelaysList = 10007
+export type SearchRelaysList = typeof SearchRelaysList
 export const InterestsList = 10015
+export type InterestsList = typeof InterestsList
 export const UserEmojiList = 10030
+export type UserEmojiList = typeof UserEmojiList
+export const DirectMessageRelaysList = 10050
+export type DirectMessageRelaysList = typeof DirectMessageRelaysList
 export const FileServerPreference = 10096
+export type FileServerPreference = typeof FileServerPreference
 export const NWCWalletInfo = 13194
+export type NWCWalletInfo = typeof NWCWalletInfo
 export const LightningPubRPC = 21000
+export type LightningPubRPC = typeof LightningPubRPC
 export const ClientAuth = 22242
+export type ClientAuth = typeof ClientAuth
 export const NWCWalletRequest = 23194
+export type NWCWalletRequest = typeof NWCWalletRequest
 export const NWCWalletResponse = 23195
+export type NWCWalletResponse = typeof NWCWalletResponse
 export const NostrConnect = 24133
+export type NostrConnect = typeof NostrConnect
 export const HTTPAuth = 27235
+export type HTTPAuth = typeof HTTPAuth
 export const Followsets = 30000
+export type Followsets = typeof Followsets
 export const Genericlists = 30001
+export type Genericlists = typeof Genericlists
 export const Relaysets = 30002
+export type Relaysets = typeof Relaysets
 export const Bookmarksets = 30003
+export type Bookmarksets = typeof Bookmarksets
 export const Curationsets = 30004
+export type Curationsets = typeof Curationsets
 export const ProfileBadges = 30008
+export type ProfileBadges = typeof ProfileBadges
 export const BadgeDefinition = 30009
+export type BadgeDefinition = typeof BadgeDefinition
 export const Interestsets = 30015
+export type Interestsets = typeof Interestsets
 export const CreateOrUpdateStall = 30017
+export type CreateOrUpdateStall = typeof CreateOrUpdateStall
 export const CreateOrUpdateProduct = 30018
+export type CreateOrUpdateProduct = typeof CreateOrUpdateProduct
 export const LongFormArticle = 30023
+export type LongFormArticle = typeof LongFormArticle
 export const DraftLong = 30024
+export type DraftLong = typeof DraftLong
 export const Emojisets = 30030
+export type Emojisets = typeof Emojisets
 export const Application = 30078
+export type Application = typeof Application
 export const LiveEvent = 30311
+export type LiveEvent = typeof LiveEvent
 export const UserStatuses = 30315
+export type UserStatuses = typeof UserStatuses
 export const ClassifiedListing = 30402
+export type ClassifiedListing = typeof ClassifiedListing
 export const DraftClassifiedListing = 30403
+export type DraftClassifiedListing = typeof DraftClassifiedListing
 export const Date = 31922
+export type Date = typeof Date
 export const Time = 31923
+export type Time = typeof Time
 export const Calendar = 31924
+export type Calendar = typeof Calendar
 export const CalendarEventRSVP = 31925
+export type CalendarEventRSVP = typeof CalendarEventRSVP
 export const Handlerrecommendation = 31989
+export type Handlerrecommendation = typeof Handlerrecommendation
 export const Handlerinformation = 31990
+export type Handlerinformation = typeof Handlerinformation
 export const CommunityDefinition = 34550
+export type CommunityDefinition = typeof CommunityDefinition

nip05.test.ts

@@ -1,18 +1,44 @@
 import { test, expect } from 'bun:test'
-import fetch from 'node-fetch'
 
-import { useFetchImplementation, queryProfile } from './nip05.ts'
+import { useFetchImplementation, queryProfile, NIP05_REGEX, isNip05 } from './nip05.ts'
+
+test('validate NIP05_REGEX', () => {
+  expect(NIP05_REGEX.test('_@bob.com.br')).toBeTrue()
+  expect(NIP05_REGEX.test('bob@bob.com.br')).toBeTrue()
+  expect(NIP05_REGEX.test('b&b@bob.com.br')).toBeFalse()
+
+  expect('b&b@bob.com.br'.match(NIP05_REGEX)).toBeNull()
+  expect(Array.from('bob@bob.com.br'.match(NIP05_REGEX) || [])).toEqual(['bob@bob.com.br', 'bob', 'bob.com.br', '.br'])
+
+  expect(isNip05('bob@bob.com.br')).toBeTrue()
+  expect(isNip05('b&b@bob.com.br')).toBeFalse()
+})
 
 test('fetch nip05 profiles', async () => {
-  useFetchImplementation(fetch)
+  const fetchStub = async (url: string) => ({
+    status: 200,
+    async json() {
+      return {
+        'https://compile-error.net/.well-known/nostr.json?name=_': {
+          names: { _: '2c7cc62a697ea3a7826521f3fd34f0cb273693cbe5e9310f35449f43622a5cdc' },
+        },
+        'https://fiatjaf.com/.well-known/nostr.json?name=_': {
+          names: { _: '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d' },
+          relays: {
+            '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d': [
+              'wss://pyramid.fiatjaf.com',
+              'wss://nos.lol',
+            ],
+          },
+        },
+      }[url]
+    },
+  })
 
-  let p1 = await queryProfile('jb55.com')
-  expect(p1!.pubkey).toEqual('32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245')
-  expect(p1!.relays).toEqual(['wss://relay.damus.io'])
+  useFetchImplementation(fetchStub)
 
-  let p2 = await queryProfile('jb55@jb55.com')
-  expect(p2!.pubkey).toEqual('32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245')
-  expect(p2!.relays).toEqual(['wss://relay.damus.io'])
+  let p2 = await queryProfile('compile-error.net')
+  expect(p2!.pubkey).toEqual('2c7cc62a697ea3a7826521f3fd34f0cb273693cbe5e9310f35449f43622a5cdc')
 
   let p3 = await queryProfile('_@fiatjaf.com')
   expect(p3!.pubkey).toEqual('3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d')

nip05.ts

@@ -1,5 +1,7 @@
 import { ProfilePointer } from './nip19.ts'
 
+export type Nip05 = `${string}@${string}`
+
 /**
  * NIP-05 regex. The localpart is optional, and should be assumed to be `_` otherwise.
  *
@@ -8,21 +10,28 @@ import { ProfilePointer } from './nip19.ts'
  * - 2: domain
  */
 export const NIP05_REGEX = /^(?:([\w.+-]+)@)?([\w_-]+(\.[\w_-]+)+)$/
+export const isNip05 = (value?: string | null): value is Nip05 => NIP05_REGEX.test(value || '')
 
-var _fetch: any
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let _fetch: any
 
 try {
   _fetch = fetch
-} catch {}
+} catch (_) {
+  null
+}
 
-export function useFetchImplementation(fetchImplementation: any) {
+export function useFetchImplementation(fetchImplementation: unknown) {
   _fetch = fetchImplementation
 }
 
 export async function searchDomain(domain: string, query = ''): Promise<{ [name: string]: string }> {
   try {
     const url = `https://${domain}/.well-known/nostr.json?name=${query}`
-    const res = await _fetch(url, { redirect: 'error' })
+    const res = await _fetch(url, { redirect: 'manual' })
+    if (res.status !== 200) {
+      throw Error('Wrong response code')
+    }
     const json = await res.json()
     return json.names
   } catch (_) {
@@ -34,20 +43,24 @@ export async function queryProfile(fullname: string): Promise<ProfilePointer | n
   const match = fullname.match(NIP05_REGEX)
   if (!match) return null
 
-  const [_, name = '_', domain] = match
+  const [, name = '_', domain] = match
 
   try {
     const url = `https://${domain}/.well-known/nostr.json?name=${name}`
-    const res = await (await _fetch(url, { redirect: 'error' })).json()
+    const res = await _fetch(url, { redirect: 'manual' })
+    if (res.status !== 200) {
+      throw Error('Wrong response code')
+    }
+    const json = await res.json()
 
-    let pubkey = res.names[name]
-    return pubkey ? { pubkey, relays: res.relays?.[pubkey] } : null
+    const pubkey = json.names[name]
+    return pubkey ? { pubkey, relays: json.relays?.[pubkey] } : null
   } catch (_e) {
     return null
   }
 }
 
-export async function isValid(pubkey: string, nip05: string): Promise<boolean> {
-  let res = await queryProfile(nip05)
+export async function isValid(pubkey: string, nip05: Nip05): Promise<boolean> {
+  const res = await queryProfile(nip05)
   return res ? res.pubkey === pubkey : false
 }

nip06.test.ts

@@ -1,28 +1,77 @@
 import { test, expect } from 'bun:test'
-import { privateKeyFromSeedWords } from './nip06.ts'
+import {
+  privateKeyFromSeedWords,
+  accountFromSeedWords,
+  extendedKeysFromSeedWords,
+  accountFromExtendedKey,
+} from './nip06.ts'
+import { hexToBytes } from '@noble/hashes/utils'
 
 test('generate private key from a mnemonic', async () => {
   const mnemonic = 'zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong'
   const privateKey = privateKeyFromSeedWords(mnemonic)
-  expect(privateKey).toEqual('c26cf31d8ba425b555ca27d00ca71b5008004f2f662470f8c8131822ec129fe2')
+  expect(privateKey).toEqual(hexToBytes('c26cf31d8ba425b555ca27d00ca71b5008004f2f662470f8c8131822ec129fe2'))
 })
 
 test('generate private key for account 1 from a mnemonic', async () => {
   const mnemonic = 'zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong'
   const privateKey = privateKeyFromSeedWords(mnemonic, undefined, 1)
-  expect(privateKey).toEqual('b5fc7f229de3fb5c189063e3b3fc6c921d8f4366cff5bd31c6f063493665eb2b')
+  expect(privateKey).toEqual(hexToBytes('b5fc7f229de3fb5c189063e3b3fc6c921d8f4366cff5bd31c6f063493665eb2b'))
 })
 
 test('generate private key from a mnemonic and passphrase', async () => {
   const mnemonic = 'zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong'
   const passphrase = '123'
   const privateKey = privateKeyFromSeedWords(mnemonic, passphrase)
-  expect(privateKey).toEqual('55a22b8203273d0aaf24c22c8fbe99608e70c524b17265641074281c8b978ae4')
+  expect(privateKey).toEqual(hexToBytes('55a22b8203273d0aaf24c22c8fbe99608e70c524b17265641074281c8b978ae4'))
 })
 
 test('generate private key for account 1 from a mnemonic and passphrase', async () => {
   const mnemonic = 'zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong'
   const passphrase = '123'
   const privateKey = privateKeyFromSeedWords(mnemonic, passphrase, 1)
-  expect(privateKey).toEqual('2e0f7bd9e3c3ebcdff1a90fb49c913477e7c055eba1a415d571b6a8c714c7135')
+  expect(privateKey).toEqual(hexToBytes('2e0f7bd9e3c3ebcdff1a90fb49c913477e7c055eba1a415d571b6a8c714c7135'))
+})
+
+test('generate private and public key for account 1 from a mnemonic and passphrase', async () => {
+  const mnemonic = 'zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong'
+  const passphrase = '123'
+  const { privateKey, publicKey } = accountFromSeedWords(mnemonic, passphrase, 1)
+  expect(privateKey).toEqual(hexToBytes('2e0f7bd9e3c3ebcdff1a90fb49c913477e7c055eba1a415d571b6a8c714c7135'))
+  expect(publicKey).toEqual('13f55f4f01576570ea342eb7d2b611f9dc78f8dc601aeb512011e4e73b90cf0a')
+})
+
+test('generate extended keys from mnemonic', () => {
+  const mnemonic = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'
+  const passphrase = ''
+  const extendedAccountIndex = 0
+  const { privateExtendedKey, publicExtendedKey } = extendedKeysFromSeedWords(
+    mnemonic,
+    passphrase,
+    extendedAccountIndex,
+  )
+
+  expect(privateExtendedKey).toBe(
+    'xprv9z78fizET65qsCaRr1MSutTSGk1fcKfSt1sBqmuWShtkjRJJ4WCKcSnha6EmgNzFSsyom3MWtydHyPtJtSLZQUtictVQtM2vkPcguh6TQCH',
+  )
+  expect(publicExtendedKey).toBe(
+    'xpub6D6V5EX8HTe95getx2tTH2QApmrA1nPJFEnneAK813RjcDdSc3WaAF7BRNpTF7o7zXjVm3DD3VMX66jhQ7wLaZ9sS6NzyfiwfzqDZbxvpDN',
+  )
+})
+
+test('generate account from extended private key', () => {
+  const xprv =
+    'xprv9z78fizET65qsCaRr1MSutTSGk1fcKfSt1sBqmuWShtkjRJJ4WCKcSnha6EmgNzFSsyom3MWtydHyPtJtSLZQUtictVQtM2vkPcguh6TQCH'
+  const { privateKey, publicKey } = accountFromExtendedKey(xprv)
+
+  expect(privateKey).toEqual(hexToBytes('5f29af3b9676180290e77a4efad265c4c2ff28a5302461f73597fda26bb25731'))
+  expect(publicKey).toBe('e8bcf3823669444d0b49ad45d65088635d9fd8500a75b5f20b59abefa56a144f')
+})
+
+test('generate account from extended public key', () => {
+  const xpub =
+    'xpub6D6V5EX8HTe95getx2tTH2QApmrA1nPJFEnneAK813RjcDdSc3WaAF7BRNpTF7o7zXjVm3DD3VMX66jhQ7wLaZ9sS6NzyfiwfzqDZbxvpDN'
+  const { publicKey } = accountFromExtendedKey(xpub)
+
+  expect(publicKey).toBe('e8bcf3823669444d0b49ad45d65088635d9fd8500a75b5f20b59abefa56a144f')
 })

nip06.ts

@@ -3,11 +3,67 @@ import { wordlist } from '@scure/bip39/wordlists/english'
 import { generateMnemonic, mnemonicToSeedSync, validateMnemonic } from '@scure/bip39'
 import { HDKey } from '@scure/bip32'
 
-export function privateKeyFromSeedWords(mnemonic: string, passphrase?: string, accountIndex = 0): string {
+const DERIVATION_PATH = `m/44'/1237'`
+
+export function privateKeyFromSeedWords(mnemonic: string, passphrase?: string, accountIndex = 0): Uint8Array {
   let root = HDKey.fromMasterSeed(mnemonicToSeedSync(mnemonic, passphrase))
-  let privateKey = root.derive(`m/44'/1237'/${accountIndex}'/0/0`).privateKey
+  let privateKey = root.derive(`${DERIVATION_PATH}/${accountIndex}'/0/0`).privateKey
   if (!privateKey) throw new Error('could not derive private key')
-  return bytesToHex(privateKey)
+  return privateKey
+}
+
+export function accountFromSeedWords(
+  mnemonic: string,
+  passphrase?: string,
+  accountIndex = 0,
+): {
+  privateKey: Uint8Array
+  publicKey: string
+} {
+  const root = HDKey.fromMasterSeed(mnemonicToSeedSync(mnemonic, passphrase))
+  const seed = root.derive(`${DERIVATION_PATH}/${accountIndex}'/0/0`)
+  const publicKey = bytesToHex(seed.publicKey!.slice(1))
+  const privateKey = seed.privateKey
+  if (!privateKey || !publicKey) {
+    throw new Error('could not derive key pair')
+  }
+  return { privateKey, publicKey }
+}
+
+export function extendedKeysFromSeedWords(
+  mnemonic: string,
+  passphrase?: string,
+  extendedAccountIndex = 0,
+): {
+  privateExtendedKey: string
+  publicExtendedKey: string
+} {
+  let root = HDKey.fromMasterSeed(mnemonicToSeedSync(mnemonic, passphrase))
+  let seed = root.derive(`${DERIVATION_PATH}/${extendedAccountIndex}'`)
+  let privateExtendedKey = seed.privateExtendedKey
+  let publicExtendedKey = seed.publicExtendedKey
+  if (!privateExtendedKey && !publicExtendedKey) throw new Error('could not derive extended key pair')
+  return { privateExtendedKey, publicExtendedKey }
+}
+
+export function accountFromExtendedKey(
+  base58key: string,
+  accountIndex = 0,
+): {
+  privateKey?: Uint8Array
+  publicKey: string
+} {
+  let extendedKey = HDKey.fromExtendedKey(base58key)
+  let version = base58key.slice(0, 4)
+  let child = extendedKey.deriveChild(0).deriveChild(accountIndex)
+  let publicKey = bytesToHex(child.publicKey!.slice(1))
+  if (!publicKey) throw new Error('could not derive public key')
+  if (version === 'xprv') {
+    let privateKey = child.privateKey!
+    if (!privateKey) throw new Error('could not derive private key')
+    return { privateKey, publicKey }
+  }
+  return { publicKey }
 }
 
 export function generateSeedWords(): string {

nip07.ts

@@ -0,0 +1,16 @@
+import { EventTemplate, NostrEvent } from './core.ts'
+import { RelayRecord } from './relay.ts'
+
+export interface WindowNostr {
+  getPublicKey(): Promise<string>
+  signEvent(event: EventTemplate): Promise<NostrEvent>
+  getRelays(): Promise<RelayRecord>
+  nip04?: {
+    encrypt(pubkey: string, plaintext: string): Promise<string>
+    decrypt(pubkey: string, ciphertext: string): Promise<string>
+  }
+  nip44?: {
+    encrypt(pubkey: string, plaintext: string): Promise<string>
+    decrypt(pubkey: string, ciphertext: string): Promise<string>
+  }
+}

nip11.test.ts

@@ -1,17 +1,16 @@
 import { describe, test, expect } from 'bun:test'
 import fetch from 'node-fetch'
-import { useFetchImplementation, fetchRelayInformation } from './nip11'
+import { useFetchImplementation, fetchRelayInformation } from './nip11.ts'
 
 // TODO: replace with a mock
 describe('requesting relay as for NIP11', () => {
   useFetchImplementation(fetch)
 
   test('testing a relay', async () => {
-    const info = await fetchRelayInformation('wss://atlas.nostr.land')
-    expect(info.name).toEqual('nostr.land')
-    expect(info.description).toContain('nostr.land family')
-    expect(info.fees).toBeTruthy()
+    const info = await fetchRelayInformation('wss://nos.lol')
+    expect(info.name).toEqual('nos.lol')
+    expect(info.description).toContain('Generally accepts notes, except spammy ones.')
     expect(info.supported_nips).toEqual([1, 2, 4, 9, 11, 12, 16, 20, 22, 28, 33, 40])
-    expect(info.software).toEqual('custom')
+    expect(info.software).toEqual('git+https://github.com/hoytech/strfry.git')
   })
 })

nip11.ts

@@ -68,7 +68,7 @@ export interface BasicRelayInformation {
  * from `[` to `]` and is after UTF-8 serialization (so some
  * unicode characters will cost 2-3 bytes). It is equal to
  * the maximum size of the WebSocket message frame.
- * @param max_subscription total number of subscriptions
+ * @param max_subscriptions total number of subscriptions
  * that may be active on a single websocket connection to
  * this relay. It's possible that authenticated clients with
  * a (paid) relationship to the relay may have higher limits.
@@ -101,12 +101,17 @@ export interface BasicRelayInformation {
  * authentication to happen before a new connection may
  * perform any other action. Even if set to False,
  * authentication may be required for specific actions.
+ * @param restricted_writes: this relay requires some kind
+ * of condition to be fulfilled in order to accept events
+ * (not necessarily, but including
  * @param payment_required this relay requires payment
  * before a new connection may perform any action.
+ * @param created_at_lower_limit: 'created_at' lower limit
+ * @param created_at_upper_limit: 'created_at' upper limit
  */
 export interface Limitations {
   max_message_length: number
-  max_subscription: number
+  max_subscriptions: number
   max_filters: number
   max_limit: number
   max_subid_length: number
@@ -116,6 +121,9 @@ export interface Limitations {
   min_pow_difficulty: number
   auth_required: boolean
   payment_required: boolean
+  created_at_lower_limit: number
+  created_at_upper_limit: number
+  restricted_writes: boolean
 }
 
 interface RetentionDetails {

nip13.test.ts

@@ -2,9 +2,14 @@ import { test, expect } from 'bun:test'
 import { getPow, minePow } from './nip13.ts'
 
 test('identifies proof-of-work difficulty', async () => {
-  const id = '000006d8c378af1779d2feebc7603a125d99eca0ccf1085959b307f64e5dd358'
-  const difficulty = getPow(id)
-  expect(difficulty).toEqual(21)
+  ;[
+    ['000006d8c378af1779d2feebc7603a125d99eca0ccf1085959b307f64e5dd358', 21],
+    ['6bf5b4f434813c64b523d2b0e6efe18f3bd0cbbd0a5effd8ece9e00fd2531996', 1],
+    ['00003479309ecdb46b1c04ce129d2709378518588bed6776e60474ebde3159ae', 18],
+    ['01a76167d41add96be4959d9e618b7a35f26551d62c43c11e5e64094c6b53c83', 7],
+    ['ac4f44bae06a45ebe88cfbd3c66358750159650a26c0d79e8ccaa92457fca4f6', 0],
+    ['0000000000000000006cfbd3c66358750159650a26c0d79e8ccaa92457fca4f6', 73],
+  ].forEach(([id, diff]) => expect(getPow(id as string)).toEqual(diff as number))
 })
 
 test('mines POW for an event', async () => {

nip13.ts

@@ -1,15 +1,19 @@
-import { type UnsignedEvent, type Event, getEventHash } from './pure.ts'
+import { bytesToHex } from '@noble/hashes/utils'
+import { type UnsignedEvent, type Event } from './pure.ts'
+import { sha256 } from '@noble/hashes/sha256'
+
+import { utf8Encoder } from './utils.ts'
 
 /** Get POW difficulty from a Nostr hex ID. */
 export function getPow(hex: string): number {
   let count = 0
 
-  for (let i = 0; i < hex.length; i++) {
-    const nibble = parseInt(hex[i], 16)
+  for (let i = 0; i < 64; i += 8) {
+    const nibble = parseInt(hex.substring(i, i + 8), 16)
     if (nibble === 0) {
-      count += 4
+      count += 32
     } else {
-      count += Math.clz32(nibble) - 28
+      count += Math.clz32(nibble)
       break
     }
   }
@@ -20,8 +24,6 @@ export function getPow(hex: string): number {
 /**
  * Mine an event with the desired POW. This function mutates the event.
  * Note that this operation is synchronous and should be run in a worker context to avoid blocking the main thread.
- *
- * Adapted from Snort: https://git.v0l.io/Kieran/snort/src/commit/4df6c19248184218c4c03728d61e94dae5f2d90c/packages/system/src/pow-util.ts#L14-L36
  */
 export function minePow(unsigned: UnsignedEvent, difficulty: number): Omit<Event, 'sig'> {
   let count = 0
@@ -41,7 +43,7 @@ export function minePow(unsigned: UnsignedEvent, difficulty: number): Omit<Event
 
     tag[1] = (++count).toString()
 
-    event.id = getEventHash(event)
+    event.id = fastEventHash(event)
 
     if (getPow(event.id) >= difficulty) {
       break
@@ -50,3 +52,9 @@ export function minePow(unsigned: UnsignedEvent, difficulty: number): Omit<Event
 
   return event
 }
+
+export function fastEventHash(evt: UnsignedEvent): string {
+  return bytesToHex(
+    sha256(utf8Encoder.encode(JSON.stringify([0, evt.pubkey, evt.created_at, evt.kind, evt.tags, evt.content]))),
+  )
+}

nip17.test.ts

@@ -0,0 +1,97 @@
+import { test, expect } from 'bun:test'
+import { getPublicKey } from './pure.ts'
+import { decode } from './nip19.ts'
+import { wrapEvent, wrapManyEvents, unwrapEvent } from './nip17.ts'
+import { hexToBytes } from '@noble/hashes/utils'
+
+const senderPrivateKey = decode(`nsec1p0ht6p3wepe47sjrgesyn4m50m6avk2waqudu9rl324cg2c4ufesyp6rdg`).data
+
+const sk1 = hexToBytes('f09ac9b695d0a4c6daa418fe95b977eea20f54d9545592bc36a4f9e14f3eb840')
+const sk2 = hexToBytes('5393a825e5892d8e18d4a5ea61ced105e8bb2a106f42876be3a40522e0b13747')
+
+const recipients = [
+  { publicKey: getPublicKey(sk1), relayUrl: 'wss://relay1.com' },
+  { publicKey: getPublicKey(sk2) }, // No relay URL for this recipient
+]
+const message = 'Hello, this is a direct message!'
+const conversationTitle = 'Private Group Conversation' // Optional
+const replyTo = { eventId: 'previousEventId123' } // Optional, for replies
+
+const wrappedEvent = wrapEvent(senderPrivateKey, recipients[0], message, conversationTitle, replyTo)
+
+test('wrapEvent', () => {
+  const expected = {
+    content: '',
+    id: '',
+    created_at: 1728537932,
+    kind: 1059,
+    pubkey: '',
+    sig: '',
+    tags: [['p', 'b60849e5aae4113b236f9deb34f6f85605b4c53930651309a0d60c7ea721aad0']],
+    [Symbol('verified')]: true,
+  }
+
+  expect(wrappedEvent.kind).toEqual(expected.kind)
+  expect(wrappedEvent.tags).toEqual(expected.tags)
+})
+
+test('wrapManyEvents', () => {
+  const expected = [
+    {
+      kind: 1059,
+      content: '',
+      created_at: 1729581521,
+      tags: [['p', '611df01bfcf85c26ae65453b772d8f1dfd25c264621c0277e1fc1518686faef9']],
+      pubkey: '',
+      id: '',
+      sig: '',
+      [Symbol('verified')]: true,
+    },
+    {
+      kind: 1059,
+      content: '',
+      created_at: 1729594619,
+      tags: [['p', 'b60849e5aae4113b236f9deb34f6f85605b4c53930651309a0d60c7ea721aad0']],
+      pubkey: '',
+      id: '',
+      sig: '',
+      [Symbol('verified')]: true,
+    },
+    {
+      kind: 1059,
+      content: '',
+      created_at: 1729560014,
+      tags: [['p', '36f7288c84d85ca6aa189dc3581d63ce140b7eeef5ae759421c5b5a3627312db']],
+      pubkey: '',
+      id: '',
+      sig: '',
+      [Symbol('verified')]: true,
+    },
+  ]
+
+  const wrappedEvents = wrapManyEvents(senderPrivateKey, recipients, message, conversationTitle, replyTo)
+
+  wrappedEvents.forEach((event, index) => {
+    expect(event.kind).toEqual(expected[index].kind)
+    expect(event.tags).toEqual(expected[index].tags)
+  })
+})
+
+test('unwrapEvent', () => {
+  const expected = {
+    kind: 14,
+    content: 'Hello, this is a direct message!',
+    pubkey: '611df01bfcf85c26ae65453b772d8f1dfd25c264621c0277e1fc1518686faef9',
+    tags: [
+      ['p', 'b60849e5aae4113b236f9deb34f6f85605b4c53930651309a0d60c7ea721aad0', 'wss://relay1.com'],
+      ['e', 'previousEventId123', '', 'reply'],
+      ['subject', 'Private Group Conversation'],
+    ],
+  }
+  const result = unwrapEvent(wrappedEvent, sk1)
+
+  expect(result.kind).toEqual(expected.kind)
+  expect(result.content).toEqual(expected.content)
+  expect(result.pubkey).toEqual(expected.pubkey)
+  expect(result.tags).toEqual(expected.tags)
+})

nip17.ts

@@ -0,0 +1,77 @@
+import { PrivateDirectMessage } from './kinds.ts'
+import { EventTemplate, NostrEvent, getPublicKey } from './pure.ts'
+import * as nip59 from './nip59.ts'
+
+type Recipient = {
+  publicKey: string
+  relayUrl?: string
+}
+
+type ReplyTo = {
+  eventId: string
+  relayUrl?: string
+}
+
+function createEvent(
+  recipients: Recipient | Recipient[],
+  message: string,
+  conversationTitle?: string,
+  replyTo?: ReplyTo,
+): EventTemplate {
+  const baseEvent: EventTemplate = {
+    created_at: Math.ceil(Date.now() / 1000),
+    kind: PrivateDirectMessage,
+    tags: [],
+    content: message,
+  }
+
+  const recipientsArray = Array.isArray(recipients) ? recipients : [recipients]
+
+  recipientsArray.forEach(({ publicKey, relayUrl }) => {
+    baseEvent.tags.push(relayUrl ? ['p', publicKey, relayUrl] : ['p', publicKey])
+  })
+
+  if (replyTo) {
+    baseEvent.tags.push(['e', replyTo.eventId, replyTo.relayUrl || '', 'reply'])
+  }
+
+  if (conversationTitle) {
+    baseEvent.tags.push(['subject', conversationTitle])
+  }
+
+  return baseEvent
+}
+
+export function wrapEvent(
+  senderPrivateKey: Uint8Array,
+  recipient: Recipient,
+  message: string,
+  conversationTitle?: string,
+  replyTo?: ReplyTo,
+): NostrEvent {
+  const event = createEvent(recipient, message, conversationTitle, replyTo)
+  return nip59.wrapEvent(event, senderPrivateKey, recipient.publicKey)
+}
+
+export function wrapManyEvents(
+  senderPrivateKey: Uint8Array,
+  recipients: Recipient[],
+  message: string,
+  conversationTitle?: string,
+  replyTo?: ReplyTo,
+): NostrEvent[] {
+  if (!recipients || recipients.length === 0) {
+    throw new Error('At least one recipient is required.')
+  }
+
+  const senderPublicKey = getPublicKey(senderPrivateKey)
+
+  // wrap the event for the sender and then for each recipient
+  return [{ publicKey: senderPublicKey }, ...recipients].map(recipient =>
+    wrapEvent(senderPrivateKey, recipient, message, conversationTitle, replyTo),
+  )
+}
+
+export const unwrapEvent = nip59.unwrapEvent
+
+export const unwrapManyEvents = nip59.unwrapManyEvents

nip19.test.ts

@@ -1,16 +1,16 @@
-import { test, expect } from 'bun:test'
+import { test, expect, describe } from 'bun:test'
 import { generateSecretKey, getPublicKey } from './pure.ts'
 import {
   decode,
   naddrEncode,
   nprofileEncode,
   npubEncode,
-  nrelayEncode,
   nsecEncode,
   neventEncode,
   type AddressPointer,
   type ProfilePointer,
   EventPointer,
+  NostrTypeGuard,
 } from './nip19.ts'
 
 test('encode and decode nsec', () => {
@@ -153,11 +153,134 @@ test('decode naddr from go-nostr with different TLV ordering', () => {
   expect(pointer.identifier).toEqual('banana')
 })
 
-test('encode and decode nrelay', () => {
-  let url = 'wss://relay.nostr.example'
-  let nrelay = nrelayEncode(url)
-  expect(nrelay).toMatch(/nrelay1\w+/)
-  let { type, data } = decode(nrelay)
-  expect(type).toEqual('nrelay')
-  expect(data).toEqual(url)
+describe('NostrTypeGuard', () => {
+  test('isNProfile', () => {
+    const is = NostrTypeGuard.isNProfile('nprofile1qqsvc6ulagpn7kwrcwdqgp797xl7usumqa6s3kgcelwq6m75x8fe8yc5usxdg')
+
+    expect(is).toBeTrue()
+  })
+
+  test('isNProfile invalid nprofile', () => {
+    const is = NostrTypeGuard.isNProfile('nprofile1qqsvc6ulagpn7kwrcwdqgp797xl7usumqa6s3kgcelwq6m75x8fe8yc5usxãg')
+
+    expect(is).toBeFalse()
+  })
+
+  test('isNProfile with invalid nprofile', () => {
+    const is = NostrTypeGuard.isNProfile('nsec1lqw6zqyanj9mz8gwhdam6tqge42vptz4zg93qsfej440xm5h5esqya0juv')
+
+    expect(is).toBeFalse()
+  })
+
+  test('isNEvent', () => {
+    const is = NostrTypeGuard.isNEvent(
+      'nevent1qqst8cujky046negxgwwm5ynqwn53t8aqjr6afd8g59nfqwxpdhylpcpzamhxue69uhhyetvv9ujuetcv9khqmr99e3k7mg8arnc9',
+    )
+
+    expect(is).toBeTrue()
+  })
+
+  test('isNEvent with invalid nevent', () => {
+    const is = NostrTypeGuard.isNEvent(
+      'nevent1qqst8cujky046negxgwwm5ynqwn53t8aqjr6afd8g59nfqwxpdhylpcpzamhxue69uhhyetvv9ujuetcv9khqmr99e3k7mg8ãrnc9',
+    )
+
+    expect(is).toBeFalse()
+  })
+
+  test('isNEvent with invalid nevent', () => {
+    const is = NostrTypeGuard.isNEvent('nprofile1qqsvc6ulagpn7kwrcwdqgp797xl7usumqa6s3kgcelwq6m75x8fe8yc5usxdg')
+
+    expect(is).toBeFalse()
+  })
+
+  test('isNAddr', () => {
+    const is = NostrTypeGuard.isNAddr(
+      'naddr1qqxnzdesxqmnxvpexqunzvpcqyt8wumn8ghj7un9d3shjtnwdaehgu3wvfskueqzypve7elhmamff3sr5mgxxms4a0rppkmhmn7504h96pfcdkpplvl2jqcyqqq823cnmhuld',
+    )
+
+    expect(is).toBeTrue()
+  })
+
+  test('isNAddr with invalid nadress', () => {
+    const is = NostrTypeGuard.isNAddr('nsec1lqw6zqyanj9mz8gwhdam6tqge42vptz4zg93qsfej440xm5h5esqya0juv')
+
+    expect(is).toBeFalse()
+  })
+
+  test('isNSec', () => {
+    const is = NostrTypeGuard.isNSec('nsec1lqw6zqyanj9mz8gwhdam6tqge42vptz4zg93qsfej440xm5h5esqya0juv')
+
+    expect(is).toBeTrue()
+  })
+
+  test('isNSec with invalid nsec', () => {
+    const is = NostrTypeGuard.isNSec('nsec1lqw6zqyanj9mz8gwhdam6tqge42vptz4zg93qsfej440xm5h5esqya0juã')
+
+    expect(is).toBeFalse()
+  })
+
+  test('isNSec with invalid nsec', () => {
+    const is = NostrTypeGuard.isNSec('nprofile1qqsvc6ulagpn7kwrcwdqgp797xl7usumqa6s3kgcelwq6m75x8fe8yc5usxdg')
+
+    expect(is).toBeFalse()
+  })
+
+  test('isNPub', () => {
+    const is = NostrTypeGuard.isNPub('npub1jz5mdljkmffmqjshpyjgqgrhdkuxd9ztzasv8xeh5q92fv33sjgqy4pats')
+
+    expect(is).toBeTrue()
+  })
+
+  test('isNPub with invalid npub', () => {
+    const is = NostrTypeGuard.isNPub('npub1jz5mdljkmffmqjshpyjgqgrhdkuxd9ztzãsv8xeh5q92fv33sjgqy4pats')
+
+    expect(is).toBeFalse()
+  })
+
+  test('isNPub with invalid npub', () => {
+    const is = NostrTypeGuard.isNPub('nsec1lqw6zqyanj9mz8gwhdam6tqge42vptz4zg93qsfej440xm5h5esqya0juv')
+
+    expect(is).toBeFalse()
+  })
+
+  test('isNote', () => {
+    const is = NostrTypeGuard.isNote('note1gmtnz6q2m55epmlpe3semjdcq987av3jvx4emmjsa8g3s9x7tg4sclreky')
+
+    expect(is).toBeTrue()
+  })
+
+  test('isNote with invalid note', () => {
+    const is = NostrTypeGuard.isNote('note1gmtnz6q2m55epmlpe3semjdcq987av3jvx4emmjsa8g3s9x7tg4sçlreky')
+
+    expect(is).toBeFalse()
+  })
+
+  test('isNote with invalid note', () => {
+    const is = NostrTypeGuard.isNote('npub1jz5mdljkmffmqjshpyjgqgrhdkuxd9ztzasv8xeh5q92fv33sjgqy4pats')
+
+    expect(is).toBeFalse()
+  })
+
+  test('isNcryptsec', () => {
+    const is = NostrTypeGuard.isNcryptsec(
+      'ncryptsec1qgg9947rlpvqu76pj5ecreduf9jxhselq2nae2kghhvd5g7dgjtcxfqtd67p9m0w57lspw8gsq6yphnm8623nsl8xn9j4jdzz84zm3frztj3z7s35vpzmqf6ksu8r89qk5z2zxfmu5gv8th8wclt0h4p',
+    )
+
+    expect(is).toBeTrue()
+  })
+
+  test('isNcryptsec with invalid ncrytpsec', () => {
+    const is = NostrTypeGuard.isNcryptsec(
+      'ncryptsec1qgg9947rlpvqu76pj5ecreduf9jxhselq2nae2kghhvd5g7dgjtcxfqtd67p9m0w57lspw8gsq6yphnm8623nsã8xn9j4jdzz84zm3frztj3z7s35vpzmqf6ksu8r89qk5z2zxfmu5gv8th8wclt0h4p',
+    )
+
+    expect(is).toBeFalse()
+  })
+
+  test('isNcryptsec with invalid ncrytpsec', () => {
+    const is = NostrTypeGuard.isNcryptsec('note1gmtnz6q2m55epmlpe3semjdcq987av3jvx4emmjsa8g3s9x7tg4sçlreky')
+
+    expect(is).toBeFalse()
+  })
 })

nip19.ts

@@ -3,6 +3,24 @@ import { bech32 } from '@scure/base'
 
 import { utf8Decoder, utf8Encoder } from './utils.ts'
 
+export type NProfile = `nprofile1${string}`
+export type NEvent = `nevent1${string}`
+export type NAddr = `naddr1${string}`
+export type NSec = `nsec1${string}`
+export type NPub = `npub1${string}`
+export type Note = `note1${string}`
+export type Ncryptsec = `ncryptsec1${string}`
+
+export const NostrTypeGuard = {
+  isNProfile: (value?: string | null): value is NProfile => /^nprofile1[a-z\d]+$/.test(value || ''),
+  isNEvent: (value?: string | null): value is NEvent => /^nevent1[a-z\d]+$/.test(value || ''),
+  isNAddr: (value?: string | null): value is NAddr => /^naddr1[a-z\d]+$/.test(value || ''),
+  isNSec: (value?: string | null): value is NSec => /^nsec1[a-z\d]{58}$/.test(value || ''),
+  isNPub: (value?: string | null): value is NPub => /^npub1[a-z\d]{58}$/.test(value || ''),
+  isNote: (value?: string | null): value is Note => /^note1[a-z\d]+$/.test(value || ''),
+  isNcryptsec: (value?: string | null): value is Ncryptsec => /^ncryptsec1[a-z\d]+$/.test(value || ''),
+}
+
 export const Bech32MaxSize = 5000
 
 /**
@@ -45,7 +63,6 @@ export type AddressPointer = {
 
 type Prefixes = {
   nprofile: ProfilePointer
-  nrelay: string
   nevent: EventPointer
   naddr: AddressPointer
   nsec: Uint8Array
@@ -119,16 +136,6 @@ export function decode(nip19: string): DecodeResult {
       }
     }
 
-    case 'nrelay': {
-      let tlv = parseTLV(data)
-      if (!tlv[0]?.[0]) throw new Error('missing TLV 0 for nrelay')
-
-      return {
-        type: 'nrelay',
-        data: utf8Decoder.decode(tlv[0][0]),
-      }
-    }
-
     case 'nsec':
       return { type: prefix, data }
 
@@ -158,15 +165,15 @@ function parseTLV(data: Uint8Array): TLV {
   return result
 }
 
-export function nsecEncode(key: Uint8Array): `nsec1${string}` {
+export function nsecEncode(key: Uint8Array): NSec {
   return encodeBytes('nsec', key)
 }
 
-export function npubEncode(hex: string): `npub1${string}` {
+export function npubEncode(hex: string): NPub {
   return encodeBytes('npub', hexToBytes(hex))
 }
 
-export function noteEncode(hex: string): `note1${string}` {
+export function noteEncode(hex: string): Note {
   return encodeBytes('note', hexToBytes(hex))
 }
 
@@ -179,7 +186,7 @@ export function encodeBytes<Prefix extends string>(prefix: Prefix, bytes: Uint8A
   return encodeBech32(prefix, bytes)
 }
 
-export function nprofileEncode(profile: ProfilePointer): `nprofile1${string}` {
+export function nprofileEncode(profile: ProfilePointer): NProfile {
   let data = encodeTLV({
     0: [hexToBytes(profile.pubkey)],
     1: (profile.relays || []).map(url => utf8Encoder.encode(url)),
@@ -187,7 +194,7 @@ export function nprofileEncode(profile: ProfilePointer): `nprofile1${string}` {
   return encodeBech32('nprofile', data)
 }
 
-export function neventEncode(event: EventPointer): `nevent1${string}` {
+export function neventEncode(event: EventPointer): NEvent {
   let kindArray
   if (event.kind !== undefined) {
     kindArray = integerToUint8Array(event.kind)
@@ -203,7 +210,7 @@ export function neventEncode(event: EventPointer): `nevent1${string}` {
   return encodeBech32('nevent', data)
 }
 
-export function naddrEncode(addr: AddressPointer): `naddr1${string}` {
+export function naddrEncode(addr: AddressPointer): NAddr {
   let kind = new ArrayBuffer(4)
   new DataView(kind).setUint32(0, addr.kind, false)
 
@@ -216,13 +223,6 @@ export function naddrEncode(addr: AddressPointer): `naddr1${string}` {
   return encodeBech32('naddr', data)
 }
 
-export function nrelayEncode(url: string): `nrelay1${string}` {
-  let data = encodeTLV({
-    0: [utf8Encoder.encode(url)],
-  })
-  return encodeBech32('nrelay', data)
-}
-
 function encodeTLV(tlv: TLV): Uint8Array {
   let entries: Uint8Array[] = []
 

nip28.ts

@@ -1,5 +1,11 @@
 import { Event, finalizeEvent } from './pure.ts'
-import { ChannelCreation, ChannelHideMessage, ChannelMessage, ChannelMetadata, ChannelMuteUser } from './kinds.ts'
+import {
+  ChannelCreation,
+  ChannelHideMessage,
+  ChannelMessage,
+  ChannelMetadata as KindChannelMetadata,
+  ChannelMuteUser,
+} from './kinds.ts'
 
 export interface ChannelMetadata {
   name: string
@@ -78,7 +84,7 @@ export const channelMetadataEvent = (t: ChannelMetadataEventTemplate, privateKey
 
   return finalizeEvent(
     {
-      kind: ChannelMetadata,
+      kind: KindChannelMetadata,
       tags: [['e', t.channel_create_event_id], ...(t.tags ?? [])],
       content: content,
       created_at: t.created_at,

nip29.ts

@@ -1,80 +1,514 @@
-import { AbstractSimplePool } from './abstract-pool'
-import { Subscription } from './abstract-relay'
-import { decode } from './nip19'
-import type { Event } from './core'
-import { fetchRelayInformation } from './nip11'
-import { normalizeURL } from './utils'
-import { AddressPointer } from './nip19'
+import { AbstractSimplePool } from './abstract-pool.ts'
+import { Subscription } from './abstract-relay.ts'
+import type { Event, EventTemplate } from './core.ts'
+import { fetchRelayInformation, RelayInformation } from './nip11.ts'
+import { AddressPointer, decode } from './nip19.ts'
+import { normalizeURL } from './utils.ts'
 
-export function subscribeRelayGroups(
-  pool: AbstractSimplePool,
-  url: string,
-  params: {
-    ongroups: (_: Group[]) => void
-    onerror: (_: Error) => void
-    onconnect?: () => void
-  },
-): () => void {
-  let normalized = normalizeURL(url)
-  let sub: Subscription
-  let groups: Group[] = []
-
-  fetchRelayInformation(normalized)
-    .then(async info => {
-      let rl = await pool.ensureRelay(normalized)
-      params.onconnect?.()
-      sub = rl.prepareSubscription(
-        [
-          {
-            kinds: [39000],
-            limit: 50,
-            authors: [info.pubkey],
-          },
-        ],
-        {
-          onevent(event: Event) {
-            groups.push(parseGroup(event, normalized))
-          },
-          oneose() {
-            params.ongroups(groups)
-            sub.onevent = (event: Event) => {
-              groups.push(parseGroup(event, normalized))
-              params.ongroups(groups)
-            }
-          },
-        },
-      )
-      sub.fire()
-    })
-    .catch(params.onerror)
-
-  return () => sub.close()
+/**
+ * Represents a NIP29 group.
+ */
+export type Group = {
+  relay: string
+  metadata: GroupMetadata
+  admins?: GroupAdmin[]
+  members?: GroupMember[]
+  reference: GroupReference
 }
 
-export async function loadGroup(pool: AbstractSimplePool, gr: GroupReference): Promise<Group> {
-  let normalized = normalizeURL(gr.host)
-
-  let info = await fetchRelayInformation(normalized)
-  let event = await pool.get([normalized], {
-    kinds: [39000],
-    authors: [info.pubkey],
-    '#d': [gr.id],
-  })
-  if (!event) throw new Error(`group '${gr.id}' not found on ${gr.host}`)
-  return parseGroup(event, normalized)
-}
-
-export async function loadGroupFromCode(pool: AbstractSimplePool, code: string): Promise<Group> {
-  let gr = parseGroupCode(code)
-  if (!gr) throw new Error(`code "${code}" does not identify a group`)
-  return loadGroup(pool, gr)
+/**
+ * Represents the metadata for a NIP29 group.
+ */
+export type GroupMetadata = {
+  id: string
+  pubkey: string
+  name?: string
+  picture?: string
+  about?: string
+  isPublic?: boolean
+  isOpen?: boolean
 }
 
+/**
+ * Represents a NIP29 group reference.
+ */
 export type GroupReference = {
   id: string
   host: string
 }
 
+/**
+ * Represents a NIP29 group member.
+ */
+export type GroupMember = {
+  pubkey: string
+  label?: string
+}
+
+/**
+ * Represents a NIP29 group admin.
+ */
+export type GroupAdmin = {
+  pubkey: string
+  label?: string
+  permissions: GroupAdminPermission[]
+}
+
+/**
+ * Represents the permissions that a NIP29 group admin can have.
+ */
+export enum GroupAdminPermission {
+  AddUser = 'add-user',
+  EditMetadata = 'edit-metadata',
+  DeleteEvent = 'delete-event',
+  RemoveUser = 'remove-user',
+  AddPermission = 'add-permission',
+  RemovePermission = 'remove-permission',
+  EditGroupStatus = 'edit-group-status',
+}
+
+/**
+ * Generates a group metadata event template.
+ *
+ * @param group - The group object.
+ * @returns An event template with the generated group metadata that can be signed later.
+ */
+export function generateGroupMetadataEventTemplate(group: Group): EventTemplate {
+  const tags: string[][] = [['d', group.metadata.id]]
+  group.metadata.name && tags.push(['name', group.metadata.name])
+  group.metadata.picture && tags.push(['picture', group.metadata.picture])
+  group.metadata.about && tags.push(['about', group.metadata.about])
+  group.metadata.isPublic && tags.push(['public'])
+  group.metadata.isOpen && tags.push(['open'])
+
+  return {
+    content: '',
+    created_at: Math.floor(Date.now() / 1000),
+    kind: 39000,
+    tags,
+  }
+}
+
+/**
+ * Validates a group metadata event.
+ *
+ * @param event - The event to validate.
+ * @returns A boolean indicating whether the event is valid.
+ */
+export function validateGroupMetadataEvent(event: Event): boolean {
+  if (event.kind !== 39000) return false
+
+  if (!event.pubkey) return false
+
+  const requiredTags = ['d'] as const
+  for (const tag of requiredTags) {
+    if (!event.tags.find(([t]) => t == tag)) return false
+  }
+
+  return true
+}
+
+/**
+ * Generates an event template for group admins.
+ *
+ * @param group - The group object.
+ * @param admins - An array of group admins.
+ * @returns The generated event template with the group admins that can be signed later.
+ */
+export function generateGroupAdminsEventTemplate(group: Group, admins: GroupAdmin[]): EventTemplate {
+  const tags: string[][] = [['d', group.metadata.id]]
+  for (const admin of admins) {
+    tags.push(['p', admin.pubkey, admin.label || '', ...admin.permissions])
+  }
+
+  return {
+    content: '',
+    created_at: Math.floor(Date.now() / 1000),
+    kind: 39001,
+    tags,
+  }
+}
+
+/**
+ * Validates a group admins event.
+ *
+ * @param event - The event to validate.
+ * @returns True if the event is valid, false otherwise.
+ */
+export function validateGroupAdminsEvent(event: Event): boolean {
+  if (event.kind !== 39001) return false
+
+  const requiredTags = ['d'] as const
+  for (const tag of requiredTags) {
+    if (!event.tags.find(([t]) => t == tag)) return false
+  }
+
+  // validate permissions
+  for (const [tag, _value, _label, ...permissions] of event.tags) {
+    if (tag !== 'p') continue
+
+    for (let i = 0; i < permissions.length; i += 1) {
+      if (typeof permissions[i] !== 'string') return false
+
+      // validate permission name from the GroupAdminPermission enum
+      if (!Object.values(GroupAdminPermission).includes(permissions[i] as GroupAdminPermission)) return false
+    }
+  }
+
+  return true
+}
+
+/**
+ * Generates an event template for a group with its members.
+ *
+ * @param group - The group object.
+ * @param members - An array of group members.
+ * @returns The generated event template with the group members that can be signed later.
+ */
+export function generateGroupMembersEventTemplate(group: Group, members: GroupMember[]): EventTemplate {
+  const tags: string[][] = [['d', group.metadata.id]]
+  for (const member of members) {
+    tags.push(['p', member.pubkey, member.label || ''])
+  }
+
+  return {
+    content: '',
+    created_at: Math.floor(Date.now() / 1000),
+    kind: 39002,
+    tags,
+  }
+}
+
+/**
+ * Validates a group members event.
+ *
+ * @param event - The event to validate.
+ * @returns Returns `true` if the event is a valid group members event, `false` otherwise.
+ */
+export function validateGroupMembersEvent(event: Event): boolean {
+  if (event.kind !== 39002) return false
+
+  const requiredTags = ['d'] as const
+  for (const tag of requiredTags) {
+    if (!event.tags.find(([t]) => t == tag)) return false
+  }
+
+  return true
+}
+
+/**
+ * Returns the normalized relay URL based on the provided group reference.
+ *
+ * @param groupReference - The group reference object containing the host.
+ * @returns The normalized relay URL.
+ */
+export function getNormalizedRelayURLByGroupReference(groupReference: GroupReference): string {
+  return normalizeURL(groupReference.host)
+}
+
+/**
+ * Fetches relay information by group reference.
+ *
+ * @param groupReference The group reference.
+ * @returns A promise that resolves to the relay information.
+ */
+export async function fetchRelayInformationByGroupReference(groupReference: GroupReference): Promise<RelayInformation> {
+  const normalizedRelayURL = getNormalizedRelayURLByGroupReference(groupReference)
+
+  return fetchRelayInformation(normalizedRelayURL)
+}
+
+/**
+ * Fetches the group metadata event from the specified pool.
+ * If the normalizedRelayURL is not provided, it will be obtained using the groupReference.
+ * If the relayInformation is not provided, it will be fetched using the normalizedRelayURL.
+ *
+ * @param {Object} options - The options object.
+ * @param {AbstractSimplePool} options.pool - The pool to fetch the group metadata event from.
+ * @param {GroupReference} options.groupReference - The reference to the group.
+ * @param {string} [options.normalizedRelayURL] - The normalized URL of the relay.
+ * @param {RelayInformation} [options.relayInformation] - The relay information object.
+ * @returns {Promise<Event>} The group metadata event that can be parsed later to get the group metadata object.
+ * @throws {Error} If the group is not found on the specified relay.
+ */
+export async function fetchGroupMetadataEvent({
+  pool,
+  groupReference,
+  relayInformation,
+  normalizedRelayURL,
+}: {
+  pool: AbstractSimplePool
+  groupReference: GroupReference
+  normalizedRelayURL?: string
+  relayInformation?: RelayInformation
+}): Promise<Event> {
+  if (!normalizedRelayURL) {
+    normalizedRelayURL = getNormalizedRelayURLByGroupReference(groupReference)
+  }
+
+  if (!relayInformation) {
+    relayInformation = await fetchRelayInformation(normalizedRelayURL)
+  }
+
+  const groupMetadataEvent = await pool.get([normalizedRelayURL], {
+    kinds: [39000],
+    authors: [relayInformation.pubkey],
+    '#d': [groupReference.id],
+  })
+
+  if (!groupMetadataEvent) throw new Error(`group '${groupReference.id}' not found on ${normalizedRelayURL}`)
+
+  return groupMetadataEvent
+}
+
+/**
+ * Parses a group metadata event and returns the corresponding GroupMetadata object.
+ *
+ * @param event - The event to parse.
+ * @returns The parsed GroupMetadata object.
+ * @throws An error if the group metadata event is invalid.
+ */
+export function parseGroupMetadataEvent(event: Event): GroupMetadata {
+  if (!validateGroupMetadataEvent(event)) throw new Error('invalid group metadata event')
+
+  const metadata: GroupMetadata = {
+    id: '',
+    pubkey: event.pubkey,
+  }
+
+  for (const [tag, value] of event.tags) {
+    switch (tag) {
+      case 'd':
+        metadata.id = value
+        break
+      case 'name':
+        metadata.name = value
+        break
+      case 'picture':
+        metadata.picture = value
+        break
+      case 'about':
+        metadata.about = value
+        break
+      case 'public':
+        metadata.isPublic = true
+        break
+      case 'open':
+        metadata.isOpen = true
+        break
+    }
+  }
+
+  return metadata
+}
+
+/**
+ * Fetches the group admins event from the specified pool.
+ * If the normalizedRelayURL is not provided, it will be obtained from the groupReference.
+ * If the relayInformation is not provided, it will be fetched using the normalizedRelayURL.
+ *
+ * @param {Object} options - The options object.
+ * @param {AbstractSimplePool} options.pool - The pool to fetch the group admins event from.
+ * @param {GroupReference} options.groupReference - The reference to the group.
+ * @param {string} [options.normalizedRelayURL] - The normalized relay URL.
+ * @param {RelayInformation} [options.relayInformation] - The relay information.
+ * @returns {Promise<Event>} The group admins event that can be parsed later to get the group admins object.
+ * @throws {Error} If the group admins event is not found on the specified relay.
+ */
+export async function fetchGroupAdminsEvent({
+  pool,
+  groupReference,
+  relayInformation,
+  normalizedRelayURL,
+}: {
+  pool: AbstractSimplePool
+  groupReference: GroupReference
+  normalizedRelayURL?: string
+  relayInformation?: RelayInformation
+}): Promise<Event> {
+  if (!normalizedRelayURL) {
+    normalizedRelayURL = getNormalizedRelayURLByGroupReference(groupReference)
+  }
+
+  if (!relayInformation) {
+    relayInformation = await fetchRelayInformation(normalizedRelayURL)
+  }
+
+  const groupAdminsEvent = await pool.get([normalizedRelayURL], {
+    kinds: [39001],
+    authors: [relayInformation.pubkey],
+    '#d': [groupReference.id],
+  })
+
+  if (!groupAdminsEvent) throw new Error(`admins for group '${groupReference.id}' not found on ${normalizedRelayURL}`)
+
+  return groupAdminsEvent
+}
+
+/**
+ * Parses a group admins event and returns an array of GroupAdmin objects.
+ *
+ * @param event - The event to parse.
+ * @returns An array of GroupAdmin objects.
+ * @throws Throws an error if the group admins event is invalid.
+ */
+export function parseGroupAdminsEvent(event: Event): GroupAdmin[] {
+  if (!validateGroupAdminsEvent(event)) throw new Error('invalid group admins event')
+
+  const admins: GroupAdmin[] = []
+
+  for (const [tag, value, label, ...permissions] of event.tags) {
+    if (tag !== 'p') continue
+
+    admins.push({
+      pubkey: value,
+      label,
+      permissions: permissions as GroupAdminPermission[],
+    })
+  }
+
+  return admins
+}
+
+/**
+ * Fetches the group members event from the specified relay.
+ * If the normalizedRelayURL is not provided, it will be obtained using the groupReference.
+ * If the relayInformation is not provided, it will be fetched using the normalizedRelayURL.
+ *
+ * @param {Object} options - The options object.
+ * @param {AbstractSimplePool} options.pool - The pool object.
+ * @param {GroupReference} options.groupReference - The group reference object.
+ * @param {string} [options.normalizedRelayURL] - The normalized relay URL.
+ * @param {RelayInformation} [options.relayInformation] - The relay information object.
+ * @returns {Promise<Event>} The group members event that can be parsed later to get the group members object.
+ * @throws {Error} If the group members event is not found.
+ */
+export async function fetchGroupMembersEvent({
+  pool,
+  groupReference,
+  relayInformation,
+  normalizedRelayURL,
+}: {
+  pool: AbstractSimplePool
+  groupReference: GroupReference
+  normalizedRelayURL?: string
+  relayInformation?: RelayInformation
+}): Promise<Event> {
+  if (!normalizedRelayURL) {
+    normalizedRelayURL = getNormalizedRelayURLByGroupReference(groupReference)
+  }
+
+  if (!relayInformation) {
+    relayInformation = await fetchRelayInformation(normalizedRelayURL)
+  }
+
+  const groupMembersEvent = await pool.get([normalizedRelayURL], {
+    kinds: [39002],
+    authors: [relayInformation.pubkey],
+    '#d': [groupReference.id],
+  })
+
+  if (!groupMembersEvent) throw new Error(`members for group '${groupReference.id}' not found on ${normalizedRelayURL}`)
+
+  return groupMembersEvent
+}
+
+/**
+ * Parses a group members event and returns an array of GroupMember objects.
+ * @param event - The event to parse.
+ * @returns An array of GroupMember objects.
+ * @throws Throws an error if the group members event is invalid.
+ */
+export function parseGroupMembersEvent(event: Event): GroupMember[] {
+  if (!validateGroupMembersEvent(event)) throw new Error('invalid group members event')
+
+  const members: GroupMember[] = []
+
+  for (const [tag, value, label] of event.tags) {
+    if (tag !== 'p') continue
+
+    members.push({
+      pubkey: value,
+      label,
+    })
+  }
+
+  return members
+}
+
+/**
+ * Fetches and parses the group metadata event, group admins event, and group members event from the specified pool.
+ * If the normalized relay URL is not provided, it will be obtained using the group reference.
+ * If the relay information is not provided, it will be fetched using the normalized relay URL.
+ *
+ * @param {Object} options - The options for loading the group.
+ * @param {AbstractSimplePool} options.pool - The pool to load the group from.
+ * @param {GroupReference} options.groupReference - The reference of the group to load.
+ * @param {string} [options.normalizedRelayURL] - The normalized URL of the relay to use.
+ * @param {RelayInformation} [options.relayInformation] - The relay information to use.
+ * @returns {Promise<Group>} A promise that resolves to the loaded group.
+ */
+export async function loadGroup({
+  pool,
+  groupReference,
+  normalizedRelayURL,
+  relayInformation,
+}: {
+  pool: AbstractSimplePool
+  groupReference: GroupReference
+  normalizedRelayURL?: string
+  relayInformation?: RelayInformation
+}): Promise<Group> {
+  if (!normalizedRelayURL) {
+    normalizedRelayURL = getNormalizedRelayURLByGroupReference(groupReference)
+  }
+
+  if (!relayInformation) {
+    relayInformation = await fetchRelayInformation(normalizedRelayURL)
+  }
+
+  const metadataEvent = await fetchGroupMetadataEvent({ pool, groupReference, normalizedRelayURL, relayInformation })
+  const metadata = parseGroupMetadataEvent(metadataEvent)
+
+  const adminsEvent = await fetchGroupAdminsEvent({ pool, groupReference, normalizedRelayURL, relayInformation })
+  const admins = parseGroupAdminsEvent(adminsEvent)
+
+  const membersEvent = await fetchGroupMembersEvent({ pool, groupReference, normalizedRelayURL, relayInformation })
+  const members = parseGroupMembersEvent(membersEvent)
+
+  const group: Group = {
+    relay: normalizedRelayURL,
+    metadata,
+    admins,
+    members,
+    reference: groupReference,
+  }
+
+  return group
+}
+
+/**
+ * Loads a group from the specified pool using the provided group code.
+ *
+ * @param {AbstractSimplePool} pool - The pool to load the group from.
+ * @param {string} code - The code representing the group.
+ * @returns {Promise<Group>} - A promise that resolves to the loaded group.
+ * @throws {Error} - If the group code is invalid.
+ */
+export async function loadGroupFromCode(pool: AbstractSimplePool, code: string): Promise<Group> {
+  const groupReference = parseGroupCode(code)
+
+  if (!groupReference) throw new Error('invalid group code')
+
+  return loadGroup({ pool, groupReference })
+}
+
+/**
+ * Parses a group code and returns a GroupReference object.
+ *
+ * @param code The group code to parse.
+ * @returns A GroupReference object if the code is valid, otherwise null.
+ */
 export function parseGroupCode(code: string): null | GroupReference {
   if (code.startsWith('naddr1')) {
     try {
@@ -99,68 +533,74 @@ export function parseGroupCode(code: string): null | GroupReference {
   return null
 }
 
+/**
+ * Encodes a group reference into a string.
+ *
+ * @param gr - The group reference to encode.
+ * @returns The encoded group reference as a string.
+ */
 export function encodeGroupReference(gr: GroupReference): string {
-  if (gr.host.startsWith('https://')) gr.host = gr.host.slice(8)
-  if (gr.host.startsWith('wss://')) gr.host = gr.host.slice(6)
-  return `${gr.host}'${gr.id}`
+  const { host, id } = gr
+  const normalizedHost = host.replace(/^(https?:\/\/|wss?:\/\/)/, '')
+
+  return `${normalizedHost}'${id}`
 }
 
-export type Group = {
-  id: string
-  relay: string
-  pubkey: string
-  name?: string
-  picture?: string
-  about?: string
-  public?: boolean
-  open?: boolean
-}
+/**
+ * Subscribes to relay groups metadata events and calls the provided event handler function
+ * when an event is received.
+ *
+ * @param {Object} options - The options for subscribing to relay groups metadata events.
+ * @param {AbstractSimplePool} options.pool - The pool to subscribe to.
+ * @param {string} options.relayURL - The URL of the relay.
+ * @param {Function} options.onError - The error handler function.
+ * @param {Function} options.onEvent - The event handler function.
+ * @param {Function} [options.onConnect] - The connect handler function.
+ * @returns {Function} - A function to close the subscription
+ */
+export function subscribeRelayGroupsMetadataEvents({
+  pool,
+  relayURL,
+  onError,
+  onEvent,
+  onConnect,
+}: {
+  pool: AbstractSimplePool
+  relayURL: string
+  onError: (err: Error) => void
+  onEvent: (event: Event) => void
+  onConnect?: () => void
+}): () => void {
+  let sub: Subscription
 
-export function parseGroup(event: Event, relay: string): Group {
-  const group: Partial<Group> = { relay, pubkey: event.pubkey }
-  for (let i = 0; i < event.tags.length; i++) {
-    const tag = event.tags[i]
-    switch (tag[0]) {
-      case 'd':
-        group.id = tag[1] || ''
-        break
-      case 'name':
-        group.name = tag[1] || ''
-        break
-      case 'about':
-        group.about = tag[1] || ''
-        break
-      case 'picture':
-        group.picture = tag[1] || ''
-        break
-      case 'open':
-        group.open = true
-        break
-      case 'public':
-        group.public = true
-        break
-    }
-  }
-  return group as Group
-}
+  const normalizedRelayURL = normalizeURL(relayURL)
 
-export type Member = {
-  pubkey: string
-  label?: string
-  permissions: string[]
-}
+  fetchRelayInformation(normalizedRelayURL)
+    .then(async info => {
+      const abstractedRelay = await pool.ensureRelay(normalizedRelayURL)
 
-export function parseMembers(event: Event): Member[] {
-  const members = []
-  for (let i = 0; i < event.tags.length; i++) {
-    const tag = event.tags[i]
-    if (tag.length < 2) continue
-    if (tag[0] !== 'p') continue
-    if (!tag[1].match(/^[0-9a-f]{64}$/)) continue
-    const member: Member = { pubkey: tag[1], permissions: [] }
-    if (tag.length > 2) member.label = tag[2]
-    if (tag.length > 3) member.permissions = tag.slice(3)
-    members.push(member)
-  }
-  return members
+      onConnect?.()
+
+      sub = abstractedRelay.prepareSubscription(
+        [
+          {
+            kinds: [39000],
+            limit: 50,
+            authors: [info.pubkey],
+          },
+        ],
+        {
+          onevent(event: Event) {
+            onEvent(event)
+          },
+        },
+      )
+    })
+    .catch(err => {
+      sub.close()
+
+      onError(err)
+    })
+
+  return () => sub.close()
 }

nip44.test.ts

@@ -7,7 +7,7 @@ const v2vec = vec.v2
 
 test('get_conversation_key', () => {
   for (const v of v2vec.valid.get_conversation_key) {
-    const key = v2.utils.getConversationKey(v.sec1, v.pub2)
+    const key = v2.utils.getConversationKey(hexToBytes(v.sec1), v.pub2)
     expect(bytesToHex(key)).toEqual(v.conversation_key)
   }
 })
@@ -15,7 +15,7 @@ test('get_conversation_key', () => {
 test('encrypt_decrypt', () => {
   for (const v of v2vec.valid.encrypt_decrypt) {
     const pub2 = bytesToHex(schnorr.getPublicKey(v.sec2))
-    const key = v2.utils.getConversationKey(v.sec1, pub2)
+    const key = v2.utils.getConversationKey(hexToBytes(v.sec1), pub2)
     expect(bytesToHex(key)).toEqual(v.conversation_key)
     const ciphertext = v2.encrypt(v.plaintext, key, hexToBytes(v.nonce))
     expect(ciphertext).toEqual(v.payload)
@@ -39,6 +39,8 @@ test('decrypt', async () => {
 
 test('get_conversation_key', async () => {
   for (const v of v2vec.invalid.get_conversation_key) {
-    expect(() => v2.utils.getConversationKey(v.sec1, v.pub2)).toThrow(/(Point is not on curve|Cannot find square root)/)
+    expect(() => v2.utils.getConversationKey(hexToBytes(v.sec1), v.pub2)).toThrow(
+      /(Point is not on curve|Cannot find square root)/,
+    )
   }
 })

nip44.ts

@@ -4,129 +4,124 @@ import { secp256k1 } from '@noble/curves/secp256k1'
 import { extract as hkdf_extract, expand as hkdf_expand } from '@noble/hashes/hkdf'
 import { hmac } from '@noble/hashes/hmac'
 import { sha256 } from '@noble/hashes/sha256'
-import { concatBytes, randomBytes, utf8ToBytes } from '@noble/hashes/utils'
+import { concatBytes, randomBytes } from '@noble/hashes/utils'
 import { base64 } from '@scure/base'
 
-const decoder = new TextDecoder()
+import { utf8Decoder, utf8Encoder } from './utils.ts'
 
-class u {
-  static minPlaintextSize = 0x0001 // 1b msg => padded to 32b
-  static maxPlaintextSize = 0xffff // 65535 (64kb-1) => padded to 64kb
+const minPlaintextSize = 0x0001 // 1b msg => padded to 32b
+const maxPlaintextSize = 0xffff // 65535 (64kb-1) => padded to 64kb
 
-  static utf8Encode = utf8ToBytes
+export function getConversationKey(privkeyA: Uint8Array, pubkeyB: string): Uint8Array {
+  const sharedX = secp256k1.getSharedSecret(privkeyA, '02' + pubkeyB).subarray(1, 33)
+  return hkdf_extract(sha256, sharedX, 'nip44-v2')
+}
 
-  static utf8Decode(bytes: Uint8Array): string {
-    return decoder.decode(bytes)
-  }
-
-  static getConversationKey(privkeyA: string, pubkeyB: string): Uint8Array {
-    const sharedX = secp256k1.getSharedSecret(privkeyA, '02' + pubkeyB).subarray(1, 33)
-    return hkdf_extract(sha256, sharedX, 'nip44-v2')
-  }
-
-  static getMessageKeys(
-    conversationKey: Uint8Array,
-    nonce: Uint8Array,
-  ): { chacha_key: Uint8Array; chacha_nonce: Uint8Array; hmac_key: Uint8Array } {
-    const keys = hkdf_expand(sha256, conversationKey, nonce, 76)
-    return {
-      chacha_key: keys.subarray(0, 32),
-      chacha_nonce: keys.subarray(32, 44),
-      hmac_key: keys.subarray(44, 76),
-    }
-  }
-
-  static calcPaddedLen(len: number): number {
-    if (!Number.isSafeInteger(len) || len < 1) throw new Error('expected positive integer')
-    if (len <= 32) return 32
-    const nextPower = 1 << (Math.floor(Math.log2(len - 1)) + 1)
-    const chunk = nextPower <= 256 ? 32 : nextPower / 8
-    return chunk * (Math.floor((len - 1) / chunk) + 1)
-  }
-
-  static writeU16BE(num: number): Uint8Array {
-    if (!Number.isSafeInteger(num) || num < u.minPlaintextSize || num > u.maxPlaintextSize)
-      throw new Error('invalid plaintext size: must be between 1 and 65535 bytes')
-    const arr = new Uint8Array(2)
-    new DataView(arr.buffer).setUint16(0, num, false)
-    return arr
-  }
-
-  static pad(plaintext: string): Uint8Array {
-    const unpadded = u.utf8Encode(plaintext)
-    const unpaddedLen = unpadded.length
-    const prefix = u.writeU16BE(unpaddedLen)
-    const suffix = new Uint8Array(u.calcPaddedLen(unpaddedLen) - unpaddedLen)
-    return concatBytes(prefix, unpadded, suffix)
-  }
-
-  static unpad(padded: Uint8Array): string {
-    const unpaddedLen = new DataView(padded.buffer).getUint16(0)
-    const unpadded = padded.subarray(2, 2 + unpaddedLen)
-    if (
-      unpaddedLen < u.minPlaintextSize ||
-      unpaddedLen > u.maxPlaintextSize ||
-      unpadded.length !== unpaddedLen ||
-      padded.length !== 2 + u.calcPaddedLen(unpaddedLen)
-    )
-      throw new Error('invalid padding')
-    return u.utf8Decode(unpadded)
-  }
-
-  static hmacAad(key: Uint8Array, message: Uint8Array, aad: Uint8Array): Uint8Array {
-    if (aad.length !== 32) throw new Error('AAD associated data must be 32 bytes')
-    const combined = concatBytes(aad, message)
-    return hmac(sha256, key, combined)
-  }
-
-  // metadata: always 65b (version: 1b, nonce: 32b, max: 32b)
-  // plaintext: 1b to 0xffff
-  // padded plaintext: 32b to 0xffff
-  // ciphertext: 32b+2 to 0xffff+2
-  // raw payload: 99 (65+32+2) to 65603 (65+0xffff+2)
-  // compressed payload (base64): 132b to 87472b
-  static decodePayload(payload: string): { nonce: Uint8Array; ciphertext: Uint8Array; mac: Uint8Array } {
-    if (typeof payload !== 'string') throw new Error('payload must be a valid string')
-    const plen = payload.length
-    if (plen < 132 || plen > 87472) throw new Error('invalid payload length: ' + plen)
-    if (payload[0] === '#') throw new Error('unknown encryption version')
-    let data: Uint8Array
-    try {
-      data = base64.decode(payload)
-    } catch (error) {
-      throw new Error('invalid base64: ' + (error as any).message)
-    }
-    const dlen = data.length
-    if (dlen < 99 || dlen > 65603) throw new Error('invalid data length: ' + dlen)
-    const vers = data[0]
-    if (vers !== 2) throw new Error('unknown encryption version ' + vers)
-    return {
-      nonce: data.subarray(1, 33),
-      ciphertext: data.subarray(33, -32),
-      mac: data.subarray(-32),
-    }
+function getMessageKeys(
+  conversationKey: Uint8Array,
+  nonce: Uint8Array,
+): { chacha_key: Uint8Array; chacha_nonce: Uint8Array; hmac_key: Uint8Array } {
+  const keys = hkdf_expand(sha256, conversationKey, nonce, 76)
+  return {
+    chacha_key: keys.subarray(0, 32),
+    chacha_nonce: keys.subarray(32, 44),
+    hmac_key: keys.subarray(44, 76),
   }
 }
 
-export class v2 {
-  static utils = u
+function calcPaddedLen(len: number): number {
+  if (!Number.isSafeInteger(len) || len < 1) throw new Error('expected positive integer')
+  if (len <= 32) return 32
+  const nextPower = 1 << (Math.floor(Math.log2(len - 1)) + 1)
+  const chunk = nextPower <= 256 ? 32 : nextPower / 8
+  return chunk * (Math.floor((len - 1) / chunk) + 1)
+}
 
-  static encrypt(plaintext: string, conversationKey: Uint8Array, nonce: Uint8Array = randomBytes(32)): string {
-    const { chacha_key, chacha_nonce, hmac_key } = u.getMessageKeys(conversationKey, nonce)
-    const padded = u.pad(plaintext)
-    const ciphertext = chacha20(chacha_key, chacha_nonce, padded)
-    const mac = u.hmacAad(hmac_key, ciphertext, nonce)
-    return base64.encode(concatBytes(new Uint8Array([2]), nonce, ciphertext, mac))
+function writeU16BE(num: number): Uint8Array {
+  if (!Number.isSafeInteger(num) || num < minPlaintextSize || num > maxPlaintextSize)
+    throw new Error('invalid plaintext size: must be between 1 and 65535 bytes')
+  const arr = new Uint8Array(2)
+  new DataView(arr.buffer).setUint16(0, num, false)
+  return arr
+}
+
+function pad(plaintext: string): Uint8Array {
+  const unpadded = utf8Encoder.encode(plaintext)
+  const unpaddedLen = unpadded.length
+  const prefix = writeU16BE(unpaddedLen)
+  const suffix = new Uint8Array(calcPaddedLen(unpaddedLen) - unpaddedLen)
+  return concatBytes(prefix, unpadded, suffix)
+}
+
+function unpad(padded: Uint8Array): string {
+  const unpaddedLen = new DataView(padded.buffer).getUint16(0)
+  const unpadded = padded.subarray(2, 2 + unpaddedLen)
+  if (
+    unpaddedLen < minPlaintextSize ||
+    unpaddedLen > maxPlaintextSize ||
+    unpadded.length !== unpaddedLen ||
+    padded.length !== 2 + calcPaddedLen(unpaddedLen)
+  )
+    throw new Error('invalid padding')
+  return utf8Decoder.decode(unpadded)
+}
+
+function hmacAad(key: Uint8Array, message: Uint8Array, aad: Uint8Array): Uint8Array {
+  if (aad.length !== 32) throw new Error('AAD associated data must be 32 bytes')
+  const combined = concatBytes(aad, message)
+  return hmac(sha256, key, combined)
+}
+
+// metadata: always 65b (version: 1b, nonce: 32b, max: 32b)
+// plaintext: 1b to 0xffff
+// padded plaintext: 32b to 0xffff
+// ciphertext: 32b+2 to 0xffff+2
+// raw payload: 99 (65+32+2) to 65603 (65+0xffff+2)
+// compressed payload (base64): 132b to 87472b
+function decodePayload(payload: string): { nonce: Uint8Array; ciphertext: Uint8Array; mac: Uint8Array } {
+  if (typeof payload !== 'string') throw new Error('payload must be a valid string')
+  const plen = payload.length
+  if (plen < 132 || plen > 87472) throw new Error('invalid payload length: ' + plen)
+  if (payload[0] === '#') throw new Error('unknown encryption version')
+  let data: Uint8Array
+  try {
+    data = base64.decode(payload)
+  } catch (error) {
+    throw new Error('invalid base64: ' + (error as any).message)
   }
-
-  static decrypt(payload: string, conversationKey: Uint8Array): string {
-    const { nonce, ciphertext, mac } = u.decodePayload(payload)
-    const { chacha_key, chacha_nonce, hmac_key } = u.getMessageKeys(conversationKey, nonce)
-    const calculatedMac = u.hmacAad(hmac_key, ciphertext, nonce)
-    if (!equalBytes(calculatedMac, mac)) throw new Error('invalid MAC')
-    const padded = chacha20(chacha_key, chacha_nonce, ciphertext)
-    return u.unpad(padded)
+  const dlen = data.length
+  if (dlen < 99 || dlen > 65603) throw new Error('invalid data length: ' + dlen)
+  const vers = data[0]
+  if (vers !== 2) throw new Error('unknown encryption version ' + vers)
+  return {
+    nonce: data.subarray(1, 33),
+    ciphertext: data.subarray(33, -32),
+    mac: data.subarray(-32),
   }
 }
 
-export default { v2 }
+export function encrypt(plaintext: string, conversationKey: Uint8Array, nonce: Uint8Array = randomBytes(32)): string {
+  const { chacha_key, chacha_nonce, hmac_key } = getMessageKeys(conversationKey, nonce)
+  const padded = pad(plaintext)
+  const ciphertext = chacha20(chacha_key, chacha_nonce, padded)
+  const mac = hmacAad(hmac_key, ciphertext, nonce)
+  return base64.encode(concatBytes(new Uint8Array([2]), nonce, ciphertext, mac))
+}
+
+export function decrypt(payload: string, conversationKey: Uint8Array): string {
+  const { nonce, ciphertext, mac } = decodePayload(payload)
+  const { chacha_key, chacha_nonce, hmac_key } = getMessageKeys(conversationKey, nonce)
+  const calculatedMac = hmacAad(hmac_key, ciphertext, nonce)
+  if (!equalBytes(calculatedMac, mac)) throw new Error('invalid MAC')
+  const padded = chacha20(chacha_key, chacha_nonce, ciphertext)
+  return unpad(padded)
+}
+
+export const v2 = {
+  utils: {
+    getConversationKey,
+    calcPaddedLen,
+  },
+  encrypt,
+  decrypt,
+}

nip46.ts

@@ -1,11 +1,12 @@
 import { NostrEvent, UnsignedEvent, VerifiedEvent } from './core.ts'
 import { generateSecretKey, finalizeEvent, getPublicKey, verifyEvent } from './pure.ts'
 import { AbstractSimplePool, SubCloser } from './abstract-pool.ts'
-import { decrypt, encrypt } from './nip04.ts'
+import { decrypt as legacyDecrypt } from './nip04.ts'
+import { getConversationKey, decrypt, encrypt } from './nip44.ts'
 import { NIP05_REGEX } from './nip05.ts'
 import { SimplePool } from './pool.ts'
 import { Handlerinformation, NostrConnect } from './kinds.ts'
-import { hexToBytes } from '@noble/hashes/utils'
+import type { RelayRecord } from './relay.ts'
 
 var _fetch: any
 
@@ -17,7 +18,7 @@ export function useFetchImplementation(fetchImplementation: any) {
   _fetch = fetchImplementation
 }
 
-export const BUNKER_REGEX = /^bunker:\/\/([0-9a-f]{64})\??([?\/\w:.=&%]*)$/
+export const BUNKER_REGEX = /^bunker:\/\/([0-9a-f]{64})\??([?\/\w:.=&%-]*)$/
 const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
 
 export type BunkerPointer = {
@@ -47,7 +48,7 @@ export async function parseBunkerInput(input: string): Promise<BunkerPointer | n
   return queryBunkerProfile(input)
 }
 
-async function queryBunkerProfile(nip05: string): Promise<BunkerPointer | null> {
+export async function queryBunkerProfile(nip05: string): Promise<BunkerPointer | null> {
   const match = nip05.match(NIP05_REGEX)
   if (!match) return null
 
@@ -85,8 +86,11 @@ export class BunkerSigner {
   }
   private waitingForAuth: { [id: string]: boolean }
   private secretKey: Uint8Array
+  private conversationKey: Uint8Array
   public bp: BunkerPointer
 
+  private cachedPubKey: string | undefined
+
   /**
    * Creates a new instance of the Nip46 class.
    * @param relays - An array of relay addresses.
@@ -100,6 +104,7 @@ export class BunkerSigner {
 
     this.pool = params.pool || new SimplePool()
     this.secretKey = clientSecretKey
+    this.conversationKey = getConversationKey(clientSecretKey, bp.pubkey)
     this.bp = bp
     this.isOpen = false
     this.idPrefix = Math.random().toString(36).substring(7)
@@ -109,13 +114,21 @@ export class BunkerSigner {
 
     const listeners = this.listeners
     const waitingForAuth = this.waitingForAuth
+    const convKey = this.conversationKey
 
     this.subCloser = this.pool.subscribeMany(
       this.bp.relays,
-      [{ kinds: [NostrConnect], '#p': [getPublicKey(this.secretKey)] }],
+      [{ kinds: [NostrConnect], authors: [bp.pubkey], '#p': [getPublicKey(this.secretKey)] }],
       {
         async onevent(event: NostrEvent) {
-          const { id, result, error } = JSON.parse(await decrypt(clientSecretKey, event.pubkey, event.content))
+          let o
+          try {
+            o = JSON.parse(decrypt(event.content, convKey))
+          } catch (err) {
+            o = JSON.parse(await legacyDecrypt(clientSecretKey, event.pubkey, event.content))
+          }
+
+          const { id, result, error } = o
 
           if (result === 'auth_url' && waitingForAuth[id]) {
             delete waitingForAuth[id]
@@ -155,7 +168,7 @@ export class BunkerSigner {
         this.serial++
         const id = `${this.idPrefix}-${this.serial}`
 
-        const encryptedContent = await encrypt(this.secretKey, this.bp.pubkey, JSON.stringify({ id, method, params }))
+        const encryptedContent = encrypt(JSON.stringify({ id, method, params }), this.conversationKey)
 
         // the request event
         const verifiedEvent: VerifiedEvent = finalizeEvent(
@@ -193,21 +206,26 @@ export class BunkerSigner {
    * Calls the "connect" method on the bunker.
    */
   async connect(): Promise<void> {
-    await this.sendRequest('connect', [getPublicKey(this.secretKey), this.bp.secret || ''])
+    await this.sendRequest('connect', [this.bp.pubkey, this.bp.secret || ''])
   }
 
   /**
-   * This was supposed to call the "get_public_key" method on the bunker,
-   * but instead we just returns the public key we already know.
+   * Calls the "get_public_key" method on the bunker.
+   * (before we would return the public key hardcoded in the bunker parameters, but
+   *  that is not correct as that may be the bunker pubkey and the actual signer
+   *  pubkey may be different.)
    */
   async getPublicKey(): Promise<string> {
-    return this.bp.pubkey
+    if (!this.cachedPubKey) {
+      this.cachedPubKey = await this.sendRequest('get_public_key', [])
+    }
+    return this.cachedPubKey
   }
 
   /**
    * Calls the "get_relays" method on the bunker.
    */
-  async getRelays(): Promise<{ [relay: string]: { read: boolean; write: boolean } }> {
+  async getRelays(): Promise<RelayRecord> {
     return JSON.parse(await this.sendRequest('get_relays', []))
   }
 
@@ -219,7 +237,7 @@ export class BunkerSigner {
   async signEvent(event: UnsignedEvent): Promise<VerifiedEvent> {
     let resp = await this.sendRequest('sign_event', [JSON.stringify(event)])
     let signed: NostrEvent = JSON.parse(resp)
-    if (signed.pubkey === this.bp.pubkey && verifyEvent(signed)) {
+    if (verifyEvent(signed)) {
       return signed
     } else {
       throw new Error(`event returned from bunker is improperly signed: ${JSON.stringify(signed)}`)
@@ -234,17 +252,12 @@ export class BunkerSigner {
     return await this.sendRequest('nip04_decrypt', [thirdPartyPubkey, ciphertext])
   }
 
-  async nip44GetKey(thirdPartyPubkey: string): Promise<Uint8Array> {
-    let resp = await this.sendRequest('nip44_get_key', [thirdPartyPubkey])
-    return hexToBytes(resp)
-  }
-
   async nip44Encrypt(thirdPartyPubkey: string, plaintext: string): Promise<string> {
     return await this.sendRequest('nip44_encrypt', [thirdPartyPubkey, plaintext])
   }
 
   async nip44Decrypt(thirdPartyPubkey: string, ciphertext: string): Promise<string> {
-    return await this.sendRequest('nip44_encrypt', [thirdPartyPubkey, ciphertext])
+    return await this.sendRequest('nip44_decrypt', [thirdPartyPubkey, ciphertext])
   }
 }
 
@@ -254,6 +267,8 @@ export class BunkerSigner {
  * @param username - The username for the account.
  * @param domain - The domain for the account.
  * @param email - The optional email for the account.
+ * @param localSecretKey - Optionally pass a local secret key that will be used to communicate with the bunker,
+                           this will default to generating a random key.
  * @throws Error if the email is present but invalid.
  * @returns A Promise that resolves to the auth_url that the client should follow to create an account.
  */
@@ -263,11 +278,11 @@ export async function createAccount(
   username: string,
   domain: string,
   email?: string,
+  localSecretKey: Uint8Array = generateSecretKey(),
 ): Promise<BunkerSigner> {
   if (email && !EMAIL_REGEX.test(email)) throw new Error('Invalid email')
 
-  let sk = generateSecretKey()
-  let rpc = new BunkerSigner(sk, bunker.bunkerPointer, params)
+  let rpc = new BunkerSigner(localSecretKey, bunker.bunkerPointer, params)
 
   let pubkey = await rpc.sendRequest('create_account', [username, domain, email || ''])
 
@@ -279,9 +294,6 @@ export async function createAccount(
   return rpc
 }
 
-// @deprecated use fetchBunkerProviders instead
-export const fetchCustodialBunkers = fetchBunkerProviders
-
 /**
  * Fetches info on available providers that announce themselves using NIP-89 events.
  * @returns A promise that resolves to an array of available bunker objects.

nip47.test.ts

@@ -1,6 +1,6 @@
 import { describe, test, expect } from 'bun:test'
 import { hexToBytes } from '@noble/hashes/utils'
-import { makeNwcRequestEvent, parseConnectionString } from './nip47'
+import { makeNwcRequestEvent, parseConnectionString } from './nip47.ts'
 import { decrypt } from './nip04.ts'
 import { NWCWalletRequest } from './kinds.ts'
 

nip49.test.ts

@@ -1,5 +1,5 @@
 import { test, expect } from 'bun:test'
-import { decrypt, encrypt } from './nip49'
+import { decrypt, encrypt } from './nip49.ts'
 import { hexToBytes } from '@noble/hashes/utils'
 
 test('encrypt and decrypt', () => {

nip49.ts

@@ -1,10 +1,15 @@
 import { scrypt } from '@noble/hashes/scrypt'
 import { xchacha20poly1305 } from '@noble/ciphers/chacha'
 import { concatBytes, randomBytes } from '@noble/hashes/utils'
-import { Bech32MaxSize, encodeBytes } from './nip19'
+import { Bech32MaxSize, Ncryptsec, encodeBytes } from './nip19.ts'
 import { bech32 } from '@scure/base'
 
-export function encrypt(sec: Uint8Array, password: string, logn: number = 16, ksb: 0x00 | 0x01 | 0x02 = 0x02): string {
+export function encrypt(
+  sec: Uint8Array,
+  password: string,
+  logn: number = 16,
+  ksb: 0x00 | 0x01 | 0x02 = 0x02,
+): Ncryptsec {
   let salt = randomBytes(16)
   let n = 2 ** logn
   let key = scrypt(password.normalize('NFKC'), salt, { N: n, r: 8, p: 1, dkLen: 32 })

nip58.test.ts

@@ -0,0 +1,357 @@
+import { expect, test } from 'bun:test'
+
+import { EventTemplate } from './core.ts'
+import {
+  BadgeAward as BadgeAwardKind,
+  BadgeDefinition as BadgeDefinitionKind,
+  ProfileBadges as ProfileBadgesKind,
+} from './kinds.ts'
+import { finalizeEvent, generateSecretKey } from './pure.ts'
+
+import {
+  BadgeAward,
+  BadgeDefinition,
+  ProfileBadges,
+  generateBadgeAwardEventTemplate,
+  generateBadgeDefinitionEventTemplate,
+  generateProfileBadgesEventTemplate,
+  validateBadgeAwardEvent,
+  validateBadgeDefinitionEvent,
+  validateProfileBadgesEvent,
+} from './nip58.ts'
+
+test('BadgeDefinition has required property "d"', () => {
+  const badge: BadgeDefinition = {
+    d: 'badge-id',
+  }
+  expect(badge.d).toEqual('badge-id')
+})
+
+test('BadgeDefinition has optional property "name"', () => {
+  const badge: BadgeDefinition = {
+    d: 'badge-id',
+    name: 'Badge Name',
+  }
+  expect(badge.name).toEqual('Badge Name')
+})
+
+test('BadgeDefinition has optional property "description"', () => {
+  const badge: BadgeDefinition = {
+    d: 'badge-id',
+    description: 'Badge Description',
+  }
+  expect(badge.description).toEqual('Badge Description')
+})
+
+test('BadgeDefinition has optional property "image"', () => {
+  const badge: BadgeDefinition = {
+    d: 'badge-id',
+    image: ['https://example.com/badge.png', '1024x1024'],
+  }
+  expect(badge.image).toEqual(['https://example.com/badge.png', '1024x1024'])
+})
+
+test('BadgeDefinition has optional property "thumbs"', () => {
+  const badge: BadgeDefinition = {
+    d: 'badge-id',
+    thumbs: [
+      ['https://example.com/thumb.png', '100x100'],
+      ['https://example.com/thumb2.png', '200x200'],
+    ],
+  }
+  expect(badge.thumbs).toEqual([
+    ['https://example.com/thumb.png', '100x100'],
+    ['https://example.com/thumb2.png', '200x200'],
+  ])
+})
+
+test('BadgeAward has required property "a"', () => {
+  const badgeAward: BadgeAward = {
+    a: 'badge-definition-address',
+    p: [
+      ['pubkey1', 'relay1'],
+      ['pubkey2', 'relay2'],
+    ],
+  }
+  expect(badgeAward.a).toEqual('badge-definition-address')
+})
+
+test('BadgeAward has required property "p"', () => {
+  const badgeAward: BadgeAward = {
+    a: 'badge-definition-address',
+    p: [
+      ['pubkey1', 'relay1'],
+      ['pubkey2', 'relay2'],
+    ],
+  }
+  expect(badgeAward.p).toEqual([
+    ['pubkey1', 'relay1'],
+    ['pubkey2', 'relay2'],
+  ])
+})
+
+test('ProfileBadges has required property "d"', () => {
+  const profileBadges: ProfileBadges = {
+    d: 'profile_badges',
+    badges: [],
+  }
+  expect(profileBadges.d).toEqual('profile_badges')
+})
+
+test('ProfileBadges has required property "badges"', () => {
+  const profileBadges: ProfileBadges = {
+    d: 'profile_badges',
+    badges: [],
+  }
+  expect(profileBadges.badges).toEqual([])
+})
+
+test('ProfileBadges badges array contains objects with required properties "a" and "e"', () => {
+  const profileBadges: ProfileBadges = {
+    d: 'profile_badges',
+    badges: [
+      {
+        a: 'badge-definition-address',
+        e: ['badge-award-event-id'],
+      },
+    ],
+  }
+  expect(profileBadges.badges[0].a).toEqual('badge-definition-address')
+  expect(profileBadges.badges[0].e).toEqual(['badge-award-event-id'])
+})
+
+test('generateBadgeDefinitionEventTemplate generates EventTemplate with mandatory tags', () => {
+  const badge: BadgeDefinition = {
+    d: 'badge-id',
+  }
+  const eventTemplate = generateBadgeDefinitionEventTemplate(badge)
+  expect(eventTemplate.tags).toEqual([['d', 'badge-id']])
+})
+
+test('generateBadgeDefinitionEventTemplate generates EventTemplate with optional tags', () => {
+  const badge: BadgeDefinition = {
+    d: 'badge-id',
+    name: 'Badge Name',
+    description: 'Badge Description',
+    image: ['https://example.com/badge.png', '1024x1024'],
+    thumbs: [
+      ['https://example.com/thumb.png', '100x100'],
+      ['https://example.com/thumb2.png', '200x200'],
+    ],
+  }
+  const eventTemplate = generateBadgeDefinitionEventTemplate(badge)
+  expect(eventTemplate.tags).toEqual([
+    ['d', 'badge-id'],
+    ['name', 'Badge Name'],
+    ['description', 'Badge Description'],
+    ['image', 'https://example.com/badge.png', '1024x1024'],
+    ['thumb', 'https://example.com/thumb.png', '100x100'],
+    ['thumb', 'https://example.com/thumb2.png', '200x200'],
+  ])
+})
+
+test('generateBadgeDefinitionEventTemplate generates EventTemplate without optional tags', () => {
+  const badge: BadgeDefinition = {
+    d: 'badge-id',
+  }
+  const eventTemplate = generateBadgeDefinitionEventTemplate(badge)
+  expect(eventTemplate.tags).toEqual([['d', 'badge-id']])
+})
+
+test('validateBadgeDefinitionEvent returns true for valid BadgeDefinition event', () => {
+  const sk = generateSecretKey()
+  const eventTemplate: EventTemplate = {
+    content: '',
+    created_at: Math.floor(Date.now() / 1000),
+    kind: BadgeDefinitionKind,
+    tags: [
+      ['d', 'badge-id'],
+      ['name', 'Badge Name'],
+      ['description', 'Badge Description'],
+      ['image', 'https://example.com/badge.png', '1024x1024'],
+      ['thumb', 'https://example.com/thumb.png', '100x100'],
+      ['thumb', 'https://example.com/thumb2.png', '200x200'],
+    ],
+  }
+  const event = finalizeEvent(eventTemplate, sk)
+  const isValid = validateBadgeDefinitionEvent(event)
+
+  expect(isValid).toBe(true)
+})
+
+test('validateBadgeDefinitionEvent returns false for invalid BadgeDefinition event', () => {
+  const sk = generateSecretKey()
+  const eventTemplate: EventTemplate = {
+    content: '',
+    created_at: Math.floor(Date.now() / 1000),
+    kind: BadgeDefinitionKind,
+    tags: [],
+  }
+  const event = finalizeEvent(eventTemplate, sk)
+  const isValid = validateBadgeDefinitionEvent(event)
+
+  expect(isValid).toBe(false)
+})
+
+test('generateBadgeAwardEventTemplate generates EventTemplate with mandatory tags', () => {
+  const badgeAward: BadgeAward = {
+    a: 'badge-definition-address',
+    p: [
+      ['pubkey1', 'relay1'],
+      ['pubkey2', 'relay2'],
+    ],
+  }
+  const eventTemplate = generateBadgeAwardEventTemplate(badgeAward)
+  expect(eventTemplate.tags).toEqual([
+    ['a', 'badge-definition-address'],
+    ['p', 'pubkey1', 'relay1'],
+    ['p', 'pubkey2', 'relay2'],
+  ])
+})
+
+test('generateBadgeAwardEventTemplate generates EventTemplate without optional tags', () => {
+  const badgeAward: BadgeAward = {
+    a: 'badge-definition-address',
+    p: [
+      ['pubkey1', 'relay1'],
+      ['pubkey2', 'relay2'],
+    ],
+  }
+  const eventTemplate = generateBadgeAwardEventTemplate(badgeAward)
+  expect(eventTemplate.tags).toEqual([
+    ['a', 'badge-definition-address'],
+    ['p', 'pubkey1', 'relay1'],
+    ['p', 'pubkey2', 'relay2'],
+  ])
+})
+
+test('generateBadgeAwardEventTemplate generates EventTemplate with optional tags', () => {
+  const badgeAward: BadgeAward = {
+    a: 'badge-definition-address',
+    p: [
+      ['pubkey1', 'relay1'],
+      ['pubkey2', 'relay2'],
+    ],
+  }
+  const eventTemplate = generateBadgeAwardEventTemplate(badgeAward)
+  expect(eventTemplate.tags).toEqual([
+    ['a', 'badge-definition-address'],
+    ['p', 'pubkey1', 'relay1'],
+    ['p', 'pubkey2', 'relay2'],
+  ])
+})
+
+test('validateBadgeAwardEvent returns true for valid BadgeAward event', () => {
+  const sk = generateSecretKey()
+  const eventTemplate: EventTemplate = {
+    content: '',
+    created_at: Math.floor(Date.now() / 1000),
+    kind: BadgeAwardKind,
+    tags: [
+      ['a', 'badge-definition-address'],
+      ['p', 'pubkey1', 'relay1'],
+      ['p', 'pubkey2', 'relay2'],
+    ],
+  }
+  const event = finalizeEvent(eventTemplate, sk)
+  const isValid = validateBadgeAwardEvent(event)
+
+  expect(isValid).toBe(true)
+})
+
+test('validateBadgeAwardEvent returns false for invalid BadgeAward event', () => {
+  const sk = generateSecretKey()
+  const eventTemplate: EventTemplate = {
+    content: '',
+    created_at: Math.floor(Date.now() / 1000),
+    kind: BadgeAwardKind,
+    tags: [],
+  }
+  const event = finalizeEvent(eventTemplate, sk)
+  const isValid = validateBadgeAwardEvent(event)
+
+  expect(isValid).toBe(false)
+})
+
+test('generateProfileBadgesEventTemplate generates EventTemplate with mandatory tags', () => {
+  const profileBadges: ProfileBadges = {
+    d: 'profile_badges',
+    badges: [],
+  }
+  const eventTemplate = generateProfileBadgesEventTemplate(profileBadges)
+  expect(eventTemplate.tags).toEqual([['d', 'profile_badges']])
+})
+
+test('generateProfileBadgesEventTemplate generates EventTemplate with optional tags', () => {
+  const profileBadges: ProfileBadges = {
+    d: 'profile_badges',
+    badges: [
+      {
+        a: 'badge-definition-address',
+        e: ['badge-award-event-id'],
+      },
+    ],
+  }
+  const eventTemplate = generateProfileBadgesEventTemplate(profileBadges)
+  expect(eventTemplate.tags).toEqual([
+    ['d', 'profile_badges'],
+    ['a', 'badge-definition-address'],
+    ['e', 'badge-award-event-id'],
+  ])
+})
+
+test('generateProfileBadgesEventTemplate generates EventTemplate with multiple optional tags', () => {
+  const profileBadges: ProfileBadges = {
+    d: 'profile_badges',
+    badges: [
+      {
+        a: 'badge-definition-address1',
+        e: ['badge-award-event-id1', 'badge-award-event-id2'],
+      },
+      {
+        a: 'badge-definition-address2',
+        e: ['badge-award-event-id3'],
+      },
+    ],
+  }
+  const eventTemplate = generateProfileBadgesEventTemplate(profileBadges)
+  expect(eventTemplate.tags).toEqual([
+    ['d', 'profile_badges'],
+    ['a', 'badge-definition-address1'],
+    ['e', 'badge-award-event-id1', 'badge-award-event-id2'],
+    ['a', 'badge-definition-address2'],
+    ['e', 'badge-award-event-id3'],
+  ])
+})
+
+test('validateProfileBadgesEvent returns true for valid ProfileBadges event', () => {
+  const sk = generateSecretKey()
+  const eventTemplate: EventTemplate = {
+    content: '',
+    created_at: Math.floor(Date.now() / 1000),
+    kind: ProfileBadgesKind,
+    tags: [
+      ['d', 'profile_badges'],
+      ['a', 'badge-definition-address'],
+      ['e', 'badge-award-event-id'],
+    ],
+  }
+  const event = finalizeEvent(eventTemplate, sk)
+  const isValid = validateProfileBadgesEvent(event)
+
+  expect(isValid).toBe(true)
+})
+
+test('validateProfileBadgesEvent returns false for invalid ProfileBadges event', () => {
+  const sk = generateSecretKey()
+  const eventTemplate: EventTemplate = {
+    content: '',
+    created_at: Math.floor(Date.now() / 1000),
+    kind: ProfileBadgesKind,
+    tags: [],
+  }
+  const event = finalizeEvent(eventTemplate, sk)
+  const isValid = validateProfileBadgesEvent(event)
+
+  expect(isValid).toBe(false)
+})

nip58.ts

@@ -0,0 +1,245 @@
+import { Event, EventTemplate } from './core.ts'
+import {
+  BadgeAward as BadgeAwardKind,
+  BadgeDefinition as BadgeDefinitionKind,
+  ProfileBadges as ProfileBadgesKind,
+} from './kinds.ts'
+
+/**
+ * Represents the structure for defining a badge within the Nostr network.
+ * This structure is used to create templates for badge definition events,
+ * facilitating the recognition and awarding of badges to users for various achievements.
+ */
+export type BadgeDefinition = {
+  /**
+   * A unique identifier for the badge. This is used to distinguish badges
+   * from one another and should be unique across all badge definitions.
+   * Typically, this could be a short, descriptive string.
+   */
+  d: string
+
+  /**
+   * An optional short name for the badge. This provides a human-readable
+   * title for the badge, making it easier to recognize and refer to.
+   */
+  name?: string
+
+  /**
+   * An optional description for the badge. This field can be used to
+   * provide more detailed information about the badge, such as the criteria
+   * for its awarding or its significance.
+   */
+  description?: string
+
+  /**
+   * An optional image URL and dimensions for the badge. The first element
+   * of the tuple is the URL pointing to a high-resolution image representing
+   * the badge, and the second element specifies the image's dimensions in
+   * the format "widthxheight". The recommended dimensions are 1024x1024 pixels.
+   */
+  image?: [string, string]
+
+  /**
+   * An optional list of thumbnail images for the badge. Each element in the
+   * array is a tuple, where the first element is the URL pointing to a thumbnail
+   * version of the badge image, and the second element specifies the thumbnail's
+   * dimensions in the format "widthxheight". Multiple thumbnails can be provided
+   * to support different display sizes.
+   */
+  thumbs?: Array<[string, string]>
+}
+
+/**
+ * Represents the structure for awarding a badge to one or more recipients
+ * within the Nostr network. This structure is used to create templates for
+ * badge award events, which are immutable and signify the recognition of
+ * individuals' achievements or contributions.
+ */
+export type BadgeAward = {
+  /**
+   * A reference to the Badge Definition event. This is typically composed
+   * of the event ID of the badge definition. It establishes a clear linkage
+   * between the badge being awarded and its original definition, ensuring
+   * that recipients are awarded the correct badge.
+   */
+  a: string
+
+  /**
+   * An array of p tags, each containing a pubkey and its associated relays.
+   */
+  p: string[][]
+}
+
+/**
+ * Represents the collection of badges a user chooses to display on their profile.
+ * This structure is crucial for applications that allow users to showcase achievements
+ * or recognitions in the form of badges, following the specifications of NIP-58.
+ */
+export type ProfileBadges = {
+  /**
+   * A unique identifier for the profile badges collection. According to NIP-58,
+   * this should be set to "profile_badges" to differentiate it from other event types.
+   */
+  d: 'profile_badges'
+
+  /**
+   * A list of badges that the user has elected to display on their profile. Each item
+   * in the array represents a specific badge, including references to both its definition
+   * and the award event.
+   */
+  badges: Array<{
+    /**
+     * The event address of the badge definition. This is a reference to the specific badge
+     * being displayed, linking back to the badge's original definition event. It allows
+     * clients to fetch and display the badge's details, such as its name, description,
+     * and image.
+     */
+    a: string
+
+    /**
+     * The event id of the badge award with corresponding relays. This references the event
+     * in which the badge was awarded to the user. It is crucial for verifying the
+     * authenticity of the badge display, ensuring that the user was indeed awarded the
+     * badge they are choosing to display.
+     */
+    e: string[]
+  }>
+}
+
+/**
+ * Generates an EventTemplate based on the provided BadgeDefinition.
+ *
+ * @param {BadgeDefinition} badgeDefinition - The BadgeDefinition object.
+ * @returns {EventTemplate} - The generated EventTemplate object.
+ */
+export function generateBadgeDefinitionEventTemplate({
+  d,
+  description,
+  image,
+  name,
+  thumbs,
+}: BadgeDefinition): EventTemplate {
+  // Mandatory tags
+  const tags: string[][] = [['d', d]]
+
+  // Append optional tags
+  name && tags.push(['name', name])
+  description && tags.push(['description', description])
+  image && tags.push(['image', ...image])
+  if (thumbs) {
+    for (const thumb of thumbs) {
+      tags.push(['thumb', ...thumb])
+    }
+  }
+
+  // Construct the EventTemplate object
+  const eventTemplate: EventTemplate = {
+    content: '',
+    created_at: Math.floor(Date.now() / 1000),
+    kind: BadgeDefinitionKind,
+    tags,
+  }
+
+  return eventTemplate
+}
+
+/**
+ * Validates a badge definition event.
+ *
+ * @param event - The event to validate.
+ * @returns A boolean indicating whether the event is a valid badge definition event.
+ */
+export function validateBadgeDefinitionEvent(event: Event): boolean {
+  if (event.kind !== BadgeDefinitionKind) return false
+
+  const requiredTags = ['d'] as const
+  for (const tag of requiredTags) {
+    if (!event.tags.find(([t]) => t == tag)) return false
+  }
+
+  return true
+}
+
+/**
+ * Generates an EventTemplate based on the provided BadgeAward.
+ *
+ * @param {BadgeAward} badgeAward - The BadgeAward object.
+ * @returns {EventTemplate} - The generated EventTemplate object.
+ */
+export function generateBadgeAwardEventTemplate({ a, p }: BadgeAward): EventTemplate {
+  // Mandatory tags
+  const tags: string[][] = [['a', a]]
+  for (const _p of p) {
+    tags.push(['p', ..._p])
+  }
+
+  // Construct the EventTemplate object
+  const eventTemplate: EventTemplate = {
+    content: '',
+    created_at: Math.floor(Date.now() / 1000),
+    kind: BadgeAwardKind,
+    tags,
+  }
+
+  return eventTemplate
+}
+
+/**
+ * Validates a badge award event.
+ *
+ * @param event - The event to validate.
+ * @returns A boolean indicating whether the event is a valid badge award event.
+ */
+export function validateBadgeAwardEvent(event: Event): boolean {
+  if (event.kind !== BadgeAwardKind) return false
+
+  const requiredTags = ['a', 'p'] as const
+  for (const tag of requiredTags) {
+    if (!event.tags.find(([t]) => t == tag)) return false
+  }
+
+  return true
+}
+
+/**
+ * Generates an EventTemplate based on the provided ProfileBadges.
+ *
+ * @param {ProfileBadges} profileBadges - The ProfileBadges object.
+ * @returns {EventTemplate} - The generated EventTemplate object.
+ */
+export function generateProfileBadgesEventTemplate({ badges }: ProfileBadges): EventTemplate {
+  // Mandatory tags
+  const tags: string[][] = [['d', 'profile_badges']]
+
+  // Append optional tags
+  for (const badge of badges) {
+    tags.push(['a', badge.a], ['e', ...badge.e])
+  }
+
+  // Construct the EventTemplate object
+  const eventTemplate: EventTemplate = {
+    content: '',
+    created_at: Math.floor(Date.now() / 1000),
+    kind: ProfileBadgesKind,
+    tags,
+  }
+
+  return eventTemplate
+}
+
+/**
+ * Validates a profile badges event.
+ *
+ * @param event - The event to validate.
+ * @returns A boolean indicating whether the event is a valid profile badges event.
+ */
+export function validateProfileBadgesEvent(event: Event): boolean {
+  if (event.kind !== ProfileBadgesKind) return false
+
+  const requiredTags = ['d'] as const
+  for (const tag of requiredTags) {
+    if (!event.tags.find(([t]) => t == tag)) return false
+  }
+
+  return true
+}

nip59.test.ts

@@ -0,0 +1,113 @@
+import { test, expect } from 'bun:test'
+import { wrapEvent, wrapManyEvents, unwrapEvent, unwrapManyEvents } from './nip59.ts'
+import { decode } from './nip19.ts'
+import { NostrEvent, getPublicKey } from './pure.ts'
+import { SimplePool } from './pool.ts'
+import { GiftWrap } from './kinds.ts'
+import { hexToBytes } from '@noble/hashes/utils'
+
+const senderPrivateKey = decode(`nsec1p0ht6p3wepe47sjrgesyn4m50m6avk2waqudu9rl324cg2c4ufesyp6rdg`).data
+const recipientPrivateKey = decode(`nsec1uyyrnx7cgfp40fcskcr2urqnzekc20fj0er6de0q8qvhx34ahazsvs9p36`).data
+const recipientPublicKey = getPublicKey(recipientPrivateKey)
+const event = {
+  kind: 1,
+  content: 'Are you going to the party tonight?',
+}
+
+const wrappedEvent = wrapEvent(event, senderPrivateKey, recipientPublicKey)
+
+test('wrapEvent', () => {
+  const expected = {
+    content: '',
+    id: '',
+    created_at: 1728537932,
+    kind: 1059,
+    pubkey: '',
+    sig: '',
+    tags: [['p', '166bf3765ebd1fc55decfe395beff2ea3b2a4e0a8946e7eb578512b555737c99']],
+    [Symbol('verified')]: true,
+  }
+  const result = wrapEvent(event, senderPrivateKey, recipientPublicKey)
+
+  expect(result.kind).toEqual(expected.kind)
+  expect(result.tags).toEqual(expected.tags)
+})
+
+test('wrapManyEvent', () => {
+  const expected = [
+    {
+      kind: 1059,
+      content: '',
+      created_at: 1729581521,
+      tags: [['p', '611df01bfcf85c26ae65453b772d8f1dfd25c264621c0277e1fc1518686faef9']],
+      pubkey: '',
+      id: '',
+      sig: '',
+      [Symbol('verified')]: true,
+    },
+    {
+      kind: 1059,
+      content: '',
+      created_at: 1729594619,
+      tags: [['p', '166bf3765ebd1fc55decfe395beff2ea3b2a4e0a8946e7eb578512b555737c99']],
+      pubkey: '',
+      id: '',
+      sig: '',
+      [Symbol('verified')]: true,
+    },
+  ]
+
+  const wrappedEvents = wrapManyEvents(event, senderPrivateKey, [recipientPublicKey])
+
+  wrappedEvents.forEach((event, index) => {
+    expect(event.kind).toEqual(expected[index].kind)
+    expect(event.tags).toEqual(expected[index].tags)
+  })
+})
+
+test('unwrapEvent', () => {
+  const expected = {
+    kind: 1,
+    content: 'Are you going to the party tonight?',
+    pubkey: '611df01bfcf85c26ae65453b772d8f1dfd25c264621c0277e1fc1518686faef9',
+    tags: [],
+  }
+  const result = unwrapEvent(wrappedEvent, recipientPrivateKey)
+
+  expect(result.kind).toEqual(expected.kind)
+  expect(result.content).toEqual(expected.content)
+  expect(result.pubkey).toEqual(expected.pubkey)
+  expect(result.tags).toEqual(expected.tags)
+})
+
+test('getWrappedEvents and unwrapManyEvents', async () => {
+  const expected = [
+    {
+      created_at: 1729721879,
+      content: 'Hello!',
+      tags: [['p', '33d6bb037bf2e8c4571708e480e42d141bedc5a562b4884ec233b22d6fdea6aa']],
+      kind: 14,
+      pubkey: 'c0f56665e73eedc90b9565ecb34d961a2eb7ac1e2747899e4f73a813f940bc22',
+      id: 'aee0a3e6487b2ac8c1851cc84f3ae0fca9af8a9bdad85c4ba5fdf45d3ee817c3',
+    },
+    {
+      created_at: 1729722025,
+      content: 'How are you?',
+      tags: [['p', '33d6bb037bf2e8c4571708e480e42d141bedc5a562b4884ec233b22d6fdea6aa']],
+      kind: 14,
+      pubkey: 'c0f56665e73eedc90b9565ecb34d961a2eb7ac1e2747899e4f73a813f940bc22',
+      id: '212387ec5efee7d6eb20b747121e9fc1adb798de6c3185e932335bb1bcc61a77',
+    },
+  ]
+  const relays = ['wss://relay.damus.io', 'wss://nos.lol']
+  const privateKey = hexToBytes('582c3e7902c10c84d1cfe899a102e56bde628972d58d63011163ce0cdf4279b6')
+  const publicKey = '33d6bb037bf2e8c4571708e480e42d141bedc5a562b4884ec233b22d6fdea6aa'
+
+  const pool = new SimplePool()
+  const wrappedEvents: NostrEvent[] = await pool.querySync(relays, { kinds: [GiftWrap], '#p': [publicKey] })
+  const unwrappedEvents = unwrapManyEvents(wrappedEvents, privateKey)
+
+  unwrappedEvents.forEach((event, index) => {
+    expect(event).toEqual(expected[index])
+  })
+})

nip59.ts

@@ -0,0 +1,107 @@
+import { EventTemplate, UnsignedEvent, NostrEvent } from './core.ts'
+import { getConversationKey, decrypt, encrypt } from './nip44.ts'
+import { getEventHash, generateSecretKey, finalizeEvent, getPublicKey } from './pure.ts'
+import { Seal, GiftWrap } from './kinds.ts'
+
+type Rumor = UnsignedEvent & { id: string }
+
+const TWO_DAYS = 2 * 24 * 60 * 60
+
+const now = () => Math.round(Date.now() / 1000)
+const randomNow = () => Math.round(now() - Math.random() * TWO_DAYS)
+
+const nip44ConversationKey = (privateKey: Uint8Array, publicKey: string) => getConversationKey(privateKey, publicKey)
+
+const nip44Encrypt = (data: EventTemplate, privateKey: Uint8Array, publicKey: string) =>
+  encrypt(JSON.stringify(data), nip44ConversationKey(privateKey, publicKey))
+
+const nip44Decrypt = (data: NostrEvent, privateKey: Uint8Array) =>
+  JSON.parse(decrypt(data.content, nip44ConversationKey(privateKey, data.pubkey)))
+
+export function createRumor(event: Partial<UnsignedEvent>, privateKey: Uint8Array): Rumor {
+  const rumor = {
+    created_at: now(),
+    content: '',
+    tags: [],
+    ...event,
+    pubkey: getPublicKey(privateKey),
+  } as any
+
+  rumor.id = getEventHash(rumor)
+
+  return rumor as Rumor
+}
+
+export function createSeal(rumor: Rumor, privateKey: Uint8Array, recipientPublicKey: string): NostrEvent {
+  return finalizeEvent(
+    {
+      kind: Seal,
+      content: nip44Encrypt(rumor, privateKey, recipientPublicKey),
+      created_at: randomNow(),
+      tags: [],
+    },
+    privateKey,
+  )
+}
+
+export function createWrap(seal: NostrEvent, recipientPublicKey: string): NostrEvent {
+  const randomKey = generateSecretKey()
+
+  return finalizeEvent(
+    {
+      kind: GiftWrap,
+      content: nip44Encrypt(seal, randomKey, recipientPublicKey),
+      created_at: randomNow(),
+      tags: [['p', recipientPublicKey]],
+    },
+    randomKey,
+  ) as NostrEvent
+}
+
+export function wrapEvent(
+  event: Partial<UnsignedEvent>,
+  senderPrivateKey: Uint8Array,
+  recipientPublicKey: string,
+): NostrEvent {
+  const rumor = createRumor(event, senderPrivateKey)
+
+  const seal = createSeal(rumor, senderPrivateKey, recipientPublicKey)
+  return createWrap(seal, recipientPublicKey)
+}
+
+export function wrapManyEvents(
+  event: Partial<UnsignedEvent>,
+  senderPrivateKey: Uint8Array,
+  recipientsPublicKeys: string[],
+): NostrEvent[] {
+  if (!recipientsPublicKeys || recipientsPublicKeys.length === 0) {
+    throw new Error('At least one recipient is required.')
+  }
+
+  const senderPublicKey = getPublicKey(senderPrivateKey)
+
+  const wrappeds = [wrapEvent(event, senderPrivateKey, senderPublicKey)]
+
+  recipientsPublicKeys.forEach(recipientPublicKey => {
+    wrappeds.push(wrapEvent(event, senderPrivateKey, recipientPublicKey))
+  })
+
+  return wrappeds
+}
+
+export function unwrapEvent(wrap: NostrEvent, recipientPrivateKey: Uint8Array): Rumor {
+  const unwrappedSeal = nip44Decrypt(wrap, recipientPrivateKey)
+  return nip44Decrypt(unwrappedSeal, recipientPrivateKey)
+}
+
+export function unwrapManyEvents(wrappedEvents: NostrEvent[], recipientPrivateKey: Uint8Array): Rumor[] {
+  let unwrappedEvents: Rumor[] = []
+
+  wrappedEvents.forEach(e => {
+    unwrappedEvents.push(unwrapEvent(e, recipientPrivateKey))
+  })
+
+  unwrappedEvents.sort((a, b) => a.created_at - b.created_at)
+
+  return unwrappedEvents
+}

nip75.ts

@@ -1,5 +1,5 @@
-import { Event, EventTemplate } from './core'
-import { ZapGoal } from './kinds'
+import { Event, EventTemplate } from './core.ts'
+import { ZapGoal } from './kinds.ts'
 
 /**
  * Represents a fundraising goal in the Nostr network as defined by NIP-75.

nip94.test.ts

@@ -21,6 +21,7 @@ describe('generateEventTemplate', () => {
       image: 'https://example.com/image.jpg',
       summary: 'Lorem ipsum',
       alt: 'Image alt text',
+      fallback: ['https://fallback1.example.com/image.jpg', 'https://fallback2.example.com/image.jpg'],
     }
 
     const expectedEventTemplate: EventTemplate = {
@@ -40,6 +41,8 @@ describe('generateEventTemplate', () => {
         ['image', 'https://example.com/image.jpg'],
         ['summary', 'Lorem ipsum'],
         ['alt', 'Image alt text'],
+        ['fallback', 'https://fallback1.example.com/image.jpg'],
+        ['fallback', 'https://fallback2.example.com/image.jpg'],
       ],
     }
 
@@ -71,6 +74,7 @@ describe('validateEvent', () => {
           ['image', 'https://example.com/image.jpg'],
           ['summary', 'Lorem ipsum'],
           ['alt', 'Image alt text'],
+          ['fallback', 'https://fallback.example.com/image.jpg'],
         ],
       },
       sk,
@@ -100,6 +104,7 @@ describe('validateEvent', () => {
           ['image', 'https://example.com/image.jpg'],
           ['summary', 'Lorem ipsum'],
           ['alt', 'Image alt text'],
+          ['fallback', 'https://fallback.example.com/image.jpg'],
         ],
       },
       sk,
@@ -129,6 +134,7 @@ describe('validateEvent', () => {
           ['image', 'https://example.com/image.jpg'],
           ['summary', 'Lorem ipsum'],
           ['alt', 'Image alt text'],
+          ['fallback', 'https://fallback.example.com/image.jpg'],
         ],
       },
       sk,
@@ -158,6 +164,7 @@ describe('validateEvent', () => {
           ['image', 'https://example.com/image.jpg'],
           ['summary', 'Lorem ipsum'],
           ['alt', 'Image alt text'],
+          ['fallback', 'https://fallback.example.com/image.jpg'],
         ],
       },
       sk,
@@ -181,6 +188,7 @@ describe('validateEvent', () => {
           ['image', 'https://example.com/image.jpg'],
           ['summary', 'Lorem ipsum'],
           ['alt', 'Image alt text'],
+          ['fallback', 'https://fallback.example.com/image.jpg'],
         ],
       },
       sk,
@@ -204,6 +212,7 @@ describe('validateEvent', () => {
           ['image', 'https://example.com/image.jpg'],
           ['summary', 'Lorem ipsum'],
           ['alt', 'Image alt text'],
+          ['fallback', 'https://fallback.example.com/image.jpg'],
         ],
       },
       sk,
@@ -227,6 +236,7 @@ describe('validateEvent', () => {
           ['image', 'https://example.com/image.jpg'],
           ['summary', 'Lorem ipsum'],
           ['alt', 'Image alt text'],
+          ['fallback', 'https://fallback.example.com/image.jpg'],
         ],
       },
       sk,
@@ -259,6 +269,7 @@ describe('validateEvent', () => {
           ['image', 'https://example.com/image.jpg'],
           ['summary', 'Lorem ipsum'],
           ['alt', 'Image alt text'],
+          ['fallback', 'https://fallback.example.com/image.jpg'],
         ],
       },
       sk,
@@ -288,6 +299,7 @@ describe('validateEvent', () => {
           ['image', 'https://example.com/image.jpg'],
           ['summary', 'Lorem ipsum'],
           ['alt', 'Image alt text'],
+          ['fallback', 'https://fallback.example.com/image.jpg'],
         ],
       },
       sk,
@@ -319,6 +331,8 @@ describe('parseEvent', () => {
           ['image', 'https://example.com/image.jpg'],
           ['summary', 'Lorem ipsum'],
           ['alt', 'Image alt text'],
+          ['fallback', 'https://fallback1.example.com/image.jpg'],
+          ['fallback', 'https://fallback2.example.com/image.jpg'],
         ],
       },
       sk,
@@ -340,6 +354,7 @@ describe('parseEvent', () => {
       image: 'https://example.com/image.jpg',
       summary: 'Lorem ipsum',
       alt: 'Image alt text',
+      fallback: ['https://fallback1.example.com/image.jpg', 'https://fallback2.example.com/image.jpg'],
     })
   })
 
@@ -364,6 +379,7 @@ describe('parseEvent', () => {
           ['image', 'https://example.com/image.jpg'],
           ['summary', 'Lorem ipsum'],
           ['alt', 'Image alt text'],
+          ['fallback', 'https://fallback.example.com/image.jpg'],
         ],
       },
       sk,

nip94.ts

@@ -1,4 +1,4 @@
-import { Event, EventTemplate } from './core'
+import { Event, EventTemplate } from './core.ts'
 import { FileMetadata as FileMetadataKind } from './kinds.ts'
 
 /**
@@ -75,6 +75,11 @@ export type FileMetadataObject = {
    * Optional: A description for accessibility, providing context or a brief description of the file.
    */
   alt?: string
+
+  /**
+   * Optional: fallback URLs in case url fails.
+   */
+  fallback?: string[]
 }
 
 /**
@@ -104,6 +109,7 @@ export function generateEventTemplate(fileMetadata: FileMetadataObject): EventTe
   if (fileMetadata.image) eventTemplate.tags.push(['image', fileMetadata.image])
   if (fileMetadata.summary) eventTemplate.tags.push(['summary', fileMetadata.summary])
   if (fileMetadata.alt) eventTemplate.tags.push(['alt', fileMetadata.alt])
+  if (fileMetadata.fallback) fileMetadata.fallback.forEach(url => eventTemplate.tags.push(['fallback', url]))
 
   return eventTemplate
 }
@@ -194,6 +200,10 @@ export function parseEvent(event: Event): FileMetadataObject {
       case 'alt':
         fileMetadata.alt = value
         break
+      case 'fallback':
+        fileMetadata.fallback ??= []
+        fileMetadata.fallback.push(value)
+        break
     }
   }
 

nip96.ts

@@ -1,6 +1,6 @@
 import { sha256 } from '@noble/hashes/sha256'
-import { EventTemplate } from './core'
-import { FileServerPreference } from './kinds'
+import { EventTemplate } from './core.ts'
+import { FileServerPreference } from './kinds.ts'
 import { bytesToHex } from '@noble/hashes/utils'
 
 /**
@@ -340,9 +340,6 @@ export async function uploadFile(
   // Create FormData object
   const formData = new FormData()
 
-  // Append the authorization header to HTML Form Data
-  formData.append('Authorization', nip98AuthorizationHeader)
-
   // Append optional fields to FormData
   optionalFormDataFields &&
     Object.entries(optionalFormDataFields).forEach(([key, value]) => {
@@ -359,7 +356,6 @@ export async function uploadFile(
     method: 'POST',
     headers: {
       Authorization: nip98AuthorizationHeader,
-      'Content-Type': 'multipart/form-data',
     },
     body: formData,
   })

nip99.test.ts

@@ -1,9 +1,9 @@
 import { describe, expect, test } from 'bun:test'
 
-import { Event } from './core'
-import { ClassifiedListing, DraftClassifiedListing } from './kinds'
-import { ClassifiedListingObject, generateEventTemplate, parseEvent, validateEvent } from './nip99'
-import { finalizeEvent, generateSecretKey } from './pure'
+import { Event } from './core.ts'
+import { ClassifiedListing, DraftClassifiedListing } from './kinds.ts'
+import { ClassifiedListingObject, generateEventTemplate, parseEvent, validateEvent } from './nip99.ts'
+import { finalizeEvent, generateSecretKey } from './pure.ts'
 
 describe('validateEvent', () => {
   test('should return true for a valid classified listing event', () => {

package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "nostr-tools",
-  "version": "2.3.1",
+  "version": "2.10.1",
   "description": "Tools for making a Nostr client.",
   "repository": {
     "type": "git",
@@ -85,6 +85,9 @@
       "require": "./lib/cjs/nip06.js",
       "types": "./lib/types/nip06.d.ts"
     },
+    "./nip07": {
+      "types": "./lib/types/nip07.d.ts"
+    },
     "./nip10": {
       "import": "./lib/esm/nip10.js",
       "require": "./lib/cjs/nip10.js",
@@ -100,6 +103,11 @@
       "require": "./lib/cjs/nip13.js",
       "types": "./lib/types/nip13.d.ts"
     },
+    "./nip17": {
+      "import": "./lib/esm/nip17.js",
+      "require": "./lib/cjs/nip17.js",
+      "types": "./lib/types/nip17.d.ts"
+    },
     "./nip18": {
       "import": "./lib/esm/nip18.js",
       "require": "./lib/cjs/nip18.js",
@@ -170,6 +178,16 @@
       "require": "./lib/cjs/nip57.js",
       "types": "./lib/types/nip57.d.ts"
     },
+    "./nip59": {
+      "import": "./lib/esm/nip59.js",
+      "require": "./lib/cjs/nip59.js",
+      "types": "./lib/types/nip59.d.ts"
+    },
+    "./nip58": {
+      "import": "./lib/esm/nip58.js",
+      "require": "./lib/cjs/nip58.js",
+      "types": "./lib/types/nip58.d.ts"
+    },
     "./nip75": {
       "import": "./lib/esm/nip75.js",
       "require": "./lib/cjs/nip75.js",

pool.test.ts

@@ -1,9 +1,9 @@
 import { afterEach, beforeEach, expect, test } from 'bun:test'
 
-import { SimplePool } from './pool.ts'
+import { SimplePool, useWebSocketImplementation } from './pool.ts'
 import { finalizeEvent, generateSecretKey, getPublicKey, type Event } from './pure.ts'
-import { useWebSocketImplementation } from './relay.ts'
 import { MockRelay, MockWebSocketClient } from './test-helpers.ts'
+import { hexToBytes } from '@noble/hashes/utils'
 
 useWebSocketImplementation(MockWebSocketClient)
 
@@ -84,6 +84,86 @@ test('same with double subs', async () => {
   expect(received).toHaveLength(2)
 })
 
+test('subscribe many map', async () => {
+  let priv = hexToBytes('8ea002840d413ccdd5be98df5dd89d799eaa566355ede83ca0bbdbb4b145e0d3')
+  let pub = getPublicKey(priv)
+
+  let received: Event[] = []
+  let event1 = finalizeEvent(
+    {
+      created_at: Math.round(Date.now() / 1000),
+      content: 'test1',
+      kind: 20001,
+      tags: [],
+    },
+    priv,
+  )
+  let event2 = finalizeEvent(
+    {
+      created_at: Math.round(Date.now() / 1000),
+      content: 'test2',
+      kind: 20002,
+      tags: [['t', 'biloba']],
+    },
+    priv,
+  )
+  let event3 = finalizeEvent(
+    {
+      created_at: Math.round(Date.now() / 1000),
+      content: 'test3',
+      kind: 20003,
+      tags: [['t', 'biloba']],
+    },
+    priv,
+  )
+
+  const [relayA, relayB, relayC] = relayURLs
+
+  pool.subscribeManyMap(
+    {
+      [relayA]: [{ authors: [pub], kinds: [20001] }],
+      [relayB]: [{ authors: [pub], kinds: [20002] }],
+      [relayC]: [{ kinds: [20003], '#t': ['biloba'] }],
+    },
+    {
+      onevent(event: Event) {
+        received.push(event)
+      },
+    },
+  )
+
+  // publish the first
+  await Promise.all(pool.publish([relayA, relayB], event1))
+  await new Promise(resolve => setTimeout(resolve, 100))
+
+  expect(received).toHaveLength(1)
+  expect(received[0]).toEqual(event1)
+
+  // publish the second
+  await pool.publish([relayB], event2)[0]
+  await new Promise(resolve => setTimeout(resolve, 100))
+
+  expect(received).toHaveLength(2)
+  expect(received[1]).toEqual(event2)
+
+  // publish a events that shouldn't match our filters
+  await Promise.all([
+    ...pool.publish([relayA, relayB], event3),
+    ...pool.publish([relayA, relayB, relayC], event1),
+    pool.publish([relayA, relayB, relayC], event2),
+  ])
+  await new Promise(resolve => setTimeout(resolve, 100))
+
+  expect(received).toHaveLength(2)
+
+  // publsih the third
+  await pool.publish([relayC], event3)[0]
+  await new Promise(resolve => setTimeout(resolve, 100))
+
+  expect(received).toHaveLength(3)
+  expect(received[2]).toEqual(event3)
+})
+
 test('query a bunch of events and cancel on eose', async () => {
   let events = new Set<string>()
 
@@ -125,3 +205,33 @@ test('get()', async () => {
   expect(event).not.toBeNull()
   expect(event).toHaveProperty('id', ids[0])
 })
+
+test('track relays when publishing', async () => {
+  let event1 = finalizeEvent(
+    {
+      kind: 1,
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [],
+      content: 'hello',
+    },
+    generateSecretKey(),
+  )
+  let event2 = finalizeEvent(
+    {
+      kind: 1,
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [],
+      content: 'hello',
+    },
+    generateSecretKey(),
+  )
+
+  pool.trackRelays = true
+  await Promise.all(pool.publish(relayURLs, event1))
+  expect(pool.seenOn.get(event1.id)).toBeDefined()
+  expect(Array.from(pool.seenOn.get(event1.id)!).map(r => r.url)).toEqual(expect.arrayContaining(relayURLs))
+
+  pool.trackRelays = false
+  await Promise.all(pool.publish(relayURLs, event2))
+  expect(pool.seenOn.get(event2.id)).toBeUndefined()
+})

pool.ts

@@ -1,9 +1,21 @@
+/* global WebSocket */
+
 import { verifyEvent } from './pure.ts'
 import { AbstractSimplePool } from './abstract-pool.ts'
 
+var _WebSocket: typeof WebSocket
+
+try {
+  _WebSocket = WebSocket
+} catch {}
+
+export function useWebSocketImplementation(websocketImplementation: any) {
+  _WebSocket = websocketImplementation
+}
+
 export class SimplePool extends AbstractSimplePool {
   constructor() {
-    super({ verifyEvent })
+    super({ verifyEvent, websocketImplementation: _WebSocket })
   }
 }
 

pure.test.ts

@@ -0,0 +1,293 @@
+import { describe, test, expect } from 'bun:test'
+
+import {
+  finalizeEvent,
+  serializeEvent,
+  getEventHash,
+  validateEvent,
+  verifyEvent,
+  verifiedSymbol,
+  getPublicKey,
+  generateSecretKey,
+} from './pure.ts'
+import { ShortTextNote } from './kinds.ts'
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils'
+
+test('private key generation', () => {
+  expect(bytesToHex(generateSecretKey())).toMatch(/[a-f0-9]{64}/)
+})
+
+test('public key generation', () => {
+  expect(getPublicKey(generateSecretKey())).toMatch(/[a-f0-9]{64}/)
+})
+
+test('public key from private key deterministic', () => {
+  let sk = generateSecretKey()
+  let pk = getPublicKey(sk)
+
+  for (let i = 0; i < 5; i++) {
+    expect(getPublicKey(sk)).toEqual(pk)
+  }
+})
+
+describe('finalizeEvent', () => {
+  test('should create a signed event from a template', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+    const publicKey = getPublicKey(privateKey)
+
+    const template = {
+      kind: ShortTextNote,
+      tags: [],
+      content: 'Hello, world!',
+      created_at: 1617932115,
+    }
+
+    const event = finalizeEvent(template, privateKey)
+
+    expect(event.kind).toEqual(template.kind)
+    expect(event.tags).toEqual(template.tags)
+    expect(event.content).toEqual(template.content)
+    expect(event.created_at).toEqual(template.created_at)
+    expect(event.pubkey).toEqual(publicKey)
+    expect(typeof event.id).toEqual('string')
+    expect(typeof event.sig).toEqual('string')
+  })
+})
+
+describe('serializeEvent', () => {
+  test('should serialize a valid event object', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+    const publicKey = getPublicKey(privateKey)
+
+    const unsignedEvent = {
+      pubkey: publicKey,
+      created_at: 1617932115,
+      kind: ShortTextNote,
+      tags: [],
+      content: 'Hello, world!',
+    }
+
+    const serializedEvent = serializeEvent(unsignedEvent)
+
+    expect(serializedEvent).toEqual(
+      JSON.stringify([
+        0,
+        publicKey,
+        unsignedEvent.created_at,
+        unsignedEvent.kind,
+        unsignedEvent.tags,
+        unsignedEvent.content,
+      ]),
+    )
+  })
+
+  test('should throw an error for an invalid event object', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+    const publicKey = getPublicKey(privateKey)
+
+    const invalidEvent = {
+      kind: ShortTextNote,
+      tags: [],
+      created_at: 1617932115,
+      pubkey: publicKey, // missing content
+    }
+
+    expect(() => {
+      // @ts-expect-error
+      serializeEvent(invalidEvent)
+    }).toThrow("can't serialize event with wrong or missing properties")
+  })
+})
+
+describe('getEventHash', () => {
+  test('should return the correct event hash', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+    const publicKey = getPublicKey(privateKey)
+
+    const unsignedEvent = {
+      kind: ShortTextNote,
+      tags: [],
+      content: 'Hello, world!',
+      created_at: 1617932115,
+      pubkey: publicKey,
+    }
+
+    const eventHash = getEventHash(unsignedEvent)
+
+    expect(typeof eventHash).toEqual('string')
+    expect(eventHash.length).toEqual(64)
+  })
+})
+
+describe('validateEvent', () => {
+  test('should return true for a valid event object', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+    const publicKey = getPublicKey(privateKey)
+
+    const unsignedEvent = {
+      kind: ShortTextNote,
+      tags: [],
+      content: 'Hello, world!',
+      created_at: 1617932115,
+      pubkey: publicKey,
+    }
+
+    const isValid = validateEvent(unsignedEvent)
+
+    expect(isValid).toEqual(true)
+  })
+
+  test('should return false for a non object event', () => {
+    const nonObjectEvent = ''
+    const isValid = validateEvent(nonObjectEvent)
+    expect(isValid).toEqual(false)
+  })
+
+  test('should return false for an event object with missing properties', () => {
+    const invalidEvent = {
+      kind: ShortTextNote,
+      tags: [],
+      created_at: 1617932115, // missing content and pubkey
+    }
+
+    const isValid = validateEvent(invalidEvent)
+
+    expect(isValid).toEqual(false)
+  })
+
+  test('should return false for an empty object', () => {
+    const emptyObj = {}
+
+    const isValid = validateEvent(emptyObj)
+
+    expect(isValid).toEqual(false)
+  })
+
+  test('should return false for an object with invalid properties', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+    const publicKey = getPublicKey(privateKey)
+
+    const invalidEvent = {
+      kind: 1,
+      tags: [],
+      created_at: '1617932115', // should be a number
+      pubkey: publicKey,
+    }
+
+    const isValid = validateEvent(invalidEvent)
+
+    expect(isValid).toEqual(false)
+  })
+
+  test('should return false for an object with an invalid public key', () => {
+    const invalidEvent = {
+      kind: 1,
+      tags: [],
+      content: 'Hello, world!',
+      created_at: 1617932115,
+      pubkey: 'invalid_pubkey',
+    }
+
+    const isValid = validateEvent(invalidEvent)
+
+    expect(isValid).toEqual(false)
+  })
+
+  test('should return false for an object with invalid tags', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+    const publicKey = getPublicKey(privateKey)
+
+    const invalidEvent = {
+      kind: 1,
+      tags: {}, // should be an array
+      content: 'Hello, world!',
+      created_at: 1617932115,
+      pubkey: publicKey,
+    }
+
+    const isValid = validateEvent(invalidEvent)
+
+    expect(isValid).toEqual(false)
+  })
+})
+
+describe('verifyEvent', () => {
+  test('should return true for a valid event signature', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+    const event = finalizeEvent(
+      {
+        kind: ShortTextNote,
+        tags: [],
+        content: 'Hello, world!',
+        created_at: 1617932115,
+      },
+      privateKey,
+    )
+
+    const isValid = verifyEvent(event)
+    expect(isValid).toEqual(true)
+  })
+
+  test('should return false for an invalid event signature', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+    const { [verifiedSymbol]: _, ...event } = finalizeEvent(
+      {
+        kind: ShortTextNote,
+        tags: [],
+        content: 'Hello, world!',
+        created_at: 1617932115,
+      },
+      privateKey,
+    )
+
+    // tamper with the signature
+    event.sig = event.sig.replace(/^.{3}/g, '666')
+
+    const isValid = verifyEvent(event)
+    expect(isValid).toEqual(false)
+  })
+
+  test('should return false when verifying an event with a different private key', () => {
+    const privateKey1 = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+
+    const privateKey2 = hexToBytes('5b4a34f4e4b23c63ad55a35e3f84a3b53d96dbf266edf521a8358f71d19cbf67')
+    const publicKey2 = getPublicKey(privateKey2)
+
+    const { [verifiedSymbol]: _, ...event } = finalizeEvent(
+      {
+        kind: ShortTextNote,
+        tags: [],
+        content: 'Hello, world!',
+        created_at: 1617932115,
+      },
+      privateKey1,
+    )
+
+    // verify with different private key
+    const isValid = verifyEvent({
+      ...event,
+      pubkey: publicKey2,
+    })
+    expect(isValid).toEqual(false)
+  })
+
+  test('should return false for an invalid event id', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+
+    const { [verifiedSymbol]: _, ...event } = finalizeEvent(
+      {
+        kind: 1,
+        tags: [],
+        content: 'Hello, world!',
+        created_at: 1617932115,
+      },
+      privateKey,
+    )
+
+    // tamper with the id
+    event.id = event.id.replace(/^.{3}/g, '666')
+
+    const isValid = verifyEvent(event)
+    expect(isValid).toEqual(false)
+  })
+})

relay.test.ts

@@ -1,5 +1,5 @@
 import { expect, test } from 'bun:test'
-
+import { Server } from 'mock-socket'
 import { finalizeEvent, generateSecretKey, getPublicKey } from './pure.ts'
 import { Relay, useWebSocketImplementation } from './relay.ts'
 import { MockRelay, MockWebSocketClient } from './test-helpers.ts'
@@ -92,3 +92,28 @@ test('listening and publishing and closing', async done => {
     ),
   )
 })
+
+test('publish timeout', async () => {
+  const url = 'wss://relay.example.com'
+  new Server(url)
+
+  const relay = new Relay(url)
+  relay.publishTimeout = 100
+  await relay.connect()
+
+  setTimeout(() => relay.close(), 20000) // close the relay to fail the test on timeout
+
+  expect(
+    relay.publish(
+      finalizeEvent(
+        {
+          kind: 1,
+          created_at: Math.floor(Date.now() / 1000),
+          tags: [],
+          content: 'hello',
+        },
+        generateSecretKey(),
+      ),
+    ),
+  ).rejects.toThrow('publish timed out')
+})

relay.ts

@@ -1,3 +1,5 @@
+/* global WebSocket */
+
 import { verifyEvent } from './pure.ts'
 import { AbstractRelay } from './abstract-relay.ts'
 
@@ -8,9 +10,19 @@ export function relayConnect(url: string): Promise<Relay> {
   return Relay.connect(url)
 }
 
+var _WebSocket: typeof WebSocket
+
+try {
+  _WebSocket = WebSocket
+} catch {}
+
+export function useWebSocketImplementation(websocketImplementation: any) {
+  _WebSocket = websocketImplementation
+}
+
 export class Relay extends AbstractRelay {
   constructor(url: string) {
-    super(url, { verifyEvent })
+    super(url, { verifyEvent, websocketImplementation: _WebSocket })
   }
 
   static async connect(url: string): Promise<Relay> {
@@ -20,4 +32,6 @@ export class Relay extends AbstractRelay {
   }
 }
 
+export type RelayRecord = Record<string, { read: boolean; write: boolean }>
+
 export * from './abstract-relay.ts'

test-helpers.ts

@@ -35,9 +35,9 @@ export class MockRelay {
       finalizeEvent(
         {
           kind: 1,
-          content: '',
+          content: 'autogenerated by relay',
           created_at: Math.floor(Date.now() / 1000),
-          tags: [],
+          tags: [['t', 'auto']],
         },
         sk,
       ),
@@ -68,9 +68,9 @@ export class MockRelay {
                   const event = finalizeEvent(
                     {
                       kind,
-                      content: '',
+                      content: 'kind-aware autogenerated by relay',
                       created_at: Math.floor(Date.now() / 1000),
-                      tags: [],
+                      tags: [['t', 'auto']],
                     },
                     sk,
                   )

tsconfig.json

@@ -1,11 +1,11 @@
 {
   "compilerOptions": {
-    "module": "esnext",
+    "module": "NodeNext",
     "target": "esnext",
     "lib": ["dom", "dom.iterable", "esnext"],
     "declaration": true,
     "strict": true,
-    "moduleResolution": "node",
+    "moduleResolution": "NodeNext",
     "skipLibCheck": true,
     "esModuleInterop": true,
     "emitDeclarationOnly": true,

wasm.ts

@@ -1,6 +1,6 @@
 import { bytesToHex } from '@noble/hashes/utils'
 import { Nostr as NostrWasm } from 'nostr-wasm'
-import { EventTemplate, Event, Nostr, VerifiedEvent, verifiedSymbol } from './core'
+import { EventTemplate, Event, Nostr, VerifiedEvent, verifiedSymbol } from './core.ts'
 
 let nw: NostrWasm
 
@@ -30,7 +30,7 @@ class Wasm implements Nostr {
   }
 }
 
-const i = new Wasm()
+const i: Wasm = new Wasm()
 export const generateSecretKey = i.generateSecretKey
 export const getPublicKey = i.getPublicKey
 export const finalizeEvent = i.finalizeEvent