release v1.12.1

Replace array list queue with a linked list one

README.md

@@ -4,6 +4,8 @@ Tools for developing [Nostr](https://github.com/fiatjaf/nostr) clients.
 
 Only depends on _@scure_ and _@noble_ packages.
 
+This package is only providing lower-level functionality. If you want an easy-to-use fully-fledged solution that abstracts the hard parts of Nostr and makes decisions on your behalf, take a look at [NDK](https://github.com/nostr-dev-kit/ndk) and [@snort/system](https://www.npmjs.com/package/@snort/system).
+
 ## Installation
 
 ```bash

event.ts

@@ -27,8 +27,8 @@ export enum Kind {
   Zap = 9735,
   RelayList = 10002,
   ClientAuth = 22242,
-  BadgeDefinition = 30008,
-  ProfileBadge = 30009,
+  ProfileBadge = 30008,
+  BadgeDefinition = 30009,
   Article = 30023
 }
 

filter.test.ts

@@ -1,4 +1,4 @@
-import {matchFilter, matchFilters} from './filter.ts'
+import {matchFilter, matchFilters, mergeFilters} from './filter.ts'
 import {buildEvent} from './test-helpers.ts'
 
 describe('Filter', () => {
@@ -18,7 +18,7 @@ describe('Filter', () => {
         kind: 1,
         pubkey: 'abc',
         created_at: 150,
-        tags: [['tag', 'value']],
+        tags: [['tag', 'value']]
       })
 
       const result = matchFilter(filter, event)
@@ -162,7 +162,12 @@ describe('Filter', () => {
         {authors: ['abc'], limit: 3}
       ]
 
-      const event = buildEvent({id: '123', kind: 1, pubkey: 'abc', created_at: 150})
+      const event = buildEvent({
+        id: '123',
+        kind: 1,
+        pubkey: 'abc',
+        created_at: 150
+      })
 
       const result = matchFilters(filters, event)
 
@@ -189,11 +194,35 @@ describe('Filter', () => {
         {kinds: [1], limit: 2},
         {authors: ['abc'], limit: 3}
       ]
-      const event = buildEvent({id: '456', kind: 2, pubkey: 'def', created_at: 200})
+      const event = buildEvent({
+        id: '456',
+        kind: 2,
+        pubkey: 'def',
+        created_at: 200
+      })
 
       const result = matchFilters(filters, event)
 
       expect(result).toEqual(false)
     })
   })
+
+  describe('mergeFilters', () => {
+    it('should merge filters', () => {
+      expect(
+        mergeFilters(
+          {ids: ['a', 'b'], limit: 3},
+          {authors: ['x'], ids: ['b', 'c']}
+        )
+      ).toEqual({ids: ['a', 'b', 'c'], limit: 3, authors: ['x']})
+
+      expect(
+        mergeFilters(
+          {kinds: [1], since: 15, until: 30},
+          {since: 10, kinds: [7], until: 15},
+          {kinds: [9, 10]}
+        )
+      ).toEqual({kinds: [1, 7, 9, 10], since: 10, until: 30})
+    })
+  })
 })

filter.ts

@@ -56,3 +56,37 @@ export function matchFilters(
   }
   return false
 }
+
+export function mergeFilters(...filters: Filter<number>[]): Filter<number> {
+  let result: Filter<number> = {}
+  for (let i = 0; i < filters.length; i++) {
+    let filter = filters[i]
+    Object.entries(filter).forEach(([property, values]) => {
+      if (
+        property === 'kinds' ||
+        property === 'ids' ||
+        property === 'authors' ||
+        property[0] === '#'
+      ) {
+        // @ts-ignore
+        result[property] = result[property] || []
+        // @ts-ignore
+        for (let v = 0; v < values.length; v++) {
+          // @ts-ignore
+          let value = values[v]
+          // @ts-ignore
+          if (!result[property].includes(value)) result[property].push(value)
+        }
+      }
+    })
+
+    if (filter.limit && (!result.limit || filter.limit > result.limit))
+      result.limit = filter.limit
+    if (filter.until && (!result.until || filter.until > result.until))
+      result.until = filter.until
+    if (filter.since && (!result.since || filter.since < result.since))
+      result.since = filter.since
+  }
+
+  return result
+}

nip19.ts

@@ -69,9 +69,7 @@ export function decode(nip19: string): DecodeResult {
         data: {
           id: bytesToHex(tlv[0][0]),
           relays: tlv[1] ? tlv[1].map(d => utf8Decoder.decode(d)) : [],
-          author: tlv[2]?.[0]
-            ? bytesToHex(tlv[2][0])
-            : undefined
+          author: tlv[2]?.[0] ? bytesToHex(tlv[2][0]) : undefined
         }
       }
     }
@@ -123,9 +121,10 @@ function parseTLV(data: Uint8Array): TLV {
   while (rest.length > 0) {
     let t = rest[0]
     let l = rest[1]
+    if (!l) throw new Error(`malformed TLV ${t}`)
     let v = rest.slice(2, 2 + l)
     rest = rest.slice(2 + l)
-    if (v.length < l) continue
+    if (v.length < l) throw new Error(`not enough data to read on TLV ${t}`)
     result[t] = result[t] || []
     result[t].push(v)
   }

nip27.test.ts

@@ -29,6 +29,25 @@ test('matchAll', () => {
   ])
 })
 
+test('matchAll with an invalid nip19', () => {
+  const result = matchAll(
+    'Hello npub129tvj896hqqkljerxkccpj9flshwnw999v9uwn9lfmwlj8vnzwgq9y5llnpub1rujdpkd8mwezrvpqd2rx2zphfaztqrtsfg6w3vdnlj!\n\nnostr:note1gmtnz6q2m55epmlpe3semjdcq987av3jvx4emmjsa8g3s9x7tg4sclreky'
+  )
+
+  expect([...result]).toEqual([
+    {
+      decoded: {
+        data: '46d731680add2990efe1cc619dc9b8014feeb23261ab9dee50e9d11814de5a2b',
+        type: 'note'
+      },
+      end: 187,
+      start: 118,
+      uri: 'nostr:note1gmtnz6q2m55epmlpe3semjdcq987av3jvx4emmjsa8g3s9x7tg4sclreky',
+      value: 'note1gmtnz6q2m55epmlpe3semjdcq987av3jvx4emmjsa8g3s9x7tg4sclreky'
+    }
+  ])
+})
+
 test('replaceAll', () => {
   const content =
     'Hello nostr:npub108pv4cg5ag52nq082kd5leu9ffrn2gdg6g4xdwatn73y36uzplmq9uyev6!\n\nnostr:note1gmtnz6q2m55epmlpe3semjdcq987av3jvx4emmjsa8g3s9x7tg4sclreky'

nip27.ts

@@ -2,8 +2,7 @@ import {decode} from './nip19.ts'
 import {NOSTR_URI_REGEX, type NostrURI} from './nip21.ts'
 
 /** Regex to find NIP-21 URIs inside event content. */
-export const regex = () =>
-  new RegExp(`\\b${NOSTR_URI_REGEX.source}\\b`, 'g')
+export const regex = () => new RegExp(`\\b${NOSTR_URI_REGEX.source}\\b`, 'g')
 
 /** Match result for a Nostr URI in event content. */
 export interface NostrURIMatch extends NostrURI {
@@ -14,18 +13,22 @@ export interface NostrURIMatch extends NostrURI {
 }
 
 /** Find and decode all NIP-21 URIs. */
-export function * matchAll(content: string): Iterable<NostrURIMatch> {
+export function* matchAll(content: string): Iterable<NostrURIMatch> {
   const matches = content.matchAll(regex())
 
   for (const match of matches) {
-    const [uri, value] = match
+    try {
+      const [uri, value] = match
 
-    yield {
-      uri: uri as `nostr:${string}`,
-      value,
-      decoded: decode(value),
-      start: match.index!,
-      end: match.index! + uri.length
+      yield {
+        uri: uri as `nostr:${string}`,
+        value,
+        decoded: decode(value),
+        start: match.index!,
+        end: match.index! + uri.length
+      }
+    } catch (_e) {
+      // do nothing
     }
   }
 }

package.json

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

relay.ts

@@ -3,6 +3,7 @@
 import {verifySignature, validateEvent, type Event} from './event.ts'
 import {matchFilters, type Filter} from './filter.ts'
 import {getHex64, getSubscriptionId} from './fakejson.ts'
+import { MessageQueue } from './utils.ts'
 
 type RelayEvent = {
   connect: () => void | Promise<void>
@@ -122,24 +123,24 @@ export function relayInit(
         listeners.disconnect.forEach(cb => cb())
       }
 
-      let incomingMessageQueue: string[] = []
+      let incomingMessageQueue: MessageQueue = new MessageQueue()
       let handleNextInterval: any
 
       ws.onmessage = e => {
-        incomingMessageQueue.push(e.data)
+        incomingMessageQueue.enqueue(e.data)
         if (!handleNextInterval) {
           handleNextInterval = setInterval(handleNext, 0)
         }
       }
 
       function handleNext() {
-        if (incomingMessageQueue.length === 0) {
+        if (incomingMessageQueue.size === 0) {
           clearInterval(handleNextInterval)
           handleNextInterval = null
           return
         }
 
-        var json = incomingMessageQueue.shift()
+        var json = incomingMessageQueue.dequeue()
         if (!json) return
 
         let subid = getSubscriptionId(json)

utils.test.ts

@@ -1,5 +1,6 @@
 import {buildEvent} from './test-helpers.ts'
 import {
+  MessageQueue,
   insertEventIntoAscendingList,
   insertEventIntoDescendingList,
 } from './utils.ts'
@@ -191,3 +192,48 @@ describe('inserting into a asc sorted list of events', () => {
     expect(list1).toHaveLength(3)
   })
 })
+
+describe('enque a message into MessageQueue', () => {
+  test('enque into an empty queue', () => {
+    const queue = new MessageQueue()
+    queue.enqueue('node1')
+    expect(queue.first!.value).toBe('node1')
+  })
+  test('enque into a non-empty queue', () => {
+    const queue = new MessageQueue()
+    queue.enqueue('node1')
+    queue.enqueue('node3')
+    queue.enqueue('node2')
+    expect(queue.first!.value).toBe('node1')
+    expect(queue.last!.value).toBe('node2')
+    expect(queue.size).toBe(3)
+  })
+  test('dequeue from an empty queue', () => {
+    const queue = new MessageQueue()
+    const item1 = queue.dequeue()
+    expect(item1).toBe(null)
+    expect(queue.size).toBe(0)
+  })
+  test('dequeue from a non-empty queue', () => {
+    const queue = new MessageQueue()
+    queue.enqueue('node1')
+    queue.enqueue('node3')
+    queue.enqueue('node2')
+    const item1 = queue.dequeue()
+    expect(item1).toBe('node1')
+    const item2 = queue.dequeue()
+    expect(item2).toBe('node3')
+  })
+  test('dequeue more than in queue', () => {
+    const queue = new MessageQueue()
+    queue.enqueue('node1')
+    queue.enqueue('node3')
+    const item1 = queue.dequeue()
+    expect(item1).toBe('node1')
+    const item2 = queue.dequeue()
+    expect(item2).toBe('node3')
+    expect(queue.size).toBe(0)
+    const item3 = queue.dequeue()
+    expect(item3).toBe(null)
+  })
+})

utils.ts

@@ -109,3 +109,79 @@ export function insertEventIntoAscendingList(
 
   return sortedArray
 }
+
+export class MessageNode {
+  private _value: string
+  private _next: MessageNode | null
+
+  public get value(): string {
+    return this._value
+  }
+  public set value(message: string) {
+    this._value = message
+  }
+  public get next(): MessageNode | null {
+    return this._next
+  }
+  public set next(node: MessageNode | null) {
+    this._next = node
+  }
+
+  constructor(message: string) {
+    this._value = message
+    this._next = null
+  }
+}
+
+export class MessageQueue {
+  private _first: MessageNode | null
+  private _last: MessageNode | null
+
+  public get first(): MessageNode | null {
+    return this._first
+  }
+  public set first(messageNode: MessageNode | null) {
+    this._first = messageNode
+  }
+  public get last(): MessageNode | null {
+    return this._last
+  }
+  public set last(messageNode: MessageNode | null) {
+    this._last = messageNode
+  }
+  private _size: number
+  public get size(): number {
+    return this._size
+  }
+  public set size(v: number) {
+    this._size = v
+  }
+
+  constructor() {
+    this._first = null
+    this._last = null
+    this._size = 0
+  }
+  enqueue(message: string): boolean {
+    const newNode = new MessageNode(message)
+    if (this._size === 0 || !this._last) {
+      this._first = newNode
+      this._last = newNode
+    } else {
+      this._last.next = newNode
+      this._last = newNode
+    }
+    this._size++
+    return true
+  }
+  dequeue(): string | null {
+    if (this._size === 0 || !this._first) return null
+
+    let prev = this._first
+    this._first = prev.next
+    prev.next = null
+
+    this._size--
+    return prev.value
+  }
+}