bump to v1.8.0

* add more test cases for event file

* add another test case for event file

* edit filter.test.js and add more test cases

README.md

@@ -170,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

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

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

index.ts

@@ -3,6 +3,7 @@ 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'

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)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-tools",
-  "version": "1.7.5",
+  "version": "1.8.0",
   "description": "Tools for making a Nostr client.",
   "repository": {
     "type": "git",

pool.ts

@@ -55,6 +55,7 @@ export class SimplePool {
       let set = this._seenOn[id] || new Set()
       set.add(url)
       this._seenOn[id] = set
+      _knownIds.add(id)
       return _knownIds.has(id)
     }
 
@@ -80,7 +81,6 @@ export class SimplePool {
       if (!r) return
       let s = r.sub(filters, modifiedOpts)
       s.on('event', (event: Event) => {
-        _knownIds.add(event.id as string)
         for (let cb of eventListeners.values()) cb(event)
       })
       s.on('eose', () => {

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