add links to jsr.io

- 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.

README.md

@@ -1,4 +1,4 @@
-# ![](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.
 
@@ -9,11 +9,19 @@ This package is only providing lower-level functionality. If you want more highe
 ## 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

abstract-pool.ts

@@ -23,7 +23,7 @@ export type SubscribeManyParams = Omit<SubscriptionParams, 'onclose' | 'id'> & {
 }
 
 export class AbstractSimplePool {
-  protected relays = new Map<string, AbstractRelay>()
+  protected relays: Map<string, AbstractRelay> = new Map()
   public seenOn: Map<string, Set<AbstractRelay>> = new Map()
   public trackRelays: boolean = false
 

abstract-relay.ts

@@ -24,6 +24,7 @@ export class AbstractRelay {
 
   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
 
@@ -198,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': {
@@ -248,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
   }
 

jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@nostr/tools",
-  "version": "2.3.2",
+  "version": "2.10.0",
   "exports": {
     ".": "./index.ts",
     "./core": "./core.ts",
@@ -20,6 +20,7 @@
     "./nip10": "./nip10.ts",
     "./nip11": "./nip11.ts",
     "./nip13": "./nip13.ts",
+    "./nip17": "./nip17.ts",
     "./nip18": "./nip18.ts",
     "./nip19": "./nip19.ts",
     "./nip21": "./nip21.ts",
@@ -34,6 +35,8 @@
     "./nip46": "./nip46.ts",
     "./nip49": "./nip49.ts",
     "./nip57": "./nip57.ts",
+    "./nip58": "./nip58.ts",
+    "./nip59": "./nip59.ts",
     "./nip75": "./nip75.ts",
     "./nip94": "./nip94.ts",
     "./nip96": "./nip96.ts",
@@ -42,4 +45,4 @@
     "./fakejson": "./fakejson.ts",
     "./utils": "./utils.ts"
   }
-}
+}

nip05.test.ts

@@ -1,24 +1,7 @@
 import { test, expect } from 'bun:test'
-import fetch from 'node-fetch'
 
 import { useFetchImplementation, queryProfile, NIP05_REGEX, isNip05 } from './nip05.ts'
 
-test('fetch nip05 profiles', async () => {
-  useFetchImplementation(fetch)
-
-  let p1 = await queryProfile('jb55.com')
-  expect(p1!.pubkey).toEqual('32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245')
-  expect(p1!.relays).toEqual(['wss://relay.damus.io'])
-
-  let p2 = await queryProfile('jb55@jb55.com')
-  expect(p2!.pubkey).toEqual('32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245')
-  expect(p2!.relays).toEqual(['wss://relay.damus.io'])
-
-  let p3 = await queryProfile('_@fiatjaf.com')
-  expect(p3!.pubkey).toEqual('3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d')
-  expect(p3!.relays).toEqual(['wss://pyramid.fiatjaf.com', 'wss://nos.lol'])
-})
-
 test('validate NIP05_REGEX', () => {
   expect(NIP05_REGEX.test('_@bob.com.br')).toBeTrue()
   expect(NIP05_REGEX.test('bob@bob.com.br')).toBeTrue()
@@ -30,3 +13,34 @@ test('validate NIP05_REGEX', () => {
   expect(isNip05('bob@bob.com.br')).toBeTrue()
   expect(isNip05('b&b@bob.com.br')).toBeFalse()
 })
+
+test('fetch nip05 profiles', async () => {
+  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]
+    },
+  })
+
+  useFetchImplementation(fetchStub)
+
+  let p2 = await queryProfile('compile-error.net')
+  expect(p2!.pubkey).toEqual('2c7cc62a697ea3a7826521f3fd34f0cb273693cbe5e9310f35449f43622a5cdc')
+
+  let p3 = await queryProfile('_@fiatjaf.com')
+  expect(p3!.pubkey).toEqual('3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d')
+  expect(p3!.relays).toEqual(['wss://pyramid.fiatjaf.com', 'wss://nos.lol'])
+})

nip05.ts

@@ -12,20 +12,26 @@ export type Nip05 = `${string}@${string}`
 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 (_) {
@@ -37,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: Nip05): Promise<boolean> {
-  let res = await queryProfile(nip05)
+  const res = await queryProfile(nip05)
   return res ? res.pubkey === pubkey : false
 }

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

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,

nip46.ts

@@ -1,9 +1,8 @@
-import { hexToBytes } from '@noble/hashes/utils'
 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 { getConversationKey, decrypt as nip44decrypt } from './nip44.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'
@@ -49,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
 
@@ -87,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.
@@ -102,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)
@@ -111,18 +114,18 @@ export class BunkerSigner {
 
     const listeners = this.listeners
     const waitingForAuth = this.waitingForAuth
-    const skBytes = this.secretKey
+    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) {
           let o
           try {
-            o = JSON.parse(await decrypt(clientSecretKey, event.pubkey, event.content))
+            o = JSON.parse(decrypt(event.content, convKey))
           } catch (err) {
-            o = JSON.parse(nip44decrypt(event.content, getConversationKey(skBytes, event.pubkey)))
+            o = JSON.parse(await legacyDecrypt(event.content, event.pubkey, event.content))
           }
 
           const { id, result, error } = o
@@ -165,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(
@@ -213,7 +216,10 @@ export class BunkerSigner {
    *  pubkey may be different.)
    */
   async getPublicKey(): Promise<string> {
-    return await this.sendRequest('get_public_key', [])
+    if (!this.cachedPubKey) {
+      this.cachedPubKey = await this.sendRequest('get_public_key', [])
+    }
+    return this.cachedPubKey
   }
 
   /**
@@ -231,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)}`)
@@ -246,11 +252,6 @@ 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])
   }
@@ -293,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.

nip59.test.ts

@@ -1,7 +1,10 @@
 import { test, expect } from 'bun:test'
-import { wrapEvent, unwrapEvent } from './nip59.ts'
+import { wrapEvent, wrapManyEvents, unwrapEvent, unwrapManyEvents } from './nip59.ts'
 import { decode } from './nip19.ts'
-import { getPublicKey } from './pure.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
@@ -11,7 +14,7 @@ const event = {
   content: 'Are you going to the party tonight?',
 }
 
-const wrapedEvent = wrapEvent(event, senderPrivateKey, recipientPublicKey)
+const wrappedEvent = wrapEvent(event, senderPrivateKey, recipientPublicKey)
 
 test('wrapEvent', () => {
   const expected = {
@@ -30,6 +33,38 @@ test('wrapEvent', () => {
   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,
@@ -37,10 +72,42 @@ test('unwrapEvent', () => {
     pubkey: '611df01bfcf85c26ae65453b772d8f1dfd25c264621c0277e1fc1518686faef9',
     tags: [],
   }
-  const result = unwrapEvent(wrapedEvent, recipientPrivateKey)
+  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

@@ -1,4 +1,4 @@
-import { EventTemplate, UnsignedEvent, Event } from './core.ts'
+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'
@@ -15,10 +15,10 @@ const nip44ConversationKey = (privateKey: Uint8Array, publicKey: string) => getC
 const nip44Encrypt = (data: EventTemplate, privateKey: Uint8Array, publicKey: string) =>
   encrypt(JSON.stringify(data), nip44ConversationKey(privateKey, publicKey))
 
-const nip44Decrypt = (data: Event, privateKey: Uint8Array) =>
+const nip44Decrypt = (data: NostrEvent, privateKey: Uint8Array) =>
   JSON.parse(decrypt(data.content, nip44ConversationKey(privateKey, data.pubkey)))
 
-export function createRumor(event: Partial<UnsignedEvent>, privateKey: Uint8Array) {
+export function createRumor(event: Partial<UnsignedEvent>, privateKey: Uint8Array): Rumor {
   const rumor = {
     created_at: now(),
     content: '',
@@ -32,7 +32,7 @@ export function createRumor(event: Partial<UnsignedEvent>, privateKey: Uint8Arra
   return rumor as Rumor
 }
 
-export function createSeal(rumor: Rumor, privateKey: Uint8Array, recipientPublicKey: string) {
+export function createSeal(rumor: Rumor, privateKey: Uint8Array, recipientPublicKey: string): NostrEvent {
   return finalizeEvent(
     {
       kind: Seal,
@@ -41,10 +41,10 @@ export function createSeal(rumor: Rumor, privateKey: Uint8Array, recipientPublic
       tags: [],
     },
     privateKey,
-  ) as Event
+  )
 }
 
-export function createWrap(seal: Event, recipientPublicKey: string) {
+export function createWrap(seal: NostrEvent, recipientPublicKey: string): NostrEvent {
   const randomKey = generateSecretKey()
 
   return finalizeEvent(
@@ -55,17 +55,53 @@ export function createWrap(seal: Event, recipientPublicKey: string) {
       tags: [['p', recipientPublicKey]],
     },
     randomKey,
-  ) as Event
+  ) as NostrEvent
 }
 
-export function wrapEvent(event: Partial<UnsignedEvent>, senderPrivateKey: Uint8Array, recipientPublicKey: string) {
+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 unwrapEvent(wrap: Event, recipientPrivateKey: Uint8Array) {
+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
+}

package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "nostr-tools",
-  "version": "2.9.0",
+  "version": "2.10.0",
   "description": "Tools for making a Nostr client.",
   "repository": {
     "type": "git",
@@ -103,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",

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')
+})