max keys 256.

fixes https://github.com/nbd-wtf/nostr-tools/issues/169

.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

.eslintrc.json

@@ -22,6 +22,7 @@
 
   "globals": {
     "document": false,
+    "BigInt": false,
     "navigator": false,
     "window": false,
     "crypto": false,

.github/workflows/npm-publish.yml

@@ -16,6 +16,7 @@ jobs:
       - run: just install-dependencies
       - run: just build
       - run: just test
+      - run: just emit-types
       - uses: JS-DevTools/npm-publish@v1
         with:
           token: ${{ secrets.NPM_TOKEN }}

.github/workflows/test.yml

@@ -9,7 +9,7 @@ jobs:
   test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: actions/setup-node@v3
         with:
           node-version: 18

README.md

@@ -10,7 +10,6 @@ Only depends on _@scure_ and _@noble_ packages.
  npm install nostr-tools # or yarn add nostr-tools
 ```
 
-
 ## Usage
 
 ### Generating a private key and a public key
@@ -138,11 +137,16 @@ const pool = new SimplePool()
 
 let relays = ['wss://relay.example.com', 'wss://relay.example2.com']
 
-let relay = await pool.ensureRelay('wss://relay.example3.com')
-
-let sub = pool.sub([...relays, relay], [{
-  authors: ['32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245']
-}])
+let sub = pool.sub(
+  [...relays, 'wss://relay.example3.com'],
+  [
+    {
+      authors: [
+        '32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245'
+      ]
+    }
+  ]
+)
 
 sub.on('event', event => {
   // this will only be called once the first time the event is received
@@ -150,11 +154,10 @@ sub.on('event', event => {
 })
 
 let pubs = pool.publish(relays, newEvent)
-pubs.forEach(pub =>
-  pub.on('ok', () => {
-    // ...
-  })
-)
+pubs.on('ok', () => {
+  // this may be called multiple times, once for every relay that accepts the event
+  // ...
+})
 
 let events = await pool.list(relays, [{kinds: [0, 1]}])
 let event = await pool.get(relays, {
@@ -167,6 +170,26 @@ let relaysForEvent = pool.seenOn(
 // relaysForEvent will be an array of URLs from relays a given event was seen on
 ```
 
+### Parsing references (mentions) from a content using NIP-10 and NIP-27
+
+```js
+import {parseReferences} from 'nostr-tools'
+
+let references = parseReferences(event)
+let simpleAugmentedContent = event.content
+for (let i = 0; i < references.length; i++) {
+  let {text, profile, event, address} = references[i]
+  let augmentedReference = profile
+    ? `<strong>@${profilesCache[profile.pubkey].name}</strong>`
+    : event
+    ? `<em>${eventsCache[event.id].content.slice(0, 5)}</em>`
+    : address
+    ? `<a href="${text}">[link]</a>`
+    : text
+  simpleAugmentedContent.replaceAll(text, augmentedReference)
+}
+```
+
 ### Querying profile data from a NIP-05 address
 
 ```js

build.js

@@ -17,7 +17,7 @@ esbuild
     packages: 'external'
   })
   .then(() => {
-    const packageJson = JSON.stringify({ type: 'module' })
+    const packageJson = JSON.stringify({type: 'module'})
     fs.writeFileSync(`${__dirname}/lib/esm/package.json`, packageJson, 'utf8')
 
     console.log('esm build success.')

event.test.js

@@ -1,48 +1,340 @@
-/* eslint-env jest */
-
 const {
+  getBlankEvent,
+  finishEvent,
+  serializeEvent,
+  getEventHash,
   validateEvent,
   verifySignature,
   signEvent,
-  getPublicKey
+  getPublicKey,
+  Kind
 } = require('./lib/nostr.cjs')
 
-const event = {
-  id: 'd7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027',
-  kind: 1,
-  pubkey: '22a12a128a3be27cd7fb250cbe796e692896398dc1440ae3fa567812c8107c1c',
-  created_at: 1670869179,
-  content:
-    'NOSTR "WINE-ACCOUNT" WITH HARVEST DATE STAMPED\n\n\n"The older the wine, the greater its reputation"\n\n\n22a12a128a3be27cd7fb250cbe796e692896398dc1440ae3fa567812c8107c1c\n\n\nNWA 2022-12-12\nAA',
-  tags: [['client', 'astral']],
-  sig: 'f110e4fdf67835fb07abc72469933c40bdc7334615610cade9554bf00945a1cebf84f8d079ec325d26fefd76fe51cb589bdbe208ac9cdbd63351ddad24a57559'
-}
+describe('Event', () => {
+  describe('getBlankEvent', () => {
+    it('should return a blank event object', () => {
+      expect(getBlankEvent()).toEqual({
+        kind: 255,
+        content: '',
+        tags: [],
+        created_at: 0
+      })
+    })
+  })
 
-const unsigned = {
-  created_at: 1671217411,
-  kind: 0,
-  tags: [],
-  content:
-    '{"name":"fiatjaf","about":"buy my merch at fiatjaf store","picture":"https://fiatjaf.com/static/favicon.jpg","nip05":"_@fiatjaf.com"}'
-}
+  describe('finishEvent', () => {
+    it('should create a signed event from a template', () => {
+      const privateKey =
+        'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
+      const publicKey = getPublicKey(privateKey)
 
-const privateKey =
-  '5c6c25b7ef18d8633e97512159954e1aa22809c6b763e94b9f91071836d00217'
+      const template = {
+        kind: Kind.Text,
+        tags: [],
+        content: 'Hello, world!',
+        created_at: 1617932115
+      }
 
-test('validate event', () => {
-  expect(validateEvent(event)).toBeTruthy()
-})
-
-test('check signature', async () => {
-  expect(verifySignature(event)).toBeTruthy()
-})
-
-test('sign event', async () => {
-  let pubkey = getPublicKey(privateKey)
-  let authored = {...unsigned, pubkey}
-
-  let sig = signEvent(authored, privateKey)
-  let signed = {...authored, sig}
-
-  expect(verifySignature(signed)).toBeTruthy()
+      const event = finishEvent(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', () => {
+    it('should serialize a valid event object', () => {
+      const privateKey =
+        'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
+      const publicKey = getPublicKey(privateKey)
+
+      const unsignedEvent = {
+        pubkey: publicKey,
+        created_at: 1617932115,
+        kind: Kind.Text,
+        tags: [],
+        content: 'Hello, world!'
+      }
+
+      const serializedEvent = serializeEvent(unsignedEvent)
+
+      expect(serializedEvent).toEqual(
+        JSON.stringify([
+          0,
+          publicKey,
+          unsignedEvent.created_at,
+          unsignedEvent.kind,
+          unsignedEvent.tags,
+          unsignedEvent.content
+        ])
+      )
+    })
+
+    it('should throw an error for an invalid event object', () => {
+      const privateKey =
+        'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
+      const publicKey = getPublicKey(privateKey)
+
+      const invalidEvent = {
+        kind: Kind.Text,
+        tags: [],
+        created_at: 1617932115,
+        pubkey: publicKey // missing content
+      }
+
+      expect(() => {
+        serializeEvent(invalidEvent)
+      }).toThrow("can't serialize event with wrong or missing properties")
+    })
+  })
+
+  describe('getEventHash', () => {
+    it('should return the correct event hash', () => {
+      const privateKey =
+        'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
+      const publicKey = getPublicKey(privateKey)
+
+      const unsignedEvent = {
+        kind: Kind.Text,
+        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', () => {
+    it('should return true for a valid event object', () => {
+      const privateKey =
+        'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
+      const publicKey = getPublicKey(privateKey)
+
+      const unsignedEvent = {
+        kind: Kind.Text,
+        tags: [],
+        content: 'Hello, world!',
+        created_at: 1617932115,
+        pubkey: publicKey
+      }
+
+      const isValid = validateEvent(unsignedEvent)
+
+      expect(isValid).toEqual(true)
+    })
+
+    it('should return false for a non object event', () => {
+      const nonObjectEvent = ''
+
+      const isValid = validateEvent(nonObjectEvent)
+
+      expect(isValid).toEqual(false)
+    })
+
+    it('should return false for an event object with missing properties', () => {
+      const invalidEvent = {
+        kind: Kind.Text,
+        tags: [],
+        created_at: 1617932115 // missing content and pubkey
+      }
+
+      const isValid = validateEvent(invalidEvent)
+
+      expect(isValid).toEqual(false)
+    })
+
+    it('should return false for an empty object', () => {
+      const emptyObj = {}
+
+      const isValid = validateEvent(emptyObj)
+
+      expect(isValid).toEqual(false)
+    })
+
+    it('should return false for an object with invalid properties', () => {
+      const privateKey =
+        '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)
+    })
+
+    it('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)
+    })
+
+    it('should return false for an object with invalid tags', () => {
+      const privateKey =
+        '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('verifySignature', () => {
+    it('should return true for a valid event signature', () => {
+      const privateKey =
+        'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
+
+      const event = finishEvent(
+        {
+          kind: Kind.Text,
+          tags: [],
+          content: 'Hello, world!',
+          created_at: 1617932115
+        },
+        privateKey
+      )
+
+      const isValid = verifySignature(event)
+
+      expect(isValid).toEqual(true)
+    })
+
+    it('should return false for an invalid event signature', () => {
+      const privateKey =
+        'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
+
+      const event = finishEvent(
+        {
+          kind: Kind.Text,
+          tags: [],
+          content: 'Hello, world!',
+          created_at: 1617932115
+        },
+        privateKey
+      )
+
+      // tamper with the signature
+      event.sig = event.sig.replace(/0/g, '1')
+
+      const isValid = verifySignature(event)
+
+      expect(isValid).toEqual(false)
+    })
+
+    it('should return false when verifying an event with a different private key', () => {
+      const privateKey1 =
+        'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
+
+      const privateKey2 =
+        '5b4a34f4e4b23c63ad55a35e3f84a3b53d96dbf266edf521a8358f71d19cbf67'
+      const publicKey2 = getPublicKey(privateKey2)
+
+      const event = finishEvent(
+        {
+          kind: Kind.Text,
+          tags: [],
+          content: 'Hello, world!',
+          created_at: 1617932115
+        },
+        privateKey1
+      )
+
+      // verify with different private key
+      const isValid = verifySignature({
+        ...event,
+        pubkey: publicKey2
+      })
+
+      expect(isValid).toEqual(false)
+    })
+  })
+
+  describe('signEvent', () => {
+    it('should sign an event object', () => {
+      const privateKey =
+        'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
+      const publicKey = getPublicKey(privateKey)
+
+      const unsignedEvent = {
+        kind: Kind.Text,
+        tags: [],
+        content: 'Hello, world!',
+        created_at: 1617932115,
+        pubkey: publicKey
+      }
+
+      const sig = signEvent(unsignedEvent, privateKey)
+
+      // verify the signature
+      const isValid = verifySignature({
+        ...unsignedEvent,
+        sig
+      })
+
+      expect(typeof sig).toEqual('string')
+      expect(sig.length).toEqual(128)
+      expect(isValid).toEqual(true)
+    })
+
+    it('should not sign an event with different private key', () => {
+      const privateKey =
+        'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
+      const publicKey = getPublicKey(privateKey)
+
+      const wrongPrivateKey =
+        'a91e2a9d9e0f70f0877bea0dbf034e8f95d7392a27a7f07da0d14b9e9d456be7'
+
+      const unsignedEvent = {
+        kind: Kind.Text,
+        tags: [],
+        content: 'Hello, world!',
+        created_at: 1617932115,
+        pubkey: publicKey
+      }
+
+      const sig = signEvent(unsignedEvent, wrongPrivateKey)
+
+      // verify the signature
+      const isValid = verifySignature({
+        ...unsignedEvent,
+        sig
+      })
+
+      expect(typeof sig).toEqual('string')
+      expect(sig.length).toEqual(128)
+      expect(isValid).toEqual(false)
+    })
+  })
 })

event.ts

@@ -13,6 +13,7 @@ export enum Kind {
   EncryptedDirectMessage = 4,
   EventDeletion = 5,
   Reaction = 7,
+  StatelessRevocation = 13,
   ChannelCreation = 40,
   ChannelMetadata = 41,
   ChannelMessage = 42,
@@ -80,6 +81,7 @@ export function getEventHash(event: UnsignedEvent): string {
 
 export function validateEvent(event: UnsignedEvent): boolean {
   if (typeof event !== 'object') return false
+  if (typeof event.kind !== 'number') return false
   if (typeof event.content !== 'string') return false
   if (typeof event.created_at !== 'number') return false
   if (typeof event.pubkey !== 'string') return false

filter.test.js

@@ -1,42 +1,176 @@
 /* eslint-env jest */
 
-const {matchFilters} = require('./lib/nostr.cjs')
+const {matchFilter, matchFilters} = require('./lib/nostr.cjs.js')
 
-test('test if filters match', () => {
-  ;[
-    {
-      filters: [{ids: ['i']}],
-      good: [{id: 'i'}],
-      bad: [{id: 'j'}]
-    },
-    {
-      filters: [{authors: ['abc']}, {kinds: [1, 3]}],
-      good: [
-        {pubkey: 'xyz', kind: 3},
-        {pubkey: 'abc', kind: 12},
-        {pubkey: 'abc', kind: 1}
-      ],
-      bad: [{pubkey: 'hhh', kind: 12}]
-    },
-    {
-      filters: [{'#e': ['yyy'], since: 444}],
-      good: [
-        {
-          tags: [
-            ['e', 'uuu'],
-            ['e', 'yyy']
-          ],
-          created_at: 555
-        }
-      ],
-      bad: [{tags: [['e', 'uuu']], created_at: 111}]
-    }
-  ].forEach(({filters, good, bad}) => {
-    good.forEach(ev => {
-      expect(matchFilters(filters, ev)).toBeTruthy()
+describe('Filter', () => {
+  describe('matchFilter', () => {
+    it('should return true when all filter conditions are met', () => {
+      const filter = {
+        ids: ['123', '456'],
+        kinds: [1, 2, 3],
+        authors: ['abc'],
+        since: 100,
+        until: 200,
+        '#tag': ['value']
+      }
+
+      const event = {
+        id: '123',
+        kind: 1,
+        pubkey: 'abc',
+        created_at: 150,
+        tags: [['tag', 'value']]
+      }
+
+      const result = matchFilter(filter, event)
+
+      expect(result).toEqual(true)
     })
-    bad.forEach(ev => {
-      expect(matchFilters(filters, ev)).toBeFalsy()
+
+    it('should return false when the event id is not in the filter', () => {
+      const filter = {ids: ['123', '456']}
+
+      const event = {id: '789'}
+
+      const result = matchFilter(filter, event)
+
+      expect(result).toEqual(false)
+    })
+
+    it('should return false when the event kind is not in the filter', () => {
+      const filter = {kinds: [1, 2, 3]}
+
+      const event = {kind: 4}
+
+      const result = matchFilter(filter, event)
+
+      expect(result).toEqual(false)
+    })
+
+    it('should return false when the event author is not in the filter', () => {
+      const filter = {authors: ['abc', 'def']}
+
+      const event = {pubkey: 'ghi'}
+
+      const result = matchFilter(filter, event)
+
+      expect(result).toEqual(false)
+    })
+
+    it('should return false when a tag is not present in the event', () => {
+      const filter = {'#tag': ['value1', 'value2']}
+
+      const event = {tags: [['not_tag', 'value1']]}
+
+      const result = matchFilter(filter, event)
+
+      expect(result).toEqual(false)
+    })
+
+    it('should return false when a tag value is not present in the event', () => {
+      const filter = {'#tag': ['value1', 'value2']}
+
+      const event = {tags: [['tag', 'value3']]}
+
+      const result = matchFilter(filter, event)
+
+      expect(result).toEqual(false)
+    })
+
+    it('should return true when filter has tags that is present in the event', () => {
+      const filter = {'#tag1': ['foo']}
+
+      const event = {
+        id: '123',
+        kind: 1,
+        pubkey: 'abc',
+        created_at: 150,
+        tags: [
+          ['tag1', 'foo'],
+          ['tag2', 'bar']
+        ]
+      }
+
+      const result = matchFilter(filter, event)
+
+      expect(result).toEqual(true)
+    })
+
+    it('should return false when the event is before the filter since value', () => {
+      const filter = {since: 100}
+
+      const event = {created_at: 50}
+
+      const result = matchFilter(filter, event)
+
+      expect(result).toEqual(false)
+    })
+
+    it('should return false when the event is after the filter until value', () => {
+      const filter = {until: 100}
+
+      const event = {created_at: 150}
+
+      const result = matchFilter(filter, event)
+
+      expect(result).toEqual(false)
+    })
+  })
+
+  describe('matchFilters', () => {
+    it('should return true when at least one filter matches the event', () => {
+      const filters = [
+        {ids: ['123'], kinds: [1], authors: ['abc']},
+        {ids: ['456'], kinds: [2], authors: ['def']},
+        {ids: ['789'], kinds: [3], authors: ['ghi']}
+      ]
+
+      const event = {id: '789', kind: 3, pubkey: 'ghi'}
+
+      const result = matchFilters(filters, event)
+
+      expect(result).toEqual(true)
+    })
+
+    it('should return true when event matches one or more filters and some have limit set', () => {
+      const filters = [
+        {ids: ['123'], limit: 1},
+        {kinds: [1], limit: 2},
+        {authors: ['abc'], limit: 3}
+      ]
+
+      const event = {id: '123', kind: 1, pubkey: 'abc', created_at: 150}
+
+      const result = matchFilters(filters, event)
+
+      expect(result).toEqual(true)
+    })
+
+    it('should return false when no filters match the event', () => {
+      const filters = [
+        {ids: ['123'], kinds: [1], authors: ['abc']},
+        {ids: ['456'], kinds: [2], authors: ['def']},
+        {ids: ['789'], kinds: [3], authors: ['ghi']}
+      ]
+
+      const event = {id: '100', kind: 4, pubkey: 'jkl'}
+
+      const result = matchFilters(filters, event)
+
+      expect(result).toEqual(false)
+    })
+
+    it('should return false when event matches none of the filters and some have limit set', () => {
+      const filters = [
+        {ids: ['123'], limit: 1},
+        {kinds: [1], limit: 2},
+        {authors: ['abc'], limit: 3}
+      ]
+      const event = {id: '456', kind: 2, pubkey: 'def', created_at: 200}
+
+      const result = matchFilters(filters, event)
+
+      expect(result).toEqual(false)
     })
   })
 })

filter.ts

@@ -7,6 +7,7 @@ export type Filter = {
   since?: number
   until?: number
   limit?: number
+  search?: string
   [key: `#${string}`]: string[]
 }
 

index.ts

@@ -3,12 +3,16 @@ export * from './relay'
 export * from './event'
 export * from './filter'
 export * from './pool'
+export * from './references'
 
 export * as nip04 from './nip04'
 export * as nip05 from './nip05'
 export * as nip06 from './nip06'
+export * as nip10 from './nip10'
 export * as nip19 from './nip19'
 export * as nip26 from './nip26'
+export * as nip39 from './nip39'
+export * as nip41 from './nip41'
 export * as nip57 from './nip57'
 
 export * as fj from './fakejson'

justfile

@@ -4,13 +4,20 @@ install-dependencies:
     yarn --ignore-engines
 
 build:
+    rm -rf lib
     node build.js
 
 test: build
     jest
 
-testOnly file: build
+test-only file: build
     jest {{file}}
 
-publish: build
+emit-types:
+    tsc # see tsconfig.json
+
+publish: build emit-types
     npm publish
+
+format:
+    prettier --plugin-search-dir . --write .

nip05.ts

@@ -37,10 +37,16 @@ export async function queryProfile(
   }
 
   if (!name.match(/^[A-Za-z0-9-_]+$/)) return null
+  if (!domain.includes('.')) return null
 
-  let res = await (
-    await _fetch(`https://${domain}/.well-known/nostr.json?name=${name}`)
-  ).json()
+  let res
+  try {
+    res = await (
+      await _fetch(`https://${domain}/.well-known/nostr.json?name=${name}`)
+    ).json()
+  } catch (err) {
+    return null
+  }
 
   if (!res?.names?.[name]) return null
 

nip06.test.js

@@ -4,12 +4,16 @@ const {nip06} = require('./lib/nostr.cjs')
 test('generate private key from a mnemonic', async () => {
   const mnemonic = 'zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong'
   const privateKey = nip06.privateKeyFromSeedWords(mnemonic)
-  expect(privateKey).toEqual('c26cf31d8ba425b555ca27d00ca71b5008004f2f662470f8c8131822ec129fe2')
+  expect(privateKey).toEqual(
+    'c26cf31d8ba425b555ca27d00ca71b5008004f2f662470f8c8131822ec129fe2'
+  )
 })
 
 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 = nip06.privateKeyFromSeedWords(mnemonic, passphrase)
-  expect(privateKey).toEqual('55a22b8203273d0aaf24c22c8fbe99608e70c524b17265641074281c8b978ae4')
+  expect(privateKey).toEqual(
+    '55a22b8203273d0aaf24c22c8fbe99608e70c524b17265641074281c8b978ae4'
+  )
 })

nip06.ts

@@ -7,7 +7,10 @@ import {
 } from '@scure/bip39'
 import {HDKey} from '@scure/bip32'
 
-export function privateKeyFromSeedWords(mnemonic: string, passphrase?: string): string {
+export function privateKeyFromSeedWords(
+  mnemonic: string,
+  passphrase?: string
+): string {
   let root = HDKey.fromMasterSeed(mnemonicToSeedSync(mnemonic, passphrase))
   let privateKey = root.derive(`m/44'/1237'/0'/0/0`).privateKey
   if (!privateKey) throw new Error('could not derive private key')

nip10.test.js

@@ -0,0 +1,353 @@
+/* eslint-env jest */
+
+const {nip10} = require('./lib/nostr.cjs')
+
+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'
+        ]
+      ]
+    }
+
+    expect(nip10.parse(event)).toEqual({
+      mentions: [
+        {
+          id: 'bbd72f0ae14374aa8fb166b483cfcf99b57d7f4cf1600ccbf17c350040834631',
+          relays: []
+        },
+        {
+          id: '5e081ebb19153357d7c31e8a10b9ceeef29313f58dc8d701f66727fab02aef64',
+          relays: []
+        },
+        {
+          id: '49aff7ae6daeaaa2777931b90f9bb29f6cb01c5a3d7d88c8ba82d890f264afb4',
+          relays: []
+        },
+        {
+          id: '567b7c11f0fe582361e3cea6fcc7609a8942dfe196ee1b98d5604c93fbeea976',
+          relays: []
+        },
+        {
+          id: '090c037b2e399ee74d9f134758928948dd9154413ca1a1acb37155046e03a051',
+          relays: []
+        }
+      ],
+      profiles: [
+        {
+          pubkey:
+            '77ce56f89d1228f7ff3743ce1ad1b254857b9008564727ebd5a1f317362f6ca7',
+          relays: []
+        },
+        {
+          pubkey:
+            '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec',
+          relays: []
+        },
+        {
+          pubkey:
+            '4ca4f5533e40da5e0508796d409e6bb35a50b26fc304345617ab017183d83ac0',
+          relays: []
+        }
+      ],
+      reply: {
+        id: '89f220b63465c93542b1a78caa3a952cf4f196e91a50596493c8093c533ebc4d',
+        relays: []
+      },
+      root: {
+        id: 'b857504288c18a15950dd05b9e8772c62ca6289d5aac373c0a8ee5b132e94e7c',
+        relays: []
+      }
+    })
+  })
+
+  test('legacy + 3 events', () => {
+    let event = {
+      tags: [
+        [
+          'e',
+          'b857504288c18a15950dd05b9e8772c62ca6289d5aac373c0a8ee5b132e94e7c'
+        ],
+        [
+          'e',
+          'bbd72f0ae14374aa8fb166b483cfcf99b57d7f4cf1600ccbf17c350040834631'
+        ],
+        [
+          'e',
+          '5e081ebb19153357d7c31e8a10b9ceeef29313f58dc8d701f66727fab02aef64'
+        ],
+        [
+          'p',
+          '77ce56f89d1228f7ff3743ce1ad1b254857b9008564727ebd5a1f317362f6ca7'
+        ],
+        [
+          'p',
+          '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec'
+        ],
+        [
+          'p',
+          '4ca4f5533e40da5e0508796d409e6bb35a50b26fc304345617ab017183d83ac0'
+        ]
+      ]
+    }
+
+    expect(nip10.parse(event)).toEqual({
+      mentions: [
+        {
+          id: 'bbd72f0ae14374aa8fb166b483cfcf99b57d7f4cf1600ccbf17c350040834631',
+          relays: []
+        }
+      ],
+      profiles: [
+        {
+          pubkey:
+            '77ce56f89d1228f7ff3743ce1ad1b254857b9008564727ebd5a1f317362f6ca7',
+          relays: []
+        },
+        {
+          pubkey:
+            '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec',
+          relays: []
+        },
+        {
+          pubkey:
+            '4ca4f5533e40da5e0508796d409e6bb35a50b26fc304345617ab017183d83ac0',
+          relays: []
+        }
+      ],
+      reply: {
+        id: '5e081ebb19153357d7c31e8a10b9ceeef29313f58dc8d701f66727fab02aef64',
+        relays: []
+      },
+      root: {
+        id: 'b857504288c18a15950dd05b9e8772c62ca6289d5aac373c0a8ee5b132e94e7c',
+        relays: []
+      }
+    })
+  })
+
+  test('legacy + 2 events', () => {
+    let event = {
+      tags: [
+        [
+          'e',
+          'b857504288c18a15950dd05b9e8772c62ca6289d5aac373c0a8ee5b132e94e7c'
+        ],
+        [
+          'e',
+          'bbd72f0ae14374aa8fb166b483cfcf99b57d7f4cf1600ccbf17c350040834631'
+        ],
+        [
+          'p',
+          '77ce56f89d1228f7ff3743ce1ad1b254857b9008564727ebd5a1f317362f6ca7'
+        ],
+        [
+          'p',
+          '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec'
+        ],
+        [
+          'p',
+          '4ca4f5533e40da5e0508796d409e6bb35a50b26fc304345617ab017183d83ac0'
+        ]
+      ]
+    }
+
+    expect(nip10.parse(event)).toEqual({
+      mentions: [],
+      profiles: [
+        {
+          pubkey:
+            '77ce56f89d1228f7ff3743ce1ad1b254857b9008564727ebd5a1f317362f6ca7',
+          relays: []
+        },
+        {
+          pubkey:
+            '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec',
+          relays: []
+        },
+        {
+          pubkey:
+            '4ca4f5533e40da5e0508796d409e6bb35a50b26fc304345617ab017183d83ac0',
+          relays: []
+        }
+      ],
+      reply: {
+        id: 'bbd72f0ae14374aa8fb166b483cfcf99b57d7f4cf1600ccbf17c350040834631',
+        relays: []
+      },
+      root: {
+        id: 'b857504288c18a15950dd05b9e8772c62ca6289d5aac373c0a8ee5b132e94e7c',
+        relays: []
+      }
+    })
+  })
+
+  test('legacy + 1 event', () => {
+    let event = {
+      tags: [
+        [
+          'e',
+          '9abbfd9b9ac5ecdab45d14b8bf8d746139ea039e931a1b376d19a239f1946590'
+        ],
+        [
+          'p',
+          '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec'
+        ]
+      ]
+    }
+
+    expect(nip10.parse(event)).toEqual({
+      mentions: [],
+      profiles: [
+        {
+          pubkey:
+            '534780e44da7b494485e85cd4cca6af4f6caa1627472432b6f2a4ece0e9e54ec',
+          relays: []
+        }
+      ],
+      reply: undefined,
+      root: {
+        id: '9abbfd9b9ac5ecdab45d14b8bf8d746139ea039e931a1b376d19a239f1946590',
+        relays: []
+      }
+    })
+  })
+
+  test.todo('recommended + a lot of events')
+  test.todo('recommended + 3 events')
+  test.todo('recommended + 2 events')
+
+  test('recommended + 1 event', () => {
+    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'
+        ],
+        ['mostr', 'https://poa.st/objects/dc50684b-6364-4264-ab16-49f4622f05ea']
+      ]
+    }
+
+    expect(nip10.parse(event)).toEqual({
+      mentions: [],
+      profiles: [
+        {
+          pubkey:
+            'a8c21fcd8aa1f4befba14d72fc7a012397732d30d8b3131af912642f3c726f52',
+          relays: ['wss://relay.mostr.pub']
+        },
+        {
+          pubkey:
+            '003d7fd21fd09ff7f6f63a75daf194dd99feefbe6919cc376b7359d5090aa9a6',
+          relays: ['wss://relay.mostr.pub']
+        },
+        {
+          pubkey:
+            '2f6fbe452edd3987d3c67f3b034c03ec5bcf4d054c521c3a954686f89f03212e',
+          relays: ['wss://relay.mostr.pub']
+        },
+        {
+          pubkey:
+            '44c7c74668ff222b0e0b30579c49fc6e22dafcdeaad091036c947f9856590f1e',
+          relays: ['wss://relay.mostr.pub']
+        },
+        {
+          pubkey:
+            'c5cf39149caebda4cdd61771c51f6ba91ef5645919004e5c4998a4ea69f00512',
+          relays: ['wss://relay.mostr.pub']
+        },
+        {
+          pubkey:
+            '094d44bb1e812696c57f57ad1c0c707812dedbe72c07e538b80639032c236a9e',
+          relays: ['wss://relay.mostr.pub']
+        },
+        {
+          pubkey:
+            'a1ba0ac9b6ec098f726a3c11ec654df4a32cbb84b5377e8788395e9c27d9ecda',
+          relays: ['wss://relay.mostr.pub']
+        }
+      ],
+      reply: {
+        id: 'f9472913904ab7e9da008dcb2d85fd4af2d2993ada483d00c646d0c4481d031d',
+        relays: ['wss://relay.mostr.pub']
+      },
+      root: undefined
+    })
+  })
+})

nip10.ts

@@ -0,0 +1,96 @@
+import type {Event} from './event'
+import type {EventPointer, ProfilePointer} from './nip19'
+
+export type NIP10Result = {
+  /**
+   * Pointer to the root of the thread.
+   */
+  root: EventPointer | undefined
+
+  /**
+   * Pointer to a "parent" event that parsed event replies to (responded to).
+   */
+  reply: EventPointer | undefined
+
+  /**
+   * Pointers to events which may or may not be in the reply chain.
+   */
+  mentions: 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 = {
+    reply: undefined,
+    root: undefined,
+    mentions: [],
+    profiles: []
+  }
+
+  const eTags: string[][] = []
+
+  for (const tag of event.tags) {
+    if (tag[0] === 'e' && tag[1]) {
+      eTags.push(tag)
+    }
+
+    if (tag[0] === 'p' && tag[1]) {
+      result.profiles.push({
+        pubkey: tag[1],
+        relays: tag[2] ? [tag[2]] : []
+      })
+    }
+  }
+
+  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)
+  }
+
+  return result
+}

nip19.test.js

@@ -35,6 +35,21 @@ test('encode and decode nprofile', () => {
   expect(data.relays).toContain(relays[1])
 })
 
+test('decode nprofile without relays', () => {
+  expect(
+    nip19.decode(
+      nip19.nprofileEncode({
+        pubkey:
+          '97c70a44366a6535c145b333f973ea86dfdc2d7a99da618c40c64705ad98e322',
+        relays: []
+      })
+    ).data
+  ).toHaveProperty(
+    'pubkey',
+    '97c70a44366a6535c145b333f973ea86dfdc2d7a99da618c40c64705ad98e322'
+  )
+})
+
 test('encode and decode naddr', () => {
   let pk = getPublicKey(generatePrivateKey())
   let relays = [
@@ -57,7 +72,7 @@ test('encode and decode naddr', () => {
   expect(data.identifier).toEqual('banana')
 })
 
-test('encode and decode naddr from habla.news', () => {
+test('decode naddr from habla.news', () => {
   let {type, data} = nip19.decode(
     'naddr1qq98yetxv4ex2mnrv4esygrl54h466tz4v0re4pyuavvxqptsejl0vxcmnhfl60z3rth2xkpjspsgqqqw4rsf34vl5'
   )
@@ -68,3 +83,20 @@ test('encode and decode naddr from habla.news', () => {
   expect(data.kind).toEqual(30023)
   expect(data.identifier).toEqual('references')
 })
+
+test('decode naddr from go-nostr with different TLV ordering', () => {
+  let {type, data} = nip19.decode(
+    'naddr1qqrxyctwv9hxzq3q80cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsxpqqqp65wqfwwaehxw309aex2mrp0yhxummnw3ezuetcv9khqmr99ekhjer0d4skjm3wv4uxzmtsd3jjucm0d5q3vamnwvaz7tmwdaehgu3wvfskuctwvyhxxmmd0zfmwx'
+  )
+
+  expect(type).toEqual('naddr')
+  expect(data.pubkey).toEqual(
+    '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d'
+  )
+  expect(data.relays).toContain(
+    'wss://relay.nostr.example.mydomain.example.com'
+  )
+  expect(data.relays).toContain('wss://nostr.banana.com')
+  expect(data.kind).toEqual(30023)
+  expect(data.identifier).toEqual('banana')
+})

nip19.ts

@@ -13,6 +13,7 @@ export type ProfilePointer = {
 export type EventPointer = {
   id: string // hex
   relays?: string[]
+  author?: string
 }
 
 export type AddressPointer = {
@@ -47,12 +48,17 @@ export function decode(nip19: string): {
       let tlv = parseTLV(data)
       if (!tlv[0]?.[0]) throw new Error('missing TLV 0 for nevent')
       if (tlv[0][0].length !== 32) throw new Error('TLV 0 should be 32 bytes')
+      if (tlv[2] && tlv[2][0].length !== 32)
+        throw new Error('TLV 2 should be 32 bytes')
 
       return {
         type: 'nevent',
         data: {
           id: secp256k1.utils.bytesToHex(tlv[0][0]),
-          relays: tlv[1] ? tlv[1].map(d => utf8Decoder.decode(d)) : []
+          relays: tlv[1] ? tlv[1].map(d => utf8Decoder.decode(d)) : [],
+          author: tlv[2]?.[0]
+            ? secp256k1.utils.bytesToHex(tlv[2][0])
+            : undefined
         }
       }
     }
@@ -133,7 +139,8 @@ export function nprofileEncode(profile: ProfilePointer): string {
 export function neventEncode(event: EventPointer): string {
   let data = encodeTLV({
     0: [secp256k1.utils.hexToBytes(event.id)],
-    1: (event.relays || []).map(url => utf8Encoder.encode(url))
+    1: (event.relays || []).map(url => utf8Encoder.encode(url)),
+    2: event.author ? [secp256k1.utils.hexToBytes(event.author)] : []
   })
   let words = bech32.toWords(data)
   return bech32.encode('nevent', words, Bech32MaxSize)

nip39.test.js

@@ -0,0 +1,15 @@
+/* eslint-env jest */
+
+const fetch = require('node-fetch')
+const {nip39} = require('./lib/nostr.cjs.js')
+
+test('validate github claim', async () => {
+  nip39.useFetchImplementation(fetch)
+
+  let result = await nip39.validateGithub(
+    'npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z',
+    'vitorpamplona',
+    'cf19e2d1d7f8dac6348ad37b35ec8421'
+  )
+  expect(result).toBe(true)
+})

nip39.ts

@@ -0,0 +1,27 @@
+var _fetch: any
+
+try {
+  _fetch = fetch
+} catch {}
+
+export function useFetchImplementation(fetchImplementation: any) {
+  _fetch = fetchImplementation
+}
+
+export async function validateGithub(
+  pubkey: string,
+  username: string,
+  proof: string
+): Promise<boolean> {
+  try {
+    let res = await (
+      await _fetch(`https://gist.github.com/${username}/${proof}/raw`)
+    ).text()
+    return (
+      res ===
+      `Verifying that I control the following Nostr public key: ${pubkey}`
+    )
+  } catch (_) {
+    return false
+  }
+}

nip41.test.js

@@ -0,0 +1,154 @@
+/* eslint-env jest */
+
+const secp256k1 = require('@noble/secp256k1')
+const {
+  getPublicKey,
+  validateEvent,
+  verifySignature,
+  generatePrivateKey,
+  nip41
+} = require('./lib/nostr.cjs')
+
+test('sanity', () => {
+  let sk = generatePrivateKey()
+
+  expect(getPublicKey(sk)).toEqual(secp256k1.Point.fromPrivateKey(sk).toHexX())
+})
+
+test('key arithmetics', () => {
+  expect(
+    secp256k1.utils.mod(secp256k1.CURVE.n + 1n, secp256k1.CURVE.n)
+  ).toEqual(1n)
+
+  let veryHighPoint = secp256k1.Point.fromPrivateKey(
+    (secp256k1.CURVE.n - 1n).toString(16).padStart(64, '0')
+  )
+  let pointAt2 = secp256k1.Point.fromPrivateKey(
+    2n.toString(16).padStart(64, '0')
+  )
+  let pointAt1 = secp256k1.Point.fromPrivateKey(
+    1n.toString(16).padStart(64, '0')
+  )
+  expect(veryHighPoint.add(pointAt2)).toEqual(pointAt1)
+
+  expect(
+    secp256k1.getPublicKey(1n.toString(16).padStart(64, '0'), true)
+  ).toEqual(pointAt1.toRawBytes(true))
+})
+
+test('testing getting child keys compatibility', () => {
+  let sk = '2222222222222222222222222222222222222222222222222222222222222222'
+  let pk = secp256k1.getPublicKey(sk, true)
+  let hsk = '3333333333333333333333333333333333333333333333333333333333333333'
+  let hpk = secp256k1.getPublicKey(hsk, true)
+
+  expect(secp256k1.utils.bytesToHex(nip41.getChildPublicKey(pk, hpk))).toEqual(
+    secp256k1.utils.bytesToHex(
+      secp256k1.getPublicKey(nip41.getChildPrivateKey(sk, hsk), true)
+    )
+  )
+})
+
+test('more testing child key derivation', () => {
+  ;[
+    {
+      sk: '448aedc74f93b71af69ed7c6860d95f148d796355517779c7631fdb64a085b26',
+      hsk: '00ee15a0a117e818073b92d7f3360029f6e091035534348f713a23d440bd8f58',
+      pk: '02e3990b0eb40452a8ffbd9fe99037deb7beeb6ab26020e8c0e8284f3009a56d0c',
+      hpk: '029e9cb07f3a3b8abcad629920d4a5460aefb6b7c08704b7f1ced8648b007ef65f'
+    },
+    {
+      sk: '778aedc74f93b71af69ed7c6860d95f148d796355517779c7631fdb64a085b26',
+      hsk: '99ee15a0a117e818073b92d7f3360029f6e091035534348f713a23d440bd8f58',
+      pk: '020d09894e321f53a7ac8bc003cb1563a4857d57ea69c39ab7189e2cccedc17d1b',
+      hpk: '0358fe19e14c78c4a8c0037a2b9d3e3a714717f2a2d8dd54a5e88d283440dcb28a'
+    },
+    {
+      sk: '2eb5edc74f93b71af69ed7c6860d95f148d796355517779c7631fdb64a085b26',
+      hsk: '65d515a0a117e818073b92d7f3360029f6e091035534348f713a23d440bd8f58',
+      pk: '03dd651a07dc6c9a54b596f6492c9623a595cb48e31af04f8c322d4ce81accb2b0',
+      hpk: '03b8c98d920141a1e168d21e9315cf933a601872ebf57751b30797fb98526c2f4f'
+    }
+  ].forEach(({pk, hpk, sk, hsk}) => {
+    expect(
+      secp256k1.utils.bytesToHex(secp256k1.getPublicKey(sk, true))
+    ).toEqual(pk)
+    expect(
+      secp256k1.utils.bytesToHex(secp256k1.getPublicKey(hsk, true))
+    ).toEqual(hpk)
+
+    expect(
+      secp256k1.utils.bytesToHex(
+        nip41.getChildPublicKey(
+          secp256k1.utils.hexToBytes(pk),
+          secp256k1.utils.hexToBytes(hpk)
+        )
+      )
+    ).toEqual(
+      secp256k1.utils.bytesToHex(
+        secp256k1.getPublicKey(nip41.getChildPrivateKey(sk, hsk), true)
+      )
+    )
+  })
+})
+
+test('generating a revocation event and validating it', () => {
+  const mnemonic =
+    'air property excess weird rare rival fade intact brave office mirror wait'
+
+  const firstKey = nip41.getPrivateKeyAtIndex(mnemonic, 9)
+  // expect(firstKey).toEqual(
+  //   '8495ba55f56485d378aa275604a45e76abbcae177e374fa06af5770c3b8e24af'
+  // )
+  const firstPubkey = getPublicKey(firstKey)
+  // expect(firstPubkey).toEqual(
+  //   '35246813a0dd45e74ce22ecdf052cca8ed47759c8f8d412c281dc2755110956f'
+  // )
+
+  // first key is compromised, revoke it
+  let {parentPrivateKey, event} = nip41.buildRevocationEvent(
+    mnemonic,
+    firstPubkey
+  )
+
+  const secondKey = nip41.getPrivateKeyAtIndex(mnemonic, 8)
+  expect(parentPrivateKey).toEqual(secondKey)
+  expect(secondKey).toEqual(
+    '1b311655ef73bed3bbebc83d0cb3eef42c6aff45f944e3a0c263eb6fdf98c617'
+  )
+
+  expect(event).toHaveProperty('kind', 13)
+  expect(event.tags).toHaveLength(2)
+  expect(event.tags[0]).toHaveLength(2)
+  expect(event.tags[1]).toHaveLength(2)
+  expect(event.tags[0][0]).toEqual('p')
+  expect(event.tags[1][0]).toEqual('hidden-key')
+
+  let hiddenKey = secp256k1.utils.hexToBytes(event.tags[1][1])
+
+  let pubkeyAlt1 = secp256k1.utils
+    .bytesToHex(
+      nip41.getChildPublicKey(
+        secp256k1.utils.hexToBytes('02' + event.pubkey),
+        hiddenKey
+      )
+    )
+    .slice(2)
+  let pubkeyAlt2 = secp256k1.utils
+    .bytesToHex(
+      nip41.getChildPublicKey(
+        secp256k1.utils.hexToBytes('03' + event.pubkey),
+        hiddenKey
+      )
+    )
+    .slice(2)
+
+  expect([pubkeyAlt1, pubkeyAlt2]).toContain(event.tags[0][1])
+
+  // receiver of revocation event can validate it
+  let secondPubkey = getPublicKey(secondKey)
+  expect(event.pubkey).toEqual(secondPubkey)
+  expect(validateEvent(event)).toBeTruthy()
+  expect(verifySignature(event)).toBeTruthy()
+  expect(nip41.validateRevocation(event)).toBeTruthy()
+})

nip41.ts

@@ -0,0 +1,160 @@
+import * as secp256k1 from '@noble/secp256k1'
+import {sha256} from '@noble/hashes/sha256'
+import {mnemonicToSeedSync} from '@scure/bip39'
+import {HARDENED_OFFSET, HDKey} from '@scure/bip32'
+
+import {getPublicKey} from './keys'
+import {Event, getEventHash, Kind, signEvent, verifySignature} from './event'
+
+const MaxKeys = 256
+
+function getRootFromMnemonic(mnemonic: string): HDKey {
+  return HDKey.fromMasterSeed(mnemonicToSeedSync(mnemonic)).derive(
+    `m/44'/1237'/41'`
+  )
+}
+
+export function getPrivateKeyAtIndex(
+  mnemonic: string,
+  targetIdx: number
+): string {
+  let root = getRootFromMnemonic(mnemonic)
+  let rootPrivateKey = secp256k1.utils.bytesToHex(root.privateKey as Uint8Array)
+  let currentPrivateKey = rootPrivateKey
+
+  for (let idx = 1; idx <= targetIdx; idx++) {
+    let hiddenPrivateKey = secp256k1.utils.bytesToHex(
+      root.deriveChild(idx + HARDENED_OFFSET).privateKey as Uint8Array
+    )
+    currentPrivateKey = getChildPrivateKey(currentPrivateKey, hiddenPrivateKey)
+  }
+
+  return currentPrivateKey
+}
+
+export function getPublicKeyAtIndex(
+  root: HDKey,
+  targetIdx: number
+): Uint8Array {
+  let rootPublicKey = root.publicKey as Uint8Array
+
+  let currentPublicKey = rootPublicKey
+  for (let idx = 1; idx <= targetIdx; idx++) {
+    let hiddenPublicKey = root.deriveChild(idx + HARDENED_OFFSET)
+      .publicKey as Uint8Array
+    currentPublicKey = getChildPublicKey(currentPublicKey, hiddenPublicKey)
+  }
+
+  return currentPublicKey
+}
+
+function getIndexOfPublicKey(root: HDKey, publicKey: string): number {
+  let rootPublicKey = root.publicKey as Uint8Array
+  if (secp256k1.utils.bytesToHex(rootPublicKey).slice(2) === publicKey) return 0
+
+  let currentPublicKey = rootPublicKey
+  for (let idx = 1; idx <= MaxKeys; idx++) {
+    let hiddenPublicKey = root.deriveChild(idx + HARDENED_OFFSET)
+      .publicKey as Uint8Array
+    let pubkeyAtIndex = getChildPublicKey(currentPublicKey, hiddenPublicKey)
+    if (secp256k1.utils.bytesToHex(pubkeyAtIndex).slice(2) === publicKey)
+      return idx
+
+    currentPublicKey = pubkeyAtIndex
+  }
+
+  throw new Error(
+    `public key ${publicKey} not in the set of the first ${MaxKeys} public keys`
+  )
+}
+
+export function getChildPublicKey(
+  parentPublicKey: Uint8Array,
+  hiddenPublicKey: Uint8Array
+): Uint8Array {
+  if (parentPublicKey.length !== 33 || hiddenPublicKey.length !== 33)
+    throw new Error(
+      'getChildPublicKey() requires public keys with the leading differentiator byte.'
+    )
+
+  let hash = sha256(
+    secp256k1.utils.concatBytes(hiddenPublicKey, parentPublicKey)
+  )
+  let hashPoint = secp256k1.Point.fromPrivateKey(hash)
+  let point = secp256k1.Point.fromHex(hiddenPublicKey).add(hashPoint)
+  return point.toRawBytes(true)
+}
+
+export function getChildPrivateKey(
+  parentPrivateKey: string,
+  hiddenPrivateKey: string
+): string {
+  let parentPublicKey = secp256k1.getPublicKey(parentPrivateKey, true)
+  let hiddenPublicKey = secp256k1.getPublicKey(hiddenPrivateKey, true)
+  let hash = sha256(
+    secp256k1.utils.concatBytes(hiddenPublicKey, parentPublicKey)
+  )
+  let hashScalar = BigInt(`0x${secp256k1.utils.bytesToHex(hash)}`)
+  let hiddenPrivateKeyScalar = BigInt(`0x${hiddenPrivateKey}`)
+  let sumScalar = hiddenPrivateKeyScalar + hashScalar
+  let modulo = secp256k1.utils.mod(sumScalar, secp256k1.CURVE.n)
+  return modulo.toString(16).padStart(64, '0')
+}
+
+export function buildRevocationEvent(
+  mnemonic: string,
+  compromisedKey: string,
+  content = ''
+): {
+  parentPrivateKey: string
+  event: Event
+} {
+  let root = getRootFromMnemonic(mnemonic)
+  let idx = getIndexOfPublicKey(root, compromisedKey)
+  let hiddenKey = secp256k1.utils.bytesToHex(
+    root.deriveChild(idx + HARDENED_OFFSET).publicKey as Uint8Array
+  )
+  let parentPrivateKey = getPrivateKeyAtIndex(mnemonic, idx - 1)
+  let parentPublicKey = getPublicKey(parentPrivateKey)
+
+  let event: Event = {
+    kind: 13,
+    tags: [
+      ['p', compromisedKey],
+      ['hidden-key', hiddenKey]
+    ],
+    created_at: Math.round(Date.now() / 1000),
+    content,
+    pubkey: parentPublicKey
+  }
+
+  event.sig = signEvent(event, parentPrivateKey)
+  event.id = getEventHash(event)
+
+  return {parentPrivateKey, event}
+}
+
+export function validateRevocation(event: Event): boolean {
+  if (event.kind !== Kind.StatelessRevocation) return false
+  if (!verifySignature(event)) return false
+
+  let invalidKeyTag = event.tags.find(([t, v]) => t === 'p' && v)
+  if (!invalidKeyTag) return false
+  let invalidKey = invalidKeyTag[1]
+
+  let hiddenKeyTag = event.tags.find(([t, v]) => t === 'hidden-key' && v)
+  if (!hiddenKeyTag) return false
+  let hiddenKey = secp256k1.utils.hexToBytes(hiddenKeyTag[1])
+  if (hiddenKey.length !== 33) return false
+
+  let currentKeyAlt1 = secp256k1.utils.hexToBytes('02' + event.pubkey)
+  let currentKeyAlt2 = secp256k1.utils.hexToBytes('03' + event.pubkey)
+  let childKeyAlt1 = secp256k1.utils
+    .bytesToHex(getChildPublicKey(currentKeyAlt1, hiddenKey))
+    .slice(2)
+  let childKeyAlt2 = secp256k1.utils
+    .bytesToHex(getChildPublicKey(currentKeyAlt2, hiddenKey))
+    .slice(2)
+
+  return childKeyAlt1 === invalidKey || childKeyAlt2 === invalidKey
+}

nip57.test.js

@@ -0,0 +1,335 @@
+const {bech32} = require('@scure/base')
+const {
+  nip57,
+  generatePrivateKey,
+  getPublicKey,
+  finishEvent
+} = require('./lib/nostr.cjs')
+
+describe('getZapEndpoint', () => {
+  test('returns null if neither lud06 nor lud16 is present', async () => {
+    const metadata = {content: '{}'}
+    const result = await nip57.getZapEndpoint(metadata)
+
+    expect(result).toBeNull()
+  })
+
+  test('returns null if fetch fails', async () => {
+    const fetchImplementation = jest.fn(() => Promise.reject(new Error()))
+    nip57.useFetchImplementation(fetchImplementation)
+
+    const metadata = {content: '{"lud16": "name@domain"}'}
+    const result = await nip57.getZapEndpoint(metadata)
+
+    expect(result).toBeNull()
+    expect(fetchImplementation).toHaveBeenCalledWith(
+      'https://domain/.well-known/lnurlp/name'
+    )
+  })
+
+  test('returns null if the response does not allow Nostr payments', async () => {
+    const fetchImplementation = jest.fn(() =>
+      Promise.resolve({json: () => ({allowsNostr: false})})
+    )
+    nip57.useFetchImplementation(fetchImplementation)
+
+    const metadata = {content: '{"lud16": "name@domain"}'}
+    const result = await nip57.getZapEndpoint(metadata)
+
+    expect(result).toBeNull()
+    expect(fetchImplementation).toHaveBeenCalledWith(
+      'https://domain/.well-known/lnurlp/name'
+    )
+  })
+
+  test('returns the callback URL if the response allows Nostr payments', async () => {
+    const fetchImplementation = jest.fn(() =>
+      Promise.resolve({
+        json: () => ({
+          allowsNostr: true,
+          nostrPubkey: 'pubkey',
+          callback: 'callback'
+        })
+      })
+    )
+    nip57.useFetchImplementation(fetchImplementation)
+
+    const metadata = {content: '{"lud16": "name@domain"}'}
+    const result = await nip57.getZapEndpoint(metadata)
+
+    expect(result).toBe('callback')
+    expect(fetchImplementation).toHaveBeenCalledWith(
+      'https://domain/.well-known/lnurlp/name'
+    )
+  })
+})
+
+describe('makeZapRequest', () => {
+  test('throws an error if amount is not given', () => {
+    expect(() =>
+      nip57.makeZapRequest({
+        profile: 'profile',
+        event: null,
+        relays: [],
+        comment: ''
+      })
+    ).toThrow()
+  })
+
+  test('throws an error if profile is not given', () => {
+    expect(() =>
+      nip57.makeZapRequest({
+        event: null,
+        amount: 100,
+        relays: [],
+        comment: ''
+      })
+    ).toThrow()
+  })
+
+  test('returns a valid Zap request', () => {
+    const result = nip57.makeZapRequest({
+      profile: 'profile',
+      event: 'event',
+      amount: 100,
+      relays: ['relay1', 'relay2'],
+      comment: 'comment'
+    })
+    expect(result.kind).toBe(9734)
+    expect(result.created_at).toBeCloseTo(Date.now() / 1000, 0)
+    expect(result.content).toBe('comment')
+    expect(result.tags).toEqual(
+      expect.arrayContaining([
+        ['p', 'profile'],
+        ['amount', '100'],
+        ['relays', 'relay1', 'relay2']
+      ])
+    )
+    expect(result.tags).toContainEqual(['e', 'event'])
+  })
+})
+
+describe('validateZapRequest', () => {
+  test('returns an error message for invalid JSON', () => {
+    expect(nip57.validateZapRequest('invalid JSON')).toBe(
+      'Invalid zap request JSON.'
+    )
+  })
+
+  test('returns an error message if the Zap request is not a valid Nostr event', () => {
+    const zapRequest = {
+      kind: 1234,
+      created_at: Date.now() / 1000,
+      content: 'content',
+      tags: [
+        ['p', 'profile'],
+        ['amount', '100'],
+        ['relays', 'relay1', 'relay2']
+      ]
+    }
+
+    expect(nip57.validateZapRequest(JSON.stringify(zapRequest))).toBe(
+      'Zap request is not a valid Nostr event.'
+    )
+  })
+
+  test('returns an error message if the signature on the Zap request is invalid', () => {
+    const privateKey = generatePrivateKey()
+    const publicKey = getPublicKey(privateKey)
+
+    const zapRequest = {
+      pubkey: publicKey,
+      kind: 9734,
+      created_at: Date.now() / 1000,
+      content: 'content',
+      tags: [
+        ['p', publicKey],
+        ['amount', '100'],
+        ['relays', 'relay1', 'relay2']
+      ]
+    }
+
+    expect(nip57.validateZapRequest(JSON.stringify(zapRequest))).toBe(
+      'Invalid signature on zap request.'
+    )
+  })
+
+  test('returns an error message if the Zap request does not have a "p" tag', () => {
+    const privateKey = generatePrivateKey()
+
+    const zapRequest = finishEvent(
+      {
+        kind: 9734,
+        created_at: Date.now() / 1000,
+        content: 'content',
+        tags: [
+          ['amount', '100'],
+          ['relays', 'relay1', 'relay2']
+        ]
+      },
+      privateKey
+    )
+
+    expect(nip57.validateZapRequest(JSON.stringify(zapRequest))).toBe(
+      "Zap request doesn't have a 'p' tag."
+    )
+  })
+
+  test('returns an error message if the "p" tag on the Zap request is not valid hex', () => {
+    const privateKey = generatePrivateKey()
+
+    const zapRequest = finishEvent(
+      {
+        kind: 9734,
+        created_at: Date.now() / 1000,
+        content: 'content',
+        tags: [
+          ['p', 'invalid hex'],
+          ['amount', '100'],
+          ['relays', 'relay1', 'relay2']
+        ]
+      },
+      privateKey
+    )
+
+    expect(nip57.validateZapRequest(JSON.stringify(zapRequest))).toBe(
+      "Zap request 'p' tag is not valid hex."
+    )
+  })
+
+  test('returns an error message if the "e" tag on the Zap request is not valid hex', () => {
+    const privateKey = generatePrivateKey()
+    const publicKey = getPublicKey(privateKey)
+
+    const zapRequest = finishEvent(
+      {
+        kind: 9734,
+        created_at: Date.now() / 1000,
+        content: 'content',
+        tags: [
+          ['p', publicKey],
+          ['e', 'invalid hex'],
+          ['amount', '100'],
+          ['relays', 'relay1', 'relay2']
+        ]
+      },
+      privateKey
+    )
+
+    expect(nip57.validateZapRequest(JSON.stringify(zapRequest))).toBe(
+      "Zap request 'e' tag is not valid hex."
+    )
+  })
+
+  test('returns an error message if the Zap request does not have a relays tag', () => {
+    const privateKey = generatePrivateKey()
+    const publicKey = getPublicKey(privateKey)
+
+    const zapRequest = finishEvent(
+      {
+        kind: 9734,
+        created_at: Date.now() / 1000,
+        content: 'content',
+        tags: [
+          ['p', publicKey],
+          ['amount', '100']
+        ]
+      },
+      privateKey
+    )
+
+    expect(nip57.validateZapRequest(JSON.stringify(zapRequest))).toBe(
+      "Zap request doesn't have a 'relays' tag."
+    )
+  })
+
+  test('returns null for a valid Zap request', () => {
+    const privateKey = generatePrivateKey()
+    const publicKey = getPublicKey(privateKey)
+
+    const zapRequest = finishEvent(
+      {
+        kind: 9734,
+        created_at: Date.now() / 1000,
+        content: 'content',
+        tags: [
+          ['p', publicKey],
+          ['amount', '100'],
+          ['relays', 'relay1', 'relay2']
+        ]
+      },
+      privateKey
+    )
+
+    expect(nip57.validateZapRequest(JSON.stringify(zapRequest))).toBeNull()
+  })
+})
+
+describe('makeZapReceipt', () => {
+  test('returns a valid Zap receipt with a preimage', () => {
+    const privateKey = generatePrivateKey()
+    const publicKey = getPublicKey(privateKey)
+
+    const zapRequest = JSON.stringify(
+      finishEvent(
+        {
+          kind: 9734,
+          created_at: Date.now() / 1000,
+          content: 'content',
+          tags: [
+            ['p', publicKey],
+            ['amount', '100'],
+            ['relays', 'relay1', 'relay2']
+          ]
+        },
+        privateKey
+      )
+    )
+    const preimage = 'preimage'
+    const bolt11 = 'bolt11'
+    const paidAt = new Date()
+
+    const result = nip57.makeZapReceipt({zapRequest, preimage, bolt11, paidAt})
+
+    expect(result.kind).toBe(9735)
+    expect(result.created_at).toBeCloseTo(paidAt.getTime() / 1000, 0)
+    expect(result.content).toBe('')
+    expect(result.tags).toContainEqual(['bolt11', bolt11])
+    expect(result.tags).toContainEqual(['description', zapRequest])
+    expect(result.tags).toContainEqual(['p', publicKey])
+    expect(result.tags).toContainEqual(['preimage', preimage])
+  })
+
+  test('returns a valid Zap receipt without a preimage', () => {
+    const privateKey = generatePrivateKey()
+    const publicKey = getPublicKey(privateKey)
+
+    const zapRequest = JSON.stringify(
+      finishEvent(
+        {
+          kind: 9734,
+          created_at: Date.now() / 1000,
+          content: 'content',
+          tags: [
+            ['p', publicKey],
+            ['amount', '100'],
+            ['relays', 'relay1', 'relay2']
+          ]
+        },
+        privateKey
+      )
+    )
+    const bolt11 = 'bolt11'
+    const paidAt = new Date()
+
+    const result = nip57.makeZapReceipt({zapRequest, bolt11, paidAt})
+
+    expect(result.kind).toBe(9735)
+    expect(result.created_at).toBeCloseTo(paidAt.getTime() / 1000, 0)
+    expect(result.content).toBe('')
+    expect(result.tags).toContainEqual(['bolt11', bolt11])
+    expect(result.tags).toContainEqual(['description', zapRequest])
+    expect(result.tags).toContainEqual(['p', publicKey])
+    expect(result.tags).not.toContain('preimage')
+  })
+})

package.json

@@ -1,17 +1,22 @@
 {
   "name": "nostr-tools",
-  "version": "1.6.3",
+  "version": "1.8.2",
   "description": "Tools for making a Nostr client.",
   "repository": {
     "type": "git",
-    "url": "https://github.com/fiatjaf/nostr-tools.git"
+    "url": "https://github.com/nbd-wtf/nostr-tools.git"
   },
+  "files": [
+    "./lib/**/*"
+  ],
+  "types": "./lib/index.d.ts",
   "main": "lib/nostr.cjs.js",
   "module": "lib/esm/nostr.mjs",
   "exports": {
     "import": "./lib/esm/nostr.mjs",
     "require": "./lib/nostr.cjs.js"
   },
+  "license": "Public domain",
   "dependencies": {
     "@noble/hashes": "1.0.0",
     "@noble/secp256k1": "^1.7.1",

pool.test.js

@@ -12,17 +12,17 @@ const {
 let pool = new SimplePool()
 
 let relays = [
-  'wss://nostr-dev.wellorder.net/',
+  'wss://relay.damus.io/',
   'wss://relay.nostr.bg/',
   'wss://nostr.fmt.wiz.biz/',
   'wss://relay.nostr.band/',
-  'wss://nostr.zebedee.cloud/'
+  'wss://nos.lol/'
 ]
 
 afterAll(() => {
   pool.close([
     ...relays,
-    'wss://nostr-relay.untethr.me',
+    'wss://nostr.wine',
     'wss://offchain.pub',
     'wss://eden.nostr.land'
   ])

pool.ts

@@ -26,21 +26,26 @@ export class SimplePool {
 
   async ensureRelay(url: string): Promise<Relay> {
     const nm = normalizeURL(url)
-    const existing = this._conn[nm]
-    if (existing) return existing
 
-    const relay = relayInit(nm)
-    this._conn[nm] = relay
+    if (!this._conn[nm]) {
+      this._conn[nm] = relayInit(nm, {
+        getTimeout: this.getTimeout * 0.9,
+        listTimeout: this.getTimeout * 0.9
+      })
+    }
 
+    const relay = this._conn[nm]
     await relay.connect()
-
     return relay
   }
 
   sub(relays: string[], filters: Filter[], opts?: SubscriptionOptions): Sub {
     let _knownIds: Set<string> = new Set()
-    let modifiedOpts = opts || {}
+    let modifiedOpts = {...(opts || {})}
     modifiedOpts.alreadyHaveEvent = (id, url) => {
+      if (opts?.alreadyHaveEvent?.(id, url)) {
+        return true
+      }
       let set = this._seenOn[id] || new Set()
       set.add(url)
       this._seenOn[id] = set
@@ -96,19 +101,17 @@ export class SimplePool {
         subs.forEach(sub => sub.unsub())
       },
       on(type, cb) {
-        switch (type) {
-          case 'event':
-            eventListeners.add(cb)
-            break
-          case 'eose':
-            eoseListeners.add(cb)
-            break
+        if (type === 'event') {
+          eventListeners.add(cb)
+        } else if (type === 'eose') {
+          eoseListeners.add(cb as () => void | Promise<void>)
         }
       },
       off(type, cb) {
         if (type === 'event') {
           eventListeners.delete(cb)
-        } else if (type === 'eose') eoseListeners.delete(cb)
+        } else if (type === 'eose')
+          eoseListeners.delete(cb as () => void | Promise<void>)
       }
     }
 
@@ -155,25 +158,42 @@ export class SimplePool {
     })
   }
 
-  publish(relays: string[], event: Event): Pub[] {
-    return relays.map(relay => {
-      let r = this._conn[normalizeURL(relay)]
-      if (!r) return badPub(relay)
-      let s = r.publish(event)
-      return s
+  publish(relays: string[], event: Event): Pub {
+    const pubPromises: Promise<Pub>[] = relays.map(async relay => {
+      let r
+      try {
+        r = await this.ensureRelay(relay)
+        return r.publish(event)
+      } catch (_) {
+        return {on() {}, off() {}}
+      }
     })
+
+    const callbackMap = new Map()
+
+    return {
+      on(type, cb) {
+        relays.forEach(async (relay, i) => {
+          let pub = await pubPromises[i]
+          let callback = () => cb(relay)
+          callbackMap.set(cb, callback)
+          pub.on(type, callback)
+        })
+      },
+
+      off(type, cb) {
+        relays.forEach(async (_, i) => {
+          let callback = callbackMap.get(cb)
+          if (callback) {
+            let pub = await pubPromises[i]
+            pub.off(type, callback)
+          }
+        })
+      }
+    }
   }
 
   seenOn(id: string): string[] {
     return Array.from(this._seenOn[id]?.values?.() || [])
   }
 }
-
-function badPub(relay: string): Pub {
-  return {
-    on(typ, cb) {
-      if (typ === 'failed') cb(`relay ${relay} not connected`)
-    },
-    off() {}
-  }
-}

references.test.js

@@ -0,0 +1,62 @@
+/* eslint-env jest */
+
+const {parseReferences} = require('./lib/nostr.cjs')
+
+test('parse mentions', () => {
+  let evt = {
+    tags: [
+      [
+        'p',
+        'c9d556c6d3978d112d30616d0d20aaa81410e3653911dd67787b5aaf9b36ade8',
+        'wss://nostr.com'
+      ],
+      [
+        'e',
+        'a84c5de86efc2ec2cff7bad077c4171e09146b633b7ad117fffe088d9579ac33',
+        'wss://other.com',
+        'reply'
+      ],
+      [
+        'e',
+        '31d7c2875b5fc8e6f9c8f9dc1f84de1b6b91d1947ea4c59225e55c325d330fa8',
+        ''
+      ]
+    ],
+    content:
+      'hello #[0], have you seen #[2]? it was made by nostr:nprofile1qqsvc6ulagpn7kwrcwdqgp797xl7usumqa6s3kgcelwq6m75x8fe8yc5usxdg on nostr:nevent1qqsvc6ulagpn7kwrcwdqgp797xl7usumqa6s3kgcelwq6m75x8fe8ychxp5v4! broken #[3]'
+  }
+
+  expect(parseReferences(evt)).toEqual([
+    {
+      text: '#[0]',
+      profile: {
+        pubkey:
+          'c9d556c6d3978d112d30616d0d20aaa81410e3653911dd67787b5aaf9b36ade8',
+        relays: ['wss://nostr.com']
+      }
+    },
+    {
+      text: '#[2]',
+      event: {
+        id: '31d7c2875b5fc8e6f9c8f9dc1f84de1b6b91d1947ea4c59225e55c325d330fa8',
+        relays: []
+      }
+    },
+    {
+      text: 'nostr:nprofile1qqsvc6ulagpn7kwrcwdqgp797xl7usumqa6s3kgcelwq6m75x8fe8yc5usxdg',
+      profile: {
+        pubkey:
+          'cc6b9fea033f59c3c39a0407c5f1bfee439b077508d918cfdc0d6fd431d39393',
+        relays: []
+      }
+    },
+    {
+      text: 'nostr:nevent1qqsvc6ulagpn7kwrcwdqgp797xl7usumqa6s3kgcelwq6m75x8fe8ychxp5v4',
+      event: {
+        id: 'cc6b9fea033f59c3c39a0407c5f1bfee439b077508d918cfdc0d6fd431d39393',
+        relays: [],
+        author: undefined
+      }
+    }
+  ])
+})

references.ts

@@ -0,0 +1,104 @@
+import {Event} from './event'
+import {decode, AddressPointer, ProfilePointer, EventPointer} from './nip19'
+
+type Reference = {
+  text: string
+  profile?: ProfilePointer
+  event?: EventPointer
+  address?: AddressPointer
+}
+
+const mentionRegex =
+  /\bnostr:((note|npub|naddr|nevent|nprofile)1\w+)\b|#\[(\d+)\]/g
+
+export function parseReferences(evt: Event): Reference[] {
+  let references: Reference[] = []
+  for (let ref of evt.content.matchAll(mentionRegex)) {
+    if (ref[2]) {
+      // it's a NIP-27 mention
+      try {
+        let {type, data} = decode(ref[1])
+        switch (type) {
+          case 'npub': {
+            references.push({
+              text: ref[0],
+              profile: {pubkey: data as string, relays: []}
+            })
+            break
+          }
+          case 'nprofile': {
+            references.push({
+              text: ref[0],
+              profile: data as ProfilePointer
+            })
+            break
+          }
+          case 'note': {
+            references.push({
+              text: ref[0],
+              event: {id: data as string, relays: []}
+            })
+            break
+          }
+          case 'nevent': {
+            references.push({
+              text: ref[0],
+              event: data as EventPointer
+            })
+            break
+          }
+          case 'naddr': {
+            references.push({
+              text: ref[0],
+              address: data as AddressPointer
+            })
+            break
+          }
+        }
+      } catch (err) {
+        /***/
+      }
+    } else if (ref[3]) {
+      // it's a NIP-10 mention
+      let idx = parseInt(ref[3], 10)
+      let tag = evt.tags[idx]
+      if (!tag) continue
+
+      switch (tag[0]) {
+        case 'p': {
+          references.push({
+            text: ref[0],
+            profile: {pubkey: tag[1], relays: tag[2] ? [tag[2]] : []}
+          })
+          break
+        }
+        case 'e': {
+          references.push({
+            text: ref[0],
+            event: {id: tag[1], relays: tag[2] ? [tag[2]] : []}
+          })
+          break
+        }
+        case 'a': {
+          try {
+            let [kind, pubkey, identifier] = ref[1].split(':')
+            references.push({
+              text: ref[0],
+              address: {
+                identifier,
+                pubkey,
+                kind: parseInt(kind, 10),
+                relays: tag[2] ? [tag[2]] : []
+              }
+            })
+          } catch (err) {
+            /***/
+          }
+          break
+        }
+      }
+    }
+  }
+
+  return references
+}

relay.test.js

@@ -9,7 +9,7 @@ const {
   signEvent
 } = require('./lib/nostr.cjs')
 
-let relay = relayInit('wss://nostr-dev.wellorder.net/')
+let relay = relayInit('wss://relay.damus.io/')
 
 beforeAll(() => {
   relay.connect()

relay.ts

@@ -4,8 +4,16 @@ import {Event, verifySignature, validateEvent} from './event'
 import {Filter, matchFilters} from './filter'
 import {getHex64, getSubscriptionId} from './fakejson'
 
-type RelayEvent = 'connect' | 'disconnect' | 'error' | 'notice'
-
+type RelayEvent = {
+  connect: () => void | Promise<void>
+  disconnect: () => void | Promise<void>
+  error: () => void | Promise<void>
+  notice: (msg: string) => void | Promise<void>
+}
+type SubEvent = {
+  event: (event: Event) => void | Promise<void>
+  eose: () => void | Promise<void>
+}
 export type Relay = {
   url: string
   status: number
@@ -15,8 +23,14 @@ export type Relay = {
   list: (filters: Filter[], opts?: SubscriptionOptions) => Promise<Event[]>
   get: (filter: Filter, opts?: SubscriptionOptions) => Promise<Event | null>
   publish: (event: Event) => Pub
-  on: (type: RelayEvent, cb: any) => void
-  off: (type: RelayEvent, cb: any) => void
+  off: <T extends keyof RelayEvent, U extends RelayEvent[T]>(
+    event: T,
+    listener: U
+  ) => void
+  on: <T extends keyof RelayEvent, U extends RelayEvent[T]>(
+    event: T,
+    listener: U
+  ) => void
 }
 export type Pub = {
   on: (type: 'ok' | 'failed', cb: any) => void
@@ -25,8 +39,14 @@ export type Pub = {
 export type Sub = {
   sub: (filters: Filter[], opts: SubscriptionOptions) => Sub
   unsub: () => void
-  on: (type: 'event' | 'eose', cb: any) => void
-  off: (type: 'event' | 'eose', cb: any) => void
+  on: <T extends keyof SubEvent, U extends SubEvent[T]>(
+    event: T,
+    listener: U
+  ) => void
+  off: <T extends keyof SubEvent, U extends SubEvent[T]>(
+    event: T,
+    listener: U
+  ) => void
 }
 
 export type SubscriptionOptions = {
@@ -35,25 +55,25 @@ export type SubscriptionOptions = {
   alreadyHaveEvent?: null | ((id: string, relay: string) => boolean)
 }
 
-export function relayInit(url: string): Relay {
+export function relayInit(
+  url: string,
+  options: {
+    getTimeout?: number
+    listTimeout?: number
+  } = {}
+): Relay {
+  let {listTimeout = 3000, getTimeout = 3000} = options
+
   var ws: WebSocket
   var openSubs: {[id: string]: {filters: Filter[]} & SubscriptionOptions} = {}
-  var listeners: {
-    connect: Array<() => void>
-    disconnect: Array<() => void>
-    error: Array<() => void>
-    notice: Array<(msg: string) => void>
-  } = {
+  var listeners: {[TK in keyof RelayEvent]: RelayEvent[TK][]} = {
     connect: [],
     disconnect: [],
     error: [],
     notice: []
   }
   var subListeners: {
-    [subid: string]: {
-      event: Array<(event: Event) => void>
-      eose: Array<() => void>
-    }
+    [subid: string]: {[TK in keyof SubEvent]: SubEvent[TK][]}
   } = {}
   var pubListeners: {
     [eventid: string]: {
@@ -63,19 +83,27 @@ export function relayInit(url: string): Relay {
     }
   } = {}
 
+  var connectionPromise: Promise<void> | undefined
   async function connectRelay(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      ws = new WebSocket(url)
+    if (connectionPromise) return connectionPromise
+    connectionPromise = new Promise((resolve, reject) => {
+      try {
+        ws = new WebSocket(url)
+      } catch (err) {
+        reject(err)
+      }
 
       ws.onopen = () => {
         listeners.connect.forEach(cb => cb())
         resolve()
       }
       ws.onerror = () => {
+        connectionPromise = undefined
         listeners.error.forEach(cb => cb())
         reject()
       }
       ws.onclose = async () => {
+        connectionPromise = undefined
         listeners.disconnect.forEach(cb => cb())
       }
 
@@ -161,6 +189,8 @@ export function relayInit(url: string): Relay {
         }
       }
     })
+
+    return connectionPromise
   }
 
   function connected() {
@@ -217,14 +247,20 @@ export function relayInit(url: string): Relay {
         delete subListeners[subid]
         trySend(['CLOSE', subid])
       },
-      on: (type: 'event' | 'eose', cb: any): void => {
+      on: <T extends keyof SubEvent, U extends SubEvent[T]>(
+        type: T,
+        cb: U
+      ): void => {
         subListeners[subid] = subListeners[subid] || {
           event: [],
           eose: []
         }
         subListeners[subid][type].push(cb)
       },
-      off: (type: 'event' | 'eose', cb: any): void => {
+      off: <T extends keyof SubEvent, U extends SubEvent[T]>(
+        type: T,
+        cb: U
+      ): void => {
         let listeners = subListeners[subid]
         let idx = listeners[type].indexOf(cb)
         if (idx >= 0) listeners[type].splice(idx, 1)
@@ -235,13 +271,20 @@ export function relayInit(url: string): Relay {
   return {
     url,
     sub,
-    on: (type: RelayEvent, cb: any): void => {
+    on: <T extends keyof RelayEvent, U extends RelayEvent[T]>(
+      type: T,
+      cb: U
+    ): void => {
       listeners[type].push(cb)
       if (type === 'connect' && ws?.readyState === 1) {
-        cb()
+        // i would love to know why we need this
+        ;(cb as () => void)()
       }
     },
-    off: (type: RelayEvent, cb: any): void => {
+    off: <T extends keyof RelayEvent, U extends RelayEvent[T]>(
+      type: T,
+      cb: U
+    ): void => {
       let index = listeners[type].indexOf(cb)
       if (index !== -1) listeners[type].splice(index, 1)
     },
@@ -252,7 +295,7 @@ export function relayInit(url: string): Relay {
         let timeout = setTimeout(() => {
           s.unsub()
           resolve(events)
-        }, 1500)
+        }, listTimeout)
         s.on('eose', () => {
           s.unsub()
           clearTimeout(timeout)
@@ -268,7 +311,7 @@ export function relayInit(url: string): Relay {
         let timeout = setTimeout(() => {
           s.unsub()
           resolve(null)
-        }, 1500)
+        }, getTimeout)
         s.on('event', (event: Event) => {
           s.unsub()
           clearTimeout(timeout)
@@ -302,8 +345,9 @@ export function relayInit(url: string): Relay {
       listeners = {connect: [], disconnect: [], error: [], notice: []}
       subListeners = {}
       pubListeners = {}
-
-      ws?.close()
+      if (ws.readyState === WebSocket.OPEN) {
+        ws?.close()
+      }
     },
     get status() {
       return ws?.readyState ?? 3

tsconfig.json

@@ -9,7 +9,7 @@
     "skipLibCheck": true,
     "esModuleInterop": true,
     "emitDeclarationOnly": true,
-    "outDir": "dist",
+    "outDir": "lib",
     "rootDir": "."
   }
 }