nip10: fix.

- 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
   }
 
@@ -261,7 +271,7 @@ export class AbstractRelay {
     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

index.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,6 +1,6 @@
 {
   "name": "@nostr/tools",
-  "version": "2.3.2",
+  "version": "2.10.3",
   "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"
   }
-}
+}

justfile

@@ -13,6 +13,9 @@ test-only file:
 
 publish: build
   npm publish
+  perl -i -0pe "s/},\n  \"optionalDependencies\": {\n/,/" package.json
+  jsr publish --allow-dirty
+  git checkout -- package.json
 
 format:
   eslint --ext .ts --fix *.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,80 +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 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 const GiftWrap = 10059
+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,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
 }

nip06.test.ts

@@ -5,38 +5,39 @@ import {
   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('2e0f7bd9e3c3ebcdff1a90fb49c913477e7c055eba1a415d571b6a8c714c7135')
+  expect(privateKey).toEqual(hexToBytes('2e0f7bd9e3c3ebcdff1a90fb49c913477e7c055eba1a415d571b6a8c714c7135'))
   expect(publicKey).toEqual('13f55f4f01576570ea342eb7d2b611f9dc78f8dc601aeb512011e4e73b90cf0a')
 })
 
@@ -63,7 +64,7 @@ test('generate account from extended private key', () => {
     'xprv9z78fizET65qsCaRr1MSutTSGk1fcKfSt1sBqmuWShtkjRJJ4WCKcSnha6EmgNzFSsyom3MWtydHyPtJtSLZQUtictVQtM2vkPcguh6TQCH'
   const { privateKey, publicKey } = accountFromExtendedKey(xprv)
 
-  expect(privateKey).toBe('5f29af3b9676180290e77a4efad265c4c2ff28a5302461f73597fda26bb25731')
+  expect(privateKey).toEqual(hexToBytes('5f29af3b9676180290e77a4efad265c4c2ff28a5302461f73597fda26bb25731'))
   expect(publicKey).toBe('e8bcf3823669444d0b49ad45d65088635d9fd8500a75b5f20b59abefa56a144f')
 })
 

nip06.ts

@@ -5,11 +5,11 @@ import { HDKey } from '@scure/bip32'
 
 const DERIVATION_PATH = `m/44'/1237'`
 
-export function privateKeyFromSeedWords(mnemonic: string, passphrase?: string, accountIndex = 0): string {
+export function privateKeyFromSeedWords(mnemonic: string, passphrase?: string, accountIndex = 0): Uint8Array {
   let root = HDKey.fromMasterSeed(mnemonicToSeedSync(mnemonic, passphrase))
   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(
@@ -17,14 +17,14 @@ export function accountFromSeedWords(
   passphrase?: string,
   accountIndex = 0,
 ): {
-  privateKey: string
+  privateKey: Uint8Array
   publicKey: string
 } {
   const root = HDKey.fromMasterSeed(mnemonicToSeedSync(mnemonic, passphrase))
   const seed = root.derive(`${DERIVATION_PATH}/${accountIndex}'/0/0`)
-  const privateKey = bytesToHex(seed.privateKey!)
   const publicKey = bytesToHex(seed.publicKey!.slice(1))
-  if (!privateKey && !publicKey) {
+  const privateKey = seed.privateKey
+  if (!privateKey || !publicKey) {
     throw new Error('could not derive key pair')
   }
   return { privateKey, publicKey }
@@ -50,7 +50,7 @@ export function accountFromExtendedKey(
   base58key: string,
   accountIndex = 0,
 ): {
-  privateKey?: string
+  privateKey?: Uint8Array
   publicKey: string
 } {
   let extendedKey = HDKey.fromExtendedKey(base58key)
@@ -59,7 +59,7 @@ export function accountFromExtendedKey(
   let publicKey = bytesToHex(child.publicKey!.slice(1))
   if (!publicKey) throw new Error('could not derive public key')
   if (version === 'xprv') {
-    let privateKey = bytesToHex(child.privateKey!)
+    let privateKey = child.privateKey!
     if (!privateKey) throw new Error('could not derive private key')
     return { privateKey, publicKey }
   }

nip10.test.ts

@@ -5,20 +5,21 @@ describe('parse NIP10-referenced events', () => {
   test('legacy + a lot of events', () => {
     let event = {
       tags: [
-        ['e', 'b857504288c18a15950dd05b9e8772c62ca6289d5aac373c0a8ee5b132e94e7c'],
-        ['e', 'bbd72f0ae14374aa8fb166b483cfcf99b57d7f4cf1600ccbf17c350040834631'],
-        ['e', '5e081ebb19153357d7c31e8a10b9ceeef29313f58dc8d701f66727fab02aef64'],
-        ['e', '49aff7ae6daeaaa2777931b90f9bb29f6cb01c5a3d7d88c8ba82d890f264afb4'],
-        ['e', '567b7c11f0fe582361e3cea6fcc7609a8942dfe196ee1b98d5604c93fbeea976'],
-        ['e', '090c037b2e399ee74d9f134758928948dd9154413ca1a1acb37155046e03a051'],
-        ['e', '89f220b63465c93542b1a78caa3a952cf4f196e91a50596493c8093c533ebc4d'],
-        ['p', '77ce56f89d1228f7ff3743ce1ad1b254857b9008564727ebd5a1f317362f6ca7'],
-        ['p', '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec'],
         ['p', '4ca4f5533e40da5e0508796d409e6bb35a50b26fc304345617ab017183d83ac0'],
+        ['p', '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec'],
+        ['p', '77ce56f89d1228f7ff3743ce1ad1b254857b9008564727ebd5a1f317362f6ca7'],
+        ['e', '89f220b63465c93542b1a78caa3a952cf4f196e91a50596493c8093c533ebc4d'],
+        ['e', '090c037b2e399ee74d9f134758928948dd9154413ca1a1acb37155046e03a051'],
+        ['e', '567b7c11f0fe582361e3cea6fcc7609a8942dfe196ee1b98d5604c93fbeea976'],
+        ['e', '49aff7ae6daeaaa2777931b90f9bb29f6cb01c5a3d7d88c8ba82d890f264afb4'],
+        ['e', '5e081ebb19153357d7c31e8a10b9ceeef29313f58dc8d701f66727fab02aef64'],
+        ['e', 'bbd72f0ae14374aa8fb166b483cfcf99b57d7f4cf1600ccbf17c350040834631'],
+        ['e', 'b857504288c18a15950dd05b9e8772c62ca6289d5aac373c0a8ee5b132e94e7c'],
       ],
     }
 
     expect(parse(event)).toEqual({
+      quotes: [],
       mentions: [
         {
           id: 'bbd72f0ae14374aa8fb166b483cfcf99b57d7f4cf1600ccbf17c350040834631',
@@ -55,33 +56,80 @@ describe('parse NIP10-referenced events', () => {
           relays: [],
         },
       ],
-      reply: {
+      root: {
         id: '89f220b63465c93542b1a78caa3a952cf4f196e91a50596493c8093c533ebc4d',
         relays: [],
       },
-      root: {
+      reply: {
         id: 'b857504288c18a15950dd05b9e8772c62ca6289d5aac373c0a8ee5b132e94e7c',
         relays: [],
       },
     })
   })
 
-  test('legacy + 3 events', () => {
+  test('modern', () => {
     let event = {
       tags: [
-        ['e', 'b857504288c18a15950dd05b9e8772c62ca6289d5aac373c0a8ee5b132e94e7c'],
-        ['e', 'bbd72f0ae14374aa8fb166b483cfcf99b57d7f4cf1600ccbf17c350040834631'],
-        ['e', '5e081ebb19153357d7c31e8a10b9ceeef29313f58dc8d701f66727fab02aef64'],
-        ['p', '77ce56f89d1228f7ff3743ce1ad1b254857b9008564727ebd5a1f317362f6ca7'],
-        ['p', '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec'],
         ['p', '4ca4f5533e40da5e0508796d409e6bb35a50b26fc304345617ab017183d83ac0'],
+        ['p', '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec'],
+        ['e', '77ce56f89d1228f7ff3743ce1ad1b254857b9008564727ebd5a1f317362f6ca7'],
+        ['e', 'bbd72f0ae14374aa8fb166b483cfcf99b57d7f4cf1600ccbf17c350040834631', '', 'root'],
+        ['e', 'b857504288c18a15950dd05b9e8772c62ca6289d5aac373c0a8ee5b132e94e7c', '', 'reply'],
       ],
     }
 
     expect(parse(event)).toEqual({
+      quotes: [],
       mentions: [
         {
-          id: 'bbd72f0ae14374aa8fb166b483cfcf99b57d7f4cf1600ccbf17c350040834631',
+          id: '77ce56f89d1228f7ff3743ce1ad1b254857b9008564727ebd5a1f317362f6ca7',
+          relays: [],
+        },
+      ],
+      profiles: [
+        {
+          pubkey: '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec',
+          relays: [],
+        },
+        {
+          pubkey: '4ca4f5533e40da5e0508796d409e6bb35a50b26fc304345617ab017183d83ac0',
+          relays: [],
+        },
+      ],
+      root: {
+        id: 'bbd72f0ae14374aa8fb166b483cfcf99b57d7f4cf1600ccbf17c350040834631',
+        relays: [],
+      },
+      reply: {
+        id: 'b857504288c18a15950dd05b9e8772c62ca6289d5aac373c0a8ee5b132e94e7c',
+        relays: [],
+      },
+    })
+  })
+
+  test('modern, inverted, author hint', () => {
+    let event = {
+      tags: [
+        ['p', '4ca4f5533e40da5e0508796d409e6bb35a50b26fc304345617ab017183d83ac0', 'wss://goiaba.com'],
+        ['p', '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec'],
+        ['p', '77ce56f89d1228f7ff3743ce1ad1b254857b9008564727ebd5a1f317362f6ca7'],
+        ['e', '5e081ebb19153357d7c31e8a10b9ceeef29313f58dc8d701f66727fab02aef64', '', 'reply'],
+        [
+          'e',
+          'bbd72f0ae14374aa8fb166b483cfcf99b57d7f4cf1600ccbf17c350040834631',
+          'wss://banana.com',
+          'root',
+          '4ca4f5533e40da5e0508796d409e6bb35a50b26fc304345617ab017183d83ac0',
+        ],
+        ['e', 'b857504288c18a15950dd05b9e8772c62ca6289d5aac373c0a8ee5b132e94e7c'],
+      ],
+    }
+
+    expect(parse(event)).toEqual({
+      quotes: [],
+      mentions: [
+        {
+          id: 'b857504288c18a15950dd05b9e8772c62ca6289d5aac373c0a8ee5b132e94e7c',
           relays: [],
         },
       ],
@@ -96,98 +144,80 @@ describe('parse NIP10-referenced events', () => {
         },
         {
           pubkey: '4ca4f5533e40da5e0508796d409e6bb35a50b26fc304345617ab017183d83ac0',
-          relays: [],
+          relays: ['wss://banana.com', 'wss://goiaba.com'],
         },
       ],
+      root: {
+        id: 'bbd72f0ae14374aa8fb166b483cfcf99b57d7f4cf1600ccbf17c350040834631',
+        relays: ['wss://banana.com', 'wss://goiaba.com'],
+        author: '4ca4f5533e40da5e0508796d409e6bb35a50b26fc304345617ab017183d83ac0',
+      },
       reply: {
         id: '5e081ebb19153357d7c31e8a10b9ceeef29313f58dc8d701f66727fab02aef64',
         relays: [],
       },
-      root: {
-        id: 'b857504288c18a15950dd05b9e8772c62ca6289d5aac373c0a8ee5b132e94e7c',
-        relays: [],
-      },
     })
   })
 
-  test('legacy + 2 events', () => {
+  test('1 event, relay hint from author', () => {
     let event = {
       tags: [
-        ['e', 'b857504288c18a15950dd05b9e8772c62ca6289d5aac373c0a8ee5b132e94e7c'],
-        ['e', 'bbd72f0ae14374aa8fb166b483cfcf99b57d7f4cf1600ccbf17c350040834631'],
-        ['p', '77ce56f89d1228f7ff3743ce1ad1b254857b9008564727ebd5a1f317362f6ca7'],
-        ['p', '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec'],
-        ['p', '4ca4f5533e40da5e0508796d409e6bb35a50b26fc304345617ab017183d83ac0'],
+        ['p', '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec', 'wss://banana.com'],
+        [
+          'e',
+          '9abbfd9b9ac5ecdab45d14b8bf8d746139ea039e931a1b376d19a239f1946590',
+          '',
+          'root',
+          '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec',
+        ],
       ],
     }
 
     expect(parse(event)).toEqual({
+      quotes: [],
       mentions: [],
       profiles: [
-        {
-          pubkey: '77ce56f89d1228f7ff3743ce1ad1b254857b9008564727ebd5a1f317362f6ca7',
-          relays: [],
-        },
         {
           pubkey: '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec',
-          relays: [],
-        },
-        {
-          pubkey: '4ca4f5533e40da5e0508796d409e6bb35a50b26fc304345617ab017183d83ac0',
-          relays: [],
+          relays: ['wss://banana.com'],
         },
       ],
       reply: {
-        id: 'bbd72f0ae14374aa8fb166b483cfcf99b57d7f4cf1600ccbf17c350040834631',
-        relays: [],
-      },
-      root: {
-        id: 'b857504288c18a15950dd05b9e8772c62ca6289d5aac373c0a8ee5b132e94e7c',
-        relays: [],
-      },
-    })
-  })
-
-  test('legacy + 1 event', () => {
-    let event = {
-      tags: [
-        ['e', '9abbfd9b9ac5ecdab45d14b8bf8d746139ea039e931a1b376d19a239f1946590'],
-        ['p', '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec'],
-      ],
-    }
-
-    expect(parse(event)).toEqual({
-      mentions: [],
-      profiles: [
-        {
-          pubkey: '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec',
-          relays: [],
-        },
-      ],
-      reply: undefined,
-      root: {
+        author: '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec',
         id: '9abbfd9b9ac5ecdab45d14b8bf8d746139ea039e931a1b376d19a239f1946590',
-        relays: [],
+        relays: ['wss://banana.com'],
+      },
+      root: {
+        author: '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec',
+        id: '9abbfd9b9ac5ecdab45d14b8bf8d746139ea039e931a1b376d19a239f1946590',
+        relays: ['wss://banana.com'],
       },
     })
   })
 
-  test('recommended + 1 event', () => {
+  test('many p 1 reply', () => {
     let event = {
       tags: [
-        ['p', 'a8c21fcd8aa1f4befba14d72fc7a012397732d30d8b3131af912642f3c726f52', 'wss://relay.mostr.pub'],
-        ['p', '003d7fd21fd09ff7f6f63a75daf194dd99feefbe6919cc376b7359d5090aa9a6', 'wss://relay.mostr.pub'],
-        ['p', '2f6fbe452edd3987d3c67f3b034c03ec5bcf4d054c521c3a954686f89f03212e', 'wss://relay.mostr.pub'],
-        ['p', '44c7c74668ff222b0e0b30579c49fc6e22dafcdeaad091036c947f9856590f1e', 'wss://relay.mostr.pub'],
-        ['p', 'c5cf39149caebda4cdd61771c51f6ba91ef5645919004e5c4998a4ea69f00512', 'wss://relay.mostr.pub'],
-        ['p', '094d44bb1e812696c57f57ad1c0c707812dedbe72c07e538b80639032c236a9e', 'wss://relay.mostr.pub'],
         ['p', 'a1ba0ac9b6ec098f726a3c11ec654df4a32cbb84b5377e8788395e9c27d9ecda', 'wss://relay.mostr.pub'],
-        ['e', 'f9472913904ab7e9da008dcb2d85fd4af2d2993ada483d00c646d0c4481d031d', 'wss://relay.mostr.pub', 'reply'],
+        ['p', '094d44bb1e812696c57f57ad1c0c707812dedbe72c07e538b80639032c236a9e', 'wss://relay.mostr.pub'],
+        ['p', 'c5cf39149caebda4cdd61771c51f6ba91ef5645919004e5c4998a4ea69f00512', 'wss://relay.mostr.pub'],
+        ['p', '44c7c74668ff222b0e0b30579c49fc6e22dafcdeaad091036c947f9856590f1e', 'wss://relay.mostr.pub'],
+        ['p', '2f6fbe452edd3987d3c67f3b034c03ec5bcf4d054c521c3a954686f89f03212e', 'wss://relay.mostr.pub'],
+        ['p', '003d7fd21fd09ff7f6f63a75daf194dd99feefbe6919cc376b7359d5090aa9a6', 'wss://relay.mostr.pub'],
+        ['p', 'a8c21fcd8aa1f4befba14d72fc7a012397732d30d8b3131af912642f3c726f52', 'wss://relay.mostr.pub'],
+        [
+          'e',
+          'f9472913904ab7e9da008dcb2d85fd4af2d2993ada483d00c646d0c4481d031d',
+          'wss://relay.mostr.pub',
+          'reply',
+          'c5cf39149caebda4cdd61771c51f6ba91ef5645919004e5c4998a4ea69f00512',
+        ],
         ['mostr', 'https://poa.st/objects/dc50684b-6364-4264-ab16-49f4622f05ea'],
       ],
     }
 
     expect(parse(event)).toEqual({
+      quotes: [],
       mentions: [],
       profiles: [
         {
@@ -222,8 +252,13 @@ describe('parse NIP10-referenced events', () => {
       reply: {
         id: 'f9472913904ab7e9da008dcb2d85fd4af2d2993ada483d00c646d0c4481d031d',
         relays: ['wss://relay.mostr.pub'],
+        author: 'c5cf39149caebda4cdd61771c51f6ba91ef5645919004e5c4998a4ea69f00512',
+      },
+      root: {
+        id: 'f9472913904ab7e9da008dcb2d85fd4af2d2993ada483d00c646d0c4481d031d',
+        relays: ['wss://relay.mostr.pub'],
+        author: 'c5cf39149caebda4cdd61771c51f6ba91ef5645919004e5c4998a4ea69f00512',
       },
-      root: undefined,
     })
   })
 })

nip10.ts

@@ -1,7 +1,7 @@
 import type { Event } from './core.ts'
 import type { EventPointer, ProfilePointer } from './nip19.ts'
 
-export type NIP10Result = {
+export function parse(event: Pick<Event, 'tags'>): {
   /**
    * Pointer to the root of the thread.
    */
@@ -13,29 +13,80 @@ export type NIP10Result = {
   reply: EventPointer | undefined
 
   /**
-   * Pointers to events which may or may not be in the reply chain.
+   * Pointers to events that may or may not be in the reply chain.
    */
   mentions: EventPointer[]
 
+  /**
+   * Pointers to events that were directly quoted.
+   */
+  quotes: EventPointer[]
+
   /**
    * List of pubkeys that are involved in the thread in no particular order.
    */
   profiles: ProfilePointer[]
-}
-
-export function parse(event: Pick<Event, 'tags'>): NIP10Result {
-  const result: NIP10Result = {
+} {
+  const result: ReturnType<typeof parse> = {
     reply: undefined,
     root: undefined,
     mentions: [],
     profiles: [],
+    quotes: [],
   }
 
-  const eTags: string[][] = []
+  let maybeParent: EventPointer | undefined
+  let maybeRoot: EventPointer | undefined
+
+  for (let i = event.tags.length - 1; i >= 0; i--) {
+    const tag = event.tags[i]
 
-  for (const tag of event.tags) {
     if (tag[0] === 'e' && tag[1]) {
-      eTags.push(tag)
+      const [_, eTagEventId, eTagRelayUrl, eTagMarker, eTagAuthor] = tag as [
+        string,
+        string,
+        undefined | string,
+        undefined | string,
+        undefined | string,
+      ]
+
+      const eventPointer: EventPointer = {
+        id: eTagEventId,
+        relays: eTagRelayUrl ? [eTagRelayUrl] : [],
+        author: eTagAuthor,
+      }
+
+      if (eTagMarker === 'root') {
+        result.root = eventPointer
+        continue
+      }
+
+      if (eTagMarker === 'reply') {
+        result.reply = eventPointer
+        continue
+      }
+
+      if (eTagMarker === 'mention') {
+        result.mentions.push(eventPointer)
+        continue
+      }
+
+      if (!maybeParent) {
+        maybeParent = eventPointer
+      } else {
+        maybeRoot = eventPointer
+      }
+
+      result.mentions.push(eventPointer)
+      continue
+    }
+
+    if (tag[0] === 'q' && tag[1]) {
+      const [_, eTagEventId, eTagRelayUrl] = tag as [string, string, undefined | string]
+      result.quotes.push({
+        id: eTagEventId,
+        relays: eTagRelayUrl ? [eTagRelayUrl] : [],
+      })
     }
 
     if (tag[0] === 'p' && tag[1]) {
@@ -43,49 +94,54 @@ export function parse(event: Pick<Event, 'tags'>): NIP10Result {
         pubkey: tag[1],
         relays: tag[2] ? [tag[2]] : [],
       })
+      continue
     }
   }
 
-  for (let eTagIndex = 0; eTagIndex < eTags.length; eTagIndex++) {
-    const eTag = eTags[eTagIndex]
-
-    const [_, eTagEventId, eTagRelayUrl, eTagMarker] = eTag as [string, string, undefined | string, undefined | string]
-
-    const eventPointer: EventPointer = {
-      id: eTagEventId,
-      relays: eTagRelayUrl ? [eTagRelayUrl] : [],
-    }
-
-    const isFirstETag = eTagIndex === 0
-    const isLastETag = eTagIndex === eTags.length - 1
-
-    if (eTagMarker === 'root') {
-      result.root = eventPointer
-      continue
-    }
-
-    if (eTagMarker === 'reply') {
-      result.reply = eventPointer
-      continue
-    }
-
-    if (eTagMarker === 'mention') {
-      result.mentions.push(eventPointer)
-      continue
-    }
-
-    if (isFirstETag) {
-      result.root = eventPointer
-      continue
-    }
-
-    if (isLastETag) {
-      result.reply = eventPointer
-      continue
-    }
-
-    result.mentions.push(eventPointer)
+  // get legacy (positional) markers, set reply to root and vice-versa if one of them is missing
+  if (!result.root) {
+    result.root = maybeRoot || maybeParent || result.reply
   }
+  if (!result.reply) {
+    result.reply = maybeParent || result.root
+  }
+
+  // remove root and reply from mentions, inherit relay hints from authors if any
+  ;[result.reply, result.root].forEach(ref => {
+    if (!ref) return
+
+    let idx = result.mentions.indexOf(ref)
+    if (idx !== -1) {
+      result.mentions.splice(idx, 1)
+    }
+    if (ref.author) {
+      let author = result.profiles.find(p => p.pubkey === ref.author)
+      if (author && author.relays) {
+        if (!ref.relays) {
+          ref.relays = []
+        }
+        author.relays.forEach(url => {
+          if (ref.relays!?.indexOf(url) === -1) ref.relays!.push(url)
+        })
+        author.relays = ref.relays
+      }
+    }
+  })
+
+  result.mentions.forEach(ref => {
+    if (ref!.author) {
+      let author = result.profiles.find(p => p.pubkey === ref.author)
+      if (author && author.relays) {
+        if (!ref.relays) {
+          ref.relays = []
+        }
+        author.relays.forEach(url => {
+          if (ref.relays!.indexOf(url) === -1) ref.relays!.push(url)
+        })
+        author.relays = ref.relays
+      }
+    }
+  })
 
   return result
 }

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

@@ -172,26 +172,6 @@ describe('NostrTypeGuard', () => {
     expect(is).toBeFalse()
   })
 
-  test('isNRelay', () => {
-    const is = NostrTypeGuard.isNRelay('nrelay1qqt8wumn8ghj7un9d3shjtnwdaehgu3wvfskueq4r295t')
-
-    expect(is).toBeTrue()
-  })
-
-  test('isNRelay with invalid nrelay', () => {
-    const is = NostrTypeGuard.isNRelay('nrelay1qqt8wumn8ghj7un9d3shjtnwdaehgu3wvfskueã4r295t')
-
-    expect(is).toBeFalse()
-  })
-
-  test('isNRelay with invalid nrelay', () => {
-    const is = NostrTypeGuard.isNRelay(
-      'nevent1qqst8cujky046negxgwwm5ynqwn53t8aqjr6afd8g59nfqwxpdhylpcpzamhxue69uhhyetvv9ujuetcv9khqmr99e3k7mg8arnc9',
-    )
-
-    expect(is).toBeFalse()
-  })
-
   test('isNEvent', () => {
     const is = NostrTypeGuard.isNEvent(
       'nevent1qqst8cujky046negxgwwm5ynqwn53t8aqjr6afd8g59nfqwxpdhylpcpzamhxue69uhhyetvv9ujuetcv9khqmr99e3k7mg8arnc9',

nip19.ts

@@ -4,7 +4,6 @@ import { bech32 } from '@scure/base'
 import { utf8Decoder, utf8Encoder } from './utils.ts'
 
 export type NProfile = `nprofile1${string}`
-export type NRelay = `nrelay1${string}`
 export type NEvent = `nevent1${string}`
 export type NAddr = `naddr1${string}`
 export type NSec = `nsec1${string}`
@@ -14,7 +13,6 @@ export type Ncryptsec = `ncryptsec1${string}`
 
 export const NostrTypeGuard = {
   isNProfile: (value?: string | null): value is NProfile => /^nprofile1[a-z\d]+$/.test(value || ''),
-  isNRelay: (value?: string | null): value is NRelay => /^nrelay1[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 || ''),

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(clientSecretKey, 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(
@@ -207,11 +210,16 @@ export class BunkerSigner {
   }
 
   /**
-   * 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
   }
 
   /**
@@ -229,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)}`)
@@ -244,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])
   }
@@ -291,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

@@ -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
+}

package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "nostr-tools",
-  "version": "2.8.0",
+  "version": "2.10.3",
   "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",
@@ -173,6 +178,11 @@
       "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",

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